#include "app.hpp"
#include <cassert>
#include <cstring>
#include <ctime>
#include <iostream>
#include <string>
#include <vector>

// ═══════════════════════════════════════════════════════════════
// DAU 单元测试
// ═══════════════════════════════════════════════════════════════

/**
 * @brief 测试 DAU_Process 正常处理有效数据帧。
 *
 * @requirement(name="基础通用通讯功能", id="SRS-F-01-001")
 * 接收多总线数据，进行 ID 过滤、波特率适配、错误帧处理。
 */
static void test_DAU_Process_ValidFrame()
{
    RawDataFrame input;
    input.busType   = BusType::CAN;
    input.len       = 8;
    input.timestamp = std::time(nullptr);
    for (uint8_t i = 0; i < input.len; ++i) {
        input.data[i] = 0x10 + i;
    }

    ValidData output;
    std::string errorLog;
    bool ok = dau::DAU_Process(input, output, errorLog);

    assert(ok == true);
    assert(output.dataLen == input.len);
    assert(output.sourceBus == BusType::CAN);
    assert(errorLog.empty());
    std::cout << "[PASS] test_DAU_Process_ValidFrame\n";
}

/**
 * @brief 测试 DAU_Process 处理错误帧（全 0xFF）。
 *
 * @requirement(name="基础通用通讯功能", id="SRS-F-01-001")
 * 错误帧处理、睡眠/唤醒管理。
 */
static void test_DAU_Process_ErrorFrame()
{
    RawDataFrame input;
    input.busType   = BusType::RS422;
    input.len       = 4;
    input.timestamp = std::time(nullptr);
    // 全 0xFF 视为错误帧
    for (uint8_t i = 0; i < input.len; ++i) {
        input.data[i] = 0xFF;
    }

    ValidData output;
    std::string errorLog;
    bool ok = dau::DAU_Process(input, output, errorLog);

    assert(ok == false);
    assert(!errorLog.empty());
    std::cout << "[PASS] test_DAU_Process_ErrorFrame\n";
}

/**
 * @brief 测试睡眠模式下数据被丢弃。
 *
 * @requirement(name="基础通用通讯功能", id="SRS-F-01-001")
 * 睡眠/唤醒管理。
 */
static void test_DAU_SleepMode()
{
    dau::DAU_SetSleep(true);

    RawDataFrame input;
    input.busType   = BusType::Ethernet;
    input.len       = 2;
    input.timestamp = std::time(nullptr);
    input.data[0]   = 0x01;
    input.data[1]   = 0x02;

    ValidData output;
    std::string errorLog;
    bool ok = dau::DAU_Process(input, output, errorLog);

    assert(ok == false);
    assert(!errorLog.empty());
    std::cout << "[PASS] test_DAU_SleepMode\n";

    dau::DAU_SetSleep(false); // 恢复
}

// ═══════════════════════════════════════════════════════════════
// PPU 单元测试
// ═══════════════════════════════════════════════════════════════

/**
 * @brief 测试 PPU_Check 接受有效标准帧。
 *
 * @requirement(name="协议兼容与互通信功能", id="SRS-F-01-002")
 * 兼容标准帧与扩展帧格式。
 */
static void test_PPU_Check_ValidStandard()
{
    CanFrame frame;
    frame.id        = 0x100;
    frame.isExtended = false;
    frame.isCanFd   = false;
    frame.dataLen   = 8;

    std::string reason;
    bool ok = ppu::PPU_Check(frame, reason);

    assert(ok == true);
    std::cout << "[PASS] test_PPU_Check_ValidStandard\n";
}

/**
 * @brief 测试 PPU_Check 拒绝超 ID 范围的标准帧。
 *
 * @requirement(name="协议兼容与互通信功能", id="SRS-F-01-002")
 * 若格式不支持，则记录日志并丢弃。
 */
static void test_PPU_Check_InvalidStandardId()
{
    CanFrame frame;
    frame.id        = 0x800; // 超出 11 位范围
    frame.isExtended = false;
    frame.isCanFd   = false;
    frame.dataLen   = 8;

    std::string reason;
    bool ok = ppu::PPU_Check(frame, reason);

    assert(ok == false);
    assert(!reason.empty());
    std::cout << "[PASS] test_PPU_Check_InvalidStandardId\n";
}

/**
 * @brief 测试 PPU_Convert CAN2.0->CANFD 转换。
 *
 * @requirement(name="协议兼容与互通信功能", id="SRS-F-01-002")
 * 依据 ARINC825 标准进行协议转换或适配。
 */
static void test_PPU_Convert_Can20ToFd()
{
    CanFrame input;
    input.id        = 0x200;
    input.isExtended = false;
    input.isCanFd   = false;
    input.dataLen   = 8;
    input.timestamp = std::time(nullptr);
    for (uint8_t i = 0; i < input.dataLen; ++i) {
        input.data[i] = 0x30 + i;
    }

    CompatibleFrame output;
    std::string log;
    bool ok = ppu::PPU_Convert(input, output, log);

    assert(ok == true);
    assert(output.id == input.id);
    assert(output.dataLen == 8);
    assert(output.isExtended == false);
    std::cout << "[PASS] test_PPU_Convert_Can20ToFd\n";
}

// ═══════════════════════════════════════════════════════════════
// DSU 单元测试
// ═══════════════════════════════════════════════════════════════

/**
 * @brief 测试 DSU_Write 与 DSU_Query 基本写入与查询。
 *
 * @requirement(name="数据存储功能", id="SRS-F-02-001")
 * 将总线数据持久化保存，接收实时数据流并进行缓冲预处理。
 * @requirement(name="数据管理与回放功能", id="SRS-F-02-002")
 * 支持对已存储数据的查询、检索。
 */
static void test_DSU_WriteAndQuery()
{
    time_t now = std::time(nullptr);
    std::vector<uint8_t> block = {0x01, 0x02, 0x03};

    bool writeOk = dsu::DSU_Write(block, 1, now);
    assert(writeOk == true);

    QueryCondition qc;
    qc.startTime  = now - 1;
    qc.endTime    = now + 1;
    qc.channelId  = 1;
    qc.maxResults = 10;

    std::vector<std::vector<uint8_t>> results;
    std::string log;
    bool queryOk = dsu::DSU_Query(qc, results, log);

    assert(queryOk == true);
    assert(results.size() >= 1);
    assert(results[0].size() == 3);
    assert(results[0][0] == 0x01);
    std::cout << "[PASS] test_DSU_WriteAndQuery\n";
}

/**
 * @brief 测试 DSU_Replay 按时序回放。
 *
 * @requirement(name="数据管理与回放功能", id="SRS-F-02-002")
 * 能够按照原始时序精确回放；回放过程需保持原始时间戳间隔。
 */
static void test_DSU_Replay()
{
    time_t now = std::time(nullptr);

    // 写入多块数据
    dsu::DSU_Write({0x10, 0x11}, 2, now);
    dsu::DSU_Write({0x20, 0x21, 0x22}, 2, now + 1);

    QueryCondition qc;
    qc.startTime  = now;
    qc.endTime    = now + 2;
    qc.channelId  = 2;
    qc.maxResults = 10;

    std::vector<uint8_t> replayOut;
    std::string log;
    bool replayOk = dsu::DSU_Replay(qc, replayOut, log);

    assert(replayOk == true);
    assert(replayOut.size() == 5); // 2 + 3 bytes
    assert(replayOut[0] == 0x10);
    assert(replayOut[2] == 0x20);
    std::cout << "[PASS] test_DSU_Replay\n";
}

// ═══════════════════════════════════════════════════════════════
// 主测试入口
// ═══════════════════════════════════════════════════════════════

int main()
{
    std::cout << "=== Avionics Network Environment - Basic Tests ===\n\n";

    // DAU 测试
    test_DAU_Process_ValidFrame();
    test_DAU_Process_ErrorFrame();
    test_DAU_SleepMode();

    // PPU 测试
    test_PPU_Check_ValidStandard();
    test_PPU_Check_InvalidStandardId();
    test_PPU_Convert_Can20ToFd();

    // DSU 测试
    test_DSU_WriteAndQuery();
    test_DSU_Replay();

    std::cout << "\n=== All tests passed! ===\n";
    return 0;
}