#pragma once

/*

 ABSTRACT DEVICE COMPONENTS LIBRARY

 */


#include "../common/adc_value.h"


namespace adc
{

template <typename IdentT, typename SerializedT = std::string>
class AdcDeviceAttribute : public AdcSerializingValueHolder<SerializedT>
{
    using base_t = AdcSerializingValueHolder<SerializedT>;

    template <typename T>
    using ret_value_t = base_t::template ret_value_t<T>;

public:
    typedef IdentT ident_t;
    typedef SerializedT serialized_t;

    enum AccessType { ReadOnly, WriteOnly, ReadWrite };

    template <typename T>
    constexpr static T DummyGetter()
    {
        return T();
    }


    template <typename T>
    constexpr static void DummySetter(const T&)
    {
    }

    template <typename T>
    constexpr static SerializedT DummySerializer(const T&)
    {
        return SerializedT();
    }

    template <typename T>
    constexpr static T DummyDeserializer(const SerializedT&)
    {
        return T();
    }


    /*  CONSTRUCTORS AND DESTRUCTOR  */

    // general read-write attribute constructor
    template <typename... SerValHolderTs>
    AdcDeviceAttribute(const IdentT& ident, SerValHolderTs&&... ctor_args)
        : base_t(std::forward<SerValHolderTs>(ctor_args)...), _ident(ident), _accessType(ReadWrite)
    {
    }


    // read-only attribute constructor
    template <typename GT,
              typename VALT = ret_value_t<GT>,
              typename SRT = decltype(utils::AdcDefaultValueConverter<>::serialize<SerializedT, VALT>)>
    AdcDeviceAttribute(const IdentT& ident,
                       GT&& getter,
                       SRT&& serializer = utils::AdcDefaultValueConverter<>::serialize<SerializedT, VALT>)
        requires std::invocable<GT> && std::invocable<SRT, const VALT&>
        : AdcDeviceAttribute(ident,
                             std::forward<GT>(getter),
                             AdcDeviceAttribute::DummySetter<VALT>,
                             AdcValueHolder::AdcValueHolderDummyValidator<VALT>,
                             std::forward<SRT>(serializer),
                             AdcDeviceAttribute::DummyDeserializer<VALT>)
    {
        _accessType = ReadOnly;
    }


    template <typename GT,
              typename VALT = ret_value_t<GT>,
              typename SRT = decltype(utils::AdcDefaultValueConverter<>::serialize<SerializedT, VALT>)>
    AdcDeviceAttribute(const IdentT& ident,
                       traits::adc_tuple_like<> auto&& tpl,
                       GT&& getter,
                       SRT&& serializer = utils::AdcDefaultValueConverter<>::serialize<SerializedT, VALT>)
        requires std::invocable<GT> && std::invocable<SRT, const VALT&>
        : AdcDeviceAttribute(ident,
                             std::forward<decltype(tpl)>(tpl),
                             std::forward<GT>(getter),
                             AdcDeviceAttribute::DummySetter<VALT>,
                             AdcValueHolder::AdcValueHolderDummyValidator<VALT>,
                             std::forward<SRT>(serializer),
                             AdcDeviceAttribute::DummyDeserializer<VALT>)
    {
        _accessType = ReadOnly;
    }


    // write-only attribute constructor
    template <typename ST,
              typename VALT = std::decay_t<traits::adc_func_arg1_t<ST>>,
              typename DSRT = decltype(utils::AdcDefaultValueConverter<>::deserialize<VALT, SerializedT>)>
    AdcDeviceAttribute(const IdentT& ident,
                       ST&& setter,
                       std::predicate<const VALT&> auto&& validator,
                       DSRT&& deserializer = utils::AdcDefaultValueConverter<>::deserialize<VALT, SerializedT>)
        requires std::invocable<DSRT, const SerializedT&>
        : AdcDeviceAttribute(ident,
                             AdcDeviceAttribute::DummyGetter<VALT>,
                             std::forward<ST>(setter),
                             std::forward<decltype(validator)>(validator),
                             AdcDeviceAttribute::DummySerializer<VALT>,
                             std::forward<DSRT>(deserializer))
    {
        _accessType = WriteOnly;
    }


    template <typename ST,
              typename VALT = std::decay_t<traits::adc_func_arg1_t<ST>>,
              typename DSRT = decltype(utils::AdcDefaultValueConverter<>::deserialize<VALT, SerializedT>)>
    AdcDeviceAttribute(const IdentT& ident,
                       traits::adc_tuple_like<> auto&& tpl,
                       ST&& setter,
                       std::predicate<const VALT&> auto&& validator,
                       DSRT&& deserializer = utils::AdcDefaultValueConverter<>::deserialize<VALT, SerializedT>)
        requires std::invocable<DSRT, const SerializedT&>
        : AdcDeviceAttribute(ident,
                             std::forward<decltype(tpl)>(tpl),
                             AdcDeviceAttribute::DummyGetter<VALT>,
                             std::forward<ST>(setter),
                             std::forward<decltype(validator)>(validator),
                             AdcDeviceAttribute::DummySerializer<VALT>,
                             std::forward<DSRT>(deserializer))
    {
        _accessType = WriteOnly;
    }



    virtual ~AdcDeviceAttribute() = default;

    IdentT ident() const { return _ident; }

    AccessType accessType() const { return _accessType; }

    using base_t::operator=;

protected:
    IdentT _ident;
    AccessType _accessType;
};

}  // namespace adc