#pragma once

#include "../common/adc_utils.h"
#include "adc_device_netmsg.h"
#include "adc_netclient.h"

namespace adc
{

template <typename IdentT = std::string, interfaces::adc_logger_c LoggerT = utils::AdcOstreamLogger<char>>
class AdcDeviceNetClient : public AdcGenericNetClient<IdentT, LoggerT>
{
    typedef AdcGenericNetClient<IdentT, LoggerT> base_t;

public:
    template <interfaces::adc_netservice_c NetServiceT, traits::adc_hashable_c SessionIdentT = std::string>
    class Session : public std::enable_shared_from_this<Session<NetServiceT, SessionIdentT>>
    {
    public:
        typedef SessionIdentT netsession_ident_t;
        typedef NetServiceT netservice_t;

        struct netsession_ctx_t {
            AdcDeviceNetClient* clientPtr;
            std::chrono::milliseconds recvTimeout;
            std::chrono::milliseconds sendTimeout;
        };

        typedef std::vector<char> message_t;

        // Session(const netsession_ident_t& id, netservice_t srv, AdcDeviceNetServer* srv_ptr)
        Session(const netsession_ident_t& id, netservice_t srv, netsession_ctx_t ctx)
            : _ident(id),
              _netService(std::move(srv)),
              _clientPtr(ctx.clientPtr),
              _recvTimeout(ctx.recvTimeout),
              _sendTimeout(ctx.sendTimeout)
        {
            _clientPtr->logInfo("Create client-to-server session with ID = {} (addr = {}, thread = {})", _ident,
                                (void*)this, utils::AdcThisThreadId());
        }


        virtual ~Session()
        {
            _clientPtr->logInfo("Delete client-to-server session with ID = {} (addr = {}, thread = {})", _ident,
                                (void*)this, utils::AdcThisThreadId());
        }

        netsession_ident_t ident() const
        {
            return _ident;
        }

        void start()
        {
            _clientPtr->logInfo("Start client-to-server session with ID = {} (addr = {}, thread = {})", _ident,
                                (void*)this, utils::AdcThisThreadId());
        }

        void stop()
        {
            _clientPtr->logInfo("Stop client-to-server session with ID = {} (addr = {}, thread = {})", _ident,
                                (void*)this, utils::AdcThisThreadId());

            _netService.close();
        }



    protected:
        netsession_ident_t _ident;
        netservice_t _netService;
        AdcDeviceNetClient* _clientPtr;

        std::chrono::milliseconds _recvTimeout = std::chrono::seconds(5);
        std::chrono::milliseconds _sendTimeout = std::chrono::seconds(5);


        // helper methods
        std::function<void(typename netservice_t::async_callback_err_t,
                           typename netservice_t::async_receive_callback_t)>
            _defaultRecvCallback = [this](auto err, auto msg) {
                if (err) {
                    _clientPtr->logError("An error occured while receiving server respond: {}",
                                         netservice_t::formattableError(err));
                } else {
                    AdcDeviceProtoMessage dev_msg(msg);

                    if (!dev_msg.isValid()) {
                        _clientPtr->logError("Invalid server respond");
                        return;
                    }

                    if (dev_msg.isACK()) {
                    } else if (dev_msg.isERROR()) {
                    } else {
                        _clientPtr->logError("Unexpectable server respond");
                    }
                }
            };

        template <traits::adc_input_char_range SendMsgT, typename TokenT>
        auto asyncSendRecv(const SendMsgT& send_msg, TokenT&& token)
        {
            return _netService.asyncSend(
                send_msg,
                [wrapper = traits::adc_pf_wrapper(std::forward<TokenT>(token)), this](auto err) {
                    if (err) {
                        this->logError("An error occured while sending the message: {}",
                                       netservice_t::formattableError(err));
                    } else {
                        _netService.asyncReceive(std::get<0>(wrapper), _recvTimeout);
                    }
                },
                _sendTimeout);
        }
    };  // end of 'Session' class declaration

    using base_t::base_t;

    virtual ~AdcDeviceNetClient() {}
};


}  // namespace adc