#pragma once
#include <string>
#include <unordered_map>
#include <vector>
#include "ClientState.h"

// NetworkInterface.h - Интерфейс для разных типов соединений
namespace ZL {

    struct RemotePlayer
    {
        std::vector<ClientState> timedRemoteStates;

        bool canFetchClientStateAtTime(std::chrono::system_clock::time_point targetTime) const
        {
            if (timedRemoteStates.empty())
            {
                return false;
            }
            if (timedRemoteStates[0].lastUpdateServerTime > targetTime)
            {
                return false;
            }

            return true;
        }

        ClientState fetchClientStateAtTime(std::chrono::system_clock::time_point targetTime) const {

            ClientState closestState;

            if (timedRemoteStates.empty())
            {
                throw std::runtime_error("No timed client states available");
                return closestState;
            }
            if (timedRemoteStates[0].lastUpdateServerTime > targetTime)
            {
                throw std::runtime_error("Found time but it is in future");
                return closestState;
            }
            if (timedRemoteStates.size() == 1)
            {
                closestState = timedRemoteStates[0];
                closestState.apply_lag_compensation(targetTime);
                return closestState;
            }


            for (size_t i = 0; i < timedRemoteStates.size() - 1; ++i)
            {
                const auto& earlierState = timedRemoteStates[i];
                const auto& laterState = timedRemoteStates[i + 1];
                if (earlierState.lastUpdateServerTime <= targetTime && laterState.lastUpdateServerTime >= targetTime)
                {
                    closestState = earlierState;
                    closestState.apply_lag_compensation(targetTime);
                    return closestState;
                }
            }

            closestState = timedRemoteStates[timedRemoteStates.size() - 1];
            closestState.apply_lag_compensation(targetTime);
            return closestState;
        }
    };

    class INetworkClient {
    public:
        virtual ~INetworkClient() = default;
        virtual void Connect(const std::string& host, uint16_t port) = 0;
        virtual void Send(const std::string& message) = 0;
        virtual bool IsConnected() const = 0;
        virtual void Poll() = 0; // Для обработки входящих пакетов
        virtual std::unordered_map<int, RemotePlayer> getRemotePlayers() = 0;
    };
}