/* Includes ----------------------------------------------------------------- */
#include "module/mr16.h"

#include <main.h>
#include <stdbool.h>
#include <stdint.h>
#include <string.h>
#include <stdio.h>

#include "bsp/flash.h"
#include "device/sx1281_driver/sx1281.h"
#include "usart.h"
#include "device/sx1281_driver/radio.h"
#include "device/lcd_driver/lcd.h"
#include "device/sx1281_driver/sx1281_driver.h"
#include "component/FreeRTOS_CLI.h"

#include "module/config.h"
/* USER INCLUDE BEGIN */

/* USER INCLUDE END */

/* Private define ----------------------------------------------------------- */
/* USER DEFINE BEGIN */

/* USER DEFINE END */

/* Private macro ------------------------------------------------------------ */
/* Private typedef ---------------------------------------------------------- */
typedef enum {
  MR16_FSM_NONE,
  MR16_FSM_INIT,
  MR16_FSM_TX,
  MR16_FSM_RX,
}MR16_FSM_t;

typedef enum {
  /* 设置主页 */
  MR16_SETTINGFSM_home,

  /*一*/
  MR16_SETTINGFSM_mode,
  /*二*/
  MR16_SETTINGFSM_RX_ID,
  /*三*/
  MR16_SETTINGFSM_radioParams,
  /*1*/
  MR16_SETTINGFSM_radioMode,
  /*2*/
  MR16_SETTINGFSM_modulationParams,
  /*3*/
  MR16_SETTINGFSM_packetParams,
  /*4*/
  MR16_SETTINGFSM_rfFrequency,
  /*5*/
  MR16_SETTINGFSM_txOutputPower,
  /*6*/
  MR16_SETTINGFSM_rampTime,
  /*7*/
  MR16_SETTINGFSM_baudrate,
}MR16_SettingFSM_t;
/* USER STRUCT BEGIN */

/* USER STRUCT END */

/* Private variables -------------------------------------------------------- */
/* USER VARIABLE BEGIN */

/* USER VARIABLE END */
SX1281_t radio;
//lcd点阵数组
extern const unsigned char logo_M[];
//串口接收数据及字长
extern uint8_t uart2_data[255],uart2_datalength;

uint8_t radioRXBuffer[BUFFER_SIZE];
uint8_t radioRXSize;

static MR16_FSM_t MR16_FSM = MR16_FSM_NONE;

static MR16_SettingFSM_t MR16_SettingFSM=MR16_SETTINGFSM_home;

extern MR16_t mr16;

int8_t MR16_CLI_Init();
/* Private function  -------------------------------------------------------- */
/* USER FUNCTION BEGIN */

/* USER FUNCTION END */
int a=0;
int8_t SX1281_Callback(SX1281_States_t source) {
  switch (source) {
    case RX_DONE:
        /* 打印状态 */
        printf( "<>>>>>>>>OnRxDone" );
        /* 从缓冲区拿数据 */
        radioRXSize = 0;
        Radio.GetPayload( radioRXBuffer, &radioRXSize, BUFFER_SIZE);
        radioRXBuffer[radioRXSize+1] = 0;
        uint16_t RXheader=(uint16_t)radioRXBuffer[1]<<8 & (uint16_t)radioRXBuffer[0];
        for (int i=0; i<3; i++) {
          if (RXheader==mr16.param->RX_ID[i]){ 
          mr16.packetCount[i]++;
          }
        }
      break;

    case RX_TIMEOUT:
        /* 打印状态 */
        printf( "<>>>>>>>>OnRXTimeout" );
		SX1281_SetRXSuccessive(&radio);
      break;

    case RX_ERROR:
        /* 打印状态 */
        printf( "<>>>>>>>>OnRxErr" );
        Radio.SetRx( ( TickTime_t ) { RADIO_TICK_SIZE_1000_US, 0x1000 } );
      break;

    case TX_DONE:
        /* 打印状态 */
        printf( "<>>>>>>>>OnTxDone" ); 
//		radio.param.packetParams.Params.Flrc.PayloadLength = data_length;	
//		Radio.SetPacketParams( &radio.param.packetParams );
        // a++;if (a>100) a=0;
        // uint8_t haha[5]={a,2,3,4,a};
        // SX1281_SetTX(&radio,(uint8_t*)haha,5);
        SX1281_SetTX(&radio,mr16.txbuffer,mr16.txbuffer[2]+5);
		// SX1281_SetTX(uart_data,data_length);
      break;

    case TX_TIMEOUT:
        /* 打印状态 */
        printf( "<>>>>>>>>OnTxTimeout" ); 
        
      break;

    case LORA_CAD_DONE:
        /* 打印状态 */
        printf( "<>>>>>>>>OnCadDone" );
      break;
    default:
      break;
  }
  return 0;  
}

/* Exported functions ------------------------------------------------------- */
int8_t MR16_UI_PowerON() {

    LCD_DrawBitmap(logo_M,180,80,64,64,CRIMSON,MSB);
}

int8_t MR16_UI_Home() {

}

int8_t MR16_UI_Setting() {

}

int8_t MR16_Init(MR16_t *mr16, MR16_Param_t *param, MR16_Mode_t mr16Mode, SX1281_RadioMode_t radioMode) {
  MR16_CLI_Init();
	
  mr16->param=param;
  mr16->param->mode=mr16Mode;
  MR16_FSM=MR16_FSM_INIT;
  SX1281_Init(&radio, &param->radioParams, radioMode);
//    SX1281_SetTX(&radio,uart_data,data_length);
  SX1281_SetRXSuccessive(&radio);
	// LCD显示
  LCD_Init(1);
  LCD_Clear(BLACK);
  LCD_DrawString(0,0,"SX1281",MEDIUMORCHID,32,LSB);
  LCD_DrawBitmap(logo_M,180,80,64,64,CRIMSON,MSB);
}

bool UART2_IdleFlag = false;
void MR16_NotifyUARTIdle(void)
{
  UART2_IdleFlag=true;
}
char cInputBuffer[256];
char cOutputBuffer[256];
int8_t MR16_Main(MR16_t *mr16, uint8_t data[],uint8_t data_length) {

  if (UART2_IdleFlag==true) {
    UART2_IdleFlag = false;
    mr16->param->mode=MR16_MODE_SETTING;

    if (uart2_datalength > 0 && uart2_datalength < sizeof(cInputBuffer)) {
      memcpy(cInputBuffer, uart2_data, uart2_datalength);
      cInputBuffer[uart2_datalength] = '\0';
    } else {
      cInputBuffer[0] = '\0';
    }

    cOutputBuffer[0] = '\0';
    BaseType_t xMore = pdTRUE;
    do {
        xMore = FreeRTOS_CLIProcessCommand(cInputBuffer, cOutputBuffer, sizeof(cOutputBuffer));
        if (cOutputBuffer[0] != '\0') {
        printf("%s", cOutputBuffer); 
        }
        cOutputBuffer[0] = '\0';
    } while (xMore == pdTRUE);
  }

  switch (mr16->param->mode) {
    case MR16_MODE_RFUART:

      break;
    case MR16_MODE_RC:
      switch (radio.appMode) {
        case APPMODE_TX:
		      SX1281_Running(&radio);
          SX1281_SetTX(&radio,mr16->txbuffer,mr16->txbuffer[2]+5);
          break;
        case APPMODE_RXSUCCESSIVE:
          SX1281_Running(&radio);
          break;
        default:
          break;
      }
    case MR16_MODE_SETTING:
      break;
    case MR16_MODE_NONE:
      break;
    default:
      break;
  }
}


/*-------------------------------------------------

					  CLI

--------------------------------------------------*/



static BaseType_t mr16CommandHandler( char *pcWriteBuffer, size_t xWriteBufferLen, const char *pcCommandString ) {
  BaseType_t len1 = 0, len2 = 0;
  const char *p1 = FreeRTOS_CLIGetParameter(pcCommandString, 1, &len1); // 第1个参数（不包含命令名）
  const char *p2 = FreeRTOS_CLIGetParameter(pcCommandString, 2, &len2); // 第2个参数

  char arg1[32] = {0};
  char arg2[32] = {0};

  if (p1) {
    size_t c1 = (len1 < (BaseType_t)(sizeof(arg1)-1)) ? (size_t)len1 : sizeof(arg1)-1;
    strncpy(arg1, p1, c1);
    arg1[c1] = '\0';
  }
  if (p2) {
    size_t c2 = (len2 < (BaseType_t)(sizeof(arg2)-1)) ? (size_t)len2 : sizeof(arg2)-1;
    strncpy(arg2, p2, c2);
    arg2[c2] = '\0';
  }

  if (strcasecmp(arg1, "save") == 0) {
    // 保存配置到Flash
    BSP_Flash_EraseSector(200);
    BSP_Flash_WriteBytes(ADDR_FLASH_SECTOR(200), (const uint8_t*)&Config_Get()->mr16, sizeof(MR16_Param_t));
    snprintf(pcWriteBuffer, xWriteBufferLen, "Configuration saved to Flash!\r\n");
  } else if (strcasecmp(arg1, "mode") == 0) {
    if (arg2[0] != '\0') {
      if (strcasecmp(arg2, "RFUART") == 0) {
        mr16.param->mode = MR16_MODE_RFUART;
        snprintf(pcWriteBuffer, xWriteBufferLen, "mode set to: %s\r\n", arg2);
      } else if (strcasecmp(arg2, "RC") == 0) {
        mr16.param->mode = MR16_MODE_RC;
        snprintf(pcWriteBuffer, xWriteBufferLen, "mode set to: %s\r\n", arg2);
      } else {
        snprintf(pcWriteBuffer, xWriteBufferLen, "Invalid mode: %s\r\n", arg2);
        return pdFALSE;
      }
    }
    snprintf(pcWriteBuffer, xWriteBufferLen, "Set -> %s\r\n", arg2);
  } else if (strcasecmp(arg1, "tx") == 0){
	  SX1281_SetTX(&radio,mr16.txbuffer,mr16.txbuffer[2]+5);
  }	else if (strcasecmp(arg1, "rx") == 0){
	  SX1281_SetRXSuccessive(&radio);
  } else if (strcasecmp(arg1, "rxid1") == 0) {
    if (arg2[0] != '\0') {
      uint16_t rxid;
      sscanf(arg2, "%hx", &rxid);
      if(rxid >0x0001 && rxid <0xFFFE){
        mr16.param->RX_ID[0] = rxid;
        snprintf(pcWriteBuffer, xWriteBufferLen, "RXID1 set to: 0x%04X\r\n", mr16.param->RX_ID[0]);
      }else{
        snprintf(pcWriteBuffer, xWriteBufferLen, "RXID1 set failed: invalid value\r\n");
        snprintf(pcWriteBuffer, xWriteBufferLen, "RXID1 now: 0x%04X\r\n", mr16.param->RX_ID[0]);
      }
    }
  }

  return pdFALSE;
}

static BaseType_t radioCommandHandler( char *pcWriteBuffer, size_t xWriteBufferLen, const char *pcCommandString ) {
  BaseType_t len1 = 0, len2 = 0;
  const char *p1 = FreeRTOS_CLIGetParameter(pcCommandString, 1, &len1); // 第1个参数（不包含命令名）
  const char *p2 = FreeRTOS_CLIGetParameter(pcCommandString, 2, &len2); // 第2个参数

  char arg1[32] = {0};
  char arg2[64] = {0};

  if (p1) {
    size_t c1 = (len1 < (BaseType_t)(sizeof(arg1)-1)) ? (size_t)len1 : sizeof(arg1)-1;
    strncpy(arg1, p1, c1);
    arg1[c1] = '\0';
  }
  if (p2) {
    size_t c2 = (len2 < (BaseType_t)(sizeof(arg2)-1)) ? (size_t)len2 : sizeof(arg2)-1;
    strncpy(arg2, p2, c2);
    arg2[c2] = '\0';
  }

  // 示例：处理 "MR16 Set hello"
  if (strcmp(arg1, "Set") == 0) {
    // arg2 是 "hello"
    snprintf(pcWriteBuffer, xWriteBufferLen, "Set -> %s\r\n", arg2);
  } else {
    snprintf(pcWriteBuffer, xWriteBufferLen, "Got: %s %s\r\n", arg1, arg2);
  }

  return pdFALSE;
}




int8_t MR16_CLI_Init() {
    static const CLI_Command_Definition_t mr16Command = {
        "mr16", // 命令名
        "mr16 <save|mode|TX|RX|rxid1|rxid2|rxid3>\r\n", // 帮助信息
        mr16CommandHandler, // 处理函数
        -1 // 可变参数数量
    };
    static const CLI_Command_Definition_t radioCommand = {
        "radio", // 命令名
        "radio <mode|modulation|packet|baudrate|power|ramptime|rffreq|tx|rx>\r\n", // 帮助信息
        radioCommandHandler, // 处理函数
        -1 // 可变参数数量
    };
    FreeRTOS_CLIRegisterCommand(&mr16Command);
    FreeRTOS_CLIRegisterCommand(&radioCommand);
}