#ifndef AAB5E4D2_A05B_4F2F_B76A_406A5A569D55
#define AAB5E4D2_A05B_4F2F_B76A_406A5A569D55

#include "mana_api.h"
#include "mana_arena.h"
#include <cassert>
#include <mesytec-mnode/mnode_cpp_types.h>
#include <mesytec-mvlc/cpp_compat.h>
#include <mesytec-mvlc/util/data_filter.h>
#include <nlohmann/json.hpp>

namespace mesytec::mnode::mana
{

namespace detail
{
inline void set(mana_offset_ptr_t &ptr, void *p)
{
    assert(p != reinterpret_cast<u8 *>(&ptr) + 1);

    if (p)
    {
        ptr.offset = reinterpret_cast<u8 *>(p) - reinterpret_cast<u8 *>(&ptr);
        // spdlog::info("detail::set: &ptr={}, p={}, offset={}", fmt::ptr(&ptr), fmt::ptr(p),
        // ptr.offset);
    }
    else
    {
        ptr.offset = 1;
    }
}
} // namespace detail

inline bool is_null(const mana_offset_ptr_t &ptr) { return ptr.offset == 1; }

inline void *get(mana_offset_ptr_t &ptr)
{
    return is_null(ptr) ? nullptr : reinterpret_cast<u8 *>(&ptr) + ptr.offset;
}

template <typename T> T *get(mana_offset_ptr_t &ptr); // to catch unsupported types

template <typename T> T *get_(mana_offset_ptr_t &ptr, mana_data_type_t expected)
{
    if (ptr.data_type != expected)
        return nullptr;

    return reinterpret_cast<T *>(get(ptr));
}

template <> u32 *get(mana_offset_ptr_t &ptr) { return get_<u32>(ptr, mana_uint32); }
template <> u64 *get(mana_offset_ptr_t &ptr) { return get_<u64>(ptr, mana_uint64); }
template <> s8 *get(mana_offset_ptr_t &ptr) { return get_<s8>(ptr, mana_sint8); }
template <> char *get(mana_offset_ptr_t &ptr) { return get_<char>(ptr, mana_sint8); }
template <> float *get(mana_offset_ptr_t &ptr) { return get_<float>(ptr, mana_float); }
template <> double *get(mana_offset_ptr_t &ptr) { return get_<double>(ptr, mana_double); }

inline void set(mana_offset_ptr_t &ptr, mana_data_type_t data_type, void *p)
{
    ptr.data_type = data_type;
    detail::set(ptr, p);
}

inline void set(mana_offset_ptr_t &ptr, std::nullptr_t) { set(ptr, mana_uint32, nullptr); }
inline void set(mana_offset_ptr_t &ptr, u32 *p) { set(ptr, mana_uint32, p); }
inline void set(mana_offset_ptr_t &ptr, u64 *p) { set(ptr, mana_uint64, p); }
inline void set(mana_offset_ptr_t &ptr, s8 *p) { set(ptr, mana_sint8, p); }
inline void set(mana_offset_ptr_t &ptr, char *p) { set(ptr, mana_sint8, p); }
inline void set(mana_offset_ptr_t &ptr, float *p) { set(ptr, mana_float, p); }
inline void set(mana_offset_ptr_t &ptr, double *p) { set(ptr, mana_double, p); }

template <typename T>
T *push_offset_array(mana::Arena &arena, mana_offset_array_t &dest, size_t size)
{
    T *ptr = arena.push_t<T>(size);
    mana::set(dest.ptr, mana_custom, ptr);
    dest.size_bytes = size * sizeof(T);
    return ptr;
}

template <typename T>
T *push_typed_offset_array(mana::Arena &arena, mana_offset_array_t &dest, size_t size)
{
    T *ptr = arena.push_t<T>(size);
    mana::set(dest.ptr, ptr);
    dest.size_bytes = size * sizeof(T);
    return ptr;
}

template <typename T> size_t element_count(mana_offset_array_t &array)
{
    return array.size_bytes / sizeof(T);
}

template <typename T> mvlc::util::span<T> get_span(mana_offset_array_t &array)
{
    auto ptr = reinterpret_cast<T *>(get(array.ptr));
    auto size = element_count<T>(array);
    return {ptr, size};
}

inline nlohmann::json make_array_descriptor(const std::string &name, mana_data_type_t data_type,
                                            size_t size, size_t bits = 0)
{
    nlohmann::json j;
    j["name"] = name;
    j["data_type"] = data_type;
    j["size"] = size;
    j["bits"] = bits;
    return j;
}

inline nlohmann::json make_array_descriptor(const std::string &name, const std::string &bit_filter)
{
    auto f = mvlc::util::make_filter_with_caches(bit_filter);
    size_t size = 1;

    if (auto c = mvlc::util::get_cache_entry(f, 'A'))
        size = 1u << c->extractBits;

    size_t bits = 0;

    if (auto c = mvlc::util::get_cache_entry(f, 'D'))
        bits = c->extractBits;

    return make_array_descriptor(name, mana_float, size, bits);
}

class ManaPlugin
{
  public:
    virtual ~ManaPlugin() = default;

    virtual void init() = 0;
    virtual void shutdown() = 0;
    virtual void begin_run(const char *descriptor_json) = 0;
    virtual void end_run(const char *descriptor_json) = 0;
    virtual void process_event(uint16_t eventIndex, mana_offset_array_t *arrays, size_t arrayCount,
                               size_t totalBytes) = 0;

    virtual void process_system_event(const uint32_t *data, size_t size) = 0;

  protected:
    ManaPlugin() = default;

  private:
    ManaPlugin(const ManaPlugin &) = delete;
    ManaPlugin &operator=(const ManaPlugin &) = delete;
};

struct ManaCPlugin: public ManaPlugin
{
    mana_plugin_t plugin_;
    void *context_ = nullptr;

    explicit ManaCPlugin(mana_plugin_t plugin)
        : plugin_(plugin)
    {
    }

    void init() override { context_ = plugin_.init(); }
    void shutdown() override { plugin_.shutdown(context_); }
    void begin_run(const char *descriptor_json) override
    {
        plugin_.begin_run(context_, descriptor_json);
    }
    void end_run(const char *descriptor_json) override
    {
        plugin_.end_run(context_, descriptor_json);
    }
    void process_event(uint16_t eventIndex, mana_offset_array_t *arrays, size_t arrayCount,
                       size_t totalBytes) override
    {
        plugin_.process_event(context_, eventIndex, arrays, arrayCount, totalBytes);
    }
    void process_system_event(const uint32_t *data, size_t size) override
    {
        plugin_.process_system_event(context_, data, size);
    }
};

} // namespace mesytec::mnode::mana

#endif /* AAB5E4D2_A05B_4F2F_B76A_406A5A569D55 */