// server/sv_main.cpp
#include "common/types.hpp"
#include "common/enet_wrapper.hpp"
#include "common/serialization.hpp"
#include "common/network_messages.hpp"
#include "common/timestamp.hpp"
#include "common/simulation_params.hpp"
#include "sapp/server_world.hpp"

#include <iostream>
#include <unordered_map>
#include <string>
#include <format>
#include <thread>
#include <chrono>
#include <vector>

using namespace netcode;

struct ClientSession {
    ENetPeer* peer = nullptr;
    ClientId client_id = INVALID_CLIENT_ID;
    EntityId entity_id = INVALID_ENTITY_ID;
    std::string name;
    bool authenticated = false;

    uint64_t last_ping_time = 0;
    uint64_t estimated_rtt_us = 0;
    uint64_t last_activity_time = 0;

    CompensationAlgorithm client_algorithm = CompensationAlgorithm::Hybrid;
};

class GameServer {
public:
    explicit GameServer(uint16_t port = 7777, const SimulationParams& params = DEFAULT_SIMULATION_PARAMS)
        : port_(port)
        , params_(params)
        , world_(params)
    {}

    bool start() {
        if (!network_.create_server(port_, 16)) {
            std::cerr << "Failed to create server on port " << port_ << "\n";
            return false;
        }

        std::cout << "Server started on port " << port_ << "\n";
        std::cout << "Tick rate: " << params_.tick_rate << " Hz\n";
        std::cout << "Snapshot rate: " << params_.snapshot_rate << " Hz\n";

        running_ = true;
        return true;
    }

    void run() {
        using namespace std::chrono;

        auto last_tick_time = steady_clock::now();
        auto last_timeout_check = steady_clock::now();

        double tick_accumulator = 0.0;
        double snapshot_accumulator = 0.0;
        double log_timer = 0.0;

        while (running_) {
            auto now = steady_clock::now();

            // Прошедшее время с последнего тика
            double dt = duration<double>(now - last_tick_time).count();

            // Обработка сети
            process_network();

            // тики
            uint32_t ticks_performed = 0;
            tick_accumulator += dt;
            while (tick_accumulator >= params_.tick_interval() && ticks_performed < 8) {
                world_.tick();
                tick_accumulator -= params_.tick_interval();
                tick_count_++;
                ticks_performed++;
            }

            // снапшоты
            snapshot_accumulator += dt;
            if (snapshot_accumulator >= params_.snapshot_interval()) {
                send_snapshots();
                snapshot_count_++;
                snapshot_accumulator -= params_.snapshot_interval();
            }

            // проверка таймаутов
            if (duration<double>(now - last_timeout_check).count() >= 5.0) {
                check_timeouts();
                last_timeout_check = now;
            }

            // логирование
            log_timer += dt;
            if (log_timer >= 1.0) {
                print_stats();
                log_timer -= 1.0;
            }

            // вычисление следующего тика
            double time_to_next_tick = params_.tick_interval() - tick_accumulator;
            double time_to_next_snapshot = params_.snapshot_interval() - snapshot_accumulator;

            double time_to_next_event = (std::min)(time_to_next_tick, time_to_next_snapshot);
            time_to_next_event = (std::max)(time_to_next_event, 0.0);

            // Обновляем время последнего тика
            last_tick_time = now;

            // Спим до следующего события
            if (time_to_next_event > 0.0005) {  // > 500 мкс
                auto sleep_duration = duration_cast<microseconds>(duration<double>(time_to_next_event));
                std::this_thread::sleep_for(sleep_duration);
            } else {
                std::this_thread::yield();  // если система решит забрать это время то ждем, если нет -- сразу начинаем выполнение
            }
        }
    }

    void stop() {
        running_ = false;
    }

private:
    void process_network() {
        ENetEvent event;
        while (network_.service(event, 0) > 0) {
            switch (event.type) {
                case ENET_EVENT_TYPE_CONNECT:
                    handle_connect(event.peer);
                    break;

                case ENET_EVENT_TYPE_RECEIVE:
                    handle_packet(event.peer, event.packet);
                    enet_packet_destroy(event.packet);
                    break;

                case ENET_EVENT_TYPE_DISCONNECT:
                    handle_disconnect(event.peer);
                    break;

                default:
                    break;
            }
        }
    }

    void handle_connect(ENetPeer* peer) {
        char hostStr[46];
        if (enet_address_get_host_ip(&peer->address, hostStr, sizeof(hostStr)) == 0) {
            std::cout << "New connection from "
                      << hostStr << ":"
                      << peer->address.port << "\n";
        } else {
            std::cout << "New connection from [unknown address]:"
                      << peer->address.port << "\n";
        }
    }

    void handle_disconnect(ENetPeer* peer) {
        auto it = sessions_by_peer_.find(peer);
        if (it != sessions_by_peer_.end()) {
            ClientId client_id = it->second;
            auto session_it = sessions_.find(client_id);
            if (session_it != sessions_.end()) {
                std::cout << "Player disconnected: " << session_it->second.name
                          << " (ID: " << client_id << ")\n";

                world_.remove_player(client_id);
                sessions_.erase(session_it);
            }
            sessions_by_peer_.erase(it);
        }
    }

    void handle_packet(ENetPeer* peer, ENetPacket* packet) {
        if (packet->dataLength < 1) return;

        ReadBuffer buf(packet->data, packet->dataLength);
        uint8_t type_byte;
        if (!buf.read_u8(type_byte)) return;

        MessageType type = static_cast<MessageType>(type_byte);

        switch (type) {
            case MessageType::ClientConnect:
                handle_client_connect(peer, buf);
                break;
            case MessageType::ClientInput:
                handle_client_input(peer, buf);
                break;
            case MessageType::ClientSetAlgorithm:
                handle_client_set_algorithm(peer, buf);
                break;
            case MessageType::PingRequest:
                handle_ping_request(peer, buf);
                break;
            default:
                break;
        }
    }

    void handle_client_connect(ENetPeer* peer, ReadBuffer& buf) {
        uint32_t protocol_version;
        if (!buf.read_u32(protocol_version)) return;

        uint8_t name_len;
        if (!buf.read_u8(name_len)) return;
        char name[33] = {};
        if (name_len > 0 && name_len <= 32) {
            buf.read_bytes(name, name_len);
        }

        uint8_t team_pref_byte;
        TeamId team_preference = TeamId::None;
        if (buf.read_u8(team_pref_byte)) {
            team_preference = static_cast<TeamId>(team_pref_byte);
        }

        if (protocol_version != 1) {
            send_reject(peer, ServerRejectMessage::Reason::VersionMismatch);
            return;
        }

        if (sessions_.size() >= 16) {
            send_reject(peer, ServerRejectMessage::Reason::ServerFull);
            return;
        }

        ClientId client_id = next_client_id_++;
        EntityId entity_id = world_.create_player(client_id, name, team_preference);
        TeamId team = world_.get_player_team(client_id);

        ClientSession session;
        session.peer = peer;
        session.client_id = client_id;
        session.entity_id = entity_id;
        session.name = name;
        session.authenticated = true;
        session.last_activity_time = Timestamp::now_us();  // НОВОЕ

        sessions_[client_id] = session;
        sessions_by_peer_[peer] = client_id;

        send_accept(peer, client_id, entity_id, team);
        send_config(peer);

        std::cout << "Player connected: " << name
                  << " (ID: " << client_id
                  << ", Entity: " << entity_id
                  << ", Team: " << (team == TeamId::Red ? "Red" : "Blue")
                  << ", Preferred: " << (team_preference == TeamId::Red ? "Red" :
                                        team_preference == TeamId::Blue ? "Blue" : "Auto") << ")\n";
    }

    void handle_client_input(ENetPeer* peer, ReadBuffer& buf) {
        auto it = sessions_by_peer_.find(peer);
        if (it == sessions_by_peer_.end()) return;

        ClientId client_id = it->second;

        auto session_it = sessions_.find(client_id);
        if (session_it != sessions_.end()) {
            session_it->second.last_activity_time = Timestamp::now_us();
        }

        uint8_t input_count;
        if (!buf.read_u8(input_count)) return;

        for (uint8_t i = 0; i < input_count && i < 16; ++i) {
            InputCommand cmd;
            if (!buf.read_u32(cmd.sequence)) break;
            if (!buf.read_u32(cmd.client_tick)) break;
            if (!buf.read_u64(cmd.timestamp_us)) break;

            uint8_t input_byte;
            if (!buf.read_u8(input_byte)) break;
            cmd.input = InputState::from_byte(input_byte);

            world_.add_player_input(client_id, cmd);
            inputs_received_++;
        }
    }

    void handle_client_set_algorithm(ENetPeer* peer, ReadBuffer& buf) {
        auto it = sessions_by_peer_.find(peer);
        if (it == sessions_by_peer_.end()) return;

        uint8_t algo_byte;
        if (!buf.read_u8(algo_byte)) return;

        ClientId client_id = it->second;
        auto session_it = sessions_.find(client_id);
        if (session_it != sessions_.end()) {
            session_it->second.client_algorithm = static_cast<CompensationAlgorithm>(algo_byte);
            std::cout << "Client " << client_id << " switched to algorithm: "
                      << algorithm_name(session_it->second.client_algorithm) << "\n";
        }
    }

    void handle_ping_request(ENetPeer* peer, ReadBuffer& buf) {
        uint32_t ping_id;
        uint64_t client_time;
        if (!buf.read_u32(ping_id)) return;
        if (!buf.read_u64(client_time)) return;

        WriteBuffer response;
        response.write_u8(static_cast<uint8_t>(MessageType::PingResponse));
        response.write_u32(ping_id);
        response.write_u64(client_time);
        response.write_u64(Timestamp::now_us());
        response.write_u32(world_.current_tick());

        network_.send(peer, NetworkChannel::Unreliable, response.data(), response.size(), false);

        auto it = sessions_by_peer_.find(peer);
        if (it != sessions_by_peer_.end()) {
            auto session_it = sessions_.find(it->second);
            if (session_it != sessions_.end()) {
                uint64_t now = Timestamp::now_us();
                if (session_it->second.last_ping_time > 0) {
                    session_it->second.estimated_rtt_us = now - session_it->second.last_ping_time;
                    world_.update_player_rtt(it->second, session_it->second.estimated_rtt_us);
                }
                session_it->second.last_ping_time = now;
            }
        }
    }

    void check_timeouts() {
        uint64_t now = Timestamp::now_us();
        const uint64_t timeout_us = 30'000'000; // 30 секунд

        std::vector<ClientId> to_disconnect;

        for (const auto& [client_id, session] : sessions_) {
            if (session.authenticated &&
                session.last_activity_time > 0 &&
                now - session.last_activity_time > timeout_us) {
                to_disconnect.push_back(client_id);
            }
        }

        for (ClientId client_id : to_disconnect) {
            auto it = sessions_.find(client_id);
            if (it != sessions_.end()) {
                std::cout << "Client timeout: " << it->second.name << "\n";
                if (it->second.peer) {
                    enet_peer_disconnect(it->second.peer, 0);
                }
                world_.remove_player(client_id);
                sessions_by_peer_.erase(it->second.peer);
                sessions_.erase(it);
            }
        }
    }

    void send_reject(ENetPeer* peer, ServerRejectMessage::Reason reason) {
        WriteBuffer buf;
        buf.write_u8(static_cast<uint8_t>(MessageType::ServerReject));
        buf.write_u8(static_cast<uint8_t>(reason));

        network_.send(peer, NetworkChannel::Reliable, buf.data(), buf.size(), true);
    }

    void send_accept(ENetPeer* peer, ClientId client_id, EntityId entity_id, TeamId team) {
        WriteBuffer buf;
        buf.write_u8(static_cast<uint8_t>(MessageType::ServerAccept));
        buf.write_u16(client_id);
        buf.write_u32(entity_id);
        buf.write_u8(static_cast<uint8_t>(team));
        buf.write_u32(world_.current_tick());
        buf.write_u64(Timestamp::now_us());

        network_.send(peer, NetworkChannel::Reliable, buf.data(), buf.size(), true);
    }

    void send_config(ENetPeer* peer) {
        WriteBuffer buf;
        buf.write_u8(static_cast<uint8_t>(MessageType::ServerConfig));
        buf.write_u32(params_.tick_rate);
        buf.write_u32(params_.snapshot_rate);
        buf.write_float(params_.arena_width);
        buf.write_float(params_.arena_height);
        buf.write_float(params_.player_radius);
        buf.write_float(params_.player_max_speed);
        buf.write_float(params_.ball_radius);

        network_.send(peer, NetworkChannel::Reliable, buf.data(), buf.size(), true);
    }

    void send_snapshots() {
        if (sessions_.empty()) return;

        WorldSnapshot snapshot = world_.create_snapshot();

        WriteBuffer buf;
        serialize_snapshot(buf, snapshot);

        network_.broadcast(NetworkChannel::Unreliable, buf.data(), buf.size(), false);
        snapshots_sent_++;
    }

    void print_stats() {
        std::cout << std::format("[Tick {}] Players: {} | Inputs/s: {} | Snapshots/s: {} | Red: {:.1f}s | Blue: {:.1f}s\n",
                                 world_.current_tick(),
                                 sessions_.size(),
                                 inputs_received_,
                                 snapshots_sent_,
                                 world_.red_team_time(),
                                 world_.blue_team_time());

        inputs_received_ = 0;
        snapshots_sent_ = 0;
    }

private:
    uint16_t port_;
    SimulationParams params_;

    ENetInitializer enet_init_;
    NetworkHost network_;

    ServerWorld world_;

    std::unordered_map<ClientId, ClientSession> sessions_;
    std::unordered_map<ENetPeer*, ClientId> sessions_by_peer_;

    ClientId next_client_id_ = 1;

    bool running_ = false;

    uint32_t tick_count_ = 0;
    uint32_t snapshot_count_ = 0;
    uint32_t inputs_received_ = 0;
    uint32_t snapshots_sent_ = 0;
    double log_timer_ = 0.0;
};

int main(int argc, char* argv[]) {
    uint16_t port = 7777;
    SimulationParams params = DEFAULT_SIMULATION_PARAMS;

    for (int i = 1; i < argc; ++i) {
        std::string arg = argv[i];
        if (arg == "-p" || arg == "--port") {
            if (i + 1 < argc) port = static_cast<uint16_t>(std::stoi(argv[++i]));
        } else if (arg == "--tick-rate") {
            if (i + 1 < argc) {
                params.tick_rate = static_cast<uint32_t>(std::stoi(argv[++i]));
                params.fixed_delta_time = 1.0 / params.tick_rate;
            }
        } else if (arg == "--snapshot-rate") {
            if (i + 1 < argc) {
                params.snapshot_rate = static_cast<uint32_t>(std::stoi(argv[++i]));
            }
        } else if (arg == "--help") {
            std::cout << "Usage: server [-p port] [--tick-rate N] [--snapshot-rate N]\n";
            return 0;
        }
    }

    try {
        GameServer server(port, params);
        if (server.start()) {
            server.run();
        }
    } catch (const std::exception& e) {
        std::cerr << "Error: " << e.what() << "\n";
        return 1;
    }

    return 0;
}