#pragma once

/*

ABSTRACT DEVICE COMPONENTS LIBRARY

 */


#include <chrono>
#include <utility>


#include "adc_netmsg.h"

namespace adc
{


template <typename ImplT>
class AdcNetService
{
protected:
    ImplT _impl;

public:
    using impl_t = ImplT;

    using typename ImplT::endpoint_t;

    using timeout_clock_t = std::chrono::steady_clock;
    using timeout_drtn_t = timeout_clock_t::duration;

    static constexpr timeout_drtn_t defaultConnectTimeout = std::chrono::seconds(5);
    // static constexpr std::chrono::duration defaultConnectTimeout = std::chrono::seconds(5);
    static constexpr timeout_drtn_t defaultSendTimeout = std::chrono::seconds(5);
    static constexpr timeout_drtn_t defaultRecvTimeout = std::chrono::seconds(5);

    template <typename... ImplCtorArgTs>
    AdcNetService(ImplCtorArgTs&&... ctor_args) : _impl(std::forward<ImplCtorArgTs>(ctor_args)...)
    {
    }


    virtual ~AdcNetService() = default;


    /*  asynchronuos operations  */

    // open connection
    template <typename... ArgTs>
    auto asyncConnect(const endpoint_t& end_point,
                      const timeout_drtn_t& timeout = defaultConnectTimeout,
                      ArgTs&&... args)
    {
        return _impl.asyncConnect(end_point, timeout, std::forward<ArgTs>(args)...);
    }


    template <traits::adc_netmessage_c NetMessageT, typename... ArgTs>
    auto asyncSend(const NetMessageT& msg, const timeout_drtn_t& timeout = defaultSendTimeout, ArgTs&&... args)
    {
        return _impl.asyncSend(msg, timeout, std::forward<ArgTs>(args)...);
    }

    template <traits::adc_netmessage_c NetMessageT, typename... ArgTs>
    auto asyncReceive(const timeout_drtn_t& timeout = defaultRecvTimeout, ArgTs&&... args)
    {
        return _impl.asyncReceive(timeout, std::forward<ArgTs>(args)...);
    }



    /*  blocking operations  */

    template <typename... ArgTs>
    auto connect(const endpoint_t& endpoint, const timeout_drtn_t& timeout = defaultConnectTimeout, ArgTs&&... args)
    {
        return _impl.connect(endpoint, timeout, std::forward<ArgTs>(args)...);
    }

    template <traits::adc_netmessage_c NetMessageT, typename... ArgTs>
    auto send(const NetMessageT& msg, const timeout_drtn_t& timeout = defaultSendTimeout, ArgTs&&... args)
    {
        return _impl.send(msg, timeout, std::forward<ArgTs>(args)...);
    }


    template <traits::adc_netmessage_c NetMessageT, typename... ArgTs>
    NetMessageT receive(const timeout_drtn_t& timeout = defaultRecvTimeout, ArgTs&&... args)
    {
        return _impl.receive(timeout, std::forward<ArgTs>(args)...);
    }

    template <typename... ArgTs>
    auto close(ArgTs&&... args)
    {
        return _impl.close(std::forward<ArgTs>(args)...);
    }
};


namespace traits
{

template <typename T>
concept adc_netservice_c = requires {
    typename T::impl_t;
    std::derived_from<T, AdcNetService<typename T::impl_t>>;
};

}  // namespace traits

}  // namespace adc