/**
 ******************************************************************************
 * @file    rf433_rx_app.c
 * @brief   RF433 RX应用层实现
 ******************************************************************************
 */

#include "rf433_config.h"

#if (RF433_MODE == RF433_MODE_RX) || (RF433_MODE == RF433_MODE_BOTH)

#include "rf433_rx_app.h"
#include "rf433.h"
#include "rf433_hal.h"
#include "main.h"
#include <stdio.h>
#include <string.h>

/* ============================================================================
 * 私有变量
 * ============================================================================ */

static rf433_rx_app_t g_rx_app = {0};

/* ============================================================================
 * 私有函数声明
 * ============================================================================ */

/**
 * @brief 控制LED_RX指示灯
 * @param state 0: 关闭, 1: 打开
 */
static void rx_led_control(uint8_t state);

/**
 * @brief 更新丢包统计
 */
static void rx_update_stats(void);

/* ============================================================================
 * 私有函数实现
 * ============================================================================ */

static void rx_led_control(uint8_t state)
{
    // LED_RX控制 - 使用gpio.c中定义的函数
    if (state) {
        gpio_led_rx_on();   // 打开LED_RX
    } else {
        gpio_led_rx_off();  // 关闭LED_RX
    }
}

static void rx_update_stats(void)
{
    // 计算丢包数
    if (g_rx_app.tx_number_record > 0) {
        g_rx_app.stats.lost_packets = g_rx_app.tx_number_record - g_rx_app.stats.total_received;
        
        // 计算丢包率
        if (g_rx_app.tx_number_record > 0) {
            g_rx_app.stats.lost_percent = (uint8_t)((g_rx_app.stats.lost_packets * 100) / g_rx_app.tx_number_record);
        } else {
            g_rx_app.stats.lost_percent = 0;
        }
    }
}

/* ============================================================================
 * 公共API实现
 * ============================================================================ */

rf433_error_t rf433_rx_app_init(const rf433_register_t *config)
{
    if (config == NULL) {
        return RF433_ERROR;
    }

    // 初始化RX应用结构体
    memset(&g_rx_app, 0, sizeof(rf433_rx_app_t));
    g_rx_app.state = RX_STATE_INIT;
    g_rx_app.is_running = false;

    // 保存配置
    memcpy(&g_rx_app.config, config, sizeof(rf433_register_t));

    // 配置RF433模块
    rf433_error_t ret = rf433_set_config(&g_rx_app.config);
    if (ret != RF433_OK) {
        return ret;
    }

    // 设置为透明传输模式
    ret = rf433_set_work_mode(RF433_WORK_MODE_TRANSPARENT);
    if (ret != RF433_OK) {
        return ret;
    }

    return RF433_OK;
}

rf433_error_t rf433_rx_app_start(void)
{
    // 启动RF433接收
    rf433_error_t ret = rf433_rx_start();
    if (ret != RF433_OK) {
        return ret;
    }

    g_rx_app.state = RX_STATE_RECEIVING;
    g_rx_app.is_running = true;

    return RF433_OK;
}

rf433_error_t rf433_rx_app_stop(void)
{
    // 停止RF433接收
    rf433_rx_stop();

    g_rx_app.is_running = false;
    g_rx_app.state = RX_STATE_IDLE;
    rx_led_control(0);

    return RF433_OK;
}

void rf433_rx_app_task(void)
{
    if (!g_rx_app.is_running) {
        return;
    }

    switch (g_rx_app.state) {
        case RX_STATE_INIT:
            // 初始化完成，进入接收状态
            g_rx_app.state = RX_STATE_RECEIVING;
            break;

        case RX_STATE_RECEIVING:
            // 尝试接收数据（使用与原始代码相同的接收机制）
            {
                uint8_t buffer[64];
                uint32_t actual_len = 0;
                
                // 使用uart1_check_rx_done检查接收完成（与原始代码一致）
                if (uart1_check_rx_done(buffer, &actual_len)) {
                    // 解析数据包
                    uint32_t tx_total = 0;
                    uint32_t tx_current = 0;
                    
                    rf433_error_t ret = rf433_rx_app_parse_packet(buffer, (uint16_t)actual_len, &tx_total, &tx_current);
                    
                    if (ret == RF433_OK) {
                        // 更新统计信息
                        g_rx_app.stats.total_received++;
                        g_rx_app.tx_total_number = tx_total;
                        g_rx_app.tx_current_number = tx_current;

                        // 更新TX序号记录
                        if (tx_current > g_rx_app.tx_number_record) {
                            g_rx_app.tx_number_record = tx_current;
                        }

                        // 更新丢包统计
                        rx_update_stats();

                        // LED闪烁指示
                        rx_led_control(1);
                        HAL_Delay(50);
                        rx_led_control(0);
                    }
                }
            }
            break;

        case RX_STATE_IDLE:
            // 空闲状态，不做任何操作
            break;

        default:
            g_rx_app.state = RX_STATE_IDLE;
            break;
    }
}

rx_state_t rf433_rx_app_get_state(void)
{
    return g_rx_app.state;
}

rf433_error_t rf433_rx_app_get_stats(rf433_rx_stats_t *stats)
{
    if (stats == NULL) {
        return RF433_ERROR;
    }

    memcpy(stats, &g_rx_app.stats, sizeof(rf433_rx_stats_t));
    return RF433_OK;
}

void rf433_rx_app_reset_stats(void)
{
    memset(&g_rx_app.stats, 0, sizeof(rf433_rx_stats_t));
    g_rx_app.tx_current_number = 0;
    g_rx_app.tx_total_number = 0;
    g_rx_app.tx_number_record = 0;
}

rf433_error_t rf433_rx_app_parse_packet(const uint8_t *packet_buf, uint16_t length,
                                         uint32_t *tx_total, uint32_t *tx_current)
{
    if (packet_buf == NULL || length == 0 || tx_total == NULL || tx_current == NULL) {
        return RF433_ERROR;
    }

    // 数据包格式: "TX.总次数.当前序号."
    // 例如: "TX.010.001." 或 "TX.100.100."
    // 参考原始代码application.c中的rx_analysis函数
    
    // 检查最小长度（原始代码要求至少10字节）
    if (length < 10) {
        return RF433_ERROR;
    }

    // 检查前缀 "TX"
    if (packet_buf[0] != 'T' || packet_buf[1] != 'X') {
        return RF433_ERROR;
    }

    // 使用sscanf解析数据包（与原始代码一致）
    // 从buffer+3开始解析，跳过"TX."
    sscanf((char*)(packet_buf + 3), "%d.%d.", tx_total, tx_current);
    
    return RF433_OK;
}

#endif /* (RF433_MODE == RF433_MODE_RX) || (RF433_MODE == RF433_MODE_BOTH) */