#pragma once

#include "adc_device_netmsg.h"
#include "adc_netserver.h"

namespace adc
{


class AdcDeviceNetServer : public AdcGenericNetServer
{
public:
    template <interfaces::adc_netservice_c NetServiceT>
    class Session : std::enable_shared_from_this<Session<NetServiceT>>
    {
    public:
        typedef std::string netsession_ident_t;
        typedef NetServiceT netservice_t;
        typedef AdcDeviceNetServer* netsession_ctx_t;

        template <traits::adc_input_char_range R>
        Session(R&& id, netservice_t srv, netsession_ctx_t ctx) : _ident(), _netService(std::move(srv)), _context(ctx)
        {
            if constexpr (std::is_array_v<std::remove_cvref_t<R>>) {
                _ident = id;
            } else {
                _ident = netsession_ident_t(id.begin(), id.end());
            }
        }

        netsession_ident_t ident() const
        {
            return _ident;
        }

        void start()
        {
            _netService.asyncReceive(
                [this](std::error_code ec, std::vector<char> msg) {
                    if (ec) {
                        stop();
                    } else {
                        auto msg_sptr = std::make_shared<std::vector<char>>(std::move(msg));

                        AdcDeviceProtoMessage dev_msg(*msg_sptr);

                        handleMessage(dev_msg);

                        _netService.asyncSend(
                            *msg_sptr,
                            [msg_sptr, this](std::error_code ec) {
                                if (ec) {
                                    stop();
                                } else {
                                    start();
                                }
                            },
                            _sendTimeout);
                    }
                },
                _recvTimeout);
        }

        void stop()
        {
            _netService.close();
        }

    protected:
        netsession_ident_t _ident;
        netservice_t _netService;
        netsession_ctx_t _context;

        std::chrono::duration<size_t> _recvTimeout = std::chrono::seconds(3600);
        std::chrono::duration<size_t> _sendTimeout = std::chrono::seconds(5);

        void handleMessage(auto& msg)
        {
            if (msg.isACK()) {
                msg.ack();
            } else if (msg.isNAMES()) {
            } else if (msg.isHELLO()) {
            } else if (msg.isGET()) {
            } else if (msg.isSET()) {
            } else if (msg.isCMD()) {
                msg.ack();
            } else {
                msg.err(std::error_code{});  // !!!!!!!!!!!!
            }
        }
    };


    using AdcGenericNetServer::AdcGenericNetServer;

    template <typename DeviceT>
    AdcDeviceNetServer& addDevice(DeviceT* dev_ptr)
    {
    }

protected:
};

}  // namespace adc