/**
 ******************************************************************************
 * @file    rf433.c
 * @brief   RF433模块驱动主实现
 * @note    基于原e32_demo.c重构，保持与原版设备兼容
 ******************************************************************************
 */

#include "rf433.h"
#include "rf433_hal.h"
#include <string.h>
#include "stm32f1xx_hal.h"

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

static bool rf433_initialized = false;
static rf433_register_t rf433_current_config;

/* E32-433T30S 默认配置（与原register_default保持一致） */
static const rf433_register_t rf433_default_config = 
{
    .register_1 = {
        .address_h = 0x00,
    },
    .register_2 = {
        .address_l = 0x00,
    },
    .register_3.field = {
        .radio_rate      = RF433_RADIO_RATE_2400,
        .uart_baud_rate  = RF433_UART_RATE_9600,
        .uart_parity     = RF433_UART_8N1,
    },
    .register_4 = {
        .channel = 0x17,
    },  
    .register_5.field = {
        .tx_power                  = RF433_TX_POWER_DBM_30,
        .packet_fec                = RF433_ON,
        .wake_on_radio_period      = RF433_WOR_PERIOD_250MS,
        .reserve                   = RF433_OFF,
        .specify_target            = RF433_OFF,
    }, 
};

/* 模块数据缓冲区 */
static uint8_t rf433_buffer[1024];

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

/**
 * @brief 向模块写入配置参数指令（基于原e32_send_config_command）
 * @param config 配置信息
 */
static void rf433_send_config_command(const rf433_register_t *config);

/**
 * @brief 向模块写入查询指令（基于原e32_send_request_command）
 * @param cmd 查询命令
 */
static void rf433_send_request_command(rf433_request_cmd_t cmd);

/**
 * @brief (查询指令)模块响应数据校验（基于原e32_response_command_check）
 * @param cmd 查询命令
 * @param buffer 指向响应数据缓冲区
 * @param length 响应数据长度
 * @return bool 正确返回true; 否则返回false
 */
static bool rf433_response_command_check(rf433_request_cmd_t cmd, uint8_t *buffer, uint8_t length);

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

/**
 * @brief 向模块写入配置参数指令
 */
static void rf433_send_config_command(const rf433_register_t *config)
{
    /* 第1字节：写入指令 
       C0：写入配置参数指令 */
    rf433_buffer[0] = 0xC0;
    
    /* 第2~6字节开始：写入用户参数寄存器 */
    memcpy(&rf433_buffer[1], (uint8_t*)config, sizeof(rf433_register_t));
    
    /* 发送写入 */
    rf433_hal_uart_tx(rf433_buffer, sizeof(rf433_register_t) + 1);
}

/**
 * @brief 向模块写入查询指令
 */
static void rf433_send_request_command(rf433_request_cmd_t cmd)
{
    /* 获取配置参数 */
    static const uint8_t request_config[3] = {0xC1, 0xC1, 0xC1};
    
    /* AT指令 获取设备类型 */
    static const char request_name[] = "AT+DEVTYPE=?";
    
    /* AT指令 获取固件版本 */
    static const char request_version[] = "AT+FWCODE=?";
    
    switch (cmd)
    {
        /* 获取配置参数 */
        case RF433_REQUEST_CMD_CONFIG:
            rf433_hal_uart_tx((uint8_t*)request_config, sizeof(request_config));
            break;
        
        /* 获取设备类型 */
        case RF433_REQUEST_CMD_NAME:
            rf433_hal_uart_tx((uint8_t*)request_name, strlen(request_name));
            break;

        /* 获取固件版本 */
        case RF433_REQUEST_CMD_VERSION:
            rf433_hal_uart_tx((uint8_t*)request_version, strlen(request_version));
            break;
    }
}

/**
 * @brief (查询指令)模块响应数据校验
 */
static bool rf433_response_command_check(rf433_request_cmd_t cmd, uint8_t *buffer, uint8_t length)
{
    bool ret = false;
    
    switch (cmd)
    {
        /* 获取配置参数 */	
        case RF433_REQUEST_CMD_CONFIG:
            
            /* 先校验 数据长度为6字节*/
            if (length == 6)
            {
                /* 数据校验 帧头必须为0xC1 */
                if (buffer[0] == 0xC1)
                {
                    ret = true;
                }
            }
            break;
        
        /* 获取设备类型 */	
        case RF433_REQUEST_CMD_NAME:
            /* 数据校验 */
            if (strncmp("DEVTYPE=", (char*)buffer, 8) == 0)
            {
                ret = true;
            }	
            break;
        
        /* 获取固件版本 */
        case RF433_REQUEST_CMD_VERSION:
            /* 数据校验 */
            if (strncmp("FWCODE=", (char*)buffer, 7) == 0)
            {
                ret = true;
            }	
            break;				
    }
    
    return ret;
}

/* ============================================================================
 * 公共函数实现
 * ============================================================================ */

/**
 * @brief 初始化RF433模块
 */
rf433_error_t rf433_init(const rf433_register_t *config)
{
    rf433_hal_error_t ret;
    
    /* 检查是否已初始化 */
    if (rf433_initialized)
    {
        return RF433_ERROR;
    }
    
    /* 初始化硬件抽象层 */
    ret = rf433_hal_init();
    if (ret != RF433_HAL_OK)
    {
        return RF433_ERROR;
    }
    
    /* 复制配置 */
    if (config == NULL)
    {
        memcpy(&rf433_current_config, &rf433_default_config, sizeof(rf433_register_t));
    }
    else
    {
        memcpy(&rf433_current_config, config, sizeof(rf433_register_t));
    }
    
    /* 设置模块配置 */
    ret = rf433_set_config(&rf433_current_config);
    if (ret != RF433_OK)
    {
        rf433_hal_deinit();
        return ret;
    }
    
    rf433_initialized = true;
    return RF433_OK;
}

/**
 * @brief 反初始化RF433模块
 */
rf433_error_t rf433_deinit(void)
{
    /* 检查是否已初始化 */
    if (!rf433_initialized)
    {
        return RF433_ERROR_NOT_INIT;
    }
    
    /* 反初始化硬件抽象层 */
    rf433_hal_deinit();
    
    rf433_initialized = false;
    return RF433_OK;
}

/**
 * @brief 设置模块配置（基于原e32_demo_menu_config）
 */
rf433_error_t rf433_set_config(const rf433_register_t *config)
{
    rf433_hal_error_t ret;
    
    /* 参数检查 */
    if (config == NULL)
    {
        return RF433_ERROR_INVALID_PARAM;
    }
    
    /* 等待模块空闲 */
    ret = rf433_hal_aux_wait();
    if (ret != RF433_HAL_OK)
    {
        return RF433_ERROR_TIMEOUT;
    }
    
    /* 切换到配置模式 */
    ret = rf433_hal_set_work_mode(RF433_WORK_MODE_CONFIG_AND_SLEEP);
    if (ret != RF433_HAL_OK)
    {
        return RF433_ERROR_TIMEOUT;
    }
    
    /* 向模块串口写入配置 */
    rf433_send_config_command(config);
    
    /* 等待模块响应 */
    /* 注意：这里需要实现uart1_wait_response_blocked的等效功能 */
    /* 暂时使用延时等待 */
    HAL_Delay(100);
    
    /* 切换回透明传输模式 */
    ret = rf433_hal_set_work_mode(RF433_WORK_MODE_TRANSPARENT);
    if (ret != RF433_HAL_OK)
    {
        return RF433_ERROR_TIMEOUT;
    }
    
    /* 保存配置 */
    memcpy(&rf433_current_config, config, sizeof(rf433_register_t));
    
    return RF433_OK;
}

/**
 * @brief 获取模块配置
 */
rf433_error_t rf433_get_config(rf433_register_t *config)
{
    /* 参数检查 */
    if (config == NULL)
    {
        return RF433_ERROR_INVALID_PARAM;
    }
    
    /* 复制当前配置 */
    memcpy(config, &rf433_current_config, sizeof(rf433_register_t));
    
    return RF433_OK;
}

/**
 * @brief 设置工作模式
 */
rf433_error_t rf433_set_work_mode(rf433_work_mode_t mode)
{
    rf433_hal_error_t ret;
    
    ret = rf433_hal_set_work_mode(mode);
    if (ret != RF433_HAL_OK)
    {
        return RF433_ERROR_TIMEOUT;
    }
    
    return RF433_OK;
}

/**
 * @brief 复位模块
 */
rf433_error_t rf433_reset(void)
{
    rf433_hal_error_t ret;
    
    ret = rf433_hal_reset();
    if (ret != RF433_HAL_OK)
    {
        return RF433_ERROR;
    }
    
    return RF433_OK;
}

/* ============================================================================
 * TX模式实现
 * ============================================================================ */

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

/**
 * @brief 发送数据（透明传输模式，基于原e32_demo_transmit）
 */
rf433_error_t rf433_transmit(uint8_t *buffer, uint16_t length)
{
    rf433_hal_error_t ret;
    
    /* 参数检查 */
    if (buffer == NULL || length == 0)
    {
        return RF433_ERROR_INVALID_PARAM;
    }
    
    /* 检查是否已初始化 */
    if (!rf433_initialized)
    {
        return RF433_ERROR_NOT_INIT;
    }
    
    /* 发送写入 */
    ret = rf433_hal_uart_tx(buffer, length);
    if (ret != RF433_HAL_OK)
    {
        return RF433_ERROR_TIMEOUT;
    }
    
    return RF433_OK;
}

/**
 * @brief 发送数据包（指定目标模式）
 */
rf433_error_t rf433_transmit_packet(const rf433_specify_target_buffer_t *packet)
{
    rf433_hal_error_t ret;
    uint16_t length;
    
    /* 参数检查 */
    if (packet == NULL)
    {
        return RF433_ERROR_INVALID_PARAM;
    }
    
    /* 检查是否已初始化 */
    if (!rf433_initialized)
    {
        return RF433_ERROR_NOT_INIT;
    }
    
    /* 计算数据包长度（3字节头 + 数据长度） */
    length = 3 + 237;  // address_h + address_l + channel + data[237]
    
    /* 发送数据包 */
    ret = rf433_hal_uart_tx((uint8_t*)packet, length);
    if (ret != RF433_HAL_OK)
    {
        return RF433_ERROR_TIMEOUT;
    }
    
    return RF433_OK;
}

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

/* ============================================================================
 * RX模式实现
 * ============================================================================ */

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

static bool rf433_rx_started = false;
static rf433_rx_callback_t rf433_rx_callback = NULL;
static void *rf433_rx_user_data = NULL;

/**
 * @brief 启动接收
 */
rf433_error_t rf433_rx_start(void)
{
    rf433_hal_error_t ret;
    
    /* 检查是否已初始化 */
    if (!rf433_initialized)
    {
        return RF433_ERROR_NOT_INIT;
    }
    
    /* 检查是否已启动 */
    if (rf433_rx_started)
    {
        return RF433_ERROR_BUSY;
    }
    
    /* 清空FIFO */
    ret = rf433_hal_fifo_clear();
    if (ret != RF433_HAL_OK)
    {
        return RF433_ERROR;
    }
    
    /* 启动UART接收（由HAL层处理） */
    /* 注意：UART接收由HAL_UART_Receive_IT启动，在HAL_UART_RxCpltCallback中调用rf433_hal_uart_rxcplt_callback */
    
    rf433_rx_started = true;
    return RF433_OK;
}

/**
 * @brief 停止接收
 */
rf433_error_t rf433_rx_stop(void)
{
    /* 检查是否已初始化 */
    if (!rf433_initialized)
    {
        return RF433_ERROR_NOT_INIT;
    }
    
    rf433_rx_started = false;
    return RF433_OK;
}

/**
 * @brief 接收数据（阻塞模式）
 */
rf433_error_t rf433_receive(uint8_t *buffer, uint16_t max_length, uint16_t *actual_length, uint32_t timeout)
{
    rf433_hal_error_t ret;
    uint16_t fifo_length;
    uint32_t start_time;
    
    /* 参数检查 */
    if (buffer == NULL || max_length == 0 || actual_length == NULL)
    {
        return RF433_ERROR_INVALID_PARAM;
    }
    
    /* 检查是否已初始化 */
    if (!rf433_initialized)
    {
        return RF433_ERROR_NOT_INIT;
    }
    
    /* 等待数据 */
    start_time = HAL_GetTick();
    while (true)
    {
        ret = rf433_hal_fifo_get_length(&fifo_length);
        if (ret != RF433_HAL_OK)
        {
            return RF433_ERROR;
        }
        
        if (fifo_length > 0)
        {
            break;
        }
        
        /* 检查超时 */
        if (timeout > 0 && (HAL_GetTick() - start_time) >= timeout)
        {
            return RF433_ERROR_TIMEOUT;
        }
        
        HAL_Delay(1);
    }
    
    /* 读取数据 */
    if (fifo_length > max_length)
    {
        fifo_length = max_length;
    }
    
    ret = rf433_hal_fifo_read(buffer, fifo_length, actual_length);
    if (ret != RF433_HAL_OK)
    {
        return RF433_ERROR;
    }
    
    return RF433_OK;
}

/**
 * @brief 检查是否有数据可读
 */
rf433_error_t rf433_rx_check_data(bool *has_data)
{
    rf433_hal_error_t ret;
    uint16_t length;
    
    /* 参数检查 */
    if (has_data == NULL)
    {
        return RF433_ERROR_INVALID_PARAM;
    }
    
    /* 检查是否已初始化 */
    if (!rf433_initialized)
    {
        return RF433_ERROR_NOT_INIT;
    }
    
    /* 获取FIFO长度 */
    ret = rf433_hal_fifo_get_length(&length);
    if (ret != RF433_HAL_OK)
    {
        return RF433_ERROR;
    }
    
    *has_data = (length > 0);
    return RF433_OK;
}

/**
 * @brief 读取数据（非阻塞模式）
 */
rf433_error_t rf433_rx_read(uint8_t *buffer, uint16_t max_length, uint16_t *actual_length)
{
    rf433_hal_error_t ret;
    uint16_t length;
    
    /* 参数检查 */
    if (buffer == NULL || max_length == 0 || actual_length == NULL)
    {
        return RF433_ERROR_INVALID_PARAM;
    }
    
    /* 检查是否已初始化 */
    if (!rf433_initialized)
    {
        return RF433_ERROR_NOT_INIT;
    }
    
    /* 获取FIFO长度 */
    ret = rf433_hal_fifo_get_length(&length);
    if (ret != RF433_HAL_OK)
    {
        return RF433_ERROR;
    }
    
    /* 检查是否有数据 */
    if (length == 0)
    {
        return RF433_ERROR_NO_DATA;
    }
    
    /* 读取数据 */
    if (length > max_length)
    {
        length = max_length;
    }
    
    ret = rf433_hal_fifo_read(buffer, length, actual_length);
    if (ret != RF433_HAL_OK)
    {
        return RF433_ERROR;
    }
    
    return RF433_OK;
}

/**
 * @brief 注册接收回调函数
 */
rf433_error_t rf433_rx_register_callback(rf433_rx_callback_t callback, void *user_data)
{
    /* 参数检查 */
    if (callback == NULL)
    {
        return RF433_ERROR_INVALID_PARAM;
    }
    
    /* 检查是否已初始化 */
    if (!rf433_initialized)
    {
        return RF433_ERROR_NOT_INIT;
    }
    
    rf433_rx_callback = callback;
    rf433_rx_user_data = user_data;
    
    return RF433_OK;
}

/**
 * @brief 注销接收回调函数
 */
rf433_error_t rf433_rx_unregister_callback(void)
{
    rf433_rx_callback = NULL;
    rf433_rx_user_data = NULL;
    return RF433_OK;
}

/**
 * @brief UART接收完成回调（由HAL层调用）
 */
void rf433_rx_uart_callback_internal(uint8_t *data, uint16_t length)
{
    /* 检查是否已启动 */
    if (!rf433_rx_started)
    {
        return;
    }
    
    /* 如果有回调函数，调用回调 */
    if (rf433_rx_callback != NULL)
    {
        rf433_rx_callback(data, length, rf433_rx_user_data);
    }
}

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