#pragma once

#include <concepts>

#include "mcc_concepts.h"
#include "mcc_traits.h"

namespace mcc
{


struct mcc_serializer_interface_t {
    virtual ~mcc_serializer_interface_t() = default;

    template <std::derived_from<mcc_serializer_interface_t> SelfT,
              traits::mcc_output_char_range R,
              typename ValueT,
              typename FmtT = std::format_string<ValueT>>
        requires(std::same_as<FmtT, std::format_string<ValueT>> || std::same_as<FmtT, std::string_view>)
    mcc_error_c auto operator()(this SelfT&& self, R& output, ValueT&& value, FmtT fmt = "{}")
    {
        return std::forward<SelfT>(self).operator=(output, std::forward<ValueT>(value), std::move(fmt));
    }
};

template <typename T>
concept mcc_serializer_c = std::derived_from<T, mcc_serializer_interface_t>;



template <typename VT>
class MccSerializer;

template <typename VT>
class MccSerializer : public mcc_serializer_interface_t
{
public:
    static constexpr std::string_view defaultDelimiter{","};

    typedef std::error_code error_t;

    MccSerializer() = default;

    ~MccSerializer() = default;

    template <typename FmtT = std::format_string<VT>>
    error_t operator()(traits::mcc_output_char_range auto& output, VT&& value, FmtT fmt = "{}")
        requires std::formattable<VT, char>
    {
        if constexpr (std::same_as<FmtT, std::format_string<VT>>) {
            std::format_to(std::back_inserter(output), fmt, value);
        } else if constexpr (std::same_as<FmtT, std::string_view>) {
            std::vformat_to(std::back_inserter(output), fmt, std::make_format_args(value));
        }

        return {};
    }

protected:
    std::string _delimiter{defaultDelimiter};
};


template <mcc_angle_c T>
class MccSerializer<T> : public mcc_serializer_interface_t
{
public:
    error_t operator()(traits::mcc_output_char_range auto& output, T&& value)
    {
        std::format_to(std::back_inserter(output), "{}", value.degrees());

        return {};
    }
};


static_assert(mcc_serializer_c<MccSerializer<float>>, "!!!");

static_assert(mcc_serializer_c<MccSerializer<impl::MccAngle>>, "!!!");

void f()
{
    MccSerializer<impl::MccAngle> s;

    std::string str;
    s(str, impl::MccAngleALT{1.1});
}

}  // namespace mcc