/*!
 * \file      shell.c
 *
 * \brief     Target shell implementation
 *
 * \copyright Revised BSD License, see section \ref LICENSE.
 *
 * \code
 *
 *            _  __ _       ________    _     
 *           | |/ /(_)___  / ____/ /_  (_)___ 
 *           |   // / __ \/ /   / __ \/ / __ \
 *          /   |/ / / / / /___/ / / / / /_/ /
 *         /_/|_/_/_/ /_/\____/_/ /_/_/ .___/ 
 *                                   /_/      
 *           (C) 2022-2025 XinChip
 *
 * \endcode
 *
 * \author     ( XinChip ) Alex-J
 *
 * \author     ( XinChip )
 */

/*-----------------------------------------------------------------------------------
	                               INCLUDE HEADE FILES
 ------------------------------------------------------------------------------------*/
#include "shell.h"

/*------------------------------------------------------------------------------------
	                                 Local Variables
 -------------------------------------------------------------------------------------*/
static XC_Cmd_Table_t XC_CMD_Table[] = {
    { XC_CMD_TEST, xc_test_handler },
    { XC_CMD_BLE_MAC, xc_ble_mac_addr_handler },
};

/*------------------------------------------------------------------------------------
	                                    Macros
 -------------------------------------------------------------------------------------*/
#define XC_CMD_TABLE_SIZE             (sizeof(XC_CMD_Table) / sizeof(XC_Cmd_Table_t))

/*------------------------------------------------------------------------------------
	                                Global Variables
 -------------------------------------------------------------------------------------*/

/*------------------------------------------------------------------------------------
	                                  Func Prototype
 -------------------------------------------------------------------------------------*/

/*------------------------------------------------------------------------------------
	                                    Functions
 -------------------------------------------------------------------------------------*/
/**
 ****************************************************************************************
 * @brief 
 *
 * @param[in]
 * @param[in]
 *
 * @return[out]
 *
 ****************************************************************************************
 */
void xc_shell_init(void)
{
    UART_InitTypeDef UART_InitStruct={0}; 

    UART_InitStruct.Parity              = UART_PARITY_DISABLE;
    UART_InitStruct.StopBits            = UART_STOP_1_BITS;
    UART_InitStruct.WordLength          = UART_UARTx_TCR_CLS_8BITS;
    UART_InitStruct.BaudRate            = UART_BAUDRATE_115200;
    UART_InitStruct.HardwareFlowControl = UART_UARTx_MCR_AFCE_DISABLE;
        
    UART_Init(XC_UART0, &UART_InitStruct);  
	UART_Enable_RxIT(XC_UART0);
    NVIC_EnableIRQ(UART0_IRQn);
}

/**
 ****************************************************************************************
 * @brief 
 *
 * @param[in]
 * @param[in]
 *
 * @return[out]
 *
 ****************************************************************************************
 */
eXC_Cmd_State xc_shell_proc(uint8_t *data, uint16_t data_len)
{
    int srgc = 0;
    int index = 0;
    char *ptr = NULL;
    char *srgv[XC_DATA_LEN];
    eXC_Cmd_State ret = XC_CMD_ERROR;
    uint8_t *rx_cmd = data + 2;
    int16_t rx_cmd_idx = data_len - 2;

    if(data_len <=2 && data[data_len] == '\0') {
        return ret;
    }
    
    if(rx_cmd_idx <= 0 || rx_cmd[rx_cmd_idx] != '\0') {
        return ret;
    }
    // 注意这里 XC指令 只判定大写
    if(data[0] != 'X' || data[1] != 'C') {
        goto xc_end;
    }

    for(index = 0; index < XC_CMD_TABLE_SIZE; index++) {
        int cmd_len = strlen(XC_CMD_Table[index].cmd);
        if(!strncmp((const char *)rx_cmd, XC_CMD_Table[index].cmd, cmd_len)) {
            ptr = (char *)rx_cmd + cmd_len;
            break;
        }
    }

    if (index >= XC_CMD_TABLE_SIZE || !XC_CMD_Table[index].fn) {
        goto xc_end;
    }

    if(ptr[0] == '?') {
        ret = XC_CMD_Table[index].fn(QUERY_CMD, srgc, srgv);
    } else if(ptr[0] == '=' ) {
        ptr += 1;
        char *str = strtok((char *)ptr, " ");
        
        while(str) {
            srgv[srgc++] = str;
            str = strtok((char *)NULL, " ");
        }
        
        ret = XC_CMD_Table[index].fn(SET_CMD, srgc, srgv);
    } else {
        ret = XC_CMD_ERROR;
    }

xc_end:
    if(ret == XC_CMD_ERROR) {
        snprintf((char *)XC_Cmd, XC_CMD_SIZE, "\r\n%s %x\r\n", XC_ERROR, 1);
        UART_SendData(XC_UART0, XC_Cmd, strlen((const char *)XC_Cmd));
    } else {
        UART_SendData(XC_UART0, XC_Cmd, strlen((const char *)XC_Cmd));
    }
    memset(XC_Cmd, 0, XC_CMD_SIZE);
    
    return ret;
}

/**
 ****************************************************************************************
 * @brief 
 *
 * @param[in]
 * @param[in]
 *
 * @return[out]
 *
 ****************************************************************************************
 */
void xc_shell_test_case(void)
{
    eXC_Shell_Proc_state sh_sta = XC_SHELL_CMD_RECV;
    uint8_t recv_buff[XC_CMD_SIZE] = { 0 };
    uint16_t recv_len = 0;
    
    xc_shell_init( );

    while(1) {
        /* main loop */
        switch(sh_sta) {
            case XC_SHELL_CMD_RECV: {
                recv_len += UART_ReceiveData(XC_UART0, recv_buff+recv_len);
                if(recv_len) {
                    if((recv_buff[recv_len-2] == '\r') && 
                       (recv_buff[recv_len-1] == '\n'))
                        sh_sta = XC_SHELL_CMD_PROC;
                }
            }
            break;

            case XC_SHELL_CMD_PROC: {
//                UART_SendData(XC_UART0, recv_buff, recv_len);
                (void)xc_shell_proc(recv_buff, recv_len);
                recv_len = 0;
                sh_sta = XC_SHELL_CMD_RECV;
            }
            break;

            default:
            break;
        }
    }
}