#pragma once

#include <cstring>
#include "../common/adc_utils.h"
// #include "adc_netmsg.h"

namespace adc
{

/*  ABSTRACT DEVICE DEFAULT APPLICATION-LEVEL NETWORK PROTOCOL DEFINITIONS  */

namespace constants
{

static constexpr char ADC_DEFAULT_KEY_VALUE_DELIMITER1[] = " ";
static constexpr char ADC_DEFAULT_VALUE_DELIMITER[] = " ";
static constexpr char ADC_DEFAULT_COMPOSITE_VALUE_DELIMITER[] = ",";

}  // namespace constants



template <traits::adc_char_range ByteSeqT,
          const char KEY_VALUE_DELIM[] = constants::ADC_DEFAULT_KEY_VALUE_DELIMITER1,
          const char VALUE_DELIM[] = constants::ADC_DEFAULT_VALUE_DELIMITER,
          const char COMPOSITE_VALUE_DELIM[] = constants::ADC_DEFAULT_COMPOSITE_VALUE_DELIMITER>
class AdcKeyValueMessage
{
public:
    static constexpr size_t keyValueDelimiterSize = utils::AdcCharArrSize(KEY_VALUE_DELIM);
    static constexpr std::span keyValueDelimiter{KEY_VALUE_DELIM, keyValueDelimiterSize};

    static constexpr size_t valueDelimiterSize = utils::AdcCharArrSize(VALUE_DELIM);
    static constexpr std::span valueDelimiter{VALUE_DELIM, valueDelimiterSize};

    static constexpr size_t compValueDelimiterSize = utils::AdcCharArrSize(COMPOSITE_VALUE_DELIM);
    static constexpr std::span compValueDelimiter{COMPOSITE_VALUE_DELIM, compValueDelimiterSize};

    static_assert(keyValueDelimiterSize && valueDelimiterSize && compValueDelimiterSize,
                  "KEY-VALUE, VALUE-PARTS AND COMPOSITE-VALUE DELIMITERS MUST NOT BE AN EMPTY ARRAY!!!");

    AdcKeyValueMessage(ByteSeqT& byte_seq) : _byteSequence(byte_seq) {}

    virtual ~AdcKeyValueMessage() = default;


    bool empty() const
    {
        return std::ranges::size(_byteSequence) == 0;
    }


    size_t size() const
    {
        return std::ranges::size(_byteSequence);
    }

    template <typename T>
        requires(traits::adc_char_view<T> && std::ranges::contiguous_range<ByteSeqT>) ||
                traits::adc_output_char_range<T>
    auto key() const
    {
        if constexpr (traits::adc_char_view<T> && std::ranges::contiguous_range<ByteSeqT>) {
            auto bs = utils::AdcTrimSpacesView<T>(_byteSequence, utils::AdcTrimType::TRIM_LEFT);
            auto found = std::ranges::search(bs, keyValueDelimiter);

            if (found.empty()) {  // no value
                return bs;
            }

            return utils::AdcTrimSpacesView<T>(std::span<const char>(bs.begin(), found.begin()),
                                               utils::AdcTrimType::TRIM_RIGHT);
        } else {
            T res;

            auto bs = _byteSequence | std::views::drop_while([](const auto& ch) { return ch = ' '; });

            auto found = std::ranges::search(bs, keyValueDelimiter);
            std::ranges::copy(bs.begin(), found.begin(), std::back_inserter(res));
            // if (found.empty()) {  // no value
            //     std::ranges::copy(bs, std::back_inserter(res));
            // } else {
            //     std::ranges::copy(bs.begin(), found.begin(), std::back_inserter(res));
            // }

            return res;
        }
    }


    auto key() const
    {
        if constexpr (std::ranges::contiguous_range<ByteSeqT>) {
            return key<std::string_view>();
        } else {
            return key<std::string>();
        }
    }


    template <typename T>
        requires(traits::adc_char_view<T> && std::ranges::contiguous_range<ByteSeqT>) ||
                traits::adc_output_char_range<T>
    auto value() const
    {
        if constexpr (traits::adc_char_view<T> && std::ranges::contiguous_range<ByteSeqT>) {
            auto bs = utils::AdcTrimSpacesView<T>(_byteSequence, utils::AdcTrimType::TRIM_LEFT);

            auto found = std::ranges::search(bs, keyValueDelimiter);
            return T(found.end(), bs.end());
        } else {
            T res;

            auto bs = _byteSequence | std::views::drop_while([](const auto& ch) { return ch == ' '; });

            auto found = std::ranges::search(bs, keyValueDelimiter);
            if (!found.empty()) {
                std::ranges::copy(found.end(), bs.end(), std::back_inserter(res));
            }

            return res;
        }
    }

    auto value() const
    {
        if constexpr (std::ranges::contiguous_range<ByteSeqT>) {
            return value<std::string_view>();
        } else {
            return value<std::string>();
        }
    }


    template <typename T>
        requires(std::ranges::contiguous_range<ByteSeqT> && traits::adc_char_view<std::ranges::range_value_t<T>>) ||
                traits::adc_range_of_output_char_range<T>
    auto valueParts(size_t start = 0, size_t N = std::numeric_limits<size_t>::max()) const
    {
        auto val = value<std::ranges::range_value_t<T>>();

        return utils::AdcSplitCharRange<T>(val, valueDelimiter, start, N);
    }

    auto valueParts(size_t start = 0, size_t N = std::numeric_limits<size_t>::max()) const
    {
        if constexpr (std::ranges::contiguous_range<ByteSeqT>) {
            return valueParts<std::vector<std::string_view>>(start, N);
        } else {
            return valueParts<std::vector<std::string>>(start, N);
        }
    }


    template <typename T>
        requires traits::adc_output_char_range<T> || traits::adc_char_view<T>
    auto joinValueParts(size_t start = 0, size_t N = std::numeric_limits<size_t>::max()) const
    {
        T res;

        if constexpr (std::ranges::contiguous_range<ByteSeqT>) {
            // auto pp = valueParts<std::vector<std::span<const char>>>(start, N);
            auto pp = valueParts<std::vector<std::span<char>>>(start, N);
            if (pp.size()) {
                // res = T{pp.front().begin(), pp.back().end()};
                res = T(pp.front().begin(), pp.back().end());
            }
        } else {
            utils::AdcJoinRange(valueParts<std::vector<std::vector<const char>>>(start, N), valueDelimiter, res);
        }

        return res;
    }


    auto joinValueParts(size_t start = 0, size_t N = std::numeric_limits<size_t>::max()) const
    {
        if constexpr (std::ranges::contiguous_range<ByteSeqT>) {
            return joinValueParts<std::string_view>(start, N);
        } else {
            return joinValueParts<std::string>(start, N);
        }
    }

    template <typename KeyT>
        requires traits::adc_output_char_range<ByteSeqT>
    AdcKeyValueMessage& setKey(const KeyT& key)
    {
        if (std::ranges::size(_byteSequence)) {
            _byteSequence = ByteSeqT();
        }

        std::ranges::copy(utils::AdcDefaultValueConverter<COMPOSITE_VALUE_DELIM>::template serialize<ByteSeqT>(key),
                          std::back_inserter(_byteSequence));

        return *this;
    }

    template <typename KeyT, typename... ValuePartTs>
        requires traits::adc_output_char_range<ByteSeqT>
    AdcKeyValueMessage& setKeyValue(const KeyT& key, ValuePartTs&&... values)
    {
        setKey(key);

        if constexpr (sizeof...(ValuePartTs)) {
            std::ranges::copy(keyValueDelimiter, std::back_inserter(_byteSequence));
            setValueHelper(std::forward<ValuePartTs>(values)...);
        }

        return *this;
    }


    template <typename KeyT, std::ranges::input_range ValuePartRangeT>
        requires traits::adc_output_char_range<ByteSeqT>
    AdcKeyValueMessage& setKeyValue(const KeyT& key, const ValuePartRangeT& values)
    {
        setKey(key);

        for (auto const& el : values) {
            std::ranges::copy(keyValueDelimiter, std::back_inserter(_byteSequence));
            setValueHelper(el);
        }

        return *this;
    }


    template <typename KeyT, traits::adc_tuple_like ValuePartTupleT>
        requires traits::adc_output_char_range<ByteSeqT>
    AdcKeyValueMessage& setKeyValue(const KeyT& key, const ValuePartTupleT& values)
    {
        setKey(key);

        if constexpr (std::tuple_size_v<ValuePartTupleT>) {
            std::apply([this]<typename... Ts>(Ts&&... args) { setValueHelper(std::forward<Ts>(args)...); }, values);
        }

        return *this;
    }


    template <typename... ValuePartTs>
        requires traits::adc_output_char_range<ByteSeqT>
    AdcKeyValueMessage& setValue(ValuePartTs&&... values)
    {
        std::vector<char> kw;
        std::ranges::copy(key<std::span<const char>>(), std::back_inserter(kw));

        return setKeyValue(kw, std::forward<ValuePartTs>(values)...);
    }


    template <typename KeyT, std::ranges::input_range ValuePartRangeT>
        requires traits::adc_output_char_range<ByteSeqT> &&
                 (!traits::adc_input_char_range<std::ranges::range_value_t<ValuePartRangeT>>)
    AdcKeyValueMessage& setValue(const ValuePartRangeT& values)
    {
        std::vector<char> kw;
        std::ranges::copy(key<std::span<const char>>(), std::back_inserter(kw));

        return setKeyValue(kw, values);
    }

    template <typename KeyT, traits::adc_tuple_like ValuePartTupleT>
        requires traits::adc_output_char_range<ByteSeqT>
    AdcKeyValueMessage& setValue(const ValuePartTupleT& values)
    {
        std::vector<char> kw;
        std::ranges::copy(key<std::span<const char>>(), std::back_inserter(kw));

        return setKeyValue(kw, values);
    }


protected:
    ByteSeqT& _byteSequence;

    template <typename ValuePartT, typename... ValuePartTs>
    void setValueHelper(ValuePartT&& value, ValuePartTs&&... values)
    {
        std::ranges::copy(utils::AdcDefaultValueConverter<COMPOSITE_VALUE_DELIM>::template serialize<ByteSeqT>(
                              std::forward<ValuePartT>(value)),
                          std::back_inserter(_byteSequence));

        if constexpr (sizeof...(ValuePartTs)) {
            std::ranges::copy(valueDelimiter, std::back_inserter(_byteSequence));
            setValueHelper(std::forward<ValuePartTs>(values)...);
        }
    }
};


template <traits::adc_char_range ByteSeqT,
          const char KEY_VALUE_DELIM[] = constants::ADC_DEFAULT_KEY_VALUE_DELIMITER1,
          const char VALUE_DELIM[] = constants::ADC_DEFAULT_VALUE_DELIMITER,
          const char COMPOSITE_VALUE_DELIM[] = constants::ADC_DEFAULT_COMPOSITE_VALUE_DELIMITER>
class AdcDeviceProtoMessage
    : protected AdcKeyValueMessage<ByteSeqT, KEY_VALUE_DELIM, VALUE_DELIM, COMPOSITE_VALUE_DELIM>
{
    using base_t = AdcKeyValueMessage<ByteSeqT, KEY_VALUE_DELIM, VALUE_DELIM, COMPOSITE_VALUE_DELIM>;

public:
    static constexpr std::string_view ACK_KEY{"ACK"};
    static constexpr std::string_view SET_KEY{"SET"};
    static constexpr std::string_view GET_KEY{"GET"};
    static constexpr std::string_view CMD_KEY{"CMD"};
    static constexpr std::string_view ERR_KEY{"ERR"};
    static constexpr std::string_view HELLO_KEY{"HELLO"};
    static constexpr std::string_view DEVICE_KEY{"DEVICE"};
    static constexpr std::string_view NAMES_KEY{"NAMES"};

    static constexpr std::array VALID_KEY{ACK_KEY, SET_KEY,   GET_KEY,    CMD_KEY,
                                          ERR_KEY, HELLO_KEY, DEVICE_KEY, NAMES_KEY};


    typedef std::array<size_t, VALID_KEY.size()> keyword_hash_array_t;

    enum KEY_IDX : size_t {
        ACK_KEY_IDX,
        SET_KEY_IDX,
        GET_KEY_IDX,
        CMD_KEY_IDX,
        ERR_KEY_IDX,
        HELLO_KEY_IDX,
        DEVICE_KEY_IDX,
        NAMES_KEY_IDX
    };

private:  // include here to allow clang compilation
    size_t _keyHash = 0;

    template <size_t... I>
    static constexpr auto computeKeywordHashesImpl(std::index_sequence<I...>)
    {
        return keyword_hash_array_t{utils::AdcFNV1aHash(VALID_KEY[I])...};
    }
    template <typename Indices = std::make_index_sequence<VALID_KEY.size()>>
    static constexpr auto computeKeywordHashes()
    {
        return computeKeywordHashesImpl(Indices{});
    }

    static constexpr keyword_hash_array_t KEY_HASHES = computeKeywordHashes();

    auto keyHash()
    {
        return _keyHash = utils::AdcFNV1aHash(key());
    }

    bool isKey(size_t idx) const
    {
        return _keyHash == KEY_HASHES[idx];
    }

public:
    AdcDeviceProtoMessage(ByteSeqT& byte_seq) : base_t(byte_seq)
    {
        keyHash();
    }

    bool isValid() const
    {
        return std::ranges::any_of(KEY_HASHES, [this](size_t h) { return _keyHash == h; });
    }

    bool isACK() const
    {
        return isKey(ACK_KEY_IDX);
    }

    bool isSET() const
    {
        return isKey(SET_KEY_IDX);
    }

    bool isGET() const
    {
        return isKey(GET_KEY_IDX);
    }

    bool isCMD() const
    {
        return isKey(CMD_KEY_IDX);
    }

    bool isERR() const
    {
        return isKey(ERR_KEY_IDX);
    }

    bool isHELLO() const
    {
        return isKey(HELLO_KEY_IDX);
    }

    bool isDEVICE() const
    {
        return isKey(DEVICE_KEY_IDX);
    }

    bool isNAMES() const
    {
        return isKey(NAMES_KEY_IDX);
    }


    template <typename T>
    auto key() const
    {
        return base_t::template key<T>();
    }

    auto key() const
    {
        return base_t::key();
    }

    template <typename T>
    auto attrs(size_t start = 0, size_t N = std::numeric_limits<size_t>::max()) const
    {
        return base_t::template valueParts<T>(start, N);
    }

    auto attrs(size_t start = 0, size_t N = std::numeric_limits<size_t>::max()) const
    {
        return base_t::valueParts(start, N);
    }


    template <typename T>
    auto joinAttrs(size_t start = 0, size_t N = std::numeric_limits<size_t>::max()) const
    {
        return base_t::template joinValueParts<T>(start, N);
    }


    auto joinAttrs(size_t start = 0, size_t N = std::numeric_limits<size_t>::max()) const
    {
        return base_t::joinValueParts(start, N);
    }


    void ack()
    {
        base_t::setKey(ACK_KEY);

        keyHash();
    }


    template <typename ParT, typename... ParTs>
    void ack(const ParT& param, const ParTs&... params)
    {
        base_t::setKeyValue(ACK_KEY, param, params...);

        keyHash();
    }


    template <std::ranges::range ParT>
    // requires(!traits::adc_input_char_range<std::ranges::range_value_t<ParT>>)
        requires(!traits::adc_input_char_range<ParT>)
    void ack(const ParT& param)
    {
        base_t::setKeyValue(ACK_KEY, param);

        keyHash();
    }


    template <traits::adc_tuple_like ParT>
    void ack(const ParT& param)
    {
        base_t::setKeyValue(ACK_KEY, param);

        keyHash();
    }


    template <traits::adc_input_char_range AttrNameT, typename ValueT, typename... ValueTs>
    void set(AttrNameT&& attr_name, ValueT&& value, ValueTs&&... values)
    {
        base_t::setKeyValue(SET_KEY, std::forward<AttrNameT>(attr_name), std::forward<ValueT>(value),
                            std::forward<ValueTs>(values)...);

        keyHash();
    }

    template <traits::adc_input_char_range AttrNameT>
    void get(AttrNameT&& attr_name)
    {
        base_t::setKeyValue(GET_KEY, std::forward<AttrNameT>(attr_name));

        keyHash();
    }

    template <traits::adc_input_char_range CmdNameT>
    void cmd(CmdNameT&& cmd_name)
    {
        base_t::setKeyValue(CMD_KEY, std::forward<CmdNameT>(cmd_name));

        keyHash();
    }

    void err(const std::error_code& ec)
    {
        base_t::setKeyValue(ERR_KEY, ec.value(), ec.category().name(), ec.message());

        keyHash();
    }

    template <traits::adc_input_char_range SenderNameT, typename... ParamTs>
    void hello(SenderNameT&& name, ParamTs&&... params)
    {
        base_t::setKeyValue(HELLO_KEY, std::forward<SenderNameT>(name), std::forward<ParamTs>(params)...);

        keyHash();
    }

    template <traits::adc_input_char_range DevNameT>
    void device(DevNameT&& dev_name)
    {
        base_t::setKeyValue(DEVICE_KEY, std::forward<DevNameT>(dev_name));

        keyHash();
    }

    void names()
    {
        base_t::setKey(NAMES_KEY);

        keyHash();
    }

    template <typename DevNameT, typename... DevNameTs>
    void names(const DevNameT& dev_name, const DevNameTs&... dev_names)
    {
        base_t::setKeyValue(NAMES_KEY, dev_name, dev_names...);

        keyHash();
    }

    template <std::ranges::input_range R>
        requires(!traits::adc_input_char_range<std::ranges::range_value_t<R>>)
    void names(const R& dev_names)
    {
        base_t::setKeyValue(NAMES_KEY, dev_names);

        keyHash();
    }

    template <traits::adc_tuple_like T>
    void names(const T& dev_names)
    {
        base_t::setKeyValue(NAMES_KEY, dev_names);

        keyHash();
    }
};



}  // namespace adc