ADC/common/adc_utils.h

#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)
{
    if constexpr (std::is_arithmetic_v<ValueT>) {
        ValueT v;

        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(&*range.begin(), &*range.end(), v);
            end_ptr = &*range.end();
        } else {
            std::string s(range.begin(), range.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)");
        }
    } else if (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)");
    }
}


/*  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 <traits::formattable VT, typename SerializedT = std::string>
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 (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 (traits::adc_input_char_range<SerializedT>) {
        return AdcFromChars<VT>(std::forward<SerializedT>(s_value));
    } else {
        static_assert(false, "TRIVIAL DESERIALIZER: UNSUPPORTED SERIALIZING TYPE!!!");
    }
}


template <std::ranges::range OutputR, traits::adc_input_char_range InputR, traits::adc_input_char_range DelimR>
OutputR AdcValueRangeFromCharRange(InputR&& input_r,
                                   DelimR&& delim,
                                   size_t max_len = std::numeric_limits<size_t>::max())
{
    OutputR res;

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

    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;
}


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

    max_len = max_len < std::ranges::size(input_r) ? max_len : std::ranges::size(input_r);

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

    --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;
}

}  // namespace adc::utils