// tcp_server.cpp - TCP 服务端（新版统一扫描协议）
//
// 消息以 '>' 结尾（不是换行）。每条命令是一个 JSON：
//   {"function":"count|check|config",
//    "scan":"start|stop",
//    "scanTime":N,          // >0: 到时自动停止，无需再发 stop（单位:秒）
//    "box":{"l":..,"w":..,"h":..,"maxPerLayer":..},
//    "task_id":".."}
// 语义：
//   - function=count/check + scan=start：启动统一后台扫描；若扫描已在运行，则
//     强制重启（旧扫描结果丢弃）；scanTime>0 时到点自动停止并返回结果。
//   - function=count/check + scan=stop：立即停止当前扫描并返回结果。
//   - function=config：重新加载配置文件。
// count/check 共用同一个 ScanSession，同一时刻只有一个采集线程访问雷达。
#include "tcp_server.h"

#include "config.h"
#include "json_utils.h"
#include "lidar_utils.h"
#include "count.h"
#include "detect.h"
#include "io_utils.h"

#include <winsock2.h>
#include <ws2tcpip.h>

#include <atomic>
#include <chrono>
#include <cctype>
#include <condition_variable>
#include <cstdlib>
#include <cstring>
#include <iostream>
#include <iomanip>
#include <map>
#include <mutex>
#include <set>
#include <sstream>
#include <thread>

namespace
{
    // ==================== 会话状态（每雷达一份，各雷达可并行扫描） ====================
    struct SessionState
    {
        bool        active    = false;                       // 是否有扫描在运行
        bool        auto_stop = false;                       // 是否到时自动停止
        std::string radar;                                   // 所属雷达标识
        std::string function;                                // "count" / "check"
        CountParams box;                                     // count 的 box 参数
        std::string task_id;
        SOCKET      owner = INVALID_SOCKET;                  // 发起者（自动停止结果回发）
        std::chrono::steady_clock::time_point deadline;      // 自动停止时刻
    };

    static std::map<std::string, SessionState> g_states;     // 雷达标识 -> 会话状态
    static std::mutex               g_life;                  // 会话生命周期锁
    static std::mutex               g_cv_mtx;                // 自动停止等待锁
    static std::condition_variable  g_cv;
    static std::atomic<bool>        g_stop{false};           // 服务端退出标志（自动停止线程用）

    // ==================== 连接管理 ====================
    // 不设 recv 超时时，任何"连上但不发数据"的连接(端口探测/异常客户端/旧TCP客户端
    // 连到HTTP端口)都会让处理线程永久阻塞在 recv 上；线程越堆越多，最终
    // std::thread 构造失败抛 std::system_error，未捕获的异常会直接终止整个进程
    // —— 表现为"先卡死、然后进程突然消失且无任何日志"。
    static const int        MAX_CONNECTIONS     = 64;        // 并发连接上限
    static const int        TCP_RECV_TIMEOUT_MS = 300000;    // TCP 长连接空闲上限 5 分钟
    static const int        HTTP_RECV_TIMEOUT_MS = 5000;     // HTTP 头部读取超时(超时按TCP协议兜底)
    static const int        SEND_TIMEOUT_MS     = 5000;      // 发送超时
    static std::atomic<int> g_conn_count{0};                 // 当前活跃连接数

    // ==================== 工作线程生命周期 ====================
    // auto_stop_loop / 客户端处理线程都是 detach 的。服务端主循环一旦返回，main 会
    // 立刻 radar_mgr.shutdown() 释放 RadarNode 与 driver，而这些线程仍在访问它们
    // —— 典型表现就是"进程突然消失、没有任何日志"。这里统计活跃工作线程，
    // 退出前先置停止位、唤醒阻塞在 recv 的连接、再等待线程真正结束。
    static std::atomic<int> g_thread_count{0};               // 活跃工作线程数
    static std::mutex       g_sock_mtx;
    static std::set<SOCKET> g_active_socks;                  // 活跃客户端 socket

    struct WorkerGuard
    {
        WorkerGuard()  { ++g_thread_count; }
        ~WorkerGuard() { --g_thread_count; }
    };

    // 服务端收尾：通知退出 + 唤醒阻塞连接 + 等待线程结束（最多 5 秒，避免卡住退出流程）
    static void stop_server_workers()
    {
        g_stop = true;
        {
            std::lock_guard<std::mutex> lk(g_sock_mtx);
            for (SOCKET s : g_active_socks)
            {
                if (s == INVALID_SOCKET) continue;
#ifdef _WIN32
                shutdown(s, SD_BOTH);            // 让阻塞的 recv 立即返回
#else
                shutdown(s, SHUT_RDWR);
#endif
            }
        }
        for (int i = 0; i < 100 && g_thread_count.load() > 0; ++i)
            std::this_thread::sleep_for(std::chrono::milliseconds(50));
        if (g_thread_count.load() > 0)
            std::cout << "[警告] 仍有 " << g_thread_count.load()
                      << " 个工作线程未退出，退出过程可能不稳定" << std::endl;
        else
            std::cout << "[关闭] 服务端工作线程已全部退出" << std::endl;
    }

    static void set_sock_timeouts(SOCKET s, int recv_ms, int send_ms)
    {
        if (s == INVALID_SOCKET) return;
#ifdef _WIN32
        DWORD r = (recv_ms > 0) ? (DWORD)recv_ms : 0;
        DWORD w = (send_ms > 0) ? (DWORD)send_ms : 0;
        setsockopt(s, SOL_SOCKET, SO_RCVTIMEO, (const char*)&r, sizeof(r));
        setsockopt(s, SOL_SOCKET, SO_SNDTIMEO, (const char*)&w, sizeof(w));
#else
        struct timeval rv; rv.tv_sec = recv_ms / 1000; rv.tv_usec = (recv_ms % 1000) * 1000;
        struct timeval wv; wv.tv_sec = send_ms / 1000; wv.tv_usec = (send_ms % 1000) * 1000;
        setsockopt(s, SOL_SOCKET, SO_RCVTIMEO, (const char*)&rv, sizeof(rv));
        setsockopt(s, SOL_SOCKET, SO_SNDTIMEO, (const char*)&wv, sizeof(wv));
#endif
    }

    // 连接句柄守卫：任何退出路径(含异常)都保证关闭 socket 并归还连接配额
    class ConnGuard
    {
    public:
        explicit ConnGuard(SOCKET s) : s_(s)
        {
            std::lock_guard<std::mutex> lk(g_sock_mtx);
            g_active_socks.insert(s_);          // 登记，供退出时统一唤醒
        }
        ~ConnGuard()
        {
            {
                std::lock_guard<std::mutex> lk(g_sock_mtx);
                g_active_socks.erase(s_);
            }
            if (s_ != INVALID_SOCKET) closesocket(s_);
            --g_conn_count;
        }
    private:
        SOCKET s_;
    };

    // ==================== 发送 ====================
    // 响应统一以 '>' 结尾
    static void send_text(SOCKET s, const std::string& msg)
    {
        std::string out = msg;
        if (!out.empty() && out.back() != '>') out += '>';
        send(s, out.c_str(), (int)out.size(), 0);
    }

    // 响应出口：resp==nullptr 直接发到 client(TCP 模式)；否则收集到 resp(HTTP 模式)。
    static void send_reply(SOCKET client, std::string* resp, const std::string& msg)
    {
        if (resp) *resp = msg;
        else      send_text(client, msg);
    }

    // ==================== 停止并取回结果 ====================
    // id: 雷达标识；need_auto=true 表示"自动到时"触发，只允许在 auto_stop 仍武装时抢到；
    // 否则（手动 stop）只要 active 即可。
    static bool claim_stop_and_fetch(const std::string& id, bool need_auto,
                                     SessionState* snap,
                                     std::vector<CountPoint>* pts)
    {
        RadarNode* node = radar_mgr.find(id);
        std::lock_guard<std::mutex> lk(g_life);
        auto it = g_states.find(id);
        if (it == g_states.end() || !it->second.active) return false;
        if (need_auto && !it->second.auto_stop) return false;   // 已被手动 stop 抢先
        *snap = it->second;
        it->second.active    = false;
        it->second.auto_stop = false;
        g_cv.notify_all();
        if (node)
        {
            node->session.stop();            // 等待采集线程退出（≤100ms轮询粒度）
            *pts = node->session.snapshot();
            node->session.reset();           // 清空点集，为下一次 start 准备
        }
        return true;
    }

    // 仅停止指定雷达的当前扫描，不返回结果（用于 start 时的强制重启）。
    // 调用方需已持有 g_life。
    static bool discard_current_locked(const std::string& id)
    {
        auto it = g_states.find(id);
        if (it == g_states.end() || !it->second.active) return false;
        it->second.active    = false;
        it->second.auto_stop = false;
        g_cv.notify_all();
        RadarNode* node = radar_mgr.find(id);
        if (node)
        {
            node->session.stop();
            node->session.reset();
        }
        return true;
    }

    // ==================== 结果计算与回包 ====================
    static void finish_count(const SessionState& snap,
                             const std::vector<CountPoint>& pts,
                             SOCKET target, std::string* resp = nullptr)
    {
        RadarScope scope(snap.radar);        // 绑定该雷达配置(分层/多边形/滤波)
        bool valid_box = snap.box.l > 0 && snap.box.w > 0 &&
                         snap.box.h > 0 && snap.box.maxPerLayer > 0;
        std::vector<CountPoint> work = pts;
        std::string detail;
        std::vector<uint8_t> top_img;
        int total = 0, tw = 0, th = 0, tlv = 0;
        double tarea = 0.0;
        if (!pts.empty() && valid_box)
        {
            sparse_density_filter(work);     // 点云级稀疏拖影过滤(默认开, 配置可调)
            z_gap_interpolate(work);         // z空隙插值：只在停止后执行一次
            total = calc_item_count(work, snap.box, &detail,
                                    &top_img, &tw, &th, &tlv, &tarea);
        }
        std::cout << "[TCP][" << snap.radar << "] count结束: task_id=" << snap.task_id
                  << ", 点数=" << pts.size() << ", 结果=" << total << std::endl;

        std::ostringstream r;
        r << "{\"code\":200,\"message\":\"count done\",\"count\":" << total;
        if (!snap.task_id.empty())
            r << ",\"task_id\":\"" << snap.task_id << "\"";
        r << ",\"radar\":\"" << snap.radar << "\"}";
        send_reply(target, resp, r.str());

        // 后台保存 PCD/图片/日志（不阻塞响应）
        // 最后一个参数 pts 是"插值前"的原始点集，用于另存 count_data_before.pcd 做对比
        if (!pts.empty() && valid_box)
            save_count_files_async(snap.radar, work, top_img, tw, th, snap.box, detail,
                                   total, tlv, tarea, &pts);
    }

    static void finish_check(const SessionState& snap,
                             const std::vector<CountPoint>& pts,
                             SOCKET target, std::string* resp = nullptr)
    {
        RadarScope scope(snap.radar);        // 绑定该雷达配置(截面参数/多边形)
        // 输出目录 data/日期/时间_taskId（由 io_utils 统一创建）
        std::string out_dir = make_task_dir(snap.task_id);
        DetectResult res;
        detect_analyze_slices(pts, out_dir, &res);

        std::ostringstream r;
        r << "{\"code\":200,\"message\":\"detect done\"";
        if (res.valid)
        {
            if (res.start_fill_pct >= 0.0)
                r << ",\"start\":{\"fill_pct\":"
                  << std::fixed << std::setprecision(2) << res.start_fill_pct
                  << ",\"y_max\":" << std::setprecision(1) << res.start_y_max
                  << ",\"y_median\":" << res.start_y_med << "}";
            if (res.end_fill_pct >= 0.0)
                r << ",\"end\":{\"fill_pct\":"
                  << std::fixed << std::setprecision(2) << res.end_fill_pct
                  << ",\"y_max\":" << std::setprecision(1) << res.end_y_max
                  << ",\"y_median\":" << res.end_y_med << "}";
        }
        if (!snap.task_id.empty())
            r << ",\"task_id\":\"" << snap.task_id << "\"";
        r << ",\"radar\":\"" << snap.radar << "\"}";
        send_reply(target, resp, r.str());
        std::cout << "[TCP][" << snap.radar << "] check结束: task_id=" << snap.task_id
                  << ", 点数=" << pts.size()
                  << (res.valid ? ", 检测有效" : ", 检测无效") << std::endl;
    }

    static void finish_and_reply(const SessionState& snap,
                                 const std::vector<CountPoint>& pts,
                                 SOCKET target, std::string* resp = nullptr)
    {
        if (snap.function == "count")
            finish_count(snap, pts, target, resp);
        else if (snap.function == "check")
            finish_check(snap, pts, target, resp);
    }

    // ==================== 自动到时停止线程 ====================
    // 多雷达：每 100ms 轮询一次所有雷达的会话，到点的各自独立停止并回包。
    static void auto_stop_loop()
    {
        WorkerGuard wg;                      // 计入活跃工作线程，退出时被等待
        while (!g_stop.load())
        {
            std::this_thread::sleep_for(std::chrono::milliseconds(100));

            std::vector<std::string> due;
            {
                std::lock_guard<std::mutex> lk(g_life);
                auto now = std::chrono::steady_clock::now();
                for (const auto& kv : g_states)
                {
                    const SessionState& st = kv.second;
                    if (st.active && st.auto_stop && now >= st.deadline)
                        due.push_back(kv.first);
                }
            }
            for (const auto& id : due)
            {
                SessionState snap;
                std::vector<CountPoint> pts;
                if (!claim_stop_and_fetch(id, true, &snap, &pts)) continue;
                std::cout << "[TCP][" << id << "] 扫描到时自动停止: function=" << snap.function
                          << ", task_id=" << snap.task_id << std::endl;
                // 异常必须就地吞掉：本线程是 detached，异常逃逸会直接终止进程
                try
                {
                    RadarScope scope(id);
                    if (snap.owner != INVALID_SOCKET)
                        finish_and_reply(snap, pts, snap.owner);
                    else
                    {
                        // HTTP 模式无长连接可推送，结果只打印并留痕
                        std::string out;
                        finish_and_reply(snap, pts, INVALID_SOCKET, &out);
                        std::cout << "[HTTP][" << id << "] scanTime到时自动停止, 无连接可推送, 结果: "
                                  << out << std::endl;
                    }
                }
                catch (const std::exception& e)
                {
                    std::cerr << "[TCP][" << id << "] 自动停止处理结果异常: " << e.what() << std::endl;
                }
                catch (...) { std::cerr << "[TCP][" << id << "] 自动停止处理结果未知异常" << std::endl; }
            }
        }
    }

    // ==================== 命令处理 ====================
    static void handle_scan_start(const std::string& msg, SOCKET client,
                                  std::string* resp, const std::string& radar_id,
                                  RadarNode* node)
    {
        std::string fn;
        json_get_string(msg, "function", fn);
        std::string task_id;
        json_get_string(msg, "task_id", task_id);
        double scan_time = 0.0;
        json_get_number(msg, "scanTime", scan_time);

        CountParams box;
        json_get_string(msg, "task_id", box.task_id);
        json_get_number(msg, "l", box.l);
        json_get_number(msg, "w", box.w);
        json_get_number(msg, "h", box.h);
        double d = 0.0;
        if (json_get_number(msg, "maxPerLayer", d) ||
            json_get_number(msg, "max", d))
            box.maxPerLayer = (int)d;

        std::ostringstream ack;
        ack << "{\"code\":200,\"message\":\"scan start\",\"function\":\"" << fn << "\"";
        if (!task_id.empty())
            ack << ",\"task_id\":\"" << task_id << "\"";
        if (scan_time > 0)
            ack << ",\"scanTime\":" << (int)scan_time;
        ack << ",\"radar\":\"" << radar_id << "\"}";

        if (!node->connected.load())
        {
            std::string fail = "radar not connected: " + radar_id;
            std::cerr << "[TCP][" << radar_id << "] " << fail << std::endl;
            send_reply(client, resp, "{\"code\":503,\"message\":\"" + fail + "\"}");
            return;
        }

        bool started = false;
        std::string fail;
        {
            std::lock_guard<std::mutex> lk(g_life);
            // 该雷达扫描运行中收到新的 start：强制重启（旧扫描结果丢弃）
            if (discard_current_locked(radar_id))
                std::cout << "[TCP][" << radar_id << "] 扫描运行中被新命令强制重启: function=" << fn
                          << ", task_id=" << task_id << std::endl;

            node->session.reset();
            // 传入 io_mtx：采集取帧与后台重连互斥，杜绝两线程并发操作同一 driver
            if (!node->session.start(*node->driver, radar_id, &node->io_mtx))
            {
                fail = "scan start failed";
            }
            else
            {
                SessionState ns;
                ns.active   = true;
                ns.radar    = radar_id;
                ns.function = fn;
                ns.box      = box;
                ns.task_id  = task_id;
                // TCP 用连接作 owner(自动到时结果回发)；HTTP 无长连接，置无效不推送
                ns.owner    = resp ? INVALID_SOCKET : client;
                if (scan_time > 0)
                {
                    ns.auto_stop = true;
                    ns.deadline  = std::chrono::steady_clock::now() +
                                   std::chrono::milliseconds((long)(scan_time * 1000.0));
                }
                g_states[radar_id] = ns;
                g_cv.notify_all();
                started = true;
            }
        }

        if (!started)
        {
            std::cerr << "[TCP][" << radar_id << "] " << fail << std::endl;
            send_reply(client, resp, "{\"code\":400,\"message\":\"" + fail + "\"}");
            return;
        }
        std::cout << "[TCP][" << radar_id << "] 扫描开始: function=" << fn
                  << ", task_id=" << task_id
                  << (scan_time > 0 ? ", 到时自动停止" : ", 等待stop") << std::endl;
        send_reply(client, resp, ack.str());
    }

    static void handle_scan_stop(const std::string& msg, SOCKET client,
                                 std::string* resp, const std::string& radar_id)
    {
        std::string fn;
        json_get_string(msg, "function", fn);

        SessionState snap;
        std::vector<CountPoint> pts;
        if (!claim_stop_and_fetch(radar_id, false, &snap, &pts))
        {
            // 未在扫描（从未 start / 已停止 / 自动到时已完成）
            std::ostringstream r;
            r << "{\"code\":200,\"message\":\"scan not running\"";
            if (fn == "count")
                r << ",\"count\":0";
            r << ",\"radar\":\"" << radar_id << "\"}";
            send_reply(client, resp, r.str());
            return;
        }
        std::cout << "[TCP][" << radar_id << "] 收到stop: function=" << snap.function
                  << ", task_id=" << snap.task_id << std::endl;
        finish_and_reply(snap, pts, client, resp);
    }

    static void handle_config(const std::string& msg, SOCKET client,
                              std::string* resp = nullptr)
    {
        (void)msg;
        std::cout << "[TCP] 收到config命令，重新读取 config/config ..." << std::endl;
        if (!load_config())        // 失败时保留原配置，绝不让进程退出
        {
            std::cerr << "[TCP] 配置重载失败，沿用现有配置" << std::endl;
            send_reply(client, resp,
                       "{\"code\":500,\"message\":\"config reload failed\"}");
            return;
        }
        reload_speed_profile();    // radar_cfg().scan.z_speed_type=configuration 时重新读取 speed.txt
        radar_mgr.sync_config();   // 配置里的雷达增删：新增节点后台连接，删除的节点停用
        std::cout << "[TCP] 配置已重载: 雷达" << cfg.ids.size() << "台:";
        for (const auto& id : cfg.ids) std::cout << " " << id;
        std::cout << std::endl;
        std::cout << "[TCP] 配置已重载: 采集=" << radar_cfg().scan.collect_duration_s
                  << "s, 速度模式=" << radar_cfg().scan.z_speed_type
                  << ", 速度=" << radar_cfg().scan.z_speed << "cm/s, 插值=" << radar_cfg().count.z_interpolate_mode
                  << ", 保留=" << cfg.log.retain_days << "天, 端口=" << cfg.server.port << std::endl;
        std::cout << "[TCP]   count容差: 基准=" << radar_cfg().count.base_tolerance
                  << "mm + 每层" << radar_cfg().count.per_level_tolerance << "mm"
                  << ", 地板高=" << radar_cfg().count.floor_height << "mm"
                  << ", SparseCut=" << (radar_cfg().filter.sparse_cut.enable ? "开" : "关")
                  << "(X±" << radar_cfg().filter.sparse_cut.x_radius << "mm,同圈>=" << radar_cfg().filter.sparse_cut.circle_min
                  << ",跨圈>=" << radar_cfg().filter.sparse_cut.run_min << ")"
                  << ", TailCut=" << (radar_cfg().filter.tail_cut.enable ? "开" : "关") << std::endl;
        send_reply(client, resp, "{\"code\":200,\"message\":\"config reloaded\"}");
    }

    // ConfigureSpeed: 标定生成 config/speed.txt（雷达横放时，每帧Y最大值=行进距离）。
    // 请求: {"function":"ConfigureSpeed","scanTime":N}，N缺省用 radar_cfg().scan.collect_duration_s。
    // 标定期间与扫描会话互斥（全程持 g_life，其他命令排队）。
    static void handle_configure_speed(const std::string& msg, SOCKET client,
                                       std::string* resp, const std::string& radar_id,
                                       RadarNode* node)
    {
        double scan_time = 0.0;
        json_get_number(msg, "scanTime", scan_time);
        double seconds = (scan_time > 0) ? scan_time : (double)radar_cfg().scan.collect_duration_s;
        if (seconds <= 0.0) seconds = 5.0;
        std::cout << "[TCP][" << radar_id << "] 收到ConfigureSpeed: 采集" << seconds
                  << "s 标定变速剖面(每帧Y最大值) ..." << std::endl;

        if (!node->connected.load())
        {
            std::string fail = "radar not connected: " + radar_id;
            std::cerr << "[TCP][" << radar_id << "] " << fail << std::endl;
            send_reply(client, resp, "{\"code\":503,\"message\":\"" + fail + "\"}");
            return;
        }

        int rows = -1;
        std::string err;
        {
            std::lock_guard<std::mutex> lk(g_life);
            if (discard_current_locked(radar_id))   // 扫描运行中先强制停止（本函数持锁）
                std::cout << "[TCP][" << radar_id << "] 扫描运行中被ConfigureSpeed中断" << std::endl;
            rows = collect_speed_profile(*node->driver, seconds, err);
        }
        if (rows < 0)
        {
            std::cerr << "[TCP][" << radar_id << "] ConfigureSpeed失败: " << err << std::endl;
            send_reply(client, resp, "{\"code\":400,\"message\":\"configure speed failed\"}");
            return;
        }
        reload_speed_profile();   // 重新载入新生成的剖面（若已是configuration则立即生效）
        std::cout << "[TCP][" << radar_id << "] speed.txt 已更新: " << rows
                  << " 帧样本 (采集" << seconds << "s)" << std::endl;
        std::ostringstream r;
        r << "{\"code\":200,\"message\":\"configure speed done\",\"rows\":" << rows
          << ",\"duration\":" << (int)seconds
          << ",\"radar\":\"" << radar_id << "\""
          << ",\"file\":\"config/speed.txt\"}";
        send_reply(client, resp, r.str());
    }

    // 处理一条命令。resp==nullptr: 直接发送(TCP)；resp!=nullptr: 响应写入该串(HTTP)。
    // 返回值: 是否产生响应。
    static bool dispatch(const std::string& raw, SOCKET client,
                         std::string* resp = nullptr)
    {
        std::string msg = json_trim(raw);
        if (msg.empty()) return false;

        std::string fn;
        if (!json_get_string(msg, "function", fn)) return false;   // 未知消息忽略

        if (fn == "config")
        {
            handle_config(msg, client, resp);
            return true;
        }

        // 其余命令需要指定雷达：{"radar":"radar1"}；缺省用第一个雷达(兼容旧客户端)
        std::string req_id;
        json_get_string(msg, "radar", req_id);
        RadarNode* node = radar_mgr.find(req_id);
        if (!node)
        {
            std::string m = "unknown radar: " + req_id;
            std::cerr << "[TCP] " << m << std::endl;
            send_reply(client, resp, "{\"code\":400,\"message\":\"" + m + "\"}");
            return true;
        }
        const std::string radar_id = node->id;
        RadarScope scope(radar_id);          // 本请求全程使用该雷达的配置

        if (fn == "ConfigureSpeed" || fn == "configurespeed")
        {
            handle_configure_speed(msg, client, resp, radar_id, node);
            return true;
        }
        if (fn != "count" && fn != "check") return false;          // 未知功能忽略

        std::string scan_cmd;
        json_get_string(msg, "scan", scan_cmd);
        if (scan_cmd == "stop")
        {
            handle_scan_stop(msg, client, resp, radar_id);
            return true;
        }
        else if (scan_cmd == "start")
        {
            handle_scan_start(msg, client, resp, radar_id, node);
            return true;
        }
        return false;                                              // 无scan/未知scan值忽略
    }

    static void handle_client(SOCKET client)
    {
        WorkerGuard wg;                     // 计入活跃工作线程，退出时被等待
        ConnGuard guard(client);            // 任何路径退出都关闭 socket 并归还配额
        set_sock_timeouts(client, TCP_RECV_TIMEOUT_MS, SEND_TIMEOUT_MS);

        char buf[4096];
        std::string rbuf;
        while (true)
        {
            int n = recv(client, buf, sizeof(buf) - 1, 0);
            if (n <= 0) break;               // 连接关闭 / 超时 / 出错
            buf[n] = '\0';
            rbuf.append(buf, n);

            // 按 '>' 分帧处理（一条消息以 '>' 结尾）
            size_t pos;
            while ((pos = rbuf.find('>')) != std::string::npos)
            {
                std::string raw = rbuf.substr(0, pos);
                rbuf.erase(0, pos + 1);
                try { dispatch(raw, client); }
                catch (const std::exception& e)
                {
                    std::cerr << "[TCP] 处理命令异常: " << e.what() << std::endl;
                }
                catch (...) { std::cerr << "[TCP] 处理命令发生未知异常" << std::endl; }
            }
            // 一直没出现 '>'：异常客户端灌数据，防止 rbuf 无限膨胀
            if (rbuf.size() > 65536) rbuf.clear();
        }
        // 客户端断开：若它是某自动扫描的 owner，扫描仍会到时自动停止；
        // 未设置 scanTime 的扫描则持续到下一次 start 强制重启或 stop。
    }
} // namespace

void run_tcp_server()
{
    std::cout << "\n========== TCP服务端模式 ==========" << std::endl;
    std::cout << "[TCP] 监听端口: " << cfg.server.port
              << "  |  消息以 '>' 结尾" << std::endl;
    std::cout << "[TCP] 已绑定雷达" << radar_mgr.nodes().size() << "台:";
    for (const auto& id : cfg.ids) std::cout << " " << id;
    std::cout << " (请求用 \"radar\" 指定，缺省用第一个)" << std::endl;

    SOCKET listen_sock = socket(AF_INET, SOCK_STREAM, 0);
    if (listen_sock == INVALID_SOCKET)
    {
        std::cerr << "[错误] 创建监听socket失败!" << std::endl;
        return;
    }

    sockaddr_in addr;
    addr.sin_family = AF_INET;
    addr.sin_addr.s_addr = INADDR_ANY;
    addr.sin_port = htons(cfg.server.port);
    if (bind(listen_sock, (sockaddr*)&addr, sizeof(addr)) == SOCKET_ERROR)
    {
        std::cerr << "[错误] 绑定端口 " << cfg.server.port << " 失败!" << std::endl;
        closesocket(listen_sock);
        return;
    }
    if (listen(listen_sock, 5) == SOCKET_ERROR)
    {
        std::cerr << "[错误] 监听失败!" << std::endl;
        closesocket(listen_sock);
        return;
    }

    // 自动到时停止线程（scanTime 模式）
    std::thread(auto_stop_loop).detach();

    std::cout << "[TCP] 初始化完成，等待命令 "
                 "{\"function\":\"count\",\"scan\":\"start\",...} ..." << std::endl;
    // 主循环必须吞掉一切异常：线程创建失败等异常若逃出 main 会直接终止进程
    try
    {
        while (true)
        {
            SOCKET client = accept(listen_sock, nullptr, nullptr);
            if (client == INVALID_SOCKET)
            {
                std::cout << "[TCP] accept失败，重试..." << std::endl;
                std::this_thread::sleep_for(std::chrono::milliseconds(200));
                continue;
            }
            set_sock_timeouts(client, TCP_RECV_TIMEOUT_MS, SEND_TIMEOUT_MS);
            if (g_conn_count.load() >= MAX_CONNECTIONS)
            {
                std::cerr << "[TCP] 并发连接数已达上限 " << MAX_CONNECTIONS
                          << "，拒绝新连接(可能有客户端连上后不发数据)" << std::endl;
                closesocket(client);
                continue;
            }
            ++g_conn_count;
            try { std::thread(handle_client, client).detach(); }
            catch (...)
            {
                --g_conn_count;
                std::cerr << "[TCP] 创建客户端处理线程失败，关闭该连接" << std::endl;
                closesocket(client);
            }
        }
    }
    catch (const std::exception& e)
    {
        std::cerr << "[TCP] 服务端主循环异常退出: " << e.what() << std::endl;
    }
    catch (...) { std::cerr << "[TCP] 服务端主循环未知异常退出" << std::endl; }
    closesocket(listen_sock);
    stop_server_workers();      // 通知并等待 detach 的工作线程退出，再交回 main 收尾
}

// ==================== HTTP 服务端模式 ====================
// 请求: POST /<任意路径>, body = 与 TCP 协议相同的 JSON(不带结尾 '>')
// 响应: HTTP 200 + application/json, body = 与 TCP 协议相同的响应文本(不带 '>')
// 注: HTTP 请求是"无连接"的。scanTime>0 的扫描到点自动停止后无法主动推送
//     结果(结果打印到日志)；客户端应在需要结果时再发一次 stop(会返回
//     "scan not running" + count:0) 或通过文件目录查看。建议流程:
//     start(不带scanTime) → 采集完成 → stop 拿结果。
namespace
{
    // 读 HTTP 请求头(依赖 socket 上的 SO_RCVTIMEO，超时 recv 返回 <0)。
    // 返回:  0 = 收到完整头(head=头, rest=已收到的 body 片段)
    //        1 = 超时/对端半关且未收到 "\r\n\r\n"(head=已收到的全部数据, 用于TCP协议兜底)
    //       -1 = 出错或没有任何数据，应关闭连接
    static int http_read_head(SOCKET c, std::string& head, std::string& rest)
    {
        char buf[8192];
        head.clear();
        rest.clear();
        while (head.size() < 65536)          // 头上限 64KB，防呆
        {
            int n = recv(c, buf, (int)sizeof(buf), 0);
            if (n < 0) return head.empty() ? -1 : 1;      // 超时/出错
            if (n == 0) return head.empty() ? -1 : 1;     // 对端关闭(可能已发部分数据)
            head.append(buf, n);
            size_t p = head.find("\r\n\r\n");
            if (p != std::string::npos)
            {
                rest = head.substr(p + 4);   // 头部之后可能已带部分 body
                head = head.substr(0, p);
                return 0;
            }
        }
        return -1;
    }

    static long http_find_content_length(const std::string& head)
    {
        std::istringstream iss(head);
        std::string line;
        while (std::getline(iss, line))
        {
            if (!line.empty() && line.back() == '\r') line.pop_back();
            size_t c = line.find(':');
            if (c == std::string::npos) continue;
            std::string key = line.substr(0, c);
            for (auto& ch : key) ch = (char)tolower((unsigned char)ch);
            if (key == "content-length")
                return strtol(line.c_str() + c + 1, nullptr, 10);
        }
        return -1;
    }

    static void http_send_response(SOCKET c, int code, const char* reason,
                                   const std::string& body)
    {
        std::ostringstream h;
        h << "HTTP/1.1 " << code << " " << reason << "\r\n"
          << "Content-Type: application/json; charset=utf-8\r\n"
          << "Content-Length: " << body.size() << "\r\n"
          << "Connection: close\r\n\r\n";
        std::string out = h.str() + body;
        int off = 0;
        while (off < (int)out.size())
        {
            int n = send(c, out.c_str() + off, (int)out.size() - off, 0);
            if (n <= 0) break;
            off += n;
        }
    }

    // 每个连接处理一个请求后即关闭(Connection: close)
    static void handle_http_client(SOCKET c)
    {
        WorkerGuard wg;                      // 计入活跃工作线程，退出时被等待
        ConnGuard guard(c);                  // 任何路径退出都关闭 socket 并归还配额
        set_sock_timeouts(c, HTTP_RECV_TIMEOUT_MS, SEND_TIMEOUT_MS);

        std::string head, rest;
        int hr = http_read_head(c, head, rest);
        if (hr < 0) return;

        // 兼容兜底：旧 TCP 客户端(直接发 "{...}" 无 HTTP 头)连到 HTTP 端口时，
        // 永远等不到 "\r\n\r\n"，原实现会让线程永久卡死且不打印任何日志。
        // 这里改为按 TCP 协议解析并直接回包，避免线程泄漏。
        if (hr != 0)
        {
            std::string raw = head;
            std::cout << "[HTTP] 收到非HTTP报文(" << raw.size() << "B)，按TCP协议处理" << std::endl;
            size_t pos;
            bool replied = false;
            while ((pos = raw.find('>')) != std::string::npos)
            {
                std::string one = raw.substr(0, pos);
                raw.erase(0, pos + 1);
                try { if (dispatch(one, c, nullptr)) replied = true; }
                catch (const std::exception& e)
                {
                    std::cerr << "[HTTP] 处理命令异常: " << e.what() << std::endl;
                }
                catch (...) { std::cerr << "[HTTP] 处理命令发生未知异常" << std::endl; }
            }
            if (!replied)
                send_text(c, "{\"code\":400,\"message\":\"unknown command, expect HTTP POST or TCP json ending with '>'\"}");
            return;
        }

        std::string line0 = head.substr(0, head.find("\r\n"));
        std::istringstream iss(line0);
        std::string method, path;
        iss >> method >> path;

        if (method != "POST")
        {
            http_send_response(c, 405, "Method Not Allowed",
                "{\"code\":405,\"message\":\"use POST, body same as TCP protocol json\"}");
            return;
        }

        long cl = http_find_content_length(head);
        if (cl < 0 || cl > 4 * 1024 * 1024)  // body 上限 4MB
        {
            http_send_response(c, 411, "Length Required",
                "{\"code\":411,\"message\":\"missing/invalid Content-Length\"}");
            return;
        }

        std::string body = rest;
        while ((long)body.size() < cl)
        {
            char buf[8192];
            int n = recv(c, buf, (int)sizeof(buf), 0);
            if (n <= 0) break;
            body.append(buf, n);
        }
        if ((long)body.size() > cl) body.resize(cl);

        std::string msg = json_trim(body);      // 完整请求体，用于分发
        std::string brief = msg;                // 仅用于日志，避免污染真实报文
        if (brief.size() > 120) brief = brief.substr(0, 120) + "...";
        std::cout << "[HTTP] POST " << path << " (" << cl << "B): "
                  << brief << std::endl;

        std::string out;
        bool handled = false;
        try { handled = dispatch(msg, INVALID_SOCKET, &out); }
        catch (const std::exception& e)
        {
            std::cerr << "[HTTP] 处理命令异常: " << e.what() << std::endl;
            out = "{\"code\":500,\"message\":\"internal error\"}";
            handled = true;
        }
        catch (...)
        {
            std::cerr << "[HTTP] 处理命令发生未知异常" << std::endl;
            out = "{\"code\":500,\"message\":\"internal error\"}";
            handled = true;
        }
        if (handled)
            http_send_response(c, 200, "OK", out);
        else
            http_send_response(c, 400, "Bad Request",
                "{\"code\":400,\"message\":\"unknown command, see TCP protocol\"}");
    }

    static void run_http_server_internal()
    {
        SOCKET listen_sock = socket(AF_INET, SOCK_STREAM, 0);
        if (listen_sock == INVALID_SOCKET)
        {
            std::cerr << "[错误] 创建HTTP监听socket失败!" << std::endl;
            return;
        }
        sockaddr_in addr;
        addr.sin_family = AF_INET;
        addr.sin_addr.s_addr = INADDR_ANY;
        addr.sin_port = htons(cfg.server.port);
        if (bind(listen_sock, (sockaddr*)&addr, sizeof(addr)) == SOCKET_ERROR)
        {
            std::cerr << "[错误] 绑定HTTP端口 " << cfg.server.port << " 失败!" << std::endl;
            closesocket(listen_sock);
            return;
        }
        if (listen(listen_sock, 5) == SOCKET_ERROR)
        {
            std::cerr << "[错误] HTTP监听失败!" << std::endl;
            closesocket(listen_sock);
            return;
        }

        // 自动到时停止线程(scanTime 模式; HTTP 下结果打印日志不推送)
        std::thread(auto_stop_loop).detach();

        std::cout << "[HTTP] 初始化完成，等待 POST 命令 "
                     "{\"function\":\"count\",\"scan\":\"start\",...} ..." << std::endl;
        // 主循环必须吞掉一切异常：线程创建失败等异常逃出 main 会直接终止进程
        try
        {
            while (true)
            {
                SOCKET client = accept(listen_sock, nullptr, nullptr);
                if (client == INVALID_SOCKET)
                {
                    std::cout << "[HTTP] accept失败，重试..." << std::endl;
                    std::this_thread::sleep_for(std::chrono::milliseconds(200));
                    continue;
                }
                set_sock_timeouts(client, HTTP_RECV_TIMEOUT_MS, SEND_TIMEOUT_MS);
                if (g_conn_count.load() >= MAX_CONNECTIONS)
                {
                    std::cerr << "[HTTP] 并发连接数已达上限 " << MAX_CONNECTIONS
                              << "，拒绝新连接(可能有客户端连上后不发数据)" << std::endl;
                    closesocket(client);
                    continue;
                }
                ++g_conn_count;
                try { std::thread(handle_http_client, client).detach(); }
                catch (...)
                {
                    --g_conn_count;
                    std::cerr << "[HTTP] 创建客户端处理线程失败，关闭该连接" << std::endl;
                    closesocket(client);
                }
            }
        }
        catch (const std::exception& e)
        {
            std::cerr << "[HTTP] 服务端主循环异常退出: " << e.what() << std::endl;
        }
        catch (...) { std::cerr << "[HTTP] 服务端主循环未知异常退出" << std::endl; }
        closesocket(listen_sock);
    }
}

void run_http_server()
{
    std::cout << "\n========== HTTP服务端模式 ==========" << std::endl;
    std::cout << "[HTTP] 监听端口: " << cfg.server.port
              << "  |  POST json body(与TCP协议相同, 不带结尾'>')" << std::endl;
    std::cout << "[HTTP] 已绑定雷达" << radar_mgr.nodes().size() << "台:";
    for (const auto& id : cfg.ids) std::cout << " " << id;
    std::cout << " (请求用 \"radar\" 指定，缺省用第一个)" << std::endl;
    run_http_server_internal();
    stop_server_workers();      // 通知并等待 detach 的工作线程退出，再交回 main 收尾
}