#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 std::declval<T>();
    }


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

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

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


    /*  CONSTRUCTORS AND DESTRUCTOR  */

    // general read-write attribute constructor
    template <typename GT,
              typename ST,
              typename VALT = ret_value_t<GT>,
              typename VT = decltype(AdcValueHolder::AdcValueHolderDummyValidator<VALT>),
              typename SRT = decltype(utils::AdcDefaultValueConverter<>::serialize<SerializedT, VALT>),
              typename DSRT = decltype(utils::AdcDefaultValueConverter<>::deserialize<VALT, SerializedT>)>
    AdcDeviceAttribute(const IdentT& ident,
                       AccessType access_type,
                       GT&& getter,
                       ST&& setter,
                       VT&& validator = AdcValueHolder::AdcValueHolderDummyValidator<VALT>,
                       SRT&& serializer = utils::AdcDefaultValueConverter<>::serialize<SerializedT, VALT>,
                       DSRT&& deserializer = utils::AdcDefaultValueConverter<>::deserialize<VALT, SerializedT>)
        requires std::invocable<GT> && std::invocable<ST, const VALT&> && std::predicate<VT, const VALT&> &&
                     std::invocable<SRT, const VALT&> && std::invocable<DSRT, const SerializedT&>
        : base_t(std::forward<GT>(getter),
                 std::forward<ST>(setter),
                 std::forward<VT>(validator),
                 std::forward<SRT>(serializer),
                 std::forward<DSRT>(deserializer)),
          _ident(ident),
          _accessType(access_type)
    {
    }


    // 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,
                             ReadOnly,
                             std::forward<GT>(getter),
                             AdcDeviceAttribute::DummySetter<VALT>,
                             AdcValueHolder::AdcValueHolderDummyValidator<VALT>,
                             std::forward<SRT>(serializer),
                             AdcDeviceAttribute::DummyDeserializer<VALT>)
    {
    }


    // 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,
                             WriteOnly,
                             AdcDeviceAttribute::DummyGetter<VALT>,
                             std::forward<ST>(setter),
                             std::forward<decltype(validator)>(validator),
                             AdcDeviceAttribute::DummySerializer<VALT>,
                             std::forward<DSRT>(deserializer))
    {
    }


    // constructor of attribute with trivially casting type converters
    template <typename... TrivCastTs, typename... Ts>
    AdcDeviceAttribute(const std::tuple<TrivCastTs...>&, Ts&&... ctor_args)
        : AdcDeviceAttribute(std::forward<Ts>(ctor_args)...)
    {
    }

    virtual ~AdcDeviceAttribute() = default;

    IdentT ident() const { return _ident; }

    AccessType accessType() const { return _accessType; }

    using base_t::operator=;

protected:
    IdentT _ident;
    AccessType _accessType;
};

}  // namespace adc