server.cpp

#include "Server.h"
#include "CryptoUtil.h"
#include "Protocol.h"

#include <spdlog/spdlog.h>
#include <algorithm>
#include <sstream>

// ─────────────────────────────────────────────────────────
//  初始化
// ─────────────────────────────────────────────────────────
Server::Server(uint16_t port)
    : port_(port)
    , listen_socket_(INVALID_SOCKET)
{
    FD_ZERO(&master_set_);
    db_ = std::make_unique<Database>("db/chatroom.db");
}

Server::~Server() {
    Stop();
}

// ─────────────────────────────────────────────────────────
//  启动
// ─────────────────────────────────────────────────────────
bool Server::Start() {
    WSADATA wsa_data;
    int rc = WSAStartup(MAKEWORD(2, 2), &wsa_data);
    if (rc != 0) {
        spdlog::error("[Server] WSAStartup 失败，错误码: {}", rc);
        return false;
    }
    spdlog::info("[Server] Winsock 初始化成功，版本: {}.{}",
                 LOBYTE(wsa_data.wVersion), HIBYTE(wsa_data.wVersion));

    if (!db_->Initialize()) {
        spdlog::error("[Server] 数据库初始化失败");
        WSACleanup();
        return false;
    }

    listen_socket_ = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
    if (listen_socket_ == INVALID_SOCKET) {
        spdlog::error("[Server] socket() 失败: {}", WSAGetLastError());
        WSACleanup();
        return false;
    }

    // SO_REUSEADDR 允许快速重启
    int reuse = 1;
    setsockopt(listen_socket_, SOL_SOCKET, SO_REUSEADDR,
               reinterpret_cast<const char*>(&reuse), sizeof(reuse));

    // TCP keepalive：自动检测断线
    int keepalive = 1;
    setsockopt(listen_socket_, SOL_SOCKET, SO_KEEPALIVE,
               reinterpret_cast<const char*>(&keepalive), sizeof(keepalive));

    sockaddr_in addr{};
    addr.sin_family      = AF_INET;
    addr.sin_addr.s_addr = INADDR_ANY;
    addr.sin_port        = htons(port_);

    if (bind(listen_socket_, reinterpret_cast<sockaddr*>(&addr), sizeof(addr)) == SOCKET_ERROR) {
        spdlog::error("[Server] bind 失败，端口 {}，错误: {}", port_, WSAGetLastError());
        closesocket(listen_socket_);
        WSACleanup();
        return false;
    }

    if (listen(listen_socket_, SOMAXCONN) == SOCKET_ERROR) {
        spdlog::error("[Server] listen 失败: {}", WSAGetLastError());
        closesocket(listen_socket_);
        WSACleanup();
        return false;
    }

    {
        std::lock_guard lock(fd_set_mutex_);
        FD_SET(listen_socket_, &master_set_);
    }

    running_ = true;
    spdlog::info("[Server] 服务端启动，监听端口: {}", port_);
    return true;
}

// ─────────────────────────────────────────────────────────
//  主循环
// ─────────────────────────────────────────────────────────
void Server::Run() {
    spdlog::info("[Server] 进入主循环，等待客户端连接...");

    while (running_.load(std::memory_order_relaxed)) {
        fd_set read_fds;

        // 复制监控集合（线程安全）
        {
            std::lock_guard lock(fd_set_mutex_);
            read_fds = master_set_;
        }

        struct timeval timeout = {1, 0};
        int ready = select(0, &read_fds, nullptr, nullptr, &timeout);

        if (!running_.load(std::memory_order_relaxed)) break;

        if (ready == SOCKET_ERROR) {
            int err = WSAGetLastError();
            if (err == WSAEINTR) continue;
            spdlog::error("[Server] select() 失败: {}", err);
            break;
        }

        if (ready == 0) continue;

        // 检查监听 socket
        if (FD_ISSET(listen_socket_, &read_fds)) {
            AcceptNewClient();
        }

        // 收集待断开的 socket（在锁外遍历，DisconnectClient 内部加锁）
        std::vector<SOCKET> to_disconnect;
        auto sessions = clients_.getAllSessions();
        for (const auto& [sock, _] : sessions) {
            if (FD_ISSET(sock, &read_fds)) {
                auto session = clients_.find(sock);
                if (session && !ReadFromClient(session)) {
                    to_disconnect.push_back(sock);
                }
            }
        }

        for (SOCKET sock : to_disconnect) {
            DisconnectClient(sock, "连接异常或主动断开");
        }
    }

    // 退出时清理所有客户端
    auto sessions = clients_.getAllSessions();
    for (const auto& [sock, _] : sessions) {
        closesocket(sock);
    }
    clients_.clear();

    if (listen_socket_ != INVALID_SOCKET) {
        closesocket(listen_socket_);
        listen_socket_ = INVALID_SOCKET;
    }

    WSACleanup();
    spdlog::info("[Server] 服务端已关闭");
}

// ─────────────────────────────────────────────────────────
//  停止
// ─────────────────────────────────────────────────────────
void Server::Stop() {
    running_ = false;
}

// ─────────────────────────────────────────────────────────
//  接受新连接
// ─────────────────────────────────────────────────────────
void Server::AcceptNewClient() {
    sockaddr_in client_addr{};
    int addr_len = sizeof(client_addr);

    SOCKET client_sock = accept(listen_socket_,
                                 reinterpret_cast<sockaddr*>(&client_addr),
                                 &addr_len);
    if (client_sock == INVALID_SOCKET) {
        spdlog::error("[Server] accept() 失败: {}", WSAGetLastError());
        return;
    }

    char ip_buf[INET_ADDRSTRLEN] = {};
    inet_ntop(AF_INET, &client_addr.sin_addr, ip_buf, sizeof(ip_buf));
    uint16_t client_port = ntohs(client_addr.sin_port);

    spdlog::info("[Server] 新连接: {}:{} (socket={})", ip_buf, client_port, client_sock);

    {
        std::lock_guard lock(fd_set_mutex_);
        FD_SET(client_sock, &master_set_);
    }

    auto session = std::make_shared<ClientSession>(client_sock);
    clients_.insert(client_sock, session);
}

// ─────────────────────────────────────────────────────────
//  从客户端读取数据
// ─────────────────────────────────────────────────────────
bool Server::ReadFromClient(std::shared_ptr<ClientSession> session) {
    char buf[4096];
    int bytes = recv(session->socket, buf, sizeof(buf), 0);

    if (bytes == 0) {
        std::string who = session->username.empty()
            ? ("未登录客户端[socket=" + std::to_string(session->socket) + "]")
            : session->username;
        spdlog::info("[Server] {} 正常断开", who);
        return false;
    }

    if (bytes == SOCKET_ERROR) {
        int err = WSAGetLastError();
        std::string who = session->username.empty()
                              ? ("socket_" + std::to_string(session->socket))
                              : session->username;
        spdlog::error("[Server] recv() 失败，客户端 {}，错误: {}", who, err);
        return false;
    }

    session->recv_buf.insert(session->recv_buf.end(), buf, buf + bytes);
    ProcessRecvBuffer(session);
    return true;
}

// ─────────────────────────────────────────────────────────
//  粘包处理
// ─────────────────────────────────────────────────────────
void Server::ProcessRecvBuffer(std::shared_ptr<ClientSession> session) {
    auto& buf = session->recv_buf;

    while (buf.size() >= HEADER_SIZE) {
        PacketHeader hdr;
        std::memcpy(&hdr, buf.data(), HEADER_SIZE);

        hdr.magic       = ntohl(hdr.magic);
        hdr.body_length = ntohl(hdr.body_length);
        hdr.msg_type    = ntohs(hdr.msg_type);

        if (hdr.magic != PACKET_MAGIC) {
            spdlog::error("[Server] socket={} 发送非法报文 (magic={:#010x})",
                          session->socket, hdr.magic);
            buf.clear();
            DisconnectClient(session->socket, "非法报文");
            return;
        }

        if (hdr.body_length > MAX_BODY_SIZE) {
            spdlog::error("[Server] socket={} 发送超大消息 ({} bytes)，断开",
                          session->socket, hdr.body_length);
            buf.clear();
            DisconnectClient(session->socket, "消息体过大");
            return;
        }

        size_t total_needed = HEADER_SIZE + hdr.body_length;
        if (buf.size() < total_needed) break;

        std::vector<uint8_t> body(buf.begin() + HEADER_SIZE, buf.begin() + total_needed);

        if (hdr.is_encrypted) {
            std::vector<uint8_t> decrypted;
            if (!CryptoUtil::Decrypt(body, decrypted)) {
                spdlog::error("[Server] socket={} 消息解密失败", session->socket);
                buf.erase(buf.begin(), buf.begin() + total_needed);
                continue;
            }
            body = std::move(decrypted);
        }

        std::string body_str(body.begin(), body.end());
        DispatchMessage(session, hdr, body_str);

        buf.erase(buf.begin(), buf.begin() + total_needed);
    }
}

// ─────────────────────────────────────────────────────────
//  断开并清理客户端
// ─────────────────────────────────────────────────────────
void Server::DisconnectClient(SOCKET sock, const std::string& reason) {
    auto session = clients_.find(sock);
    if (!session) return;

    std::string who = session->username.empty()
        ? ("socket_" + std::to_string(sock))
        : session->username;

    bool was_authenticated = session->authenticated && !session->username.empty();

    spdlog::info("[Server] 断开客户端: {} (原因: {})", who, reason);

    if (was_authenticated) {
        std::string notify = session->username + " 已离开聊天室";
        BroadcastSystem(notify, sock);
        if (onClientLeave_) onClientLeave_(session->username);
        if (onOnlineCount_) onOnlineCount_(static_cast<int>(clients_.authenticatedCount()));
    }

    {
        std::lock_guard lock(fd_set_mutex_);
        FD_CLR(sock, &master_set_);
    }

    closesocket(sock);
    clients_.erase(sock);
}

// ─────────────────────────────────────────────────────────
//  消息分发
// ─────────────────────────────────────────────────────────
void Server::DispatchMessage(std::shared_ptr<ClientSession> session,
                             const PacketHeader& hdr,
                             const std::string& body) {
    if (!session->authenticated) {
        if (hdr.msg_type != static_cast<uint16_t>(MessageType::MSG_LOGIN_REQ) &&
            hdr.msg_type != static_cast<uint16_t>(MessageType::MSG_REGISTER_REQ) &&
            hdr.msg_type != static_cast<uint16_t>(MessageType::MSG_ECHO_REQ))
        {
            spdlog::warn("[Server] 未认证客户端 (socket={}) 发送了需认证消息类型 {:#x}",
                         session->socket, hdr.msg_type);
            SendPacket(session->socket, MessageType::MSG_SYSTEM_NOTIFY, "请先登录");
            return;
        }
    }

    switch (static_cast<MessageType>(hdr.msg_type)) {
        case MessageType::MSG_LOGIN_REQ:       OnLoginReq(session, body);       break;
        case MessageType::MSG_REGISTER_REQ:    OnRegisterReq(session, body);    break;
        case MessageType::MSG_LOGOUT:          OnLogout(session);              break;
        case MessageType::MSG_CHAT_PUBLIC:     OnChatPublic(session, body);    break;
        case MessageType::MSG_CHAT_PRIVATE:    OnChatPrivate(session, body);    break;
        case MessageType::MSG_ONLINE_LIST_REQ:  OnOnlineListReq(session);        break;
        case MessageType::MSG_KICK_REQ:        OnKickReq(session, body);        break;
        case MessageType::MSG_ECHO_REQ:        OnEchoReq(session, body);        break;
        default:
            spdlog::warn("[Server] 未知消息类型: {:#x}", hdr.msg_type);
            break;
    }
}

// ─────────────────────────────────────────────────────────
//  登录处理
// ─────────────────────────────────────────────────────────
void Server::OnLoginReq(std::shared_ptr<ClientSession> session, const std::string& body) {
    auto fields = SplitFields(body, '|', 2);
    if (fields.size() < 2) {
        SendPacket(session->socket, MessageType::MSG_LOGIN_RESP,
                   std::to_string(static_cast<int>(StatusCode::RC_ERROR)) + "|参数错误");
        return;
    }

    const std::string& username = fields[0];
    const std::string& password = fields[1];

    if (session->authenticated) {
        SendPacket(session->socket, MessageType::MSG_LOGIN_RESP,
                   std::to_string(static_cast<int>(StatusCode::RC_ERROR)) + "|已经登录");
        return;
    }

    UserInfo user;
    if (!db_->AuthenticateUser(username, password, user)) {
        spdlog::warn("[Server] 登录失败: {} - 用户名或密码错误", username);
        SendPacket(session->socket, MessageType::MSG_LOGIN_RESP,
                   std::to_string(static_cast<int>(StatusCode::RC_AUTH_FAILED)) + "|用户名或密码错误");
        return;
    }

    // 检查同名用户是否已在线（使用线程安全的查找）
    if (clients_.findByUsername(username)) {
        SendPacket(session->socket, MessageType::MSG_LOGIN_RESP,
                   std::to_string(static_cast<int>(StatusCode::RC_ERROR)) + "|该账号已在线");
        return;
    }

    session->authenticated = true;
    session->username = username;
    session->is_admin = user.is_admin;

    std::string role = user.is_admin ? "管理员" : "普通用户";
    spdlog::info("[Server] 用户登录: {} [{}]", username, role);

    SendPacket(session->socket, MessageType::MSG_LOGIN_RESP,
               std::to_string(static_cast<int>(StatusCode::RC_OK)) +
               "|登录成功|" + (user.is_admin ? "1" : "0"));
    BroadcastSystem(username + " 加入了聊天室", session->socket);

    // 触发 GUI 回调
    if (onClientJoin_) onClientJoin_(username);
    if (onOnlineCount_) onOnlineCount_(static_cast<int>(clients_.authenticatedCount()));
}

// ─────────────────────────────────────────────────────────
//  注册处理
// ─────────────────────────────────────────────────────────
void Server::OnRegisterReq(std::shared_ptr<ClientSession> session, const std::string& body) {
    auto fields = SplitFields(body, '|', 2);
    if (fields.size() < 2) {
        SendPacket(session->socket, MessageType::MSG_REGISTER_RESP,
                   std::to_string(static_cast<int>(StatusCode::RC_ERROR)) + "|参数错误");
        return;
    }

    const std::string& username = fields[0];
    const std::string& password = fields[1];

    if (username.size() < 3 || username.size() > 20 ||
        username.find_first_not_of(
            "abcdefghijklmnopqrstuvwxyz"
            "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
            "0123456789_") != std::string::npos)
    {
        SendPacket(session->socket, MessageType::MSG_REGISTER_RESP,
                   std::to_string(static_cast<int>(StatusCode::RC_ERROR)) +
                       "|用户名只能包含字母/数字/下划线，长度3-20");
        return;
    }

    if (password.size() < 6) {
        SendPacket(session->socket, MessageType::MSG_REGISTER_RESP,
                   std::to_string(static_cast<int>(StatusCode::RC_ERROR)) + "|密码至少6位");
        return;
    }

    if (!db_->RegisterUser(username, password, false)) {
        SendPacket(session->socket, MessageType::MSG_REGISTER_RESP,
                   std::to_string(static_cast<int>(StatusCode::RC_USER_EXISTS)) + "|用户名已存在");
        return;
    }

    spdlog::info("[Server] 新用户注册: {}", username);
    SendPacket(session->socket, MessageType::MSG_REGISTER_RESP,
               std::to_string(static_cast<int>(StatusCode::RC_OK)) + "|注册成功，请登录");
}

// ─────────────────────────────────────────────────────────
//  登出
// ─────────────────────────────────────────────────────────
void Server::OnLogout(std::shared_ptr<ClientSession> session) {
    spdlog::info("[Server] 用户主动退出: {}", session->username);
    DisconnectClient(session->socket, "用户主动退出");
}

// ─────────────────────────────────────────────────────────
//  群聊
// ─────────────────────────────────────────────────────────
void Server::OnChatPublic(std::shared_ptr<ClientSession> session, const std::string& body) {
    if (body.empty()) return;

    std::string formatted = GetTimestamp() + "|" + session->username + "|" + body;
    spdlog::info("[群聊] {}: {}", session->username, body);

    clients_.forEachAuthenticated([&](SOCKET sock, std::shared_ptr<ClientSession>) {
        SendPacket(sock, MessageType::MSG_CHAT_PUBLIC, formatted);
    });
}

// ─────────────────────────────────────────────────────────
//  私聊
// ─────────────────────────────────────────────────────────
void Server::OnChatPrivate(std::shared_ptr<ClientSession> session, const std::string& body) {
    auto fields = SplitFields(body, '|', 2);
    if (fields.size() < 2) {
        SendPacket(session->socket, MessageType::MSG_SYSTEM_NOTIFY, "私聊格式错误");
        return;
    }

    const std::string& receiver_name = fields[0];
    const std::string& content       = fields[1];

    if (receiver_name == session->username) {
        SendPacket(session->socket, MessageType::MSG_SYSTEM_NOTIFY, "不能给自己发私聊");
        return;
    }

    auto target = clients_.findByUsername(receiver_name);
    if (!target) {
        SendPacket(session->socket, MessageType::MSG_SYSTEM_NOTIFY,
                   "用户 " + receiver_name + " 不在线");
        return;
    }

    std::string to_receiver = GetTimestamp() + "|" + session->username + "|" + content;
    std::string to_sender   = GetTimestamp() + "|[→" + receiver_name + "]|" + content;

    spdlog::info("[私聊] {} → {}: {}", session->username, receiver_name, content);

    SendPacket(target->socket, MessageType::MSG_CHAT_PRIVATE, to_receiver);
    SendPacket(session->socket, MessageType::MSG_CHAT_PRIVATE, to_sender);
}

// ─────────────────────────────────────────────────────────
//  在线列表
// ─────────────────────────────────────────────────────────
void Server::OnOnlineListReq(std::shared_ptr<ClientSession> session) {
    SendPacket(session->socket, MessageType::MSG_ONLINE_LIST_RESP, GetOnlineList());
}

// ─────────────────────────────────────────────────────────
//  踢人
// ─────────────────────────────────────────────────────────
void Server::OnKickReq(std::shared_ptr<ClientSession> session, const std::string& body) {
    if (!session->is_admin) {
        spdlog::warn("[Server] 非管理员 {} 尝试踢人", session->username);
        SendPacket(session->socket, MessageType::MSG_SYSTEM_NOTIFY, "权限不足");
        return;
    }

    std::string target_name = body;
    target_name.erase(0, target_name.find_first_not_of(" \t\r\n"));
    target_name.erase(target_name.find_last_not_of(" \t\r\n") + 1);

    if (target_name == session->username) {
        SendPacket(session->socket, MessageType::MSG_SYSTEM_NOTIFY, "不能踢自己");
        return;
    }

    auto target = clients_.findByUsername(target_name);
    if (!target) {
        SendPacket(session->socket, MessageType::MSG_SYSTEM_NOTIFY,
                   "用户 " + target_name + " 不在线");
        return;
    }

    SOCKET target_sock = target->socket;

    SendPacket(target_sock, MessageType::MSG_KICK_NOTIFY,
               "您已被管理员 " + session->username + " 踢出聊天室");
    spdlog::info("[Server] 管理员 {} 踢出用户 {}", session->username, target_name);
    SendPacket(session->socket, MessageType::MSG_SYSTEM_NOTIFY, "已踢出: " + target_name);
    BroadcastSystem(target_name + " 被管理员踢出聊天室", target_sock);
    DisconnectClient(target_sock, "被管理员踢出");
}

// ─────────────────────────────────────────────────────────
//  Echo
// ─────────────────────────────────────────────────────────
void Server::OnEchoReq(std::shared_ptr<ClientSession> session, const std::string& body) {
    spdlog::debug("[Echo] socket={} 发来: {}", session->socket, body);
    SendPacket(session->socket, MessageType::MSG_ECHO_RESP, "ECHO: " + body);
}

// ─────────────────────────────────────────────────────────
//  发送
// ─────────────────────────────────────────────────────────
bool Server::SendAll(SOCKET sock, const std::vector<uint8_t>& data) {
    size_t total_sent = 0;
    while (total_sent < data.size()) {
        int sent = send(sock,
                        reinterpret_cast<const char*>(data.data()) + total_sent,
                        static_cast<int>(data.size() - total_sent), 0);
        if (sent == SOCKET_ERROR) {
            return false;
        }
        total_sent += sent;
    }
    return true;
}

bool Server::SendPacket(SOCKET sock, MessageType type, const std::string& body) {
    auto packet = BuildPacket(type, body);
    return SendAll(sock, packet);
}

// ─────────────────────────────────────────────────────────
//  广播
// ─────────────────────────────────────────────────────────
void Server::BroadcastSystem(const std::string& msg, SOCKET exclude_sock) {
    clients_.forEachAuthenticated([&](SOCKET sock, std::shared_ptr<ClientSession>) {
        if (sock != exclude_sock) {
            SendPacket(sock, MessageType::MSG_SYSTEM_NOTIFY,
                       GetTimestamp() + "|[系统]|" + msg);
        }
    });
}

// ─────────────────────────────────────────────────────────
//  在线列表
// ─────────────────────────────────────────────────────────
std::string Server::GetOnlineList() const {
    std::ostringstream oss;
    bool first = true;
    clients_.forEachAuthenticated([&](SOCKET, std::shared_ptr<ClientSession> sess) {
        if (!first) oss << ",";
        oss << sess->username;
        if (sess->is_admin) oss << "[管理员]";
        first = false;
    });
    return oss.str();
}

// ─────────────────────────────────────────────────────────
//  从外部（GUI 线程）踢出用户
// ─────────────────────────────────────────────────────────
void Server::kickUser(const std::string& username) {
    auto target = clients_.findByUsername(username);
    if (!target) return;

    SOCKET target_sock = target->socket;
    spdlog::info("[Server] 管理员从GUI踢出用户: {}", username);

    SendPacket(target_sock, MessageType::MSG_KICK_NOTIFY,
               "您已被管理员踢出聊天室");
    BroadcastSystem(username + " 被管理员踢出聊天室", target_sock);
    DisconnectClient(target_sock, "被管理员踢出");
}