#include <iostream>
#include <thread>
#include <chrono>
#include <atomic>
#include <string>
#include <vector>

// 包含TCPServer头文件
#include "IYTCPServer.h"

class TCPServerTest
{
private:
    IYTCPServer* m_pServer;
    std::atomic<bool> m_bRunning;
    int m_nPort;
    std::thread m_sendThread;

public:
    /**
     * @brief 构造函数
     * @param port 服务器监听端口
     */
    TCPServerTest(int port) : m_pServer(nullptr), m_bRunning(false), m_nPort(port)
    {
        // 创建TCPServer实例
        if (!VrCreatYTCPServer(&m_pServer)) {
            std::cerr << "Failed to create TCPServer instance" << std::endl;
        }
    }

    /**
     * @brief 析构函数
     */
    ~TCPServerTest()
    {
        Stop();
        if (m_pServer) {
            m_pServer->Close();
            delete m_pServer;
            m_pServer = nullptr;
        }
    }

    /**
     * @brief 初始化服务器
     * @return true表示成功，false表示失败
     */
    bool Initialize()
    {
        if (!m_pServer) {
            return false;
        }

        // 初始化socket
        if (!m_pServer->Init(m_nPort, false)) {
            std::cerr << "Failed to initialize server socket" << std::endl;
            return false;
        }

        // 设置事件回调
        m_pServer->SetEventCallback([this](const TCPClient* pClient, TCPServerEventType eventType) {
            this->OnServerEvent(pClient, eventType);
        });

        // 启动服务器线程
        if (!m_pServer->Start([this](const TCPClient* pClient, const char* pData, const unsigned int nLen) {
            this->OnDataReceived(pClient, pData, nLen);
        }, false)) {
            std::cerr << "Failed to start server" << std::endl;
            return false;
        }

        std::cout << "Server initialized successfully on port " << m_nPort << std::endl;
        return true;
    }

    /**
     * @brief 启动数据发送线程
     * @return true表示成功，false表示失败
     */
    bool Start()
    {
        if (!m_pServer) {
            return false;
        }

        m_bRunning = true;
        m_sendThread = std::thread(&TCPServerTest::SendDataLoop, this);
        std::cout << "Server started, sending data to clients..." << std::endl;
        return true;
    }

    /**
     * @brief 停止服务器
     */
    void Stop()
    {
        m_bRunning = false;
        
        if (m_sendThread.joinable()) {
            m_sendThread.join();
        }

        if (m_pServer) {
            m_pServer->Stop();
        }

        std::cout << "Server stopped" << std::endl;
    }

private:
    /**
     * @brief 服务器事件回调函数
     * @param pClient 客户端指针
     * @param eventType 事件类型
     */
    void OnServerEvent(const TCPClient* pClient, TCPServerEventType eventType)
    {
        switch (eventType) {
        case TCP_EVENT_CLIENT_CONNECTED:
            std::cout << "Client connected" << std::endl;
            break;
        case TCP_EVENT_CLIENT_DISCONNECTED:
            std::cout << "Client disconnected" << std::endl;
            break;
        case TCP_EVENT_CLIENT_EXCEPTION:
            std::cout << "Client exception" << std::endl;
            break;
        default:
            std::cout << "Unknown event" << std::endl;
            break;
        }
    }

    /**
     * @brief 数据接收回调函数
     * @param pClient 客户端指针
     * @param pData 数据指针
     * @param nLen 数据长度
     */
    void OnDataReceived(const TCPClient* pClient, const char* pData, const unsigned int nLen)
    {
        // 服务器测试程序只需要发送数据，不需要处理接收的数据
        std::cout << "Received " << nLen << " bytes from client" << std::endl;
    }

    /**
     * @brief 持续发送数据的循环
     */
    void SendDataLoop()
    {
        int counter = 0;
        char pData[1024];
        while (m_bRunning) {
            // 构造要发送的数据
            *(int *)(pData) = ++counter;
            
            // 发送给所有连接的客户端
            if (m_pServer) {
                m_pServer->SendAllData(pData, sizeof(pData));
            }

            // 每秒发送一次
            std::this_thread::sleep_for(std::chrono::milliseconds(10));
        }
    }
};

int main(int argc, char* argv[])
{
    std::cout << "TCP Server Test Program" << std::endl;
    std::cout << "=======================" << std::endl;

    // 默认端口为8080
    int port = 8080;
    if (argc > 1) {
        port = std::stoi(argv[1]);
    }

    TCPServerTest serverTest(port);

    // 初始化服务器
    if (!serverTest.Initialize()) {
        std::cerr << "Failed to initialize server" << std::endl;
        return -1;
    }

    // 启动服务器
    if (!serverTest.Start()) {
        std::cerr << "Failed to start server" << std::endl;
        return -1;
    }

    // 等待用户输入以停止服务器
    std::cout << "Server is running. Press Enter to stop..." << std::endl;
    while(true){
        std::cin.get();
        std::this_thread::sleep_for(std::chrono::seconds(10));
    }

    // 停止服务器
    serverTest.Stop();

    std::cout << "TCP Server Test completed!" << std::endl;
    return 0;
}