#pragma once

#include "base/callback.h"
#include "base/threading/sequenced_task_runner_handle.h"
#include "rust/cxx.h"

namespace bluetooth {
namespace shim {
namespace rust {

template <class TArg>
class TrampolineCallback {
 public:
  TrampolineCallback(base::Callback<void(TArg)> callback) : callback_(callback) {}

  void Run(TArg value) const {
    callback_.Run(value);
  }

 private:
  base::Callback<void(TArg)> callback_;
};

template <class TArg>
class TrampolineOnceCallback {
 public:
  TrampolineOnceCallback(base::OnceCallback<void(TArg)> callback)
      : callback_(new base::OnceCallback<void(TArg)>(std::move(callback))) {}
  ~TrampolineOnceCallback() {
    if (callback_ != nullptr) {
      delete callback_;
      callback_ = nullptr;
    }
  }

  void Run(TArg value) const {
    std::move(*callback_).Run(value);
    delete callback_;
    ((TrampolineOnceCallback<TArg>*)this)->callback_ = nullptr;
  }

 private:
  base::OnceCallback<void(TArg)>* callback_;
};

class OnceClosure {
 public:
  OnceClosure(base::OnceClosure closure) : closure_(new base::OnceClosure(std::move(closure))) {}
  ~OnceClosure() {
    if (closure_ != nullptr) {
      delete closure_;
      closure_ = nullptr;
    }
  }

  void Run() const {
    std::move(*closure_).Run();
    delete closure_;
    ((OnceClosure*)this)->closure_ = nullptr;
  }

 private:
  base::OnceClosure* closure_;
};

using u8SliceCallback = TrampolineCallback<::rust::Slice<const uint8_t>>;
using u8SliceOnceCallback = TrampolineOnceCallback<::rust::Slice<const uint8_t>>;

}  // namespace rust
}  // namespace shim
}  // namespace bluetooth

#include "src/bridge.rs.h"