#pragma once

#include "adc_netservice_asio.h"

namespace adc::impl
{

class AdcNetSessionASIO
{
public:
    typedef std::string netsession_ident_t;

    template <traits::adc_input_char_range R,
              adc_asio_transport_proto_c TRANSPORT_PROTOT,
              interfaces::adc_netsession_proto_c<std::string_view> SESSION_PROTOT,
              traits::adc_output_char_range RMSGT = std::vector<char>,
              traits::adc_is_callable RECV_MSG_TOKENT>
    AdcNetSessionASIO(const R& id,
                      std::shared_ptr<AdcNetServiceASIOBase<TRANSPORT_PROTOT, SESSION_PROTOT, RMSGT>> netservice,
                      RECV_MSG_TOKENT&& recv_msg_token)
        : _ident(id.begin(), id.end())
    {
        // check receive message completion token signature and deduce message type
        if constexpr (!adc_asio_special_comp_token_c<RECV_MSG_TOKENT>) {
            static_assert(traits::adc_func_traits<RECV_MSG_TOKENT>::arity == 2, "INVALID COMPLETION TOKEN SIGNATURE!");
            static_assert(
                std::is_same_v<std::remove_cvref_t<traits::adc_func_arg1_t<RECV_MSG_TOKENT>>, std::error_code>,
                "INVALID COMPLETION TOKEN SIGNATURE!");
            static_assert(traits::adc_output_char_range<
                              std::tuple_element_t<1, typename traits::adc_func_traits<RECV_MSG_TOKENT>::args_t>>,
                          "INVALID COMPLETION TOKEN SIGNATURE!");
        }

        using msg_t = std::conditional_t<
            adc_asio_special_comp_token_c<RECV_MSG_TOKENT>, RMSGT,
            std::remove_cvref_t<std::tuple_element_t<1, typename traits::adc_func_traits<RECV_MSG_TOKENT>::args_t>>>;


        _startFunc = [netservice, wrapper = traits::adc_pf_wrapper(std::forward<RECV_MSG_TOKENT>(recv_msg_token)),
                      this]() {
            //
            netservice->asyncReceive(std::get<0>(wrapper), _recvTimeout);
        };

        _stopFunc = [netservice]() {
            // stop
            netservice->close();
        };
    }

    template <adc_asio_transport_proto_c TRANSPORT_PROTOT,
              interfaces::adc_netsession_proto_c<std::string_view> SESSION_PROTOT,
              traits::adc_output_char_range RMSGT = std::vector<char>,
              traits::adc_is_callable RECV_MSG_TOKENT>
    AdcNetSessionASIO(std::shared_ptr<AdcNetServiceASIOBase<TRANSPORT_PROTOT, SESSION_PROTOT, RMSGT>> netservice,
                      RECV_MSG_TOKENT&& recv_msg_token)
        : AdcNetSessionASIO(std::derived_from<TRANSPORT_PROTOT, asio::ip::tcp>   ? "TCP SESSION"
                            : std::derived_from<TRANSPORT_PROTOT, asio::ip::udp> ? "UDP SESSION"
                            : std::derived_from<TRANSPORT_PROTOT, asio::local::seq_packet_protocol>
                                ? "UNIX SEQPACKET SESSION"
                            : std::derived_from<TRANSPORT_PROTOT, asio::local::stream_protocol> ? "UNIX STREAM SESSION"
                                                                                                : "UNKNOWN",
                            std::move(netservice),
                            std::forward<RECV_MSG_TOKENT>(recv_msg_token))
    {
    }


    virtual ~AdcNetSessionASIO()
    {
        stop();
    }


    netsession_ident_t ident() const
    {
        return _ident;
    }


    void start()
    {
        _startFunc();
    }

    void stop()
    {
        _stopFunc();
    }


    template <traits::adc_time_duration_c TimeoutT>
    AdcNetSessionASIO& setDefaultTimeouts(const TimeoutT& send_timeout, const TimeoutT& recv_timeout)
    {
        _sendTimeout = send_timeout;
        _recvTimeout = recv_timeout;

        return *this;
    }

protected:
    netsession_ident_t _ident;

    std::function<void()> _startFunc;
    std::function<void()> _stopFunc;

    std::chrono::duration<std::chrono::seconds::rep, std::chrono::seconds::period> _recvTimeout =
        std::chrono::seconds::max();

    std::chrono::duration<std::chrono::seconds::rep, std::chrono::seconds::period> _sendTimeout =
        std::chrono::seconds(5);
};

}  // namespace adc::impl