#pragma once

#include <algorithm>
#include <ranges>
#include <vector>

#include "../common/adc_traits.h"


/*

ABSTRACT DEVICE COMPONENTS LIBRARY

 */



/*  GENERIC NETWORK MESSAGE CLASS   */

namespace adc
{


namespace traits
{

template <typename T>
concept adc_output_range_of_char_range_c = requires {
    requires std::ranges::output_range<T, std::ranges::range_value_t<T>>;
    requires std::ranges::output_range<std::ranges::range_value_t<T>, char>;
};


}  // namespace traits


namespace utils
{

template <traits::adc_output_range_of_char_range_c OutR,
          traits::adc_input_char_range InR,
          traits::adc_input_char_range DelimT = std::string_view>
size_t AdcSplitCharRangeToTokens(OutR& result, const InR& input, const DelimT& delim = std::string_view(" "))
{
    decltype(std::ranges::split_view(input, delim)) vv;

    if constexpr (std::is_array_v<DelimT>) {
        vv = input | std::views::split(std::string_view(delim));
    } else {
        vv = input | std::views::split(delim);
    }

    std::ranges::transform(vv, std::back_inserter(result),
                           [](const auto& el) { return std::string(el.begin(), el.end()); });

    // return number of tokens
    return std::ranges::distance(vv.begin(), vv.end());
}

}  // namespace utils


class AdcNetMessageInterface
{
public:
    typedef std::vector<std::string_view> output_seq_t;

    bool messageEmpty() const { return _outputSequence.empty(); }

    template <typename T, typename... Ts>
    void appendBytes(const T& v, const Ts&... vs)
    {
        if constexpr (std::is_array_v<std::remove_cvref_t<T>>) {  // to handle with trailing '\0' in plain char array
            appendBytes(std::string_view(v), vs...);
        } else {
            if constexpr (traits::adc_input_char_range<T>) {
                std::ranges::copy(v, std::back_inserter(_storageSequence.emplace_back()));
            } else if constexpr (traits::formattable<T>) {
                std::format_to(std::back_inserter(_storageSequence.emplace_back()), "{}", v);
            } else {
                static_assert(false, "UNSUPPORTED TYPE!!!");
            }
            updateState();
        }

        if constexpr (sizeof...(Ts)) {
            appendBytes(vs...);
        }
    }


    template <typename T, typename... Ts>
    void setBytes(const T& v, const Ts&... vs)
    {
        _storageSequence.clear();
        _outputSequence.clear();

        appendBytes(v, vs...);
    }



    template <std::input_iterator IterT>
    void appendBytes(IterT begin, IterT end)
    {
        static_assert(std::is_same_v<std::iter_value_t<IterT>, char>, "INVALID ITERATOR VALUE TYPE!!!");

        std::ranges::copy(begin, end, std::back_inserter(_storageSequence.emplace_back()));

        updateState();
    }


    template <std::input_iterator IterT>
    void setBytes(IterT begin, IterT end)
    {
        _storageSequence.clear();
        _outputSequence.clear();

        appendBytes(begin, end);
    }


    virtual size_t byteSize() const
    {
        if (_outputSequence.empty()) {
            return 0;
        }

        auto v = _outputSequence | std::views::join;

        return std::ranges::distance(v.begin(), v.end());
    }


    template <traits::adc_output_char_range<char> R>
    size_t bytes(R& r)
    {
        if (_outputSequence.empty()) {
            return 0;
        }

        auto v = _outputSequence | std::views::join;

        std::ranges::copy(v, std::back_inserter(r));

        return std::ranges::distance(v.begin(), v.end());
    };

    virtual const output_seq_t& storageSeq() = 0;

protected:
    std::vector<std::string> _storageSequence;

    output_seq_t _outputSequence;

    AdcNetMessageInterface() : _storageSequence(), _outputSequence(){};

    template <typename T, typename... Ts>
    AdcNetMessageInterface(const T& v, const Ts&... vs) : AdcNetMessageInterface()
    {
        appendBytes(v, vs...);
    }

    virtual ~AdcNetMessageInterface() = default;

    AdcNetMessageInterface(const AdcNetMessageInterface&) = default;
    AdcNetMessageInterface(AdcNetMessageInterface&&) = default;

    AdcNetMessageInterface& operator=(const AdcNetMessageInterface&) = default;
    AdcNetMessageInterface& operator=(AdcNetMessageInterface&&) = default;

    virtual bool byteStorageEmpty() const
    {
        for (const auto& el : _storageSequence) {
            if (!el.empty()) {
                return false;
            };
        }

        return true;
    }

    virtual void updateState()
    {
        // just add view to byte data
        _outputSequence.emplace_back(_storageSequence.back());
    };
};


/*   GENERIC (NOTHING SPECIAL) NETWORK MESSAGE   */

class AdcGenericNetMessage : public AdcNetMessageInterface
{
public:
    using AdcNetMessageInterface::AdcNetMessageInterface;

    virtual ~AdcGenericNetMessage() = default;

    const output_seq_t& storageSeq() override { return _outputSequence; };
};


namespace constants
{

static constexpr char ADC_DEFAULT_TOKEN_DELIMITER[] = " ";
static constexpr char ADC_DEFAULT_KEY_PARAM_DELIMITER[] = " ";
static constexpr char ADC_DEFAULT_PARAM_PARAM_DELIMITER[] = " ";

}  // namespace constants


template <const char* TOKEN_DELIM = constants::ADC_DEFAULT_TOKEN_DELIMITER>
class AdcTokenNetMessage : protected AdcNetMessageInterface  // (hide setBytes/appendBytes)
{
    using base_t = AdcNetMessageInterface;

public:
    static constexpr std::string_view tokenDelimiter{TOKEN_DELIM};

    // back to public access
    using base_t::bytes;
    using base_t::byteSize;
    using base_t::messageEmpty;


    AdcTokenNetMessage() = default;

    template <typename T, typename... Ts>
    AdcTokenNetMessage(const T& v, const Ts&... vs) : AdcTokenNetMessage()
    {
        appendTokens(v, vs...);
    }

    virtual ~AdcTokenNetMessage() = default;


    template <typename T, typename... Ts>
    void appendTokens(const T& v, const Ts&... vs)
    {
        if (_storageSequence.size()) {                     // some tokens are already in storage
            _outputSequence.emplace_back(tokenDelimiter);  // add delimiter in output sequence
        }

        if constexpr (traits::adc_input_char_range<T> || traits::formattable<T>) {
            this->appendBytes(v);
        } else if constexpr (std::ranges::input_range<T>) {
            using el_t = std::ranges::range_value_t<T>;
            static_assert(traits::adc_input_char_range<el_t> || traits::formattable<el_t>,
                          "INVALID TYPE OF INPUT TOKENS!!!");

            if (std::ranges::distance(v.begin(), v.end())) {
                for (const auto& el : v) {
                    this->appendBytes(el);
                }
            }

        } else {
            static_assert(false, "UNSUPPORTED (CANNOT BE SERIALIZED TO BYTES) TYPE OF INPUT TOKENS!!!");
        }

        if constexpr (sizeof...(Ts)) {
            appendTokens(vs...);
        }
    }

    template <typename T, typename... Ts>
    void setTokens(const T& v, const Ts&... vs)
    {
        _storageSequence.clear();
        _outputSequence.clear();

        appendTokens(v, vs...);
    }

    template <traits::adc_output_range_of_char_range_c R>
    void tokens(R& r, size_t start = 0, size_t N = std::numeric_limits<size_t>::max()) const
    {
        if (byteStorageEmpty()) {
            return;
        }

        if ((start >= _storageSequence.size()) || !N) {
            return;
        }

        std::ranges::copy(_storageSequence | std::views ::drop(start) | std::views::take(N), std::back_inserter(r));
    }


    template <traits::adc_output_char_range R>
    void tokensBytes(R& r, size_t start = 0, size_t N = std::numeric_limits<size_t>::max()) const
    {
        if (byteStorageEmpty()) {
            return;
        }

        if ((start >= _storageSequence.size()) || !N) {
            return;
        }

        auto max_el = _storageSequence.size() - start;
        N = N >= max_el ? max_el * 2 - 1 : N * 2 - 1;

        std::ranges::copy(_outputSequence | std::views::drop(start * 2) | std::views::take(N) | std::views::join,
                          std::back_inserter(r));
    }

    const output_seq_t& storageSeq() override
    {
        // nothing special, just returns the reference
        return _outputSequence;
    }


    template <std::input_iterator IterT>
    void appendFromBytes(IterT begin, IterT end)
    {
        static_assert(std::is_same_v<std::iter_value_t<IterT>, char>, "INVALID ITERATOR VALUE TYPE!!!");

        auto curr_n_toks = _storageSequence.size();
        auto n_toks = utils::AdcSplitCharRangeToTokens(_storageSequence, std::span(begin, end), tokenDelimiter);

        if (n_toks) {
            n_toks += curr_n_toks;

            if (curr_n_toks) {
                _outputSequence.emplace_back(tokenDelimiter);  // add delimiter in output sequence
            }
            _outputSequence.emplace_back(_storageSequence[curr_n_toks]);

            for (auto i = curr_n_toks + 1; i < n_toks; ++i) {
                _outputSequence.emplace_back(tokenDelimiter);  // add delimiter in output sequence
                _outputSequence.emplace_back(_storageSequence[i]);
            }
        }
    }


    template <std::input_iterator IterT>
    void setFromBytes(IterT begin, IterT end)
    {
        _storageSequence.clear();
        _outputSequence.clear();

        appendFromBytes(begin, end);
    }



protected:
    // void updateState() override
    // {
    //     if (_outputSequence.size()) {                      // some tokens are already in storage
    //         _outputSequence.emplace_back(tokenDelimiter);  // add delimiter in output sequence
    //     }
    //     _outputSequence.emplace_back(_storageSequence.back());
    // }
};


template <const char* KEY_PARAM_DELIM = constants::ADC_DEFAULT_KEY_PARAM_DELIMITER,
          const char* PARAM_PARAM_DELIM = constants::ADC_DEFAULT_PARAM_PARAM_DELIMITER>
class AdcKeyParamNetMessage : protected AdcTokenNetMessage<PARAM_PARAM_DELIM>
{
    using base_t = AdcTokenNetMessage<PARAM_PARAM_DELIM>;

public:
    static constexpr std::string_view keyparamDelimiter{KEY_PARAM_DELIM};
    static constexpr std::string_view paramparamDelimiter{PARAM_PARAM_DELIM};

    // back to public access
    using base_t::bytes;
    using base_t::byteSize;
    using base_t::messageEmpty;
    using base_t::storageSeq;

    AdcKeyParamNetMessage() = default;

    template <typename KeyT, typename... ParamTs>
    AdcKeyParamNetMessage(const KeyT& key, const ParamTs&... params) : AdcKeyParamNetMessage()
    {
        setKeyParam(key, params...);
    }

    virtual ~AdcKeyParamNetMessage() = default;

    // key and params
    template <typename KeyT, typename... ParamTs>
    void setKeyParam(const KeyT& key, const ParamTs&... params)
    {
        _key.clear();
        this->_storageSequence.clear();
        this->_outputSequence.clear();

        // TODO: what if key is an empty range?!!!

        if constexpr (traits::adc_input_char_range<KeyT> || traits::formattable<KeyT>) {
            std::ranges::copy(key, std::back_inserter(_key));
        } else if constexpr (traits::formattable<KeyT>) {
            std::format_to(std::back_inserter(_key), "{}", key);
        } else {
            static_assert(false, "INVALID KEY-VALUE TYPE!!!");
        }

        this->_outputSequence.emplace_back(_key);

        if constexpr (sizeof...(ParamTs)) {
            this->_outputSequence.emplace_back(keyparamDelimiter);  // add key-param delimiter in output sequence
            this->appendTokens(params...);
        }
    }


    template <traits::adc_output_char_range R>
    void key(R& r) const
    {
        if constexpr (std::is_convertible_v<std::string, R>) {
            r = _key;
            return;
        }

        std::ranges::copy(_key, std::back_inserter(r));
    }

    template <traits::adc_output_range_of_char_range_c R>
    void params(R& r, size_t start = 0, size_t N = std::numeric_limits<size_t>::max()) const
    {
        this->tokens(r, start, N);
    }


    template <traits::adc_output_char_range R>
    void paramsBytes(R& r, size_t start = 0, size_t N = std::numeric_limits<size_t>::max()) const
    {
        // '+1' since the first 2 elements in _outputSequence are key and key-param delimiter
        this->tokensBytes(r, start + 1, N);
    }


    template <std::input_iterator IterT>
    void setFromBytes(IterT begin, IterT end)
    {
        auto sp = std::span(begin, end);

        auto found = std::ranges::search(sp, keyparamDelimiter);

        if (found.empty()) {  // no parameters
            setKeyParam(sp);
        } else {
            auto N = std::ranges::distance(sp.begin(), found.begin());
            setKeyParam(sp.first(N));
            this->_outputSequence.emplace_back(keyparamDelimiter);  // add key-param delimiter in output sequence
            base_t::appendFromBytes(found.begin() + keyparamDelimiter.size(), sp.end());
        }
    }


protected:
    std::string _key;
    // _outputSequence will store parameters
};

}  // namespace adc