#include "hard_system_time.h"

#include "soft_time.h"
#include "test.h"

//系统时间定时器初始化
void system_time_initial(void) { system_time_init(); }

//获取系统时间
unsigned int micros(void) { return hard_micros(); }

//获取两次时间差，同时处理超过72分钟重新计时的错误问题。单位us
#define ERR_DT 2500

unsigned int time_interval(unsigned int time_cur, unsigned int *time_last)
{
    unsigned int interval = time_cur - *time_last;

    if (time_cur < *time_last)
    {
        *time_last = time_cur;
        interval = ERR_DT;
    }

    return interval;
}

/*
测试发现，32位寄存器的CPU上两个时间差不会出现一个循环后卡死的情况。//10081142 -
4105048205 = 200000233;
测试micros() = 10081142(0X 99 D376), system_time = 4105048205(0X F4AE 108D),
micros() - system_time = 200000233.

*/
//试图解决32位定时器只能计时72分钟，用64位的变量来累计计时
void time_hookfunction(void) {}


#ifdef SOFT_TIMER_TEST


//============================================================================
// 测试函数
//============================================================================

/**
 * @brief 测试系统时间初始化
 */
void test_time_init(void)
{
    printf("\n=== Test: System Time Init ===\n");
    
    system_time_initial();
    printf("System time initialized\n");
    
    uint32_t time = micros();
    printf("Current time: %u us\n", time);
    
    if (time > 0) {
        printf("[PASS] Time init test\n");
    } else {
        printf("[FAIL] Time init test\n");
    }
}

/**
 * @brief 测试 micros() 函数
 */
void test_micros(void)
{
    printf("\n=== Test: micros() Function ===\n");
    
    uint32_t t1 = micros();
    printf("Time 1: %u us\n", t1);
    
    // 简单延时
    for (volatile int i = 0; i < 10000; i++);
    
    uint32_t t2 = micros();
    printf("Time 2: %u us\n", t2);
    printf("Delta: %u us\n", t2 - t1);
    
    if (t2 > t1) {
        printf("[PASS] micros() test\n");
    } else {
        printf("[FAIL] micros() test\n");
    }
}

/**
 * @brief 测试 time_interval() 函数
 */
void test_time_interval(void)
{
    printf("\n=== Test: time_interval() Function ===\n");
    
    uint32_t last_time = micros();
    printf("Last time: %u us\n", last_time);
    
    // 延时一段时间
    for (volatile int i = 0; i < 50000; i++);
    
    uint32_t cur_time = micros();
    printf("Current time: %u us\n", cur_time);
    
    uint32_t interval = time_interval(cur_time, &last_time);
    printf("Interval: %u us\n", interval);
    printf("New last time: %u us\n", last_time);
    
    if (interval > 0) {
        printf("[PASS] time_interval() test\n");
    } else {
        printf("[FAIL] time_interval() test\n");
    }
}

/**
 * @brief 测试 time_interval() 溢出处理
 */
void test_time_interval_overflow(void)
{
    printf("\n=== Test: time_interval() Overflow Handling ===\n");
    
    // 模拟溢出情况
    uint32_t last_time = 0xFFFFFFF0;  // 接近最大值
    uint32_t cur_time = 100;           // 溢出后的值
    
    printf("Simulate: last=0x%X, cur=0x%X\n", last_time, cur_time);
    
    uint32_t interval = time_interval(cur_time, &last_time);
    printf("Interval: %u us\n", interval);
    printf("New last time: %u us\n", last_time);
    
    if (interval == 2500) {  // ERR_DT
        printf("[PASS] Overflow handling test\n");
    } else {
        printf("[FAIL] Overflow handling test (expected 2500)\n");
    }
}

/**
 * @brief 连续时间采集测试
 */
void test_time_continuous(void)
{
    printf("\n=== Test: Continuous Time Collection ===\n");
    
    uint32_t last_time = micros();
    printf("Start time: %u us\n", last_time);
    
    for (int i = 0; i < 10; i++) {
        // 简单延时
        for (volatile int j = 0; j < 10000; j++);
        
        uint32_t cur_time = micros();
        uint32_t interval = time_interval(cur_time, &last_time);
        
        printf("  Sample %d: interval=%u us\n", i+1, interval);
    }
    
    printf("[PASS] Continuous collection test\n");
}

/**
 * @brief 测试 time_hookfunction()
 */
void test_time_hook(void)
{
    printf("\n=== Test: time_hookfunction() ===\n");
    
    printf("Calling time_hookfunction()...\n");
    time_hookfunction();
    printf("time_hookfunction() executed\n");
    
    printf("[PASS] Hook function test\n");
}

//============================================================================
// 主测试函数
//============================================================================

/**
 * @brief 运行所有时间接口测试
 */
void run_time_test(void)
{
    printf("\n");
    printf("========================================\n");
    printf("    System Time Interface Test\n");
    printf("========================================\n");
    
    test_time_init();
    test_micros();
    test_time_interval();
    test_time_interval_overflow();
    test_time_continuous();
    test_time_hook();
    
    printf("\n========================================\n");
    printf("    All tests completed\n");
    printf("========================================\n");
}

/**
 * @brief 快速测试（只测试基本功能）
 */
void run_time_quick_test(void)
{
    printf("\n=== Quick Time Test ===\n");
    
    system_time_initial();
    
    uint32_t start = micros();
    printf("Start: %u us\n", start);
    
    for (volatile int i = 0; i < 50000; i++);
    
    uint32_t end = micros();
    printf("End: %u us\n", end);
    printf("Elapsed: %u us\n", end - start);
    
    uint32_t last = start;
    uint32_t interval = time_interval(end, &last);
    printf("Interval via function: %u us\n", interval);
    
    printf("Quick test done\n");
}

#endif