#pragma once

/*

ABSTRACT DEVICE COMPONENTS LIBRARY

    spdlog-library extensions

*/


#ifdef USE_SPDLOG_LIBRARY

#include "../common/adc_spdlog.h"
#include "../common/adc_traits.h"

#include "adc_netserver.h"

namespace adc
{

template <traits::adc_netserver_session_c SessionT>
class AdcNetServerSessionSpdlogDecorator : public AdcSpdlogGenericMarkDecorator<SessionT>
{
protected:
    using base_t = AdcSpdlogGenericMarkDecorator<SessionT>;

    std::string _sessionID;

public:
    using base_t::logDebug;
    using base_t::logInfo;
    using base_t::logMethodCalling;

    // using SessionT::sessionIdent;
    using typename SessionT::session_ident_t;

    static_assert(traits::formattable<session_ident_t>, "NETWORK SESSION IDENT TYPE MUST BE A FORMATTABLE ONE!!!");

    template <typename... ImplCtorArgTs>
    AdcNetServerSessionSpdlogDecorator(std::shared_ptr<spdlog::logger> logger, ImplCtorArgTs&&... ctor_args)
        : base_t("ADC NETSERVER SESSION", logger, std::forward<ImplCtorArgTs>(ctor_args)...)
    {
        logMethodCalling(__PRETTY_FUNCTION__);

        fmt::format_to(std::back_inserter(_sessionID), "{}", SessionT::sessionIdent());

        this->setPattern(base_t::constructPattern(_sessionID));

        logDebug("Creating network server session with ID = [{}] (ADDR = {})", _sessionID, this->_thisAddress);
        logDebug("Use logger with ", this->loggerInfo());
    }

    virtual ~AdcNetServerSessionSpdlogDecorator()
    {
        logMethodCalling(__PRETTY_FUNCTION__);

        logDebug("Deleting network server session with ID = [{}] (ADDR = {})", _sessionID, this->_thisAddress);
    };

    virtual session_ident_t sessionIdent() const override
    {
        logMethodCalling(__PRETTY_FUNCTION__);

        return SessionT::sessionIdent();
    };

    virtual void start() override
    {
        logMethodCalling(__PRETTY_FUNCTION__);

        logInfo("Starting network server session with ID = [{}]", _sessionID);

        SessionT::start();

        logInfo("Network server session [{}] is started", _sessionID);
    };

    virtual void stop() override
    {
        logMethodCalling(__PRETTY_FUNCTION__);

        logInfo("Stopping network server session with ID = [{}]", _sessionID);

        SessionT::stop();

        logInfo("Network server session [{}] is stopped", _sessionID);
    };
};



template <traits::adc_netserver_c ServerT>
class AdcNetServerSpdlogDecorator : public AdcSpdlogGenericMarkDecorator<ServerT>
{
protected:
    using base_t = AdcSpdlogGenericMarkDecorator<ServerT>;

    std::string _serverID;

public:
    using base_t::logCritical;
    using base_t::logDebug;
    using base_t::logError;
    using base_t::logInfo;
    using base_t::logMsg;
    using base_t::logWarn;

    using typename ServerT::server_ident_t;

    static_assert(traits::formattable<server_ident_t>, "NETWORK SERVER IDENT TYPE MUST BE A FORMATTABLE ONE!!!");

    template <typename... ImplCtorArgTs>
    AdcNetServerSpdlogDecorator(std::shared_ptr<spdlog::logger> logger, ImplCtorArgTs&&... ctor_args)
        : base_t("ADC NETSERVER", logger, std::forward<ImplCtorArgTs>(ctor_args)...)
    {
        this->logMethodCalling(__PRETTY_FUNCTION__);

        fmt::format_to(std::back_inserter(_serverID), "{}", ServerT::serverIdent());

        this->setPattern(base_t::constructPattern(_serverID));

        logDebug("Creating network server with ID = [{}] (ADDR = {})", _serverID, this->_thisAddress);
        logDebug("Use logger with ", this->loggerInfo());
    }


    virtual ~AdcNetServerSpdlogDecorator()
    {
        this->logMethodCalling(__PRETTY_FUNCTION__);

        logDebug("Deleting network server with ID = [{}] (ADDR = {})", _serverID, this->_thisAddress);
    }


    virtual server_ident_t serverIdent() const
    {
        this->logMethodCalling(__PRETTY_FUNCTION__);

        return ServerT::serverIdent();
    }

    virtual void start()
    {
        this->logMethodCalling(__PRETTY_FUNCTION__);

        logInfo("Starting network server");

        ServerT::start();

        logInfo("Network server is started");
    };

    virtual void stop()
    {
        this->logMethodCalling(__PRETTY_FUNCTION__);

        logInfo("Stopping network server ...");

        ServerT::stop();

        logInfo("Network server is stopped");
    };
};

}  // namespace adc

#endif