/**
  ******************************************************************************
  * @file    cmd_parser.c
  * @brief   ASCII指令解析模块实现
  * @author  Application Layer
  * @version 1.1
  ******************************************************************************
  * @attention
  * 本模块实现ASCII文本指令的解析和处理
  * 关键特性：
  * 1. 状态机解析，健壮可靠
  * 2. 完善的安全防护（缓冲区边界检查、超时重置、字符过滤）
  * 3. 异或校验，FF特权后门
  * 4. 支持RL、DI、ECHO指令
  * 
  * 修订历史：
  * v1.1 - 修复审查报告高危-6、中危-7/8
  ******************************************************************************
  */

#include "cmd_parser.h"
#include "uart2_print.h"
#include "io_monitor.h"
#include "relay_control.h"
#include <string.h>
#include <ctype.h>
#include <stdio.h>  // snprintf
#include <stdlib.h> // atoi

#define DEBUG_CMD_PARSER  1

#if DEBUG_CMD_PARSER
#define DEBUG_LOG(fmt, ...)  UART2_Print_Printf("[CMD] " fmt "\r\n", ##__VA_ARGS__)
#else
#define DEBUG_LOG(fmt, ...)
#endif

typedef enum {
    PARSE_IDLE,
    PARSE_CMD,
    PARSE_PARAM1,
    PARSE_PARAM2,
    PARSE_CHECKSUM,
    PARSE_COMPLETE
} parse_state_t;

typedef struct {
    parse_state_t state;
    cmd_frame_t frame;
    uint8_t field_index;
    uint8_t checksum_acc;
    uint8_t cs_buffer[2];
    uint8_t cs_index;
    uint32_t last_rx_tick;
    uint32_t error_count;
    uint32_t valid_count;
} parser_context_t;

static parser_context_t ctx;

static void reset_parser(void)
{
    ctx.state = PARSE_IDLE;
    ctx.field_index = 0;
    ctx.checksum_acc = 0;
    ctx.cs_index = 0;
    memset(&ctx.frame, 0, sizeof(ctx.frame));
}

static bool is_valid_cmd_char(char c)
{
    return isupper((unsigned char)c) || isdigit((unsigned char)c);
}

static bool is_valid_param_char(char c)
{
    return isprint((unsigned char)c) && c != '*' && c != '\r' && c != '\n';
}

static uint8_t hex_char_to_val(char c)
{
    if (c >= '0' && c <= '9') return c - '0';
    if (c >= 'A' && c <= 'F') return c - 'A' + 10;
    if (c >= 'a' && c <= 'f') return c - 'a' + 10;
    return 0;
}

static uint8_t hex_to_byte(char high, char low)
{
    return (hex_char_to_val(high) << 4) | hex_char_to_val(low);
}

static uint8_t calc_checksum(const char *data, uint8_t len)
{
    uint8_t cs = 0;
    for (uint8_t i = 0; i < len; i++) {
        cs ^= (uint8_t)data[i];
    }
    return cs;
}

static void send_response_ok(const char *content)
{
    char msg[64];
    uint8_t cs;
    
    int len = snprintf(msg, sizeof(msg), "$OK,%s*", content);
    cs = calc_checksum(msg + 1, len - 1);
    snprintf(msg + len, sizeof(msg) - len, "%02X\r\n", cs);
    
    UART2_Print_String(msg);
}

static void send_response_err(const char *err_code)
{
    char msg[32];
    uint8_t cs;
    
    int len = snprintf(msg, sizeof(msg), "$ERR,%s*", err_code);
    cs = calc_checksum(msg + 1, len - 1);
    snprintf(msg + len, sizeof(msg) - len, "%02X\r\n", cs);
    
    UART2_Print_String(msg);
}

static bool is_str_empty(const char *str)
{
    return (str == NULL || str[0] == '\0');
}

static bool is_str_numeric(const char *str)
{
    if (is_str_empty(str)) {
        return false;
    }
    while (*str) {
        if (!isdigit((unsigned char)*str)) {
            return false;
        }
        str++;
    }
    return true;
}

static void process_cmd_frame(const cmd_frame_t *frame)
{
    DEBUG_LOG("CMD=%s P1=%s P2=%s CS=%02X/%02X %s", 
              frame->cmd, frame->param1, frame->param2,
              frame->received_cs, frame->calculated_cs,
              frame->skip_checksum ? "(skip)" : "");
    
    if (strcmp(frame->cmd, "RL") == 0) {
        if (!is_str_numeric(frame->param1) || !is_str_numeric(frame->param2)) {
            send_response_err("PARAM");
            DEBUG_LOG("Invalid RL params: not numeric");
            return;
        }
        
        int relay_id = atoi(frame->param1);
        int state = atoi(frame->param2);
        
        if (relay_id >= 1 && relay_id <= 4 && (state == 0 || state == 1)) {
            Relay_SetState(relay_id, state ? true : false);
            
            char resp[32];
            snprintf(resp, sizeof(resp), "RL,%d,%d", relay_id, state);
            send_response_ok(resp);
            
            DEBUG_LOG("Relay %d -> %s", relay_id, state ? "ON" : "OFF");
        } else {
            send_response_err("PARAM");
            DEBUG_LOG("Invalid RL params: id=%d state=%d", relay_id, state);
        }
    }
    else if (strcmp(frame->cmd, "DI") == 0) {
        if (is_str_empty(frame->param1) || strcmp(frame->param1, "0") == 0) {
            uint8_t states = IO_Monitor_GetAllStates();
            char resp[32];
            snprintf(resp, sizeof(resp), "DI,%d%d%d%d", 
                     (states >> 0) & 1, (states >> 1) & 1,
                     (states >> 2) & 1, (states >> 3) & 1);
            send_response_ok(resp);
            DEBUG_LOG("DI all states: 0x%02X", states);
        }
        else if (is_str_numeric(frame->param1)) {
            int channel = atoi(frame->param1);
            if (channel >= 1 && channel <= 4) {
                uint8_t state = IO_Monitor_GetState(channel - 1);
                char resp[32];
                snprintf(resp, sizeof(resp), "DI,%d,%d", channel, state);
                send_response_ok(resp);
                DEBUG_LOG("DI%d = %d", channel, state);
            } else {
                send_response_err("PARAM");
                DEBUG_LOG("Invalid DI channel: %d", channel);
            }
        }
        else {
            send_response_err("PARAM");
            DEBUG_LOG("Invalid DI param: not numeric");
        }
    }
    else if (strcmp(frame->cmd, "ECHO") == 0) {
        send_response_ok("ECHO");
        DEBUG_LOG("ECHO response sent");
    }
    else {
        send_response_err("CMD");
        DEBUG_LOG("Unknown command: %s", frame->cmd);
    }
}

void CmdParser_Init(void)
{
    memset(&ctx, 0, sizeof(ctx));
    ctx.state = PARSE_IDLE;
    
    DEBUG_LOG("Init OK");
}

void CmdParser_FeedByte(uint8_t byte, uint32_t current_tick)
{
    if (ctx.state != PARSE_IDLE && ctx.state != PARSE_COMPLETE) {
        if (current_tick - ctx.last_rx_tick >= PARSE_TIMEOUT_MS) {
            ctx.error_count++;
            DEBUG_LOG("Timeout, reset parser");
            reset_parser();
            if (byte == '$') {
                ctx.state = PARSE_CMD;
            }
            return;
        }
    }
    ctx.last_rx_tick = current_tick;
    
    switch (ctx.state) {
        case PARSE_IDLE:
            if (byte == '$') {
                reset_parser();
                ctx.state = PARSE_CMD;
            }
            break;
            
        case PARSE_CMD:
            if (byte == ',') {
                ctx.frame.cmd[ctx.field_index] = '\0';
                ctx.state = PARSE_PARAM1;
                ctx.field_index = 0;
            } else if (byte == '*') {
                ctx.frame.cmd[ctx.field_index] = '\0';
                ctx.state = PARSE_CHECKSUM;
                ctx.field_index = 0;
                ctx.cs_index = 0;
            } else if (is_valid_cmd_char(byte)) {
                if (ctx.field_index < CMD_MAX_LEN - 1) {
                    ctx.frame.cmd[ctx.field_index++] = byte;
                    ctx.checksum_acc ^= byte;
                } else {
                    ctx.error_count++;
                    reset_parser();
                }
            } else {
                ctx.error_count++;
                reset_parser();
            }
            break;
            
        case PARSE_PARAM1:
            if (byte == ',') {
                ctx.frame.param1[ctx.field_index] = '\0';
                ctx.state = PARSE_PARAM2;
                ctx.field_index = 0;
            } else if (byte == '*') {
                ctx.frame.param1[ctx.field_index] = '\0';
                ctx.state = PARSE_CHECKSUM;
                ctx.field_index = 0;
                ctx.cs_index = 0;
            } else if (is_valid_param_char(byte)) {
                if (ctx.field_index < PARAM_MAX_LEN - 1) {
                    ctx.frame.param1[ctx.field_index++] = byte;
                    ctx.checksum_acc ^= byte;
                } else {
                    ctx.error_count++;
                    reset_parser();
                }
            } else {
                ctx.error_count++;
                reset_parser();
            }
            break;
            
        case PARSE_PARAM2:
            if (byte == '*') {
                ctx.frame.param2[ctx.field_index] = '\0';
                ctx.state = PARSE_CHECKSUM;
                ctx.field_index = 0;
                ctx.cs_index = 0;
            } else if (is_valid_param_char(byte)) {
                if (ctx.field_index < PARAM_MAX_LEN - 1) {
                    ctx.frame.param2[ctx.field_index++] = byte;
                    ctx.checksum_acc ^= byte;
                } else {
                    ctx.error_count++;
                    reset_parser();
                }
            } else {
                ctx.error_count++;
                reset_parser();
            }
            break;
            
        case PARSE_CHECKSUM:
            if (byte == '\n') {
                ctx.frame.received_cs = hex_to_byte(ctx.cs_buffer[0], ctx.cs_buffer[1]);
                ctx.frame.calculated_cs = ctx.checksum_acc;
                ctx.frame.skip_checksum = (ctx.frame.received_cs == 0xFF);
                
                if (ctx.frame.skip_checksum || 
                    ctx.frame.received_cs == ctx.frame.calculated_cs) {
                    ctx.frame.valid = true;
                    ctx.state = PARSE_COMPLETE;
                    ctx.valid_count++;
                } else {
                    ctx.error_count++;
                    DEBUG_LOG("Checksum error: recv=%02X calc=%02X", 
                              ctx.frame.received_cs, ctx.frame.calculated_cs);
                    send_response_err("CS");
                    reset_parser();
                }
            } else if (byte != '\r') {
                if (ctx.cs_index < 2) {
                    ctx.cs_buffer[ctx.cs_index++] = byte;
                }
            }
            break;
            
        case PARSE_COMPLETE:
            reset_parser();
            if (byte == '$') {
                ctx.state = PARSE_CMD;
            }
            break;
    }
}

void CmdParser_Task(void)
{
    if (ctx.state == PARSE_COMPLETE && ctx.frame.valid) {
        process_cmd_frame(&ctx.frame);
        reset_parser();
    }
}

bool CmdParser_HasCompleteFrame(cmd_frame_t *frame)
{
    if (ctx.state == PARSE_COMPLETE && ctx.frame.valid) {
        if (frame) {
            memcpy(frame, &ctx.frame, sizeof(cmd_frame_t));
        }
        return true;
    }
    return false;
}

void CmdParser_Acknowledge(void)
{
    reset_parser();
}

uint32_t CmdParser_GetErrorCount(void)
{
    return ctx.error_count;
}

uint32_t CmdParser_GetValidCount(void)
{
    return ctx.valid_count;
}