#include "gprs.h"
#include "sundry.h"
#include "main.h"
#include "uart.h"
#include "stdlib.h"
#include "billing.h"
#include "administrator.h"
#include "lcd.h"
#include "system_log.h"
#include "low_pwr_test.h"
#include "power_manage.h"
#include "gpio.h"
#include "bootloader_iap.h"

GPRS_SOFT_PARA_T gprs_soft_para_g = {GPRS_IDLE, GPRS_MEANS_NONE};
/*gprsÍøÂç²ÎÊýĬÈÏÖµ*/
TYPE_CHECK_SIZE(GPRS_NETWORK_CFG_PARA_T, 213); // ºË²é½á¹¹Ìå´óС
GPRS_NETWORK_CFG_PARA_T gprs_network_cfg_para_g = {
    .gprs_ip_1[0] = 120,
    .gprs_ip_1[1] = 77,
    .gprs_ip_1[2] = 85,
    .gprs_ip_1[3] = 236,
    .gprs_port_1 = 9692,
    .gprs_link_type_1 = GLT_TCP,
    .gprs_ip_2[0] = 39,
    .gprs_ip_2[1] = 108,
    .gprs_ip_2[2] = 81,
    .gprs_ip_2[3] = 105,
    .gprs_port_2 = 9898,
    .gprs_link_type_2 = GLT_TCP,
    .save_data_period_min_time = 60,
    .gprs_interval_type = GIM_PERIOD,
    .gprs_send_period_min_time = 1440,
    .gprs_reference_time_bcd[0] = 0,
    .gprs_reference_time_bcd[1] = 0x10,
    .gprs_timed_number = 1,
    .gprs_timing_time_bcd[0][0] = 0,
    .gprs_timing_time_bcd[0][1] = 0x10,
    .gprs_restart_send_interval_min_time = GPRS_RECONNECTION_INTERVAL_TIME,
    .gprs_restart_number = 0,
    .gprs_timeout = GPRS_TIMEOUT,
    .aes128_secret_key[0] = {8, 7, 6, 5, 4, 3, 2, 1, 0, 0, 0, 0, 0, 0, 0, 0},
};

static const GPRS_FUNC_TABLE_DRV_T gprs_tab_func[] = {
    {GPRS_IDLE, Gprs_IDLE_Process},
    {GPRS_OPEN_PWR, Gprs_Open_PWR_Process},
    {GPRS_OPEN_MODULE, Gprs_Open_Module_Process},
    {GPRS_LOGIN, Gprs_LoginProcess},
    {GPRS_SEND_DATA, Gprs_SendDataProcess},
    {GPRS_RECV_DATA, Gprs_RecvDataProcess},
    {GPRS_SEND_ALARM, Gprs_SendAlarmProcess},
    {GPRS_CLOSE_PWR, Gprs_Close_PWR_Process},
    {GPRS_CLOSE_MODULE, Gprs_Close_Module_Process},
    {GPRS_RESTART, Gprs_RestartProcess},
};

void Gprs_IO_Init(void)
{
  CMU_PERCLK_SetableEx(PADCLK, ENABLE); // PADʱÖÓ£¨GPIO£©Ê¹Äܺ¯Êý
  OutputIO(GPRS_PWR_PORT, GPRS_PWR_PIN, OUT_PUSHPULL);
  OutputIO(GPRS_SWITCH_PORT, GPRS_SWITCH_PIN, OUT_PUSHPULL);
  GPRS_SWITCH_H;
  GPRS_PWR_OFF;
}

GPRS_STATUS Gprs_IDLE_Process(void)
{
  return GPRS_IDLE;
}

/**/
GPRS_STATUS Gprs_Open_PWR_Process(void)
{
  Gprs_GPIO_Uart5_Clk_Init();
  /*ÏÈ¿ªµçÔ´£¬ÔÙ¿ªÄ£×é*/
  if (GPIO_ReadOutputDataBit(GPRS_PWR_PORT, GPRS_PWR_PIN) == Bit_RESET) // µçÔ´¹Ø±Õ
  {
    //		gprs_test_g.gprs_start_cnt++;
    GPRS_PWR_ON; // µçÔ´¿ªÆô
    __SYS_DELAY_SEC_TIME_SET_(gprs_delay_para, 1);
    __SYS_DELAY_SEC_TIME_SET_(gprs_timeout_para, gprs_network_cfg_para_g.gprs_timeout);
    return GPRS_OPEN_MODULE;
  }
  return GPRS_CLOSE_PWR;
}

GPRS_STATUS Gprs_Open_Module_Process(void)
{
  /*            ____________
   *PWR     ___/
   *            __      ____
   *SWITCH  ___/  |____|
   *             |   |
   *             |   |
   *            T1  T2    ¿ª¹Øµçƽ³ÖÐøʱ¼ä T1:30ms  T2:0.5~1S
   */
  if (GPIO_ReadOutputDataBit(GPRS_SWITCH_PORT, GPRS_SWITCH_PIN) == Bit_RESET) // Ä£¿éÒý½ÅÀ­µÍ
  {
    if (sys_delay_sec_para_g.gprs_delay_para.delay_flag)
    {
      sys_delay_sec_para_g.gprs_delay_para.delay_flag = RESET;
      GPRS_SWITCH_L;
      __SYS_DELAY_SEC_TIME_SET_(gprs_delay_para, 1);
    }
  }
  else if (GPIO_ReadOutputDataBit(GPRS_SWITCH_PORT, GPRS_SWITCH_PIN) == Bit_SET) // Ä£¿éÒý½ÅÀ­¸ß
  {
    if (sys_delay_sec_para_g.gprs_delay_para.delay_flag)
    {
      sys_delay_sec_para_g.gprs_delay_para.delay_flag = RESET;
      GPRS_SWITCH_H; // Ä£¿é¿ªÆô
#if NB_OR_4G_FLAG
      gprs_module_para_g.gprs_module_state = LOGIN_CMD_CMEE_NB; // ÉèÖõǼµÚÒ»¸öÄ£¿éÃüÁî
#else
      gprs_module_para_g.gprs_module_state = LOGIN_CMD_CMEE; // ÉèÖõǼµÚÒ»¸öÄ£¿éÃüÁî
#endif
#if GPRS_PROTOCOL_SELECT
      /*¼ÆËã·¢ËÍÌõÊýºÍ×ÜÖ¡Êý*/
      gprs_protocol_head_tail_g.gprs_protocol_head.frame_sum = Gprs_Protocol_GetSendDataNum_FrameSum(&gprs_save_send_para_g);
#endif
      __SYS_DELAY_SEC_TIME_SET_(gprs_delay_para, GPRS_BOOT_INIT_TIME); // Ä£¿é¿ªÆôºóÐèBootºÍInitʱ¼ä10S
      return GPRS_LOGIN;
    }
  }
  return GPRS_OPEN_MODULE;
}

GPRS_STATUS Gprs_LoginProcess(void)
{
  /*µ±ÑÓʱʱ¼äµ½»òÎÞÐèÑÓʱʱ½øÈë*/
  if (sys_delay_sec_para_g.gprs_delay_para.delay_flag || (!sys_delay_sec_para_g.gprs_delay_para.delay_time))
  {
    sys_delay_sec_para_g.gprs_delay_para.delay_flag = RESET;
#if GPRS_PROTOCOL_SELECT
    Gprs_Module_SendLogin(gprs_module_para_g.gprs_module_state,
                          gprs_network_cfg_para_g.gprs_ip_1, gprs_network_cfg_para_g.gprs_port_1);
#else
    Gprs_Module_SendLogin(gprs_module_para_g.gprs_module_state,
                          gprs_network_cfg_para_g.gprs_ip_2, gprs_network_cfg_para_g.gprs_port_2);
#endif
    return GPRS_RECV_DATA;
  }
  return GPRS_LOGIN;
}

static uint8_t temp_send_buffer[1024] = {0};
GPRS_STATUS Gprs_SendDataProcess(void)
{
  uint8_t cr[1] = {0x0D};
  static uint16_t send_data_length = 0;
#if NB_OR_4G_FLAG
  uint8_t temp_buff[25];
  GPRS_PROTOCOL_SEND_BUFFER_T *soft_buffer = NULL;
  /*¹¹ÔìÊý¾Ý·¢Ëͳ¤¶È*/
  send_data_length = Gprs_Protocol_DataLength(gprs_protocol_para_g.gprs_protocol_type, &gprs_protocol_encrypt_para_g);
  /*ЭÒéÊý¾ÝÖ¡ÅäÖÃ*/
  Gprs_Protocol_SendDataConfig(gprs_protocol_para_g.gprs_protocol_type, temp_send_buffer, &gprs_protocol_head_tail_g);
  /*NBµÄATÖ¸ÁîÔ¤ÏÈ·ÅÈëbuffÖÐ*/
  sprintf((char *)temp_buff, "%s,%d,", AT_SSEND_NB, send_data_length);
  uint8_t at_len = strlen((char *)temp_buff);
  if ((soft_buffer = (GPRS_PROTOCOL_SEND_BUFFER_T *)malloc(sizeof(GPRS_PROTOCOL_SEND_BUFFER_T) + 2 * send_data_length + at_len)) != NULL)
  {
    /*ATÖ¸Áî²»ÄܺÍÊý¾Ý·Ö¿ª·¢ËÍ£¬²»È»»áµ¼ÖÂNB·¢ËÍ´íλµÄÇé¿ö£¬ÒªÍ¬Ê±·¢ËÍ*/
    /*ATÖ¸ÁîbuffºÍÊý¾Ýbuff½øÐÐÕûºÏ*/
    memcpy(soft_buffer->send_buffer, temp_buff, at_len);
    Hex_2_Ascii(temp_send_buffer, &soft_buffer->send_buffer[at_len], send_data_length); // NBÐèÒª·¢ËÍASCII
    /*·¢ËÍЭÒéÊý¾Ý*/
    HAL_UART_Transmit(&huart3, soft_buffer->send_buffer, at_len + 2 * send_data_length, 1000);
    HAL_UART_Transmit(&huart3, cr, 1, 10);
    free(soft_buffer);
    soft_buffer = NULL;
  }
#else
  //  GPRS_PROTOCOL_SEND_BUFFER_T *soft_buffer = NULL;
  //  if ((soft_buffer = (GPRS_PROTOCOL_SEND_BUFFER_T *)malloc(sizeof(GPRS_PROTOCOL_SEND_BUFFER_T) + send_data_length)) != NULL)
  //  {
  /*¸æËßÄ£×éÒª·¢ËÍÊý¾Ý²¢ÉèÖ÷¢ËÍÊý¾Ý³¤¶È*/
  if (gprs_resend_data_flag_g == 0)
  {
    /*¹¹ÔìÊý¾Ý·¢Ëͳ¤¶È*/
    send_data_length = Gprs_Protocol_DataLength(gprs_protocol_para_g.gprs_protocol_type, &gprs_protocol_encrypt_para_g);
    __GPRS_MODULE_SEND_LENGTH__(send_data_length);
  }
  /*·¢ËÍЭÒéÊý¾Ý*/
  else if (gprs_resend_data_flag_g == 1)
  {
    gprs_resend_data_flag_g = 0;
    /*ЭÒéÊý¾ÝÖ¡ÅäÖÃ*/
    Gprs_Protocol_SendDataConfig(gprs_protocol_para_g.gprs_protocol_type, temp_send_buffer, &gprs_protocol_head_tail_g);
    GPRS_SEND_NORMAL(temp_send_buffer, send_data_length);
    GPRS_SEND_NORMAL(cr, 1);
    memset(temp_send_buffer, 0, sizeof(temp_send_buffer));
  }
//    free(soft_buffer);
//    soft_buffer = NULL;
//  }
#endif
  return GPRS_RECV_DATA;
}
GPRS_STATUS Gprs_RecvDataProcess(void)
{
  uint8_t *rec_ptr = NULL;
  uint16_t recv_valid_data_length = 0; // ½ÓÊÕµÄÓÐЧÊý¾Ý³¤¶È
  Gprs_Uart1_Rx_DMA_CH5_Check();
  /*µÇ¼½ÓÊÕ*/
  if (gprs_module_para_g.gprs_module_state != SEND_CMD_ZIPSENDRAW)
  {
    Gprs_Module_RecvLogin(&gprs_module_para_g, &gprs_protocol_head_tail_g.gprs_protocol_normal_data_head);
    if (gprs_module_para_g.gprs_module_state == SEND_CMD_ZIPSENDRAW)
    {
      gprs_protocol_para_g.gprs_protocol_type = PROTOCOL_NORMAL_SEND_CMD; // ЭÒé·¢ËÍÃüÁî
      have_gprs_send_flag = SUCCESS_0;
      return GPRS_SEND_DATA;
    }
    return GPRS_LOGIN;
  }
  else /*·¢ËͽÓÊÕ*/
  {
    /*Ä£×é½ÓÊÕÊý¾Ý´¦Àí*/
    uint8_t gprs_module_recv_flag = Gprs_Module_RecvDataProcess(&recv_valid_data_length, &rec_ptr, &gprs_module_para_g);
    if (gprs_module_recv_flag == 1)
    {
#if NB_OR_4G_FLAG
      Ascii_2_Hex(rec_ptr, rec_ptr, (2 * recv_valid_data_length)); // ¸ñʽת»¯
#endif
      gprs_protocol_para_g.gprs_protocol_type = Gprs_Protocol_RecvDataConfig(rec_ptr, recv_valid_data_length); // ЭÒéÊý¾Ý½âÎö
      memset(gprs_module_para_g.gprs_recv_buf, 0, sizeof(gprs_module_para_g.gprs_recv_buf));
      if (gprs_protocol_para_g.gprs_protocol_type == PROTOCOL_END_STATUS || gprs_protocol_para_g.gprs_protocol_type == PROTOCOL_UNKOWN_STATUS)
      {
        __SYS_STATUS_BYTES_STATUS(gprs_status, RESET, AV_GPRS_FAIL);
        __SYS_DELAY_SEC_TIME_SET_(gprs_timeout_para, 0); // ³¬Ê±Ê±¼äÇåÁ㣬²»²úÉú³¬Ê±flag
        return GPRS_CLOSE_MODULE;
      }
      else
      {
        __SYS_DELAY_SEC_TIME_SET_(gprs_timeout_para, gprs_network_cfg_para_g.gprs_timeout); // ½ÓÊÕµ½·þÎñÆ÷·µ»ØÊý¾ÝÖØÖó¬Ê±Ê±¼ä
        return GPRS_SEND_DATA;
      }
    }
    else if (gprs_module_recv_flag == 3)
      return GPRS_SEND_DATA;
  }
  return GPRS_RECV_DATA;
}
GPRS_STATUS Gprs_SendAlarmProcess(void)
{
  return GPRS_LOGIN;
}

GPRS_STATUS Gprs_Close_Module_Process(void)
{
  /*        ________________
   *PWR
   *        ____       _____
   *SWITCH      |_____|
   *               |     |
   *               |     |
   *              T1    T2    ¿ª¹Øµçƽ³ÖÐøʱ¼ä T1:3S  T2 > 22ms
   */
  if (GPIO_ReadOutputDataBit(GPRS_SWITCH_PORT, GPRS_SWITCH_PIN) == Bit_RESET) // Ä£¿éÒý½ÅÀ­µÍ
  {
    GPRS_SWITCH_L;
    __SYS_DELAY_SEC_TIME_SET_(gprs_delay_para, 4);
  }
  else if (GPIO_ReadOutputDataBit(GPRS_SWITCH_PORT, GPRS_SWITCH_PIN) == Bit_SET) // Ä£¿éÒý½ÅÀ­¸ß
  {
    if (sys_delay_sec_para_g.gprs_delay_para.delay_flag)
    {
      sys_delay_sec_para_g.gprs_delay_para.delay_flag = RESET;
      GPRS_SWITCH_H; // Ä£¿é¹Ø±Õ
      __SYS_DELAY_SEC_TIME_SET_(gprs_delay_para, 1);
      return GPRS_CLOSE_PWR;
    }
  }
  return GPRS_CLOSE_MODULE;
}

static uint8_t gprs_timeout_alarm_flag = 0;
GPRS_STATUS Gprs_Close_PWR_Process(void)
{
  /*ÏȹØÄ£×飬ÔٹصçÔ´*/
  if (GPIO_ReadOutputDataBit(GPRS_PWR_PORT, GPRS_PWR_PIN) == Bit_SET) // µçÔ´¿ªÆô
  {
    if (sys_delay_sec_para_g.gprs_delay_para.delay_flag)
    {
      sys_delay_sec_para_g.gprs_delay_para.delay_flag = RESET;
      GPRS_PWR_OFF; // µçÔ´¹Ø±Õ
      OTA_UpdataResetHandler();
      //			if(sys_show_state_bytes_id_g == A_RESTART)
      //				sys_clear_state_bytes_id_g = A_RESTART;
      if (restart_alarm_flag)
      {
        restart_alarm_flag = 0;
        Alarm_List_Node_Deleted(&pList_head, A_RESTART); // ¸´Î»±¨¾¯ÏÔʾÇå³ý
      }
      if (gprs_timeout_alarm_flag) // ³¬Ê±Ö±½Ó²úÉú±¨¾¯Éϱ¨£¬´ËʱԶ´«×´Ì¬»¹Î´¿ÕÏе¼Ö²»ÄÜÖر¨£¬ËùÒÔÌõ¼þ·ÅÔÚÕâÀï
        __SYS_STATUS_ALARM_BYTES_SET(gprs_status);
      return GPRS_IDLE;
    }
    return GPRS_CLOSE_PWR;
  }
  return GPRS_IDLE;
}
static uint16_t gprs_restart_interval_time_g = 0;
GPRS_STATUS Gprs_RestartProcess(void)
{
  if (!(--gprs_restart_interval_time_g))
  {
    //		Gprs_GPIO_Usart3_Clk_Init();
    pwr_vol_g.alka_flag = AMS_GPRS_BEFORE;
    return GPRS_IDLE;
  }
  return GPRS_RESTART;
}

void Gprs_IntervalHandler(GPRS_SEND_MEANS *pGprs_send_means, GPRS_NETWORK_CFG_PARA_T *gprs_net_para_p, __IO RTC_TimeDateTypeDef *calendar_p)
{
  if (calendar_p->Second == 0x07)
  {
    uint16_t ref_time_m = 0;
    switch (gprs_net_para_p->gprs_interval_type)
    {
    case GIM_PERIOD:
      ref_time_m = BCD_2_HEX_U8(gprs_net_para_p->gprs_reference_time_bcd[0]) * 60 + BCD_2_HEX_U8(gprs_net_para_p->gprs_reference_time_bcd[1]);
      if (Func_PeriodStartHandler(ref_time_m, gprs_net_para_p->gprs_send_period_min_time,
                                  &period_para_g.gprs_send_period.period_flag, &period_para_g.gprs_send_period.last_time_m, calendar_p))
        *pGprs_send_means = GPRS_MEANS_RTC_PERIOD;
      break;
    case GIM_TIMED:
      for (uint8_t i = 0; i < gprs_net_para_p->gprs_timed_number; i++)
      {
        if (calendar_p->Hour == gprs_net_para_p->gprs_timing_time_bcd[i][0] &&
            calendar_p->Minute == gprs_net_para_p->gprs_timing_time_bcd[i][1])
          *pGprs_send_means = GPRS_MEANS_RTC_TIMED;
      }
      break;
    case GIM_PERIOD_TIMED:
      ref_time_m = BCD_2_HEX_U8(gprs_net_para_p->gprs_reference_time_bcd[0]) * 60 + BCD_2_HEX_U8(gprs_net_para_p->gprs_reference_time_bcd[1]);
      if (Func_PeriodStartHandler(ref_time_m, gprs_net_para_p->gprs_send_period_min_time,
                                  &period_para_g.gprs_send_period.period_flag, &period_para_g.gprs_send_period.last_time_m, calendar_p))
        *pGprs_send_means = GPRS_MEANS_RTC_PERIOD;
      for (uint8_t i = 0; i < gprs_net_para_p->gprs_timed_number; i++)
      {
        if (calendar_p->Hour == gprs_net_para_p->gprs_timing_time_bcd[i][0] &&
            calendar_p->Minute == gprs_net_para_p->gprs_timing_time_bcd[i][1])
          *pGprs_send_means = GPRS_MEANS_RTC_TIMED;
      }
      break;
    default:
      break;
    }
  }
}

void Gprs_StartJudge(GPRS_SOFT_PARA_T *gprs_soft_para_p_p)
{
  /*·¢Ëͼä¸ô´¦Àí*/
  Gprs_IntervalHandler(&gprs_soft_para_p_p->gprs_send_type_flag, &gprs_network_cfg_para_g, &calendar_g);
  if (gprs_soft_para_p_p->gprs_send_type_flag) // Æô¶¯Ô¶´«Ìõ¼þ£ºÊ±¼äµ½£¨¼ä¸ô/¶¨Ê±Ê±¼ä£© °´¼ü ±¨¾¯ ¸´Î»
  {
    /*GPRSÖØÁ¬µ¹Ê±ÆÚ¼ä²úÉúÁËʱ¼äµ½/°´¼ü/ÆäËû±¨¾¯£¬Ö±½ÓÆô¶¯GPRS*/
    if (gprs_soft_para_p_p->gprs_state == GPRS_IDLE || gprs_soft_para_p_p->gprs_state == GPRS_RESTART)
    {
#if GPRS_PROTOCOL_SELECT
      gprs_protocol_head_tail_g.gprs_protocol_normal_data_head.sys_send_type = gprs_soft_para_p_p->gprs_send_type_flag;
#else
      gprs_protocol_head_tail_g.gprs_protocol_normal_data_head.sys_send_type = gprs_soft_para_p_p->gprs_send_type_flag;
#endif
      /*ͨѶʧ°Ü -> ״̬/±¨¾¯×ÖÖÃλ -> ¿ªÆôÔ¶´«±¨¾¯/ÖØÁ¬*/
      if (gprs_timeout_alarm_flag && gprs_soft_para_p_p->gprs_send_type_flag == GPRS_MEANS_AGAIN)
      {
        gprs_restart_interval_time_g = gprs_network_cfg_para_g.gprs_restart_send_interval_min_time * 60; // ÖØÁ¬¼ä¸ôʱ¼ä
        gprs_soft_para_p_p->gprs_state = GPRS_RESTART;
      }
      else
        pwr_vol_g.alka_flag = AMS_GPRS_BEFORE;
      gprs_timeout_alarm_flag = 0;
    }
    gprs_soft_para_p_p->gprs_send_type_flag = GPRS_MEANS_NONE;
  }
  if (__SYS_DELAY_SEC_FLAG_GET(gprs_timeout_para) == SET) // ³¬Ê±
  {
    //		gprs_test_g.gprs_time_cnt++;
    gprs_timeout_alarm_flag = 1; // ÓÃÓÚͨѶʧ°ÜÖØÁ¬
    __SYS_DELAY_SEC_FLAG_CLEAR_(gprs_timeout_para);
    gprs_soft_para_p_p->gprs_state = GPRS_CLOSE_MODULE;
  }
}

void Gprs_Process(GPRS_SOFT_PARA_T *gprs_soft_para_p)
{
  /*·¢ËÍ¿ªÆôÅжÏ*/
  Gprs_StartJudge(gprs_soft_para_p);
  if (gprs_soft_para_p->gprs_state && (LargeCurrent_LimitingProcess() & 2)) // ·§¿ÕÏвÅÄܽøÈë
  {
    for (uint8_t i = 0; i < GPRS_FUNC_TABLE_NUM; i++)
    {
      // ²é±í
      if (gprs_tab_func[i].gprs_func_table == gprs_soft_para_p->gprs_state && gprs_tab_func[i].GprsFuncHandler != NULL)
      {
        gprs_soft_para_p->gprs_state = gprs_tab_func[i].GprsFuncHandler();
        break;
      }
    }
  }
}