#pragma once

#include <algorithm>
#include <charconv>
#include <limits>
#include <ranges>
#include <regex>

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


namespace adc::utils
{

static bool AdcIsSpace(char in) noexcept
{
    static constexpr auto ws = {' ', '\t', '\n', '\v', '\r', '\f'};
    return std::ranges::any_of(ws, [in](auto p) { return p == in; });
};


template <traits::adc_char_range R>
static auto AdcTrimSpaces(R&& r)
{
    return r | std::views::drop_while(AdcIsSpace) | std::views::reverse | std::views::drop_while(AdcIsSpace) |
           std::views::reverse;
}


template <typename ValueT, traits::adc_char_range R>
static ValueT AdcFromChars(R&& range)
{
    using v_t = std::remove_cv_t<ValueT>;


#ifdef _LIBCPP_VERSION  // clang's libc++ does not have floating-point overloads for std::from_chars
    if constexpr (traits::adc_is_any_v<v_t, char, int, long, long long, __int128>) {
#else
    if constexpr (traits::adc_is_any_of_v<v_t, unsigned char, char, unsigned short, short, unsigned long, long,
                                          unsigned long long, long long, unsigned int, int, unsigned __int128, __int128,
                                          float, double, long double>) {
#endif
        v_t v;

        auto rr = AdcTrimSpaces(range);

        std::from_chars_result res;
        const char* end_ptr;

        // std::from_chars needs random-access container!!!
        if constexpr (std::ranges::random_access_range<R>) {
            res = std::from_chars(&*rr.begin(), &*rr.end(), v);
            end_ptr = &*rr.end();
        } else {
            std::string s(rr.begin(), rr.end());
            end_ptr = s.data() + s.size();
            res = std::from_chars(s.data(), s.data() + s.size(), v);
        }

        if (res.ec == std::errc()) {
            if (res.ptr != end_ptr) {
                throw std::invalid_argument(
                    "AdcFromChars: cannot convert char-range to user-type value (invalid argument)");
            }

            return v;
        } else if (res.ec == std::errc::invalid_argument) {
            throw std::invalid_argument(
                "AdcFromChars: cannot convert char-range to user-type value (invalid argument)");
        } else if (res.ec == std::errc::result_out_of_range) {
            throw std::invalid_argument(
                "AdcFromChars: cannot convert char-range to user-type value (result out of range)");
        }
#ifdef _LIBCPP_VERSION  // clang's libc++ does not have floating-point overloads for std::from_chars
    } else if constexpr (std::is_floating_point_v<v_t>) {
        v_t v;

        auto rr = AdcTrimSpaces(range);

        std::string s(rr.begin(), rr.end());
        size_t pos;
        try {
            if constexpr (std::is_same_v<v_t, float>) {
                v = std::stof(s, &pos);
            } else if constexpr (std::is_same_v<v_t, double>) {
                v = std::stod(s, &pos);
            } else if constexpr (std::is_same_v<v_t, long double>) {
                v = std::stold(s, &pos);
            }
        } catch (const std::invalid_argument&) {
            throw std::invalid_argument(
                "AdcFromChars: cannot convert char-range to user-type value (invalid argument)");
        } catch (const std::out_of_range&) {
            throw std::invalid_argument(
                "AdcFromChars: cannot convert char-range to user-type value (result out of range)");
        }

        if (pos != s.size()) {
            throw std::invalid_argument(
                "AdcFromChars: cannot convert char-range to user-type value (invalid argument)");
        }

        return v;
#endif
    } else if constexpr (std::is_constructible_v<ValueT, std::ranges::iterator_t<R>, std::ranges::iterator_t<R>>) {
        return ValueT(range.begin(), range.end());
    } else {
        static_assert(false,
                      "AdcFromChars: CANNOT CONVERT CHAR-RANGE TO USER-TYPE VALUE (UNSUPPORTED USER-VALUE TYPE)");
        // throw std::invalid_argument(
        //     "AdcFromChars: cannot convert char-range to user-type value (unsupported user-value type)");
    }

    return ValueT();
}


/*  TRIVIAL SERIALIZER/DESERIALIZER  */

static const std::regex AdcIntegerRegex("^ *[+-]?\\d+\\d* *$", std::regex::ECMAScript);
static const std::regex AdcRealRegex("^ *[-+]?\\d+\\d*\\.?\\d*([Ee][-+]?\\d+)? *$", std::regex::ECMAScript);

template <typename SerializedT, traits::formattable VT>
static SerializedT AdcTrivialSerializer(VT&& value)
{
    using v_t = std::decay_t<VT>;

    if constexpr (std::is_convertible_v<v_t, SerializedT>) {
        return static_cast<SerializedT>(std::forward<VT>(value));
    } else if constexpr (traits::adc_output_char_range<SerializedT>) {
        SerializedT s_val;
        std::format_to(std::back_inserter(s_val), "{}", std::forward<VT>(value));
        return s_val;
    } else {
        // throw std::invalid_argument("trivial serializer: cannot serialize value");
        static_assert(false, "TRIVIAL SERIALIZER: UNSUPPORTED SERIALIZING TYPE!!!");
    }
}


template <typename VT, typename SerializedT = std::string>
static VT AdcTrivialDeserializer(SerializedT&& s_value)
{
    if constexpr (std::is_convertible_v<SerializedT, VT>) {
        return static_cast<VT>(std::forward<SerializedT>(s_value));
    } else if constexpr (traits::adc_input_char_range<SerializedT>) {
        return AdcFromChars<VT>(std::forward<SerializedT>(s_value));
    } else {
        static_assert(false, "TRIVIAL DESERIALIZER: UNSUPPORTED SERIALIZING TYPE!!!");
    }

    return VT();
}


template <std::ranges::range OutputR, traits::adc_input_char_range InputR, traits::adc_input_char_range DelimR>
static auto AdcValueRangeFromCharRange(OutputR& res,
                                       InputR&& input_r,
                                       DelimR&& delim,
                                       size_t max_len = std::numeric_limits<size_t>::max())
{
    if (max_len == 0) {
        return res.begin();
    }

    using value_t = std::ranges::range_value_t<OutputR>;

    if constexpr (std::is_array_v<std::remove_cvref_t<DelimR>>) {
        std::ranges::copy(std::views::split(std::forward<InputR>(input_r), std::string_view(delim)) |
                              std::views::filter([](const auto& r) { return !std::ranges::empty(r); }) |
                              std::views::transform([](auto vl) { return AdcTrivialDeserializer<value_t>(vl); }) |
                              std::views::take(max_len),
                          std::back_inserter(res));
    } else {
        std::ranges::copy(std::views::split(std::forward<InputR>(input_r), std::forward<DelimR>(delim)) |
                              std::views::filter([](const auto& r) { return !std::ranges::empty(r); }) |
                              std::views::transform([](auto vl) { return AdcTrivialDeserializer<value_t>(vl); }) |
                              std::views::take(max_len),
                          std::back_inserter(res));
    }

    return res.begin();
}


template <traits::adc_output_char_range OutputR, std::ranges::range InputR, traits::adc_input_char_range DelimR>
static auto AdcCharRangeFromValueRange(OutputR& res,
                                       InputR&& input_r,
                                       DelimR&& delim,
                                       size_t max_len = std::numeric_limits<size_t>::max())
{
    max_len = max_len < std::ranges::size(input_r) ? max_len : std::ranges::size(input_r);

    if (max_len == 0) {
        return res.begin();
    }

    --max_len;

    if (max_len) {
        auto view = input_r | std::views::take(max_len) | std::views::transform([&delim](auto v) {
                        auto r = AdcTrivialSerializer<OutputR>(v);
                        std::ranges::copy(delim, std::back_inserter(r));
                        return r;
                    }) |
                    std::views::join;

        std::ranges::copy(view, std::back_inserter(res));

        auto view1 = input_r | std::views::drop(max_len) | std::views::take(1) | std::views::transform([](auto v) {
                         auto r = AdcTrivialSerializer<OutputR>(v);
                         return r;
                     }) |
                     std::views::join;
        std::ranges::copy(view1, std::back_inserter(res));
    } else {
        res = AdcTrivialSerializer<OutputR>(*std::forward<InputR>(input_r).begin());
    }

    return res.begin();
}


namespace details
{

template <size_t I = 0, typename... Ts>
void setTupleElements(std::tuple<Ts...>& tp, auto&& r)
{
    if (I < std::ranges::distance(r)) {
        if constexpr (I < sizeof...(Ts)) {
            std::get<I>(tp) =
                AdcFromChars<std::tuple_element_t<I, std::tuple<Ts...>>>(*(r | std::views::drop(I)).begin());

            setTupleElements<I + 1>(tp, std::forward<decltype(r)>(r));
        }
    }
}


template <size_t I = 0, typename... Ts>
void fromTupleElements(const std::tuple<Ts...>& tp, auto& r, const auto& delim)
{
    using r_t = std::decay_t<decltype(r)>;

    if constexpr (I < (sizeof...(Ts) - 1)) {
        auto el = AdcTrivialSerializer<r_t>(std::get<I>(tp));
        std::ranges::copy(el, std::back_inserter(r));
        std::ranges::copy(delim, std::back_inserter(r));

        fromTupleElements<I + 1>(tp, r, delim);
    } else if constexpr (I == (sizeof...(Ts) - 1)) {
        auto el = AdcTrivialSerializer<r_t>(std::get<I>(tp));
        std::ranges::copy(el, std::back_inserter(r));
    }
}

}  // namespace details


template <traits::adc_input_char_range InputR, traits::adc_input_char_range DelimR, typename... Ts>
static void AdcTupleFromCharRange(std::tuple<Ts...>& tp, InputR&& input_r, DelimR&& delim)
{
    if constexpr (std::is_array_v<std::remove_cvref_t<DelimR>>) {
        auto r = std::views::split(std::forward<InputR>(input_r), std::string_view(delim)) |
                 std::views::filter([](const auto& r) { return !std::ranges::empty(r); });
        details::setTupleElements(tp, r);
    } else {
        auto r = std::views::split(std::forward<InputR>(input_r), std::forward<DelimR>(delim)) |
                 std::views::filter([](const auto& r) { return !std::ranges::empty(r); });
        details::setTupleElements(tp, r);
    }
}


template <traits::adc_output_char_range OutputR, traits::adc_input_char_range DelimR, typename... Ts>
static auto AdcCharRangeFromTuple(OutputR& res, const std::tuple<Ts...>& tp, DelimR&& delim)
{
    if constexpr (sizeof...(Ts) > 1) {
        details::fromTupleElements(tp, res, delim);
    } else {
        res = AdcTrivialSerializer<OutputR>(std::get<0>(tp));
    }

    return res.begin();
}


namespace details
{

template <typename DerivedT>
class AdcDelimiter
{
public:
    template <traits::adc_input_char_range DT = std::string_view>
    auto& setDelimiter(const DT& delimiter)
    {
        _delimiter = std::string{delimiter.begin(), delimiter.end()};

        return static_cast<DerivedT&>(*this);
    }

    auto& setDelimiter(const char* delimiter)
    {
        _delimiter = std::string{delimiter};

        return static_cast<DerivedT&>(*this);
    }

protected:
    template <traits::adc_input_char_range DT = std::string_view>
    AdcDelimiter(const DT& delimiter = ",") : _delimiter(delimiter.begin(), delimiter.end())
    {
    }

    AdcDelimiter(const char* delimiter = ",") : _delimiter(delimiter) {}

    virtual ~AdcDelimiter() = default;

    std::string _delimiter;
};

}  // namespace details

/*
 */
template <traits::adc_output_char_range SerializedT = std::string>
class AdcDefaultSerializer : public details::AdcDelimiter<AdcDefaultSerializer<SerializedT>>
{
    std::string _delimiter;

    using base_t = details::AdcDelimiter<AdcDefaultSerializer<SerializedT>>;

public:
    template <typename DT = std::string_view>
    AdcDefaultSerializer(const DT& delimiter = ",") : base_t(delimiter)
    {
    }

    virtual ~AdcDefaultSerializer() = default;

    template <typename T>
    SerializedT operator()(const T& value)
    {
        SerializedT res;

        if constexpr (traits::adc_is_tuple_v<T>) {
            AdcCharRangeFromTuple(res, value, _delimiter);
        } else if constexpr (traits::adc_input_char_range<T>) {
            AdcCharRangeFromValueRange(res, value, _delimiter);
        } else {
            res = AdcTrivialSerializer<SerializedT>(value);
        }

        return res;
    }
};


/*
 */
template <traits::adc_input_char_range SerializedT = std::string>
class AdcDefaultDeserializer : public details::AdcDelimiter<AdcDefaultDeserializer<SerializedT>>
{
    std::string _delimiter;

    using base_t = details::AdcDelimiter<AdcDefaultSerializer<SerializedT>>;

public:
    template <typename DT = std::string_view>
    AdcDefaultDeserializer(const DT& delimiter = ",") : base_t(delimiter)
    {
    }

    virtual ~AdcDefaultDeserializer() = default;

    template <typename T>
    T deserialization(const SerializedT& value)
    {
        T res;

        if constexpr (traits::adc_is_tuple_v<T>) {
            AdcTupleFromCharRange(res, value, _delimiter);
        } else if constexpr (traits::adc_output_char_range<T>) {
            AdcValueRangeFromCharRange(res, value, _delimiter);
        } else {
            res = AdcTrivialDeserializer<T>(value);
        }

        return res;
    }
};

namespace constants
{

static constexpr char DEFAULT_CONVERTER_DELIMITER[] = " ";

}  // namespace constants

template <const char* DELIMITER = constants::DEFAULT_CONVERTER_DELIMITER>
class AdcDefaultValueConverter
{
public:
    template <typename SerializedT, typename ValueT>
    static SerializedT serialize(const ValueT& value)
    {
        SerializedT res;

        if constexpr (traits::adc_is_tuple_v<ValueT>) {
            AdcCharRangeFromTuple(res, value, DELIMITER);
        } else if constexpr (traits::adc_input_char_range<ValueT>) {
            AdcCharRangeFromValueRange(res, value, DELIMITER);
        } else {
            res = AdcTrivialSerializer<SerializedT>(value);
        }

        return res;
    }


    template <typename ValueT, typename SerializedT>
    static ValueT deserialize(const SerializedT& svalue)
    {
        if constexpr (std::is_void_v<ValueT>) {
            return;
        }

        ValueT res;

        if constexpr (traits::adc_is_tuple_v<ValueT>) {
            AdcTupleFromCharRange(res, svalue, DELIMITER);
        } else if constexpr (traits::adc_output_char_range<ValueT>) {
            AdcValueRangeFromCharRange(res, svalue, DELIMITER);
        } else {
            res = AdcTrivialDeserializer<ValueT>(svalue);
        }

        return res;
    }
};

}  // namespace adc::utils