#pragma once

#include "../common/adc_utils.h"
#include "adc_net_concepts.h"
#include "adc_netserver.h"

namespace adc
{


/*  */


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

    template <typename... LoggerCtorArgTs>
    AdcGenericNetClient(const IdentT& ident, LoggerCtorArgTs&&... args)
        : _clientIdent(ident), LoggerT(std::forward<LoggerCtorArgTs>(args)...)
    {
    }


    virtual ~AdcGenericNetClient()
    {
        stopAllSessions();
    }

    template <interfaces::adc_netsession_c SessionT, typename... NetServiceCtorArgTs>
    void asyncConnect(const SessionT::netservice_t::endpoint_t& endpoint,
                      SessionT::netsession_ident_t id,
                      SessionT::netsession_ctx_t sess_ctx,
                      NetServiceCtorArgTs&&... ctor_args)
    {
        auto srv_sptr =
            std::make_shared<typename SessionT::netservice_t>(std::forward<NetServiceCtorArgTs>(ctor_args)...);

        srv_sptr->asyncConnect(
            endpoint,
            [id = std::move(id), sess_ctx = std::move(sess_ctx), srv_sptr, this](auto ec) {
                if (ec) {
                    this->logError("Cannot connect to server: {}", SessionT::netservice_t::formattableError(ec));
                } else {
                    auto sess = std::make_shared<SessionT>(id, std::move(*srv_sptr), sess_ctx);
                    startSession(sess);
                }
            },
            _connectTimeout);
    }


    template <interfaces::adc_netsession_c SessionT, typename... NetServiceCtorArgTs>
    void connect(const SessionT::netservice_t::endpoint_t& endpoint,
                 SessionT::netsession_ident_t id,
                 SessionT::netsession_ctx_t sess_ctx,
                 NetServiceCtorArgTs&&... ctor_args)
    {
        typename SessionT::netservice_t srv(std::forward<NetServiceCtorArgTs>(ctor_args)...);
        srv.connect(endpoint, _connectTimeout);

        auto sess = std::make_shared<SessionT>(std::move(id), std::move(srv), std::move(sess_ctx));
        startSession(sess);
    }


    template <traits::adc_time_duration_c DT>
    void setConnectTimeout(const DT& timeout)
    {
        _connectTimeout = std::chrono::duration_cast<decltype(_connectTimeout)>(timeout);
    }

    auto getConnectionTimeout() const
    {
        return _connectTimeout;
    }

protected:
    client_ident_t _clientIdent;

    std::chrono::milliseconds _connectTimeout = std::chrono::milliseconds(5000);
};

}  // namespace adc