#pragma once

#include <asio/awaitable.hpp>
#include <asio/ip/tcp.hpp>
#include <asio/local/seq_packet_protocol.hpp>
#include <asio/local/stream_protocol.hpp>
#include <asio/serial_port.hpp>

#include <spdlog/spdlog.h>

#include "comm_server_endpoint.h"
#include "mount.h"

namespace mcc
{


namespace traits
{

template <typename T>
concept mcc_endpoint_c = std::derived_from<T, asio::serial_port> || std::derived_from<T, asio::ip::tcp::endpoint> ||
                         std::derived_from<T, asio::local::stream_protocol::endpoint> ||
                         std::derived_from<T, asio::local::seq_packet_protocol::endpoint>;

template <typename T>
static constexpr bool is_serial_proto = std::derived_from<T, asio::serial_port>;

template <typename T>
static constexpr bool is_tcp_proto = std::derived_from<T, asio::ip::tcp::endpoint>;

template <typename T>
static constexpr bool is_local_stream_proto = std::derived_from<T, asio::local::stream_protocol::endpoint>;

template <typename T>
static constexpr bool is_local_seqpack_proto = std::derived_from<T, asio::local::seq_packet_protocol::endpoint>;

}  // namespace traits


class MccMountServer
{
public:
    MccMountServer(asio::io_context& ctx, std::shared_ptr<spdlog::logger> logger)
        : _asioContext(ctx), _serverLogger(std::move(logger))
    {
    }

    ~MccMountServer() {}

    void listen(traits::mcc_endpoint_c auto endpoint)
    {
        using epn_t = std::decay_t<decltype(endpoint)>;

        std::error_code ec;

        if constexpr (traits::is_serial_proto<epn_t>) {
            // first, check if port is openned
            if (!endpoint.is_open()) {
                if (ec) {
                    // ??????????
                    _serverLogger->error("Serial port was not open!");
                    return;
                }
            }

            _serialPorts.emplace_back(std::move(endpoint));

        } else if constexpr (traits::is_tcp_proto<epn_t>) {
        } else if constexpr (traits::is_local_stream_proto<epn_t>) {
        } else if constexpr (traits::is_local_seqpack_proto<epn_t>) {
        } else {
            static_assert(false, "INVALID ENDPOINT!!!");
        }
    }


    // close listening on all endpoints
    void stop()
    {
        std::error_code ec;
        size_t N = 0, M = 0;

        _serverLogger->info("Close all listening endpoints ...");

        auto num =
            _serialPorts.size() + _tcpAcceptors.size() + _localStreamAcceptors.size() + _localSeqpackAcceptors.size();
        if (!num) {
            _serverLogger->info("There are no listening ports/sockets!");
            return;
        }

        if (_serialPorts.size()) {
            _serverLogger->debug("Close serial ports ...");

            for (auto& s_port : _serialPorts) {
                s_port.close(ec);
                if (ec) {
                    _serverLogger->error("Cannot close serial port! ec = '{}'", ec.message());
                    ++M;
                }
                ++N;
            }

            _serverLogger->debug("{} from {} serial ports were closed!", M, N);

            _serialPorts.clear();
        }

        if (_tcpAcceptors.size()) {
            _serverLogger->debug("Close TCP listening sockets ...");
            N = 0;
            M = 0;

            for (auto& acc : _tcpAcceptors) {
                acc.close(ec);
                if (ec) {
                    _serverLogger->error("Cannot close TCP socket! ec = '{}'", ec.message());
                    ++M;
                }
                ++N;
            }

            _serverLogger->debug("{} from {} TCP sockets were closed!", M, N);

            _tcpAcceptors.clear();
        }

        if (_localStreamAcceptors.size()) {
            _serverLogger->debug("Close local stream listening sockets ...");
            N = 0;
            M = 0;

            for (auto& acc : _localStreamAcceptors) {
                acc.close(ec);
                if (ec) {
                    _serverLogger->error("Cannot close local stream socket! ec = '{}'", ec.message());
                    ++M;
                }
                ++N;
            }

            _serverLogger->debug("{} from {} local stream sockets were closed!", M, N);

            _localStreamAcceptors.clear();
        }

        if (_localSeqpackAcceptors.size()) {
            _serverLogger->debug("Close local seqpack listening sockets ...");
            N = 0;
            M = 0;

            for (auto& acc : _localSeqpackAcceptors) {
                acc.close(ec);
                if (ec) {
                    _serverLogger->error("Cannot close local seqpack socket! ec = '{}'", ec.message());
                    ++M;
                }
                ++N;
            }

            _serverLogger->debug("{} from {} local seqpack sockets were closed!", M, N);

            _localSeqpackAcceptors.clear();
        }

        _serverLogger->info("The all server listening endpoints were closed!");
    }

private:
    asio::io_context& _asioContext;
    std::shared_ptr<spdlog::logger> _serverLogger;

    std::vector<asio::serial_port> _serialPorts;
    std::vector<asio::ip::tcp::acceptor> _tcpAcceptors;
    std::vector<asio::local::stream_protocol::acceptor> _localStreamAcceptors;
    std::vector<asio::local::seq_packet_protocol::acceptor> _localSeqpackAcceptors;

    void startAccept(traits::mcc_endpoint_c auto endpoint)
    {
        using epn_t = std::decay_t<decltype(endpoint)>;

        try {
            std::stringstream st;
            auto acc = epn_t::protocol_type::endpoint(_asioContext, endpoint);
            st << acc.local_endpoint();
            _serverLogger->info("Try to start listening at <{}> endpoint ...", st.str());

            if constexpr (traits::is_tcp_proto<epn_t>) {
                _tcpAcceptors.emplace_back(std::move(acc));
            } else if constexpr (traits::is_local_stream_proto<epn_t>) {
                _localStreamAcceptors.emplace_back(std::move(acc));
            } else if constexpr (traits::is_local_seqpack_proto<epn_t>) {
                _localSeqpackAcceptors.emplace_back(std::move(acc));
            } else {
                static_assert(false, "INVALID ENDPOINT!!!");
            }


        } catch (const std::system_error& err) {
            _serverLogger->error("An error occured while creating of connection acceptor! ec = '{}'", err.what());
        }
    }

    template <typename AccT>
    void doAccept()
    {
    }
};

}  // namespace mcc