/*****************************************************************************
 * 模块名称：CH395F NET 层测试（Phase 6~11）
 * 模块功能：基于 BSD Socket API（单连接模式）的 NET 层测试，由 ch395fTestTask
 *          任务内的 net_layer_test_main() / net_layer_client_test_main() 事件
 *          循环驱动，需 PC 配合。
 *          包含 Phase 6(TCP Echo) / 7(TCP Client) / 8(大文件) / 9(Select) /
 *          10(边界) / 11(KeepAlive) 及监听循环。
 * 作者：王建锋
 * 创建日期：2026-07-22
 ******************************************************************************/

#include <string.h>
#include "cmsis_os.h"
#include "net_socket.h"
#include "net_types.h"
#include "ch395f_test.h"
#include "ch395f_test_task.h"
#include "net_test_task.h"

#define DBG_TAG "[NET_TEST]"
#include "dbg_log.h"

/*
 * 收发缓冲区 —— 全局静态，不在任务栈上。
 * s_rx_buf 仅在 Phase 6(Echo)/8(大文件)/10(边界)/11(KeepAlive) 中使用。
 * s_tx_buf 仅在 Phase 8(大文件) 和 Phase 10(边界) 中使用。
 * Phase 7(TCP Client) 使用函数内局部小缓冲（64B 递增 + 回显）。
 *
 * 大小依据：
 *   - CH395F 单 Socket 接收缓冲按 1KB block 配置（net_socket.c 中
 *     set_recv_buf(sock, 30, 2) = 2KB），单次 net_recv 至多返回 ~2KB，
 *     故 s_rx_buf 实际只需 ≥ 2KB（此处 32KB 留足余量）。
 *   - Phase 8(大文件) 现改为流式分块：每次仅填一个窗口（≤1024B）即发出，
 *     不再一次性填入整文件，故 s_tx_buf 只需 ≥ 单窗口大小（此处 32KB 留足余量）。
 *   取 32KB(32768) 同时满足两者并留余量，且为 2 的幂；相比原 64KB
 *   在 STM32F4（128KB RAM）上节省一半静态空间。
 */
#define TEST_BUF_SIZE       32768


/* ===================================================================
 * Phase 6 — NET 层 TCP Echo（基础收发）
 *
 * 测试目的：验证 BSD Socket API（net_socket）的单连接 TCP Echo 通路。
 *          Socket 0 复用监听和数据通道。PC 发任意数据，MCU 原样返回。
 *          这是 Phase 7/8/9/10 的基础。
 *
 * 入口条件：Socket 0 处于 ESTABLISHED（TCP 连接已建立）。
 * 通过：数据收发一致。
 * 失败：send/recv 数量不匹配。
 * =================================================================== */

#ifdef ENABLE_PHASE6_TESTS
static void phase6_run(int32_t sockfd) {
    /*
     * 单连接 TCP Echo：NET_MSG_DONTWAIT 非阻塞收，原样回显。
     * 连接断开由 net 层自动重监听（auto_relisten），应用层不维护生命周期；
     * 字节完整性由 PC 侧校验（data == test_data），固件不做每连接自检。
     */
    int32_t n = net_recv(sockfd, s_rx_buf, TEST_BUF_SIZE, NET_MSG_DONTWAIT);
    if (n > 0) {
        int32_t sent = net_send(sockfd, s_rx_buf, n, 0);
        if (sent != n) {
            DBG_ERROR("echo: send %d != recv %d", sent, n);
        }
    }
}
#endif

/* ===================================================================
 * Phase 7 — NET 层 TCP Client（主动连接 PC 回显服务器）
 *
 * 测试目的：验证 BSD Socket API 的 TCP Client 路径（net_socket + net_bind
 *          + net_connect + net_send + net_recv）：
 *          1. MCU 主动连接 PC 回显服务器（192.168.1.2:8080）
 *          2. 64B 递增数据回显后，固件侧逐字节比对 + 32 位累加和校验
 *          3. 关闭并重新连接（规避 TIME_WAIT：每轮换本地端口）
 *          4. 连接超时负向用例（PC 服务关闭时 connect 不应成功）
 *
 * 入口条件：PC 运行 `python test/ch395f_socket_test.py tcp_server --port 8081`
 *          （TC 703 需先关闭该服务）。
 * TC 映射：TC 701（连接 + 回显）/ TC 702（关闭重连）/ TC 703（连接超时）。
 * 通过：回显逐字节一致且 32 位 checksum 匹配；重连全部成功；超时用例未建连。
 * 失败：连接失败 / 回显不一致 / 重连中断 / 超时用例误建连。
 * =================================================================== */

#ifdef ENABLE_PHASE7_TESTS
#include "net_select.h"

#ifndef PHASE7_REMOTE_IP
#define PHASE7_REMOTE_IP        "192.168.1.2"
#endif
#ifndef PHASE7_REMOTE_PORT
#define PHASE7_REMOTE_PORT      8081
#endif
#ifndef PHASE7_LOCAL_PORT
#define PHASE7_LOCAL_PORT       50000
#endif
#ifndef PHASE7_LOOP_COUNT
#define PHASE7_LOOP_COUNT       3
#endif
#ifndef PHASE7_EXCH_SIZE
#define PHASE7_EXCH_SIZE        64
#endif
#ifndef PHASE7_CONN_TIMEOUT_MS
#define PHASE7_CONN_TIMEOUT_MS  10000
#endif
#ifndef PHASE7_TIMEOUT_TEST_MS
#define PHASE7_TIMEOUT_TEST_MS  30000   /* TC 703 连接超时窗（指南规定 30s） */
#endif

/* 32 位累加和：足以发现丢字节/错位，比 CRC32 便宜 */
static uint32_t phase7_cksum(const uint8_t *p, uint32_t n) {
    uint32_t s = 0;
    while (n--) s += *p++;
    return s;
}

/* 单次 TCP Client 会话：对应 TC 701 主体 / TC 702 单轮。
 * 每轮使用不同本地端口 local_port 规避 TIME_WAIT。
 * 返回 1 表示全流程通过，0 表示中途失败（已记录 TEST_CHECK）。 */
static int32_t phase7_session(uint16_t local_port)
{
    int32_t sockfd = net_socket(NET_AF_INET, NET_SOCK_STREAM);
    if (sockfd < 0) {
        TEST_CHECK(0, "TC701 socket create");
        return 0;
    }

    /* 绑定本地端口（不同轮用不同端口规避 TIME_WAIT） */
    {
        struct net_sockaddr_in laddr;
        memset(&laddr, 0, sizeof(laddr));
        laddr.sin_family = NET_AF_INET;
        laddr.sin_port   = net_htons(local_port);
        if (net_bind(sockfd, (struct net_sockaddr *)&laddr, sizeof(laddr)) < 0) {
            TEST_CHECK(0, "TC701 bind port %d", local_port);
            net_close(sockfd);
            return 0;
        }
    }

    /* 目标地址 */
    struct net_sockaddr_in raddr;
    memset(&raddr, 0, sizeof(raddr));
    raddr.sin_family      = NET_AF_INET;
    raddr.sin_port        = net_htons((uint16_t)PHASE7_REMOTE_PORT);
    raddr.sin_addr.s_addr = net_inet_addr(PHASE7_REMOTE_IP);

    DBG_INFO("TC701 connecting %s:%d (local port %d)",
             PHASE7_REMOTE_IP, PHASE7_REMOTE_PORT, local_port);
    int32_t rc = net_connect(sockfd, (struct net_sockaddr *)&raddr, sizeof(raddr));
    TEST_CHECK(rc == 0, "TC701 connect issued (ret=%d)", rc);
    if (rc != 0) { net_close(sockfd); return 0; }

    /* 等待连接建立：轮询 socket 状态（ESTABLISHED）。
     * 用 net_select 触发 net_poll 并作为 100ms 节拍，状态以 net_get_sock 为准。 */
    {
        int32_t connected = 0;
        uint32_t tick = HAL_GetTick();
        while (HAL_GetTick() - tick < PHASE7_CONN_TIMEOUT_MS) {
            net_sock_t *sk = net_get_sock(sockfd);
            if (sk && sk->state == NET_SOCK_STATE_ESTABLISHED) { 
                connected = 1; break; 
            }
            if (sk && sk->state == NET_SOCK_STATE_CLOSED) {
                break; /* 连接失败 */
            }
            osDelay(100);   /* 仅作等待/让出 CPU；连接状态由 netTask 的 net_poll 每 10ms 刷新 */
        }
        TEST_CHECK(connected, "TC701 connected within %dms", PHASE7_CONN_TIMEOUT_MS);
        if (!connected) { net_close(sockfd); return 0; }
    }

    /* 数据交换：64B 递增模式 */
    uint8_t tx[PHASE7_EXCH_SIZE];
    uint8_t rx[PHASE7_EXCH_SIZE];
    for (int32_t i = 0; i < PHASE7_EXCH_SIZE; i++) tx[i] = (uint8_t)i;

    int32_t sent = net_send(sockfd, tx, PHASE7_EXCH_SIZE, 0);
    TEST_CHECK(sent == PHASE7_EXCH_SIZE, "TC701 send %dB (sent=%d)", PHASE7_EXCH_SIZE, sent);
    if (sent != PHASE7_EXCH_SIZE) { net_close(sockfd); return 0; }

    int32_t recvd = 0;
    uint32_t tick = HAL_GetTick();
    while (recvd < PHASE7_EXCH_SIZE) {
        int32_t n = net_recv(sockfd, rx + recvd, PHASE7_EXCH_SIZE - recvd, NET_MSG_DONTWAIT);
        if (n > 0) {
            recvd += n;
        } else if (n == 0) {
            break;  /* 对端关闭 */
        } else if (n < 0 && net_get_errno() == NET_ERR_WOULDBLOCK) {
            if (HAL_GetTick() - tick > PHASE7_CONN_TIMEOUT_MS) break;
            osDelay(10);
            continue;
        } else {
            break;  /* 其它错误 */
        }
        if (HAL_GetTick() - tick > PHASE7_CONN_TIMEOUT_MS) break;
    }

    int32_t ok = (recvd == PHASE7_EXCH_SIZE);
    if (ok) {
        int32_t bad = 0;
        for (int32_t i = 0; i < PHASE7_EXCH_SIZE; i++) {
            if (rx[i] != (uint8_t)i) { bad = 1; break; }
        }
        TEST_CHECK(!bad, "TC701 byte-compare %dB", PHASE7_EXCH_SIZE);
        TEST_CHECK(1, "TC701 recv %dB, cksum=0x%08X", recvd, phase7_cksum(rx, PHASE7_EXCH_SIZE));
    } else {
        TEST_CHECK(0, "TC701 recv %dB (expect %d)", recvd, PHASE7_EXCH_SIZE);
    }

    net_close(sockfd);
    return ok;
}

/* TC 703（负向）：连接超时。PC 未在 REMOTE_IP:REMOTE_PORT 提供服务时，
 * connect 不应成功建立。本用例需先关闭 PC 端 tcp_server（与 TC 701/702 互斥环境：
 * 701/702 要求服务端在线，703 要求服务端离线，故 703 应在独立的一轮中运行）。 */
static void phase7_test_timeout(void)
{
    int32_t sockfd = net_socket(NET_AF_INET, NET_SOCK_STREAM);
    if (sockfd < 0) { TEST_CHECK(0, "TC703 socket create"); return; }

    struct net_sockaddr_in raddr;
    memset(&raddr, 0, sizeof(raddr));
    raddr.sin_family      = NET_AF_INET;
    raddr.sin_port        = net_htons((uint16_t)PHASE7_REMOTE_PORT);
    raddr.sin_addr.s_addr = net_inet_addr(PHASE7_REMOTE_IP);

    DBG_INFO("TC703 connecting %s:%d (expect TIMEOUT, PC server must be OFF)",
             PHASE7_REMOTE_IP, PHASE7_REMOTE_PORT);
    int32_t rc = net_connect(sockfd, (struct net_sockaddr *)&raddr, sizeof(raddr));
    TEST_CHECK(rc == 0, "TC703 connect issued (ret=%d)", rc);
    if (rc != 0) { net_close(sockfd); return; }

    int32_t established = 0;
    uint32_t tick = HAL_GetTick();
    while (HAL_GetTick() - tick < PHASE7_TIMEOUT_TEST_MS) {
        net_sock_t *sk = net_get_sock(sockfd);
        if (sk && sk->state == NET_SOCK_STATE_ESTABLISHED) { established = 1; break; }
        if (sk && sk->state == NET_SOCK_STATE_CLOSED) break;
        osDelay(100);   /* 仅作等待/让出 CPU；连接状态由 netTask 的 net_poll 每 10ms 刷新 */
    }
    if (established) {
        TEST_CHECK(0, "TC703 connected?! stop PC server and retry");
    } else {
        TEST_CHECK(1, "TC703 no-connect within %dms (timeout as expected)", PHASE7_TIMEOUT_TEST_MS);
    }
    net_close(sockfd);
}

/* TC 704：多 Socket 并发 TCP Client。
 * 多 Socket 模式下 Socket 1~7 才可用；本用例同时打开 Socket 0~7，
 * 各自连 PC echo server，每路独立收发 PHASE7_EXCH_SIZE 字节回显并比对，
 * 验证 8 个 Socket 均能独立工作。依赖 PC 端 tcp_server 支持并发连接。 */
#ifndef PHASE7_MULTI_COUNT
#define PHASE7_MULTI_COUNT     8
#endif
#ifndef PHASE7_MULTI_BASE_PORT
#define PHASE7_MULTI_BASE_PORT 51000
#endif

static int32_t phase7_session_multi(void)
{
    int32_t sockfd[PHASE7_MULTI_COUNT];
    uint8_t tx[PHASE7_EXCH_SIZE];
    uint8_t rx[PHASE7_EXCH_SIZE];
    for (int32_t i = 0; i < PHASE7_EXCH_SIZE; i++) tx[i] = (uint8_t)i;

    /* 1) 打开并连接所有 Socket（各自绑定不同本地端口规避 TIME_WAIT） */
    for (int32_t i = 0; i < PHASE7_MULTI_COUNT; i++) {
        sockfd[i] = net_socket(NET_AF_INET, NET_SOCK_STREAM);
        if (sockfd[i] < 0) {
            TEST_CHECK(0, "TC704 socket create #%d", i);
            for (int32_t j = 0; j < i; j++) net_close(sockfd[j]);
            return 0;
        }
        struct net_sockaddr_in laddr;
        memset(&laddr, 0, sizeof(laddr));
        laddr.sin_family = NET_AF_INET;
        laddr.sin_port   = net_htons((uint16_t)(PHASE7_MULTI_BASE_PORT + i));
        if (net_bind(sockfd[i], (struct net_sockaddr *)&laddr, sizeof(laddr)) < 0) {
            TEST_CHECK(0, "TC704 bind #%d port %d", i, PHASE7_MULTI_BASE_PORT + i);
            net_close(sockfd[i]);
            for (int32_t j = 0; j < i; j++) net_close(sockfd[j]);
            return 0;
        }
        struct net_sockaddr_in raddr;
        memset(&raddr, 0, sizeof(raddr));
        raddr.sin_family      = NET_AF_INET;
        raddr.sin_port        = net_htons((uint16_t)PHASE7_REMOTE_PORT);
        raddr.sin_addr.s_addr = net_inet_addr(PHASE7_REMOTE_IP);
        int32_t rc = net_connect(sockfd[i], (struct net_sockaddr *)&raddr, sizeof(raddr));
        TEST_CHECK(rc == 0, "TC704 connect #%d issued (ret=%d)", i, rc);
        if (rc != 0) {
            net_close(sockfd[i]);
            for (int32_t j = 0; j < i; j++) net_close(sockfd[j]);
            return 0;
        }
    }

    /* 2) 等待所有连接建立（或超时） */
    {
        uint32_t tick = HAL_GetTick();
        int32_t all_up = 0;
        while (HAL_GetTick() - tick < PHASE7_CONN_TIMEOUT_MS) {
            all_up = 1;
            for (int32_t i = 0; i < PHASE7_MULTI_COUNT; i++) {
                net_sock_t *sk = net_get_sock(sockfd[i]);
                if (!sk || sk->state != NET_SOCK_STATE_ESTABLISHED) { all_up = 0; break; }
            }
            if (all_up) break;
            osDelay(100);
        }
        TEST_CHECK(all_up, "TC704 all %d sockets established within %dms", PHASE7_MULTI_COUNT, PHASE7_CONN_TIMEOUT_MS);
        if (!all_up) {
            for (int32_t i = 0; i < PHASE7_MULTI_COUNT; i++) {
                net_sock_t *sk = net_get_sock(sockfd[i]);
                if (sk) DBG_ERROR("TC704 socket #%d state=%d", i, sk->state);
                net_close(sockfd[i]);
            }
            return 0;
        }
    }

    /* 3) 每路独立收发回显 */
    int32_t ok = 1;
    for (int32_t i = 0; i < PHASE7_MULTI_COUNT; i++) {
        int32_t sent = net_send(sockfd[i], tx, PHASE7_EXCH_SIZE, 0);
        if (sent != PHASE7_EXCH_SIZE) {
            TEST_CHECK(0, "TC704 socket #%d send %dB (sent=%d)", i, PHASE7_EXCH_SIZE, sent);
            ok = 0;
            continue;
        }
        int32_t recvd = 0;
        uint32_t tick = HAL_GetTick();
        while (recvd < PHASE7_EXCH_SIZE) {
            int32_t n = net_recv(sockfd[i], rx + recvd, PHASE7_EXCH_SIZE - recvd, NET_MSG_DONTWAIT);
            if (n > 0) recvd += n;
            else if (n == 0) break;
            else if (n < 0 && net_get_errno() == NET_ERR_WOULDBLOCK) {
                if (HAL_GetTick() - tick > PHASE7_CONN_TIMEOUT_MS) break;
                osDelay(10);
                continue;
            } else break;
            if (HAL_GetTick() - tick > PHASE7_CONN_TIMEOUT_MS) break;
        }
        int32_t sock_ok = (recvd == PHASE7_EXCH_SIZE);
        if (sock_ok) {
            int32_t bad = 0;
            for (int32_t k = 0; k < PHASE7_EXCH_SIZE; k++) if (rx[k] != (uint8_t)k) { bad = 1; break; }
            TEST_CHECK(!bad, "TC704 socket #%d echo %dB OK", i, PHASE7_EXCH_SIZE);
        } else {
            TEST_CHECK(0, "TC704 socket #%d recv %dB (expect %d)", i, recvd, PHASE7_EXCH_SIZE);
            ok = 0;
        }
    }

    /* 4) 关闭所有 */
    for (int32_t i = 0; i < PHASE7_MULTI_COUNT; i++) net_close(sockfd[i]);

    return ok;
}

void net_layer_client_test_main(void)
{
    DBG_INFO("=== CH395F Phase 7 Tests (NET TCP Client) ===");

    DBG_INFO("--- TC 701: connect + %dB echo exchange ---", PHASE7_EXCH_SIZE);
    phase7_session((uint16_t)PHASE7_LOCAL_PORT);

    DBG_INFO("--- TC 702: close/reconnect x%d ---", PHASE7_LOOP_COUNT);
    {
        int32_t all_ok = 1;
        for (int32_t i = 0; i < PHASE7_LOOP_COUNT; i++) {
            if (!phase7_session((uint16_t)(PHASE7_LOCAL_PORT + 1 + i))) all_ok = 0;
        }
        TEST_CHECK(all_ok, "TC702 reconnect x%d all passed", PHASE7_LOOP_COUNT);
    }

    DBG_INFO("--- TC 704: %d-socket concurrent client (PC %s:%d MUST be ON) ---",
             PHASE7_MULTI_COUNT, PHASE7_REMOTE_IP, PHASE7_REMOTE_PORT);
    phase7_session_multi();

    DBG_INFO("--- TC 703: connect timeout (PC %s:%d MUST be OFF) ---",
             PHASE7_REMOTE_IP, PHASE7_REMOTE_PORT);
    phase7_test_timeout();

    TEST_REPORT("Phase 7");
}
#endif

/* ===================================================================
 * Phase 8 — 大文件 / 批量传输（默认 100KB，文件收发）
 *
 * 测试目的：验证超过 Socket 接收缓冲（2KB）的大块数据在 net_send /
 *          net_recv 层经分块后的正确处理；并支持「文件发送(MCU→PC) /
 *          文件接收(PC→MCU) / 回显 round-trip」三种方向。
 *
 * 数据模式：递增字节，绝对位置 p 处字节 = (p & 0xFF)；发送端按窗口
 *          (offset + i) 生成，接收端按 offset 逐字节比对（自校验）。
 *          整包另用 CRC32（与 PC zlib.crc32 一致）做整体校验。
 *
 * 缓冲策略：s_tx_buf / s_rx_buf 仅 32KB，100KB 须按窗口逐块生成/校验，
 *          不整体驻留 RAM（流式分块）。
 *
 * 方向选择（编译宏 PHASE8_DIRECTION）：
 *   0 = ECHO  发 100KB 经 PC 回显，MCU 收齐校验（默认）
 *   1 = SEND  MCU 发 100KB，PC 落盘 rx_100k.bin 校验
 *   2 = RECV  PC 发 100KB（+4B CRC32 尾），MCU 收齐字节+CRC 校验
 * =================================================================== */

/* Phase 8 方向配置：须早于下方缓冲声明，以按方向精确控制 s_tx_buf 等是否参与编译 */
#ifdef ENABLE_PHASE8_TESTS
#define PHASE8_DIR_ECHO         0
#define PHASE8_DIR_SEND         1
#define PHASE8_DIR_RECV         2
#ifndef PHASE8_FILE_SIZE
#define PHASE8_FILE_SIZE        102400      /* 100KB */
#endif
#ifndef PHASE8_DIRECTION
#define PHASE8_DIRECTION        PHASE8_DIR_ECHO
#endif
#endif

#if defined(ENABLE_PHASE6_TESTS)  || \
    (defined(ENABLE_PHASE8_TESTS) && (PHASE8_DIRECTION != PHASE8_DIR_SEND)) || \
    defined(ENABLE_PHASE10_TESTS) || defined(ENABLE_PHASE11_TESTS)
static uint8_t s_rx_buf[TEST_BUF_SIZE];
#endif
/* s_tx_buf 仅 SEND/ECHO（及 Phase 10）需要；RECV 不发送，避免未使用变量警告 */
#if (defined(ENABLE_PHASE8_TESTS) && (PHASE8_DIRECTION != PHASE8_DIR_RECV)) || \
    defined(ENABLE_PHASE10_TESTS)
static uint8_t s_tx_buf[TEST_BUF_SIZE];
#endif


#ifdef ENABLE_PHASE8_TESTS

/* CRC32（标准，与 Python zlib.crc32 一致；初始 0xFFFFFFFF，末异或 0xFFFFFFFF）
 *   仅 RECV 方向需要：MCU 收齐后比对 PC 附在文件末尾的 4 字节 CRC32。 */
#if PHASE8_DIRECTION == PHASE8_DIR_RECV
static uint32_t phase8_crc32_step(uint32_t crc, const uint8_t *data, uint32_t len) {
    for (uint32_t i = 0; i < len; i++) {
        crc ^= data[i];
        for (int32_t k = 0; k < 8; k++) {
            crc = (crc & 1u) ? (crc >> 1) ^ 0xEDB88320u : (crc >> 1);
        }
    }
    return crc;
}
#endif

/* 仅 SEND/ECHO 方向需要：生成递增模式发送窗口 */
#if PHASE8_DIRECTION != PHASE8_DIR_RECV
static void phase8_fill(uint8_t *buf, uint32_t size, uint32_t offset) {
    for (uint32_t i = 0; i < size; i++) {
        buf[i] = (uint8_t)((offset + i) & 0xFF);
    }
}
#endif

/* 仅 ECHO/RECV 方向需要：逐字节校验接收数据 */
#if PHASE8_DIRECTION != PHASE8_DIR_SEND
static int32_t phase8_verify(uint8_t *buf, uint32_t size, uint32_t offset) {
    for (uint32_t i = 0; i < size; i++) {
        if (buf[i] != (uint8_t)((offset + i) & 0xFF)) {
            DBG_ERROR("Phase8: mismatch at %lu (expect 0x%02X, got 0x%02X)",
                      offset + i, (uint8_t)((offset + i) & 0xFF), buf[i]);
            return 0;
        }
    }
    return 1;
}
#endif

static void phase8_run(int32_t sockfd) {
#if PHASE8_DIRECTION == PHASE8_DIR_RECV
    /* PC 发送文件（尾附 4B CRC32），MCU 接收并逐字节 + CRC32 校验 */
    DBG_INFO("Phase8[RECV]: receiving %d-byte file", PHASE8_FILE_SIZE);

    uint32_t recvd = 0;
    uint32_t crc = 0xFFFFFFFFu;
    while (recvd < PHASE8_FILE_SIZE) {
        int32_t to_read = (PHASE8_FILE_SIZE - recvd) > (TEST_BUF_SIZE - 4)
                        ? (TEST_BUF_SIZE - 4) : (int)(PHASE8_FILE_SIZE - recvd);
        int32_t n = net_recv(sockfd, s_rx_buf, to_read, 0);
        if (n <= 0) {
            DBG_ERROR("Phase8[RECV]: recv fail at %lu (ret=%d)", recvd, n);
            return;
        }
        int32_t ok = phase8_verify(s_rx_buf, (uint32_t)n, recvd);
        TEST_CHECK(ok, "Phase8[RECV]: verify at %lu (%d bytes)", recvd, n);
        if (!ok) return;
        crc = phase8_crc32_step(crc, s_rx_buf, (uint32_t)n);
        recvd += (uint32_t)n;
    }

    /* 读取 PC 附在文件末尾的 4 字节 CRC32（小端） */
    uint8_t foot[4];
    uint32_t got = 0;
    while (got < 4) {
        int32_t n = net_recv(sockfd, foot + got, (int)(4 - got), 0);
        if (n <= 0) {
            DBG_ERROR("Phase8[RECV]: footer recv fail (ret=%d)", n);
            return;
        }
        got += (uint32_t)n;
    }
    uint32_t crc_exp = crc ^ 0xFFFFFFFFu;
    uint32_t crc_act = ((uint32_t)foot[0]) | ((uint32_t)foot[1] << 8)
                     | ((uint32_t)foot[2] << 16) | ((uint32_t)foot[3] << 24);
    TEST_CHECK(crc_act == crc_exp,
               "Phase8[RECV]: CRC32 exp=0x%08X act=0x%08X", crc_exp, crc_act);
    DBG_INFO("Phase8[RECV]: done, CRC32=0x%08X", crc_exp);

#elif PHASE8_DIRECTION == PHASE8_DIR_SEND
    /* MCU 发送文件，PC 落盘校验（PC 侧自行比对字节/CRC32） */
    DBG_INFO("Phase8[SEND]: sending %d-byte file", PHASE8_FILE_SIZE);

    uint32_t sent = 0;
    while (sent < PHASE8_FILE_SIZE) {
        /* 每次填充一个滑动窗口（≤ s_tx_buf 容量）；net_send 内部按硬件发送 FIFO
         * (NET_SEND_CHUNK_MAX=1KB，见 Trap 20) 自动拆分写入，无需此处逐 1KB 分块 */
        uint32_t chunk = (PHASE8_FILE_SIZE - sent) > (uint32_t)TEST_BUF_SIZE
                            ? (uint32_t)TEST_BUF_SIZE : (PHASE8_FILE_SIZE - sent);
        phase8_fill(s_tx_buf, chunk, sent);
        int32_t n = net_send(sockfd, s_tx_buf, (int)chunk, 0);
        if (n <= 0) {
            DBG_ERROR("Phase8[SEND]: send fail at %lu (ret=%d)", sent, n);
            return;
        }
        sent += (uint32_t)n;
    }
    DBG_INFO("Phase8[SEND]: sent %d bytes", PHASE8_FILE_SIZE);
    TEST_CHECK(1, "Phase8[SEND]: %d-byte file sent", PHASE8_FILE_SIZE);

#else /* PHASE8_DIR_ECHO */
    /* 发 100KB 经 PC 回显（tcp_server --max-conn 1），MCU 收齐逐字节校验 */
    DBG_INFO("Phase8[ECHO]: transferring %d-byte file", PHASE8_FILE_SIZE);

    uint32_t sent = 0;
    while (sent < PHASE8_FILE_SIZE) {
        /* 同 SEND：填充滑动窗口（≤ s_tx_buf），由 net_send 内部按硬件 FIFO 自动拆分 */
        uint32_t chunk = (PHASE8_FILE_SIZE - sent) > (uint32_t)TEST_BUF_SIZE
                            ? (uint32_t)TEST_BUF_SIZE : (PHASE8_FILE_SIZE - sent);
        phase8_fill(s_tx_buf, chunk, sent);
        int32_t n = net_send(sockfd, s_tx_buf, (int)chunk, 0);
        if (n <= 0) {
            DBG_ERROR("Phase8[ECHO]: send fail at %lu (ret=%d)", sent, n);
            return;
        }
        sent += (uint32_t)n;
    }

    uint32_t recvd = 0;
    while (recvd < PHASE8_FILE_SIZE) {
        int32_t n = net_recv(sockfd, s_rx_buf, TEST_BUF_SIZE, 0);
        if (n <= 0) {
            DBG_ERROR("Phase8[ECHO]: recv fail at %lu (ret=%d)", recvd, n);
            return;
        }
        int32_t ok = phase8_verify(s_rx_buf, (uint32_t)n, recvd);
        TEST_CHECK(ok, "Phase8[ECHO]: verify at %lu (%d bytes)", recvd, n);
        if (!ok) return;
        recvd += (uint32_t)n;
    }
    TEST_CHECK(1, "Phase8[ECHO]: %d-byte file transfer complete", PHASE8_FILE_SIZE);
#endif

    /* 一次性传输完成：主动关闭数据连接，触发 net 层自动重监听。
     * 否则 accept 循环会在“仍打开的同一条连接”上重复执行本 Phase——
     * SEND/RECV 由 PC 端先关闭尚可终止，ECHO 方向 PC 回显客户端不会主动
     * 关闭，会导致 MCU 无限重复、PC 端 tcp_file --op echo 一直挂起。 */
    net_close(sockfd);
}
#endif

/* ===================================================================
 * Phase 9 — Select/Poll I/O 多路复用
 *
 * 测试目的：验证 net_select() API 在单 Socket 模式下正确工作：
 *          1. Socket 0 有数据到达时 select 返回正数
 *          2. NET_FD_ISSET 正确指示就绪的 Socket
 *          3. 超时（50ms 无数据）时返回 0
 *
 * 入口条件：Socket 0 处于 ESTABLISHED。
 * 通过：select 检测到数据并成功回显。
 * 失败：select 未检测到数据或回显失败。
 * =================================================================== */

#ifdef ENABLE_PHASE9_TESTS
#include "net_select.h"
static uint32_t s_phase9_count = 0;

static void phase9_run(int32_t sockfd) {
    net_fd_set readfds;
    net_timeval tv;

    /*
     * 配置 select：只监测 Socket 0 的可读状态，超时 50ms。
     * NET_FD_ZERO 清空集合，NET_FD_SET 添加 Socket 0。
     * 50ms 超时确保不阻塞任务循环太久。
     */
    NET_FD_ZERO(&readfds);
    NET_FD_SET(sockfd, &readfds);
    tv.tv_sec = 0;
    tv.tv_usec = 50000;

    int32_t nfds = net_select(sockfd + 1, &readfds, NULL, NULL, &tv);
    if (nfds <= 0) return;

    /* Socket 0 可读：非阻塞接收并回显 */
    if (NET_FD_ISSET(sockfd, &readfds)) {
        int32_t n = net_recv(sockfd, s_rx_buf, TEST_BUF_SIZE, NET_MSG_DONTWAIT);
        if (n > 0) {
            int32_t sent = net_send(sockfd, s_rx_buf, n, 0);
            if (sent == n) {
                s_phase9_count++;
                TEST_CHECK(1, "Phase9: select echo #%lu (%d bytes)", s_phase9_count, n);
            }
        }
    }
}
#endif

/* ===================================================================
 * Phase 10 — 边界条件测试
 *
 * 测试目的：验证以下 DMA 和协议栈边界情况：
 *          1. TC-NET-1001: 4095B（SPI 最大载荷 -1，单次 DMA 容纳）
 *          2. TC-NET-1002: 4096B（= SPI 最大载荷，填满单次 DMA）
 *          3. TC-NET-1003: 4097B（超过 SPI 最大载荷，拆 2 次 DMA）
 *          4. TC-NET-1004: 零长度发送（返回 -1）
 *          5. TC-NET-1005: 20 × 100B 连续快速发送
 *
 * 各用例通过状态机（s_phase10_stage）串行执行，每次 phase10_run 推进一个
 * 步骤（发送→等待→接收→验证→下一阶段）。发送数据为递增模式字节
 * （buf[i] = seed + i），接收端按相同模式验证。
 *
 * 入口条件：Socket 0 处于 ESTABLISHED。
 * 通过：各用例自身判定。
 * =================================================================== */

#ifdef ENABLE_PHASE10_TESTS
static int32_t s_phase10_stage = 0;
static uint32_t s_phase10_recv = 0;

static void phase10_fill(uint8_t *buf, uint32_t size, uint8_t seed) {
    for (uint32_t i = 0; i < size; i++) {
        buf[i] = (uint8_t)(seed + i);
    }
}

static int32_t phase10_verify(uint8_t *buf, uint32_t size, uint8_t seed) {
    for (uint32_t i = 0; i < size; i++) {
        if (buf[i] != (uint8_t)(seed + i)) return 0;
    }
    return 1;
}

static void phase10_run(int32_t sockfd) {
    /* 阶段 0 → 1：发送 4095B */
    if (s_phase10_stage == 0) {
        DBG_INFO("Phase10: 4095B (DMA-1)");
        phase10_fill(s_tx_buf, 4095, 0x10);
        int32_t sent = net_send(sockfd, s_tx_buf, 4095, 0);
        TEST_CHECK(sent == 4095, "Phase10: send 4095B (sent=%d)", sent);
        s_phase10_recv = 0;
        s_phase10_stage = 1;
        return;
    }
    /* 阶段 1：接收并验证 4095B 回显 */
    if (s_phase10_stage == 1) {
        int32_t n = net_recv(sockfd, s_rx_buf + s_phase10_recv, (int)(4095 - s_phase10_recv), 0);
        if (n > 0) {
            s_phase10_recv += (uint32_t)n;
            if (s_phase10_recv >= 4095) {
                TEST_CHECK(phase10_verify(s_rx_buf, 4095, 0x10), "Phase10: verify 4095B");
                s_phase10_stage = 2;
            }
        }
        return;
    }
    /* 阶段 2 → 3：发送 4096B（DMA 边界精确值） */
    if (s_phase10_stage == 2) {
        DBG_INFO("Phase10: 4096B (DMA exact)");
        phase10_fill(s_tx_buf, 4096, 0x20);
        int32_t sent = net_send(sockfd, s_tx_buf, 4096, 0);
        TEST_CHECK(sent == 4096, "Phase10: send 4096B (sent=%d)", sent);
        s_phase10_recv = 0;
        s_phase10_stage = 3;
        return;
    }
    /* 阶段 3：接收并验证 4096B 回显 */
    if (s_phase10_stage == 3) {
        int32_t n = net_recv(sockfd, s_rx_buf + s_phase10_recv, (int)(4096 - s_phase10_recv), 0);
        if (n > 0) {
            s_phase10_recv += (uint32_t)n;
            if (s_phase10_recv >= 4096) {
                TEST_CHECK(phase10_verify(s_rx_buf, 4096, 0x20), "Phase10: verify 4096B");
                s_phase10_stage = 4;
            }
        }
        return;
    }
    /* 阶段 4 → 5：发送 4097B（超过 DMA 上限，自动拆 4096+1） */
    if (s_phase10_stage == 4) {
        DBG_INFO("Phase10: 4097B (DMA+1, 2 SPI xacts)");
        phase10_fill(s_tx_buf, 4097, 0x30);
        int32_t sent = net_send(sockfd, s_tx_buf, 4097, 0);
        TEST_CHECK(sent == 4097, "Phase10: send 4097B (sent=%d)", sent);
        s_phase10_recv = 0;
        s_phase10_stage = 5;
        return;
    }
    /* 阶段 5：接收并验证 4097B 回显 */
    if (s_phase10_stage == 5) {
        int32_t n = net_recv(sockfd, s_rx_buf + s_phase10_recv, (int)(4097 - s_phase10_recv), 0);
        if (n > 0) {
            s_phase10_recv += (uint32_t)n;
            if (s_phase10_recv >= 4097) {
                TEST_CHECK(phase10_verify(s_rx_buf, 4097, 0x30), "Phase10: verify 4097B");
                s_phase10_stage = 6;
            }
        }
        return;
    }
    /* 阶段 6：零长度发送 —— 期望 net_send 返回 -1（NET_ERR_INVAL） */
    if (s_phase10_stage == 6) {
        DBG_INFO("Phase10: zero-length send");
        int32_t sent = net_send(sockfd, s_tx_buf, 0, 0);
        TEST_CHECK(sent < 0, "Phase10: send 0B returns %d (expect <0)", sent);
        s_phase10_stage = 7;
        return;
    }
    /* 阶段 7：20 × 100B 快速发送 */
    if (s_phase10_stage == 7) {
        DBG_INFO("Phase10: 20x rapid sends (100B each)");
        phase10_fill(s_tx_buf, 100, 0x40);
        int32_t all_ok = 1;
        for (int32_t i = 0; i < 20; i++) {
            if (net_send(sockfd, s_tx_buf, 100, 0) != 100) {
                TEST_CHECK(0, "Phase10: rapid #%d fail", i + 1);
                all_ok = 0; break;
            }
            osDelay(1);
        }
        if (all_ok) {
            TEST_CHECK(1, "Phase10: 20x rapid sends OK");
            s_phase10_recv = 0;
            s_phase10_stage = 8;
        } else {
            s_phase10_stage = 0;
        }
        return;
    }
    /* 阶段 8：接收 2000B 回显总和并验证 */
    if (s_phase10_stage == 8) {
        int32_t n = net_recv(sockfd, s_rx_buf + s_phase10_recv, (int)(2000 - s_phase10_recv), 0);
        if (n > 0) {
            s_phase10_recv += (uint32_t)n;
            if (s_phase10_recv >= 2000) {
                TEST_CHECK(1, "Phase10: all echo received");
                TEST_REPORT("Phase 10");
                s_phase10_stage = 0;
            }
        }
        return;
    }
}
#endif

/* ===================================================================
 * Phase 11 — TCP KeepAlive 超时断开
 *
 * 测试目的：验证 CH395F 的 TCP KeepAlive 机制：
 *          1. 连接空闲超过 idle 阈值（60s）后开始发送探测包
 *          2. 探测无响应（默认 3 次 × 5s = 15s）后触发 TIMEOUT
 *          3. Socket 自动关闭并回到 LISTEN
 *
 * 入口条件：Socket 0 处于 ESTABLISHED，PC 连接后静置（不发数据）。
 * 通过：KeepAlive 断开时间 ≥ 60s（从连接建立到 recv 返回 0 的间隔）。
 * 失败：不到 60s 就断开（可能是其他原因导致）或 75s 后仍未断开。
 * =================================================================== */

#ifdef ENABLE_PHASE11_TESTS
static int32_t      s_phase11_armed = 0;
static uint32_t s_phase11_start = 0;

static void phase11_run(int32_t sockfd) {
    /*
     * 第一次调用：记录开始时间并 arm。
     * 后续调用：非阻塞 recv，若返回 0 表示连接已断开（KeepAlive 触发）。
     * 计算耗时与 60s idle 阈值比较。
     */
    if (!s_phase11_armed) {
        s_phase11_armed = 1;
        s_phase11_start = HAL_GetTick();
        DBG_INFO("Phase11: idle wait for KeepAlive timeout (60s)");
        return;
    }

    int32_t n = net_recv(sockfd, s_rx_buf, 64, NET_MSG_DONTWAIT);
    if (n == 0) {
        uint32_t elapsed = HAL_GetTick() - s_phase11_start;
        TEST_CHECK(elapsed >= 60000,
                   "Phase11: KeepAlive triggered after %lums (expect >=60000ms)", elapsed);
        TEST_REPORT("Phase 11");
        s_phase11_armed = 0;
    }
}
#endif

void net_layer_test_main(void)
{
    int32_t sockfd = -1;
    int32_t phase_active = 0;
    uint32_t accept_retry = 0;
    struct net_sockaddr_in client_addr;
    int32_t addrlen = sizeof(client_addr);

    sockfd = net_socket(NET_AF_INET, NET_SOCK_STREAM);
    if (sockfd < 0) {
        DBG_ERROR("Test task: net_socket failed");
        return;
    }
    DBG_INFO("Test task: socket %d created", sockfd);

    {
        struct net_sockaddr_in addr;
        memset(&addr, 0, sizeof(addr));
        addr.sin_family = NET_AF_INET;
        addr.sin_port   = net_htons(8080);
        if (net_bind(sockfd, (struct net_sockaddr *)&addr, sizeof(addr)) < 0) {
            DBG_ERROR("Test task: net_bind failed");
            return;
        }
        DBG_INFO("Test task: bound to port 8080");
    }

    if (net_listen(sockfd) < 0) {
        DBG_ERROR("Test task: net_listen failed");
        return;
    }
    DBG_INFO("Test task: listening on 8080 (single-socket mode)");

    /* ==================== 事件驱动阶段 ====================
     * Phase 6/8~11（NET 层）在 TCP 监听循环中运行，需要 PC 客户端连接。
     * （Phase 7 TCP Client 为独立入口 net_layer_client_test_main，不在本循环。）
     * 没有连接时循环等待；连接建立后执行对应 Phase。
     * 断开后自动重新 listen。
     */
    for (;;) {
        if (!phase_active) {
            int32_t acc = net_accept(sockfd, (struct net_sockaddr *)&client_addr, &addrlen);
            if (acc < 0) {
                if (accept_retry % 100 == 0) {
                    DBG_INFO("Test task: waiting for connection...");
                }
                accept_retry++;
                osDelay(100);
                continue;
            }
            accept_retry = 0;
            phase_active = 1;
            DBG_INFO("Test task: client accepted (fd=%d)", acc);

            /* 连接建立，重置各 Phase 内部状态 */
#ifdef ENABLE_PHASE10_TESTS
            s_phase10_stage = 0;
#endif
#ifdef ENABLE_PHASE11_TESTS
            s_phase11_armed = 0;
#endif
        }

        /* 每 10ms 依次执行各已启用 Phase */
#ifdef ENABLE_PHASE6_TESTS
        phase6_run(sockfd);
#endif
#ifdef ENABLE_PHASE8_TESTS
        phase8_run(sockfd);
        phase_active = 0;   /* Phase 8 一次性完成，发完即止 */
#endif
#ifdef ENABLE_PHASE9_TESTS
        phase9_run(sockfd);
#endif
#ifdef ENABLE_PHASE10_TESTS
        phase10_run(sockfd);
#endif
#ifdef ENABLE_PHASE11_TESTS
        phase11_run(sockfd);
#endif

        /*
         * 单连接模式：连接断开由 net 层自动重监听（auto_relisten），
         * 应用层不巡检/不重监听，回显循环持续服务新连接。
         */
        osDelay(10);
    }
}
