#pragma once


/*

ABSTRACT DEVICE COMPONENTS LIBRARY

 */


#include <functional>
#include <system_error>

#include "adc_traits.h"
#include "adc_utils.h"


namespace adc
{

// error codes
enum class AdcValueHolderErrorCode : int { ERROR_OK, ERROR_NO_CONV_FUNC, ERROR_INTERNAL_TYPE_MISMATCH };

enum class AdcSerializingValueHolderErrorCode : int { ERROR_OK, ERROR_INVALID_SERIALIZED_TYPE };

}  // namespace adc


namespace std
{

template <>
class is_error_code_enum<adc::AdcValueHolderErrorCode> : public true_type
{
};

template <>
class is_error_code_enum<adc::AdcSerializingValueHolderErrorCode> : public true_type
{
};

}  // namespace std


namespace adc
{

// error category
struct AdcValueHolderErrorCategory : public std::error_category {
    AdcValueHolderErrorCategory() : std::error_category() {}

    const char* name() const noexcept { return "ADC_VALUE_HOLDER_CATEGORY"; }

    std::string message(int ec) const
    {
        AdcValueHolderErrorCode err = static_cast<AdcValueHolderErrorCode>(ec);

        switch (err) {
            case AdcValueHolderErrorCode::ERROR_OK:
                return "OK";
            case AdcValueHolderErrorCode::ERROR_NO_CONV_FUNC:
                return "conversion function is not defined";
            case AdcValueHolderErrorCode::ERROR_INTERNAL_TYPE_MISMATCH:
                return "try to setup default conversion function for invalid type (internal type mismatch)";
            default:
                return "UNKNOWN";
        }
    }

    static const AdcValueHolderErrorCategory& get()
    {
        static const AdcValueHolderErrorCategory constInst;
        return constInst;
    }
};


struct AdcSerializingValueHolderErrorCategory : public std::error_category {
    AdcSerializingValueHolderErrorCategory() : std::error_category() {}

    const char* name() const noexcept { return "ADC_SERIALIZING_VALUE_HOLDER_CATEGORY"; }

    std::string message(int ec) const
    {
        AdcSerializingValueHolderErrorCode err = static_cast<AdcSerializingValueHolderErrorCode>(ec);

        switch (err) {
            case AdcSerializingValueHolderErrorCode::ERROR_OK:
                return "OK";
            case AdcSerializingValueHolderErrorCode::ERROR_INVALID_SERIALIZED_TYPE:
                return "invalid user-passed serialized type";
            default:
                return "UNKNOWN";
        }
    }

    static const AdcSerializingValueHolderErrorCategory& get()
    {
        static const AdcSerializingValueHolderErrorCategory constInst;
        return constInst;
    }
};


inline std::error_code make_error_code(AdcValueHolderErrorCode ec)
{
    return std::error_code(static_cast<int>(ec), AdcValueHolderErrorCategory::get());
}


inline std::error_code make_error_code(AdcSerializingValueHolderErrorCode ec)
{
    return std::error_code(static_cast<int>(ec), AdcSerializingValueHolderErrorCategory::get());
}


/*

                      GENERAL-PURPOSE VALUE HOLDER CLASS

 */


class AdcValueHolder
{
protected:
    template <typename T>
    using ret_value_t = std::decay_t<traits::adc_retval_t<T>>;

    template <typename VT>
    inline static std::unordered_map<const AdcValueHolder*, std::function<VT()>> _getterFunc{};

    template <typename VT>
    inline static std::unordered_map<const AdcValueHolder*, std::function<void(const VT&)>> _setterFunc{};

    std::function<void()> _clearFunc;

    std::function<void(AdcValueHolder*)> _copyFunc;
    std::function<void(AdcValueHolder*)> _moveFunc;


public:
    // default trivial types (just arithmetic ones)
    constexpr static std::tuple<bool,
                                char,
                                short,
                                int,
                                long,
                                long long,
                                unsigned char,
                                unsigned short,
                                unsigned int,
                                unsigned long,
                                unsigned long long,
                                float,
                                double,
                                long double>
        defaultTrivialConvTypes{};


    /*  CONSTRUCTORS AND DESTRUCTOR  */

    template <std::invocable<> GT, typename ValueT = ret_value_t<GT>, std::invocable<const ValueT&> ST>
    AdcValueHolder(GT&& getter, ST&& setter)
    {
        _getterFunc<ValueT>.emplace(this, std::forward<GT>(getter));
        _setterFunc<ValueT>.emplace(this, std::forward<ST>(setter));

        _clearFunc = [this]() {
            _getterFunc<ValueT>.erase(this);
            _setterFunc<ValueT>.erase(this);
        };

        // copy TO other
        _copyFunc = [this](AdcValueHolder* other) {
            _getterFunc<ValueT>.emplace(other, _getterFunc<ValueT>[this]);
            _setterFunc<ValueT>.emplace(other, _setterFunc<ValueT>[this]);
        };

        // move TO other
        _moveFunc = [this](AdcValueHolder* other) {
            _getterFunc<ValueT>.emplace(other, std::move(_getterFunc<ValueT>[this]));
            _setterFunc<ValueT>.emplace(other, std::move(_setterFunc<ValueT>[this]));
        };
    }


    template <traits::adc_tuple_like<> TupleT,
              std::invocable<> GT,
              typename ValueT = ret_value_t<GT>,
              std::invocable<const ValueT&> ST>
    AdcValueHolder(TupleT&&, GT&& getter, ST&& setter)
        : AdcValueHolder(std::forward<GT>(getter), std::forward<ST>(setter))
    {
        // setup trivially-defined conversion function
        AdcValueHolder::setupTrivialConvertFunc<ValueT, std::decay_t<TupleT>>();
    }

    AdcValueHolder(const AdcValueHolder& other)
    {
        _clearFunc();

        other._copyFunc(this);

        _clearFunc = other._clearFunc;
        _copyFunc = other._copyFunc;
        _moveFunc = other._moveFunc;
    };


    AdcValueHolder(AdcValueHolder&& other)
    {
        _clearFunc();

        other._moveFunc(this);

        _clearFunc = std::move(other._clearFunc);
        _copyFunc = std::move(other._copyFunc);
        _moveFunc = std::move(other._moveFunc);
    };

    virtual ~AdcValueHolder() { _clearFunc(); };


    /*  PUBLIC METHODS  */


    template <typename FromFuncT, typename ToFuncT>
    AdcValueHolder& addConvertFunc(FromFuncT&& func_from_internal, ToFuncT&& func_to_internal)
        requires std::invocable<FromFuncT, const ret_value_t<ToFuncT>&> &&
                 std::invocable<ToFuncT, const ret_value_t<FromFuncT>&>
    {
        using value_t = ret_value_t<ToFuncT>;  // it must be internal value type
        using user_t = ret_value_t<FromFuncT>;

        _getterFunc<user_t>[this] = [wrapper = traits::adc_pf_wrapper(std::forward<FromFuncT>(func_from_internal)),
                                     this]() {
            auto& getter = _getterFunc<value_t>[this];
            if (getter) {
                auto val = getter();
                return std::get<0>(wrapper)(val);  // convert from internal type
            }
            // invalid conversion function signature
            throw std::system_error(AdcValueHolderErrorCode::ERROR_INTERNAL_TYPE_MISMATCH);
        };


        _setterFunc<user_t>[this] = [wrapper = traits::adc_pf_wrapper(std::forward<ToFuncT>(func_to_internal)),
                                     this](const user_t& val) {
            value_t value = std::get<0>(wrapper)(val);  // convert to internal type
            auto& setter = _setterFunc<value_t>[this];
            if (setter) {
                setter(value);
            } else {
                // invalid conversion function signature
                throw std::system_error(AdcValueHolderErrorCode::ERROR_INTERNAL_TYPE_MISMATCH);
            }
        };

        _clearFunc = [prev_clear = _clearFunc, this]() {
            prev_clear();

            _getterFunc<user_t>.erase(this);
            _setterFunc<user_t>.erase(this);
        };


        _copyFunc = [prev_copy = _copyFunc, this](AdcValueHolder* other) {
            prev_copy(other);

            _getterFunc<user_t>.emplace(other, _getterFunc<user_t>[this]);
            _setterFunc<user_t>.emplace(other, _setterFunc<user_t>[this]);
        };

        // move TO other
        _moveFunc = [prev_move = _moveFunc, this](AdcValueHolder* other) {
            prev_move(other);

            _getterFunc<user_t>.emplace(other, std::move(_getterFunc<user_t>[this]));
            _setterFunc<user_t>.emplace(other, std::move(_setterFunc<user_t>[this]));
        };

        return *this;
    }


    template <typename UT>
    operator UT() const
    {
        using val_t = std::decay_t<UT>;

        auto getter = _getterFunc<val_t>[this];
        if (getter) {
            return getter();
        }

        throw std::system_error(AdcValueHolderErrorCode::ERROR_NO_CONV_FUNC);
    }

    template <typename UT>
    AdcValueHolder& operator=(UT&& value)
    {
        using val_t = std::decay_t<UT>;

        auto setter = _setterFunc<val_t>[this];
        if (setter) {
            setter(std::forward<UT>(value));
            // setter(value);
        } else {
            throw std::system_error(AdcValueHolderErrorCode::ERROR_NO_CONV_FUNC);
        }

        return *this;
    }


    AdcValueHolder& operator=(AdcValueHolder&& other)
    {
        if (&other != this) {
            _clearFunc();

            other._moveFunc(this);

            _clearFunc = std::move(other._clearFunc);
            _copyFunc = std::move(other._copyFunc);
            _moveFunc = std::move(other._moveFunc);
        }

        return *this;
    }

    AdcValueHolder& operator=(const AdcValueHolder& other)
    {
        if (&other != this) {
            _clearFunc();

            other._copyFunc(this);

            _clearFunc = other._clearFunc;
            _copyFunc = other._copyFunc;
            _moveFunc = other._moveFunc;
        }

        return *this;
    }


protected:
    template <typename VT, size_t I, typename TupleT>
    void setupTrivialConvertFuncImpl()
    {
        if constexpr (I < std::tuple_size_v<TupleT>) {
            using elem_t = std::tuple_element_t<I, TupleT>;

            if constexpr (!std::is_same_v<VT, elem_t>) {
                addConvertFunc([](const VT& v) { return static_cast<elem_t>(v); },
                               [](const elem_t& v) { return static_cast<VT>(v); });
            }

            setupTrivialConvertFuncImpl<VT, I + 1, TupleT>();
        }
    }

    template <typename VT, typename TupleT>
    void setupTrivialConvertFunc()
    {
        setupTrivialConvertFuncImpl<VT, 0, TupleT>();
    }
};



class AdcSerializingValueHolder : public AdcValueHolder
{
protected:
    template <typename SerializedT>
    inline static std::unordered_map<const AdcSerializingValueHolder*, std::function<SerializedT()>> _serializerFunc{};

    template <typename SerializedT>
    inline static std::unordered_map<const AdcSerializingValueHolder*, std::function<void(const SerializedT&)>>
        _deserializerFunc{};

    // shadow base class's members
    std::function<void()> _clearFunc;
    std::function<void(AdcSerializingValueHolder*)> _copyFunc;
    std::function<void(AdcSerializingValueHolder*)> _moveFunc;

public:
    template <
        std::invocable<> GT,
        typename ValueT = ret_value_t<GT>,
        std::invocable<const ValueT&> ST,
        std::invocable<const ValueT&> SRT = decltype(utils::AdcDefaultValueConverter<>::serialize<std::string, ValueT>),
        typename SerializedT = ret_value_t<SRT>,
        std::invocable<const SerializedT&> DSRT =
            decltype(utils::AdcDefaultValueConverter<>::deserialize<ValueT, SerializedT>)>
    AdcSerializingValueHolder(GT&& getter,
                              ST&& setter,
                              SRT&& serializer = utils::AdcDefaultValueConverter<>::serialize<std::string, ValueT>,
                              DSRT&& deserializer = utils::AdcDefaultValueConverter<>::deserialize<ValueT, SerializedT>)
        : AdcValueHolder(std::forward<GT>(getter), std::forward<ST>(setter))
    {
        _serializerFunc<SerializedT>[this] = [wrapper = traits::adc_pf_wrapper(std::forward<SRT>(serializer)), this]() {
            auto& serializer = std::get<0>(wrapper);


            auto val = _getterFunc<ValueT>[this]();

            return serializer(val);
        };


        _deserializerFunc<SerializedT>[this] = [wrapper = traits::adc_pf_wrapper(std::forward<DSRT>(deserializer)),
                                                this](const SerializedT& sval) {
            auto& deserializer = std::get<0>(wrapper);

            ValueT val = deserializer(sval);

            _setterFunc<ValueT>[this](val);
        };

        _clearFunc = [this]() {
            _serializerFunc<SerializedT>.erase(this);
            _deserializerFunc<SerializedT>.erase(this);
        };

        _copyFunc = [this](AdcSerializingValueHolder* other) {
            _serializerFunc<SerializedT>.emplace(other, _serializerFunc<SerializedT>[this]);
            _deserializerFunc<SerializedT>.emplace(other, _deserializerFunc<SerializedT>[this]);
        };

        _moveFunc = [this](AdcSerializingValueHolder* other) {
            _serializerFunc<SerializedT>.emplace(other, std::move(_serializerFunc<SerializedT>[this]));
            _deserializerFunc<SerializedT>.emplace(other, std::move(_deserializerFunc<SerializedT>[this]));
        };
    }


    template <
        traits::adc_tuple_like<> TupleT,
        std::invocable<> GT,
        typename ValueT = ret_value_t<GT>,
        std::invocable<const ValueT&> ST,
        std::invocable<const ValueT&> SRT = decltype(utils::AdcDefaultValueConverter<>::serialize<std::string, ValueT>),
        typename SerializedT = ret_value_t<SRT>,
        std::invocable<const SerializedT&> DSRT =
            decltype(utils::AdcDefaultValueConverter<>::deserialize<ValueT, SerializedT>)>
    AdcSerializingValueHolder(TupleT&&,
                              GT&& getter,
                              ST&& setter,
                              SRT&& serializer = utils::AdcDefaultValueConverter<>::serialize<std::string, ValueT>,
                              DSRT&& deserializer = utils::AdcDefaultValueConverter<>::deserialize<ValueT, SerializedT>)
        : AdcSerializingValueHolder(std::forward<GT>(getter),
                                    std::forward<ST>(setter),
                                    std::forward<SRT>(serializer),
                                    std::forward<DSRT>(deserializer))
    {
        AdcValueHolder::setupTrivialConvertFunc<ValueT, std::decay_t<TupleT>>();
    }


    virtual ~AdcSerializingValueHolder() { _clearFunc(); };

    AdcSerializingValueHolder(const AdcSerializingValueHolder& other) : AdcValueHolder(other)
    {
        _clearFunc();

        _copyFunc(other);
    }


    AdcSerializingValueHolder(AdcSerializingValueHolder&& other) : AdcValueHolder(std::move(other))
    {
        _clearFunc();

        _moveFunc(other);
    }

    AdcSerializingValueHolder& operator=(const AdcSerializingValueHolder& other)
    {
        AdcValueHolder::operator=(other);
        _copyFunc(other);

        return *this;
    }

    AdcSerializingValueHolder& operator=(AdcSerializingValueHolder&& other)
    {
        AdcValueHolder::operator=(std::move(other));
        _moveFunc(other);

        return *this;
    }


    using AdcValueHolder::operator=;


    template <typename SerializedT>
    SerializedT serialize()
    {
        using s_t = std::decay_t<SerializedT>;

        auto& serializer = _serializerFunc<s_t>[this];

        if (serializer) {
            return serializer();
        }

        throw std::system_error(AdcSerializingValueHolderErrorCode::ERROR_INVALID_SERIALIZED_TYPE);
    }

    template <typename SerializedT>
    void deserialize(const SerializedT& sval)
    {
        using s_t = std::decay_t<SerializedT>;

        auto& deserializer = _deserializerFunc<s_t>[this];
        if (deserializer) {
            deserializer(sval);
        } else {
            throw std::system_error(AdcSerializingValueHolderErrorCode::ERROR_INVALID_SERIALIZED_TYPE);
        }
    }
};


/*
    factory functions

 */

template <typename HolderT, typename... Ts>
HolderT makeArithmValue(Ts&&... ctor_args)
{
    static_assert(std::is_same_v<HolderT, AdcValueHolder> || std::is_same_v<HolderT, AdcSerializingValueHolder>,
                  "Invalid value holder type!!!");

    return HolderT(AdcValueHolder::defaultTrivialConvTypes, std::forward<Ts>(ctor_args)...);
}

}  // namespace adc