/*
 * ATSystem.c
 *
 *  Created on: Nov 1, 2019
 *      Author: Yasin
 */

/*********************************************************************
* INCLUDES
*/
#include "ATSystem.h"
#include <string.h>

/*********************************************************************
* CONSTANTS
*/
#define AT_HEAD_STATE1    0x00
#define AT_HEAD_STATE2    0x01
#define AT_DATA_STATE     0x02
#define AT_FCS_STATE      0x03

#define AT_CMD_BUFF_MAX   150

/*********************************************************************
* LOCAL FUNCTIONS
*/
static void AT_HandleCMD( uint8_t *msg_ptr );
static uint8_t AT_get_next_cmdUnit( AT_CmdUnit* cmdUnit, uint8_t start_point, uint8_t* msg );
static int AT_CmdCmp( AT_CmdUnit* cmdUnit, uint8_t* str2 );
static void AT_UpperCaseCmd( AT_CmdUnit *cmdUnit );
#if AT_FCS_VERIFY
static byte AT_UartCalcFCS( uint8_t *msg_ptr, uint8_t len );
#endif

void AT_Cmd_Help( uint8_t cmd_ptr, uint8_t* msg_ptr );

/*********************************************************************
 * LOCAL VARIABLES
 */
uint8_t AT_RxBuffer[AT_CMD_BUFF_MAX];      // UART Rx buffer
uint8_t at_state = AT_HEAD_STATE1;         // AT_command_Rx_state
uint8_t AT_templen = 0;                    // the length of AT_command

const AT_Cmd_t AT_Cmd_Arr[] = {
  {"BLOAD",     NULL,             "Enter The Boot Loader Menu"},
  {"HELP",      AT_Cmd_Help,      "show all the AT commands"},
};

const uint16_t AT_CMD_SZ = sizeof(AT_Cmd_Arr) / sizeof(AT_Cmd_Arr[0]);

/***************************************************************************************************
* @fn      AT_Process
*
* @brief   | Head  |   Data   |  End  |  FCS   |
*          |   2   |   0-Len  |   1   |   1    |
*          |  AT   |     ?    | '\r'  | verify |
*
* @field processed by AT_HandleCMD()  : Data + End('\r')
* @field verified  by AT_UartCalcFCS(): Data + End('\r')
*
*          Parses the data and send the data to correct place (AT or APP)
*
* @param   port     - UART port
* @param   event    - Event that causes the callback
*
*
* @return  None
***************************************************************************************************/
void AT_Process(uint8_t ch)
{
	/*
	 * due to the AT_Process may be re-entried during AT_HandleCMD aused by HallUARTPollISR,
	 * which is denergerous, As a result of some command ERROR, so we prevent the function from being re-entryed
	 */
	static uint8_t isProcessing = FALSE;

	if (isProcessing) return;
	isProcessing = TRUE;

	switch (at_state) {
  	case AT_HEAD_STATE1:
  		if (ch == 'A' || ch == 'a')
  			at_state = AT_HEAD_STATE2;
  		break;

  	case AT_HEAD_STATE2:
  		if (ch == 'T' || ch == 't')
  			at_state = AT_DATA_STATE;
  		else if (ch == 'A' || ch == 'a')
  			at_state = AT_HEAD_STATE2;
  		else
  			at_state = AT_HEAD_STATE1;
  		break;

  	case AT_DATA_STATE:
#if AT_UART_BACKSPACE
  		if (ch == '\b' || ch == '\x7f') 
			{ // for backspace function, allow user to delete characters
  			if (AT_templen > 0)
  				AT_templen--;
  			break;
  		}
#endif
  		if (ch == '\r') 
			{
  			AT_RxBuffer[AT_templen++] = '\r';
#if AT_FCS_VERIFY
  			at_state = AT_FCS_STATE;
  			break;
#else
			AT_HandleCMD(AT_RxBuffer);
			memset(AT_RxBuffer, 0x00, AT_templen);
			AT_templen = 0;
			at_state = AT_HEAD_STATE1;
#endif
			} 
			else 
			{
				if (AT_templen < (AT_CMD_BUFF_MAX - 1)) {
					AT_RxBuffer[AT_templen++] = ch;
					// still in AT_DATA_STATE;
				} else {
					memset(AT_RxBuffer, 0, AT_CMD_BUFF_MAX);
					AT_templen = 0;
					at_state = AT_HEAD_STATE1;
				}
			}
			break;

#if AT_FCS_VERIFY
		case AT_FCS_STATE:

			/* Make sure it's correct */
			if ((AT_UartCalcFCS(AT_RxBuffer, AT_templen) == ch)) 
			{
				AT_HandleCMD(AT_RxBuffer);
				osal_memset(AT_RxBuffer, 0x00, AT_templen);
				AT_templen = 0;
			} 
			else 
			{
				AT_ERROR(AT_FATAL_ERROR); // SEND FCS ERROR MSG AT_FATAL_ERROR
			}

			/* Reset the state, send or discard the buffers at this point */
			at_state = AT_HEAD_STATE1;

			break;
#endif

	default:
		break;
	}
    
	isProcessing = FALSE;
}

#if AT_FCS_VERIFY
/***************************************************************************************************
 * @fn      AT_UartCalcFCS
 *
 * @brief   Calculate the FCS of a message buffer by XOR'ing each byte.
 *          Remember to NOT include Head fields, so start at the CMD field.
 *
 * @param   byte *msg_ptr - message pointer
 * @param   byte len - length (in bytes) of message
 *
 * @return  result byte
 ***************************************************************************************************/
static byte AT_UartCalcFCS( uint8_t *msg_ptr, uint8_t len )
{
  byte x;
  byte xorResult;

  xorResult = 0;

  for ( x = 0; x < len; x++, msg_ptr++ )
    xorResult = xorResult ^ *msg_ptr;

  return ( xorResult );
}
#endif

/***************************************************************************************************
 * @fn      AT_HandleCMD
 *
 * @brief   Parse the AT_commands and call it's response function
 *
 * @param   byte *msg_ptr - message pointer
 *
 * @return  None
 ***************************************************************************************************/
static void AT_HandleCMD( uint8_t *msg_ptr )
{
  uint8_t cmd_ptr = 0;
  uint16_t i;
  AT_DEBUG("\r\n", 2);
  AT_DEBUG(msg_ptr, strlen((char*)msg_ptr));

  // Get next cmdUnit and upper case it
  AT_CmdUnit cmdUnit;
  cmd_ptr = AT_get_next_cmdUnit(&cmdUnit, cmd_ptr, msg_ptr);
  AT_UpperCaseCmd(&cmdUnit);

  // process the cmdUnit
  if (cmdUnit.symbol == '\r') {  // which means there is no followed operator or command
    AT_OK();
  }
  else if (cmdUnit.symbol == '\0') {
    AT_ERROR(AT_LACK_OPERATOR);
  }
  else if (cmdUnit.symbol == '+') {
    for (i = 0; i < AT_CMD_SZ; i++) {
      if (AT_CmdCmp(&cmdUnit, (uint8_t*)AT_Cmd_Arr[i].AT_Cmd_str) == 0) {
#if AT_DEBUG_INF_SHOW
        AT_NEXT_LINE();
        AT_RESP(AT_Cmd_Arr[i].ATCmdDescription, strlen(AT_Cmd_Arr[i].ATCmdDescription));
#endif
        AT_Cmd_Arr[i].AT_CmdFn(cmd_ptr, msg_ptr);
        break;
      }
    }
    if (AT_CMD_SZ == i) {
      if (AT_CmdCmp(&cmdUnit, (uint8_t*)"") == 0) {
        AT_ERROR(AT_LACK_CMD);
      } else {
        AT_ERROR(AT_UNKNOWN_CMD);
      }
    }
  }
  else {
    AT_ERROR(AT_INVALID_PARA);
  }
}

/***************************************************************************************************
 * @fn      AT_UARTWriteErrMsg
 *
 * @brief   Send error messages
 *          Respose :
 *                    ERROR:<error code>
 *
 *
 * @param   uint8_t errCode - indicate different error
 * @param   uint8_t fn - type of error
 *
 * @return  None
 ***************************************************************************************************/
void AT_UARTWriteErrMsg( uint8_t errCode )
{
  uint8_t* errMsg_t = (uint8_t*)"\r\nERROR:XX\r\n";
  uint8_t errMsg[sizeof("\r\nERROR:XX\r\n")];
  uint8_t ch;
  uint8_t* pStr = &errMsg[sizeof("\r\nERROR:")-1];
  for (int i = 0; i < sizeof(errMsg); i++) {
    errMsg[i] = errMsg_t[i];
  }
  ch = (errCode >> 4) & 0x0F;
  *pStr++ = ch + ((ch < 10) ? '0' : '7');
  ch = errCode & 0x0F;
  *pStr++ = ch + ((ch < 10) ? '0' : '7');
  AT_RESP(errMsg, sizeof("\r\nERROR:XX\r\n")-1);
}

/***************************************************************************************************
 * @fn      AT_get_next_cmdUnit
 *
 * @brief   The command have servel unit, this funciton get the next unit
 *          and save it in cmdUnit(type of AT_CmdUnit, see in AT_UART.h)
 *
 * @param   AT_CmdUnit* cmdUnit - the place to save the cmd unit
 * @param   uint8_t start_point   - the point show the place we start scan the command
 * @param   uint8_t* msg          - the command to scan
 *
 * @return  start_point
 ***************************************************************************************************/
uint8_t AT_get_next_cmdUnit( AT_CmdUnit* cmdUnit, uint8_t start_point, uint8_t* msg )
{
  cmdUnit->unitLen=0;
  for(;;start_point++){
    if(msg[start_point] == ' '|| msg[start_point] == '\0'){
      continue;
    }
    else if((msg[start_point]<='z' && msg[start_point]>='a') ||
       (msg[start_point]<='Z' && msg[start_point]>='A') ||
       (msg[start_point]<='9' && msg[start_point]>='0')){
       cmdUnit->symbol ='\0';                 //indicate no operator
       break;
    }
    else if(msg[start_point] == '\r'){        //indicate the end of one command
      cmdUnit->symbol =msg[start_point];
      return start_point;
    }
    else {
      cmdUnit->symbol =msg[start_point];
      start_point++;
      break;
    }
  }

  for(;;start_point++){
    if(msg[start_point] == ' '|| msg[start_point] == '\0'){
      continue;
    }
    else while((msg[start_point]<='z' && msg[start_point]>='a') ||
       (msg[start_point]<='Z' && msg[start_point]>='A') ||
       (msg[start_point]<='9' && msg[start_point]>='0') )   {
       if(cmdUnit->unitLen==0) cmdUnit->unit = &msg[start_point];
       cmdUnit->unitLen++;
       start_point++;
    }
    return start_point;
  }
}

/***************************************************************************************************
 * @fn      AT_CmdCmp
 *
 * @brief   Compare with str2, if equal, return 0; else return cmdUnit.unit[i] - str2[i]
 *
 * @param   AT_CmdUnit* cmdUnit - the cmd unit need to be upper cased
 * @param   uint8_t* str2 - the string to compare with
 *
 * @return  int8
 ***************************************************************************************************/
int AT_CmdCmp( AT_CmdUnit* cmdUnit, uint8_t* str2 )
{
  int i;
  for(i = 0; i < cmdUnit->unitLen; i++) {
    if (cmdUnit->unit[i] != str2[i]) {
      return cmdUnit->unit[i] - str2[i];
    }
  }
  return 0 - str2[cmdUnit->unitLen];
}

/***************************************************************************************************
 * @fn      AT_UpperCaseCmd
 *
 * @brief   Upper case the command
 *
 * @param   AT_CmdUnit* cmdUnit - the cmd unit need to be upper cased
 *
 * @return  None
 ***************************************************************************************************/
void AT_UpperCaseCmd( AT_CmdUnit *cmdUnit )
{
  uint8_t i;
  for (i = 0; i < cmdUnit->unitLen; i++) {
    if (cmdUnit->unit[i] <= 'z' && cmdUnit->unit[i] >= 'a') {
      cmdUnit->unit[i] += ('A' - 'a');
    }
  }
}

#if AT_CMD_PATTERN_CHECK
static uint8_t AT_Pattern_Check( char* pattern, AT_CmdUnit* cmdUnitArr );
/***************************************************************************************************
 * @fn      AT_Pattern_Check
 *
 * @brief   Check the command pattern
 *
 * @param   char* pattern  - the pattern to be checked
 * @param   AT_CmdUnit* cmdUnitArr - the command unit
 *
 * @return  uint8_t
 ***************************************************************************************************/
uint8_t AT_Pattern_Check( char* pattern, AT_CmdUnit* cmdUnitArr )
{
  uint8_t i=0;
  for(;pattern[i+1]!='\0';i++) {
    if(pattern[i] != cmdUnitArr[i].symbol){
      if(cmdUnitArr[i].symbol =='\0') return AT_LACK_OPERATOR;
      else if(cmdUnitArr[i].symbol =='\r') return AT_LACK_PARA;
      else return AT_INVALID_PARA;
    }
  }
  if(pattern[i]=='\r') {
    if(cmdUnitArr[i].symbol!='\r') return AT_INVALID_PARA;
  }
  else{
    if(pattern[i] != cmdUnitArr[i].symbol){
      if(cmdUnitArr[i].symbol =='\0') return AT_LACK_OPERATOR;
      else if(cmdUnitArr[i].symbol =='\r') return AT_LACK_PARA;
      else return AT_INVALID_PARA;
    }
  }
  return AT_NO_ERROR;
}
#endif

/*******************************************************************************
 * @fn      AT_Cmd_Help
 *
 * @brief   AT+HELP - show all the AT commands
 *
 * @param   uint8_t cmd_ptr  - the point show the place we start scan the command
 * @param   uint8_t* msg_ptr - the message pointer
 *
 * @return  None
 ******************************************************************************/
void AT_Cmd_Help( uint8_t cmd_ptr, uint8_t* msg_ptr )
{
  AT_CmdUnit cmdUnitArr[1];
  cmd_ptr = AT_get_next_cmdUnit(&cmdUnitArr[0], cmd_ptr, msg_ptr);
  AT_PARSE_CMD_PATTERN_ERROR("\r",cmdUnitArr);

  uint8_t i;
  AT_NEW_LINE();
  
  for(i = 0; i < AT_CMD_SZ; i++) {
    // uint8_t j;
    AT_NEXT_LINE();
    AT_RESP("AT+", 3);
    AT_RESP(AT_Cmd_Arr[i].AT_Cmd_str, strlen(AT_Cmd_Arr[i].AT_Cmd_str));
    AT_RESP(".................", AT_CMD_HELP_DESC_OFFSET - strlen(AT_Cmd_Arr[i].AT_Cmd_str)-3);
    AT_RESP(AT_Cmd_Arr[i].ATCmdDescription, strlen(AT_Cmd_Arr[i].ATCmdDescription));
  }
  AT_NEW_LINE();
  AT_OK();
}