#pragma once

/*

 ABSTRACT DEVICE COMPONENTS LIBRARY

 */


#include <functional>
#include <system_error>

#include "adc_traits.h"

namespace adc
{

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

}  // namespace adc


namespace std
{

template <>
class is_error_code_enum<adc::AdcValueHolderErrorCode> : 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 "DEVA_DEVICE_ATTRIBUTE"; }

    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)";
            case AdcValueHolderErrorCode::ERROR_VALUE_IS_NOT_VALID:
                return "user value is not valid";
            default:
                return "UNKNOWN";
        }
    }

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


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



/*

                         GENERAL-PURPOSE VALUE HOLDER CLASS WITH OPTIONAL VALIDATOR

 */


class AdcValueHolder
{
protected:
    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{};

    void init(std::invocable<> auto&& getter,
              std::invocable<const traits::adc_retval_t<decltype(getter)>&> auto&& setter,
              std::predicate<const traits::adc_retval_t<decltype(getter)>&> auto&& validator)
    {
        using value_t = traits::adc_retval_t<decltype(getter)>;

        static_assert(!std::is_same_v<value_t, void>, "THE getter MUST NOT RETURN void TYPE!!!");

        using g_t = decltype(getter);
        using s_t = decltype(setter);
        using vld_t = decltype(validator);

        _getterFunc<value_t>[this] = [wrapper = traits::adc_pf_wrapper(std::forward<g_t>(getter))]() {
            return std::get<0>(wrapper)();
        };


        _setterFunc<value_t>[this] = [wrapper =
                                          traits::adc_pf_wrapper(std::forward<s_t>(setter),
                                                                 std::forward<vld_t>(validator))](const value_t& val) {
            if (std::get<1>(wrapper)(val)) {
                std::get<0>(wrapper)(val);
            } else {
                throw std::system_error(AdcValueHolderErrorCode::ERROR_VALUE_IS_NOT_VALID);
            }
        };
    }

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{};

    // always-true validator
    // constexpr static auto AdcValueHolderDummyValidator = [](const auto&) { return true; };
    template <typename VT>
    constexpr static bool AdcValueHolderDummyValidator(const VT&)
    {
        return true;
    };

    /*  CONSTRUCTORS AND DESTRUCTOR  */

    template <typename GT,
              typename VALT = traits::adc_retval_t<GT>,
              typename VT = decltype(AdcValueHolder::AdcValueHolderDummyValidator<VALT>)>
    AdcValueHolder(GT&& getter,
                   std::invocable<const VALT&> auto&& setter,
                   VT&& validator = AdcValueHolder::AdcValueHolderDummyValidator<VALT>)
        requires std::invocable<GT> && std::predicate<VT, const VALT&>
    {
        init(std::forward<GT>(getter), std::forward<decltype(setter)>(setter),
             std::forward<decltype(validator)>(validator));
    }


    template <typename... Ts>
    AdcValueHolder(std::invocable<> auto&& getter,
                   std::invocable<const traits::adc_retval_t<decltype(getter)>&> auto&& setter,
                   std::predicate<const traits::adc_retval_t<decltype(getter)>&> auto&& validator,
                   const std::tuple<Ts...>& /* tuple-of-trivially-converting-types */)
        : AdcValueHolder(std::forward<decltype(getter)>(getter),
                         std::forward<decltype(setter)>(setter),
                         std::forward<decltype(validator)>(validator))
    {
        // setup trivially-defined conversion function
        AdcValueHolder::setupTrivialConvertFunc<traits::adc_retval_t<decltype(getter)>, std::tuple<Ts...>>();
    }


    template <typename... Ts>
    AdcValueHolder(std::invocable<> auto&& getter,
                   std::invocable<const traits::adc_retval_t<decltype(getter)>&> auto&& setter,
                   const std::tuple<Ts...>& t /* tuple-of-trivially-converting-types */)
        : AdcValueHolder(std::forward<decltype(getter)>(getter),
                         std::forward<decltype(setter)>(setter),
                         AdcValueHolder::AdcValueHolderDummyValidator<traits::adc_retval_t<decltype(getter)>>,
                         t)
    {
    }


    AdcValueHolder(const AdcValueHolder&) = default;
    AdcValueHolder(AdcValueHolder&&) = default;

    virtual ~AdcValueHolder() = default;


    /*  PUBLIC METHODS  */


    template <typename GT,
              typename VALT = traits::adc_retval_t<GT>,
              typename VT = decltype(AdcValueHolder::AdcValueHolderDummyValidator<VALT>)>
    AdcValueHolder& resetValueHolder(GT&& getter,
                                     std::invocable<const VALT&> auto&& setter,
                                     VT&& validator = AdcValueHolder::AdcValueHolderDummyValidator<VALT>)
        requires std::invocable<GT> && std::predicate<VT, const VALT&>
    {
        init(std::forward<decltype(getter)>(getter), std::forward<decltype(setter)>(setter),
             std::forward<decltype(validator)>(validator));

        return *this;
    }


    template <typename... Ts>
    AdcValueHolder& resetValueHolder(std::invocable<> auto&& getter,
                                     std::invocable<const traits::adc_retval_t<decltype(getter)>&> auto&& setter,
                                     std::predicate<const traits::adc_retval_t<decltype(getter)>&> auto&& validator,
                                     const std::tuple<Ts...>& /* tuple-of-trivially-converting-types */)
    {
        resetValueHolder(std::forward<decltype(getter)>(getter), std::forward<decltype(setter)>(setter),
                         std::forward<decltype(validator)>(validator));

        // setup trivially-defined conversion function
        AdcValueHolder::setupTrivialConvertFunc<traits::adc_retval_t<decltype(getter)>, std::tuple<Ts...>>();

        return *this;
    }


    template <typename... Ts>
    AdcValueHolder& resetValueHolder(std::invocable<> auto&& getter,
                                     std::invocable<const traits::adc_retval_t<decltype(getter)>&> auto&& setter,
                                     const std::tuple<Ts...>& t /* tuple-of-trivially-converting-types */)
    {
        return resetValueHolder(std::forward<decltype(getter)>(getter), std::forward<decltype(setter)>(setter),
                                AdcValueHolder::AdcValueHolderDummyValidator<traits::adc_retval_t<decltype(getter)>>,
                                t);
    }


    template <typename FromFuncT, typename ToFuncT>
    AdcValueHolder& addConvertFunc(FromFuncT&& func_from_internal, ToFuncT&& func_to_internal)
        requires std::invocable<FromFuncT, std::remove_cvref_t<traits::adc_retval_t<ToFuncT>>> &&
                 std::invocable<ToFuncT, std::remove_cvref_t<traits::adc_retval_t<FromFuncT>>>
    {
        using from_sig_t = typename traits::adc_func_traits<FromFuncT>;
        using to_sig_t = typename traits::adc_func_traits<ToFuncT>;
        // using value_t = typename to_sig_t::ret_t;  // internal value type
        using value_t = std::remove_cv_t<typename to_sig_t::ret_t>;  // internal value type
        // using user_t = typename from_sig_t::ret_t;
        using user_t = std::remove_cv_t<typename from_sig_t::ret_t>;

        // static_assert(!std::is_same_v<value_t, void>, "void IS NOT VALID TYPE!!!");

        // static_assert(!std::is_void_v<typename traits::adc_func_traits<FromFuncT>::arg1_t>,
        //               "INVALID CONVERSIONAL FUNCTION!!!");

        // static_assert(std::is_same_v<std::remove_cvref_t<typename traits::adc_func_traits<FromFuncT>::arg1_t>,
        // value_t>,
        //               "INVALID CONVERSIONAL FUNCTION!!!");

        _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);
            }
        };

        return *this;
    }


    template <typename UT>
    operator UT()
    {
        using v_t = std::remove_reference_t<UT>;
        using val_t = std::conditional_t<std::is_array_v<v_t>, std::add_pointer_t<std::remove_extent_t<v_t>>, v_t>;

        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 v_t = std::remove_reference_t<UT>;
        // using v_t = std::remove_cvref_t<UT>;
        // using val_t = std::conditional_t<std::is_array_v<v_t>, std::add_pointer_t<std::remove_extent_t<v_t>>, v_t>;
        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) = default;
    AdcValueHolder& operator=(const AdcValueHolder& other) = default;


protected:
    /*  STATIC HELPER METHODS   */

    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); });
            }

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

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


/*
    factory functions

 */

template <typename GT,
          typename VALT = traits::adc_retval_t<GT>,
          typename VT = decltype(AdcValueHolder::AdcValueHolderDummyValidator<VALT>)>
AdcValueHolder make_arith_valueholder(GT&& getter,
                                      std::invocable<const VALT&> auto&& setter,
                                      VT&& validator = AdcValueHolder::AdcValueHolderDummyValidator<VALT>)
    requires std::invocable<GT> && std::predicate<VT, const VALT&>
{
    using val_t = traits::adc_retval_t<GT>;

    // static_assert(std::predicate<decltype(validator), const traits::adc_retval_t<decltype(getter)>&>,
    //               "INVALID VALIDATOR TYPE!!!");

    static_assert(std::is_arithmetic_v<val_t>, "GETTER MUST RETURN AN ARITHMETIC TYPE VALUE!!!");

    return AdcValueHolder(std::forward<GT>(getter), std::forward<decltype(setter)>(setter),
                          std::forward<decltype(validator)>(validator), AdcValueHolder::_defaultTrivialConvTypes);
}


/*  */

template <typename SerializedT = std::string>
class AdcSerializingValueHolder : public AdcValueHolder
{
protected:
    std::function<SerializedT()> _serializerWrapper = []() {

    };

    std::function<void(const SerializedT&)> _deserializerWrapper;

    template <typename GT, typename ST, typename VT, typename SRT, typename DSRT>
    void init(GT&& getter, ST&& setter, VT&& validator, SRT&& serializer, DSRT&& deserializer)
    {
        _serializerWrapper = [wrapper =
                                  traits::adc_pf_wrapper(std::forward<GT>(getter), std::forward<SRT>(serializer))]() {
            auto& getter = std::get<0>(wrapper);
            auto& serializer = std::get<1>(wrapper);

            auto val = getter();
            return serializer(val);
        };


        using v_t = traits::adc_retval_t<GT>;

        _serializerWrapper = [wrapper =
                                  traits::adc_pf_wrapper(std::forward<ST>(setter), std::forward<VT>(validator),
                                                         std::forward<DSRT>(deserializer))](const SerializedT& sval) {
            auto& setter = std::get<0>(wrapper);
            auto& validator = std::get<1>(wrapper);
            auto& deserializer = std::get<2>(wrapper);

            v_t val = deserializer(sval);

            if (validator(val)) {
                setter(val);
            } else {
                throw std::system_error(AdcValueHolderErrorCode::ERROR_VALUE_IS_NOT_VALID);
            }
        };
    }

public:
    using AdcValueHolder::AdcValueHolder;

    virtual ~AdcSerializingValueHolder() = default;
};


}  // namespace adc