#include "CServer.h"
#include "CEngine.h"
#include "CConVarManager.h"
#include "CBufferWrapper.h"
#include "U_Networking.h"
#include "CClient.h"

CServer::CClient::CClient(const CEndPoint& point) : EndPoint(point) {}

void CServer::V_PostInit()
{
    unsigned short port = Networking::HostPort;
    COMPONENT_CALL_GET(port, CConVarManager, GetConVarValue<unsigned short>("net.hostport", Networking::HostPort));

    Transceiver = std::make_unique<CNetTransceiver>(port);
    Transceiver->Queue.Enabled = true;

    Transceiver->StartAsync();
}

void CServer::ProcessDatagram(boost::asio::ip::udp::endpoint point, std::vector<std::uint8_t>& buffer, CTimePoint ptime)
{
    //Log::Instance() << "[SV] There's a datagram from " << point.address().to_string() << ":" << point.port() << Log::Endl;

    CBufferWrapper packet(buffer);
    if(IsClientExist(point))
    {
        auto& client = GetClient(point);
        client.LastPacket = ptime;

        if(!client.Authorized)
        {
            auto message = packet.ReadLenString<std::uint8_t, std::string>();
            if(message == "EngineGL 5.0 Ready For Transmit")
            {
                client.Authorized = true;
                Log::Instance() << "Client authorized!\n";
                SendServerInfoTo(client);
            }
        }
        else
        {
            HandleClientPacket(client, buffer, ptime);
        }
    }
    else
    {
        auto message = packet.ReadLenString<std::uint8_t, std::string>();
        if(message == "EngineGL 5.0 Connection Cookie")
        {
            auto nickname = packet.ReadLenString<std::uint8_t, std::u16string>();
            auto id = GetFreeID();

            CClient client(point);
            client.NickName = StringUtils::U16ToWstr(nickname);
            client.LastPacket = ptime;
            client.MessagesManager.UserData = static_cast<size_t>(id);
            client.MessagesManager.PackDelay = 1.0 / m_svRate;

            Clients.emplace(id, std::move(client));
            
            std::vector<std::uint8_t> answer_buf;
            CBufferWrapper answer(answer_buf);

            answer.WriteLenString<std::uint8_t, std::string>("EngineGL 5.0 Connection Accepted");

            Transceiver->SendAsync(point, answer_buf);

            Log::Instance() << "[Server] Client #" << id << " connected from " << point.address().to_string() << ":" << point.port();
            Log::Instance() << " with a nickname of \"" << StringUtils::U16ToWstr(nickname) << "\"\n";
        }
    }
}

void CServer::HandleClientPacket(CClient& client, std::vector<std::uint8_t>& buffer, CTimePoint ptime)
{
    client.MessagesManager.AddReceivedPacket(std::move(buffer), ptime);
}

bool CServer::CClient::operator==(const CClient& other) const
{
    return EndPoint == other.EndPoint;
}

void CServer::SendReliableMessageTo(CClient& client, std::shared_ptr<CNetMessage> msg)
{
    client.MessagesManager.SendReliable(msg);
}

void CServer::SendUnreliableMessageTo(CClient& client, std::shared_ptr<CNetMessage> msg)
{
    client.MessagesManager.SendUnreliable(msg);
}

void CServer::SendReliableMessageToAll(std::shared_ptr<CNetMessage> msg)
{
    for(auto& kv : Clients)
    {
        auto& client = kv.second;
        client.MessagesManager.SendReliable(msg); //DONE msg used to be invalid after first send
    }
}

void CServer::SendUnreliableMessageToAll(std::shared_ptr<CNetMessage> msg)
{
    for(auto& kv : Clients)
    {
        auto& client = kv.second;
        client.MessagesManager.SendUnreliable(msg); //DONE msg used to be invalid after first send
    }
}

void CServer::SendServerInfoTo(CClient& client)
{
    auto msg = std::make_shared<CNetServerInfo>();
    SendReliableMessageTo(client, msg);
}

void CServer::SendServerInfoToAll()
{
    auto msg = std::make_shared<CNetServerInfo>();
    SendReliableMessageToAll(msg);
}

void CServer::SetRate(double timesPerSecond)
{
    m_svRate = timesPerSecond;
    for(auto& kv : Clients)
    {
        auto& client = kv.second;
        client.MessagesManager.PackDelay = 1.0 / m_svRate;
    }
    SendServerInfoToAll();
}

void CServer::CClient::Update()
{
    if(Authorized)
    {
        auto server = CEngine::GetInstance()->Components.GetComponentTyped<CServer>();
        MessagesManager.ProcessPackets();
        MessagesManager.ProcessMessages();

        std::vector<std::uint8_t> snapshot;
        if(MessagesManager.PackSnapshot(snapshot))
        {
            server->Transceiver->SendAsync(EndPoint, snapshot);
        }
    }
}

void CServer::V_Update()
{
    std::uint32_t timeout = 20000;
    COMPONENT_CALL_GET(timeout, CConVarManager, GetConVarValue<std::uint32_t>("net.timeout", 20000));

    std::vector<clientid_t> ToKick;
    for(auto& kv : Clients)
    {
        auto& client = kv.second;
        auto diff = CEngine::GetInstance()->Time.GetCurrent() - client.LastPacket;

        if(diff >= std::chrono::milliseconds(timeout))
        {
            ToKick.push_back(kv.first);
        }
    }

    for(auto tokick : ToKick)
    {
        //TODO kick client
    }

    std::vector<CNetTransceiver::CPacket> packets;
    {
        std::lock_guard<std::mutex> _lock(Transceiver->Queue.Mutex);
        packets.swap(Transceiver->Queue.Container);
    }

    for(auto& pack : packets)
    {
        ProcessDatagram(pack.From, pack.Data, pack.ReceivedAt);
    }

    for(auto& kv : Clients)
    {
        auto& client = kv.second;
        client.Update();
    }
}

clientid_t CServer::GetFreeID()
{
    clientid_t max = std::numeric_limits<clientid_t>::max();

    for(clientid_t i = 0; i <= max; i++)
    {
        auto it = Clients.find(i);
        if(it == Clients.end())
        {
            return i;
        }
    }
    return max;
}

bool CServer::IsClientExist(const CEndPoint& endpoint)
{
    return m_getClientIterator(endpoint) != Clients.end();
}

CServer::CClient& CServer::GetClient(const CEndPoint& endpoint)
{
    return m_getClientIterator(endpoint)->second;
}

std::unordered_map<clientid_t, CServer::CClient>::iterator CServer::m_getClientIterator(const CEndPoint& endpoint)
{
    return std::find_if(Clients.begin(), Clients.end(), [&endpoint](auto& kv) -> bool { return kv.second.EndPoint == endpoint; });
}

double CServer::GetRate() const
{
    return m_svRate;
}

void CNetServerInfo::V_Write(CBufferWrapper& wrapper)
{
    auto server = CEngine::GetInstance()->Components.GetComponentTyped<CServer>();
    if(!server) { return; }

    wrapper.Write<double>(server->GetRate());
}

void CNetServerInfo::V_Read(CBufferWrapper& wrapper)
{
    Rate = wrapper.Read<double>();
}

void CNetServerInfo::Process()
{
    auto client = CEngine::GetInstance()->Components.GetComponentTyped<CClient>();
    if(!client) { return; }

    client->SetServerRate(Rate);
}

LINK_SOL_USERTYPE(CServer);
LINK_NET_MESSAGE_TO_CLASS(CNetServerInfo, serverinfo);
LINK_COMPONENT_TO_CLASS(CServer, server);