/*
 * L505.c
 *
 *  Created on: Apr 1, 2021
 *      Author: wushufeng
 */

#include "drv_ec800k.h"
#include <stdint.h>
#include "VK_Com.h"
#include "VK_Log.h"
#include "rtdef.h"
#include "rtthread.h"
#include "rttypes.h"

#define DBG_TAG "DTU_LOG"
#define DBG_LVL DBG_INFO
#include "rtdbg.h"


Cclient_t client1 = {
    .mode = "TCP",
    /*教培IP和PORT*/
    .ip = "uavedu.jiagutech.com",
    .port = "19763",
    .connect_ID = 0,
    .connect_sta = false,
    .error_cnt = 0,
};

CLte_dev_t lte_dev = {
    .client1 = (Cclient_t *)&client1,
    .config_sta = false,
    .reset_flag = DTU_CF_NEED_RESET,
    .dev_init_flag = true,
    .data_tx_paused = false,
};

lte_diag_t lte_diag = {0};
static bool lte_log_clock_query_done = false;

void lte_diag_at_begin(const char *cmd) {
  rt_size_t i;

  lte_diag.at_commands++;
  lte_diag.last_at_elapsed = rt_tick_get();
  lte_diag.last_at_result = -2;
  for (i = 0; i < sizeof(lte_diag.last_at_cmd) - 1 && cmd[i] != '\0'; i++) {
    lte_diag.last_at_cmd[i] = (cmd[i] == '\r' || cmd[i] == '\n') ? '_' : cmd[i];
  }
  lte_diag.last_at_cmd[i] = '\0';
}

void lte_diag_at_end(rt_int32_t result) {
  rt_tick_t now = rt_tick_get();
  lte_diag.last_at_elapsed = now - lte_diag.last_at_elapsed;
  lte_diag.last_at_result = result;
  if (result == -1) {
    lte_diag.at_timeouts++;
  } else if (result != 0) {
    lte_diag.at_errors++;
  }
}

void lte_diag_uart2_rx(rt_size_t size) {
  lte_diag.uart2_rx_bytes += size;
  lte_diag.last_uart2_rx_tick = rt_tick_get();
}

void lte_diag_uart2_tx(rt_size_t size) {
  lte_diag.uart2_tx_bytes += size;
  lte_diag.last_uart2_tx_tick = rt_tick_get();
}

void lte_diag_uart_error(const char *name, rt_uint32_t error_code) {
  lte_diag.last_uart_error_code = error_code;
  if (name != RT_NULL && rt_strcmp(name, "uart2") == 0) {
    lte_diag.uart2_error_count++;
  } else if (name != RT_NULL && rt_strcmp(name, "uart3") == 0) {
    lte_diag.uart3_error_count++;
  }
}

void lte_diag_fmu_rx(rt_size_t size) {
  lte_diag.fmu_rx_bytes += size;
  lte_diag.last_fmu_rx_tick = rt_tick_get();
}

void lte_diag_fmu_tx(rt_size_t size) {
  lte_diag.fmu_tx_bytes += size;
  lte_diag.last_fmu_tx_tick = rt_tick_get();
}

void lte_diag_connect_attempt(void) {
  lte_diag.connect_attempts++;
  if (lte_diag.connect_attempts > 1) {
    lte_diag.reconnect_count++;
  }
}

void lte_diag_connect_success(void) {
  lte_diag.connect_tick = rt_tick_get();
  lte_diag.last_server_rx_tick = lte_diag.connect_tick;
}

void lte_diag_module_reset(void) {
  lte_diag.reset_count++;
}

void BSP_LTE_SendData(uint8_t *pdata, uint32_t length) {
  if (lte_dev.com_dev != RT_NULL) {
    if (lte_dev.data_tx_mutex != RT_NULL) {
      rt_mutex_take(lte_dev.data_tx_mutex, RT_WAITING_FOREVER);
    }
    rt_ssize_t written = rt_device_write(lte_dev.com_dev, 0, pdata, length);
    if (written > 0) {
      lte_diag_uart2_tx((rt_size_t)written);
    }
    if (written != (rt_ssize_t)length) {
      lte_diag.uart2_write_failures++;
    }
    if (lte_dev.data_tx_mutex != RT_NULL) {
      rt_mutex_release(lte_dev.data_tx_mutex);
    }
  }
}

void BSP_LTE_SetDataTxPaused(bool paused) {
  if (lte_dev.data_tx_mutex != RT_NULL) {
    rt_mutex_take(lte_dev.data_tx_mutex, RT_WAITING_FOREVER);
  }
  lte_dev.data_tx_paused = paused;
  if (lte_dev.data_tx_mutex != RT_NULL) {
    rt_mutex_release(lte_dev.data_tx_mutex);
  }
}

void BSP_LTE_InitLogClock(void) {
  if (lte_log_clock_query_done) {
    return;
  }

  lte_log_clock_query_done = true;
  if (BSP_LTE_SendCmd(AT_QLTS, DEFAULT_EXPECT, DEFAULT_ERROR,
                      LTE_CMD_WAIT_NORMAL) == 0) {
    if (dev_log_time_set_from_at((const char *)lte_dev.at_buf) != 0) {
      LOG_W("EC800K clock is not synchronized; using untimestamped logs\n");
    }
  } else {
    LOG_W("EC800K clock query failed; using untimestamped logs\n");
  }
}

int16_t BSP_LTE_SendCmd(const char *cmd, const char *expect, const char *error,
                        uint32_t waittime) {
  lte_diag_at_begin(cmd);
  LOG_I("%s\n", cmd);
  BSP_LTE_SendData((uint8_t *)cmd, rt_strlen(cmd));

  rt_err_t ret = rt_sem_take(lte_dev.com_dev_rx_sem, waittime);
  if (ret == RT_EOK) {
    rt_thread_mdelay(500);

    rt_memset(lte_dev.at_buf, 0, sizeof(lte_dev.at_buf));

    rt_ssize_t read_len = rt_device_read(lte_dev.com_dev, 0, lte_dev.at_buf,
                                         sizeof(lte_dev.at_buf));
    if (read_len > 0) {
      lte_diag_uart2_rx((rt_size_t)read_len);
    }

    LOG_I("%s\n", lte_dev.at_buf);
    /* 清空缓存 */
    uint8_t c;
    while (rt_device_read(lte_dev.com_dev, 0, &c, 1) == 1) {
    }

    if (expect != NULL && NULL != rt_strstr((char *)lte_dev.at_buf, expect)) {
      lte_diag_at_end(0);
      return 0;
    } else if (error != NULL && NULL != rt_strstr((char *)lte_dev.at_buf, error)) {
      lte_diag_at_end(1);
      return 1;
    } else {
      lte_diag_at_end(2);
      return 2;
    }
  } else {
    lte_diag_at_end(-1);
    return -1;
  }
}

int16_t BSP_LTE_SendATE(int16_t retry) {
  do {
    if (0 == BSP_LTE_SendCmd(AT_ATE0, DEFAULT_EXPECT, DEFAULT_ERROR,
                             LTE_CMD_WAIT_NORMAL)) {
      return 0;
    }
    retry--;
  } while (retry);

  return -1;
}

int extract_number(const char *src, char *dest) {
  if(src == RT_NULL || dest == RT_NULL){
    return -1;
  }
  char *start = NULL;
  char *end = NULL;
  if (strchr(src, '\n') != NULL) {
    start = strchr(src, '\n') + 1;
    if (start != NULL) {
      end = strchr(start, '\r');
    }
  }
  if (start != NULL && end != NULL) {
    int length = end - start;
    if(length >= 30){
      return -1;
    }
    strncpy(dest, start, length);
    dest[length] = '\0';
  }
  return 0;
}

int BSP_LTE_GetIMEI(char *pIMEI) {
  int ret = 0;
  // while (0 != BSP_LTE_SendCmd(AT_IMEI, DEFAULT_EXPECT, DEFAULT_ERROR,
  //                             LTE_CMD_WAIT_NORMAL));
  ret = BSP_LTE_SendCmd(AT_IMEI, DEFAULT_EXPECT, DEFAULT_ERROR,
                        LTE_CMD_WAIT_NORMAL);
  if (ret != 0) {
    return -1;
  }
  if (extract_number((const char *)lte_dev.at_buf, pIMEI) == -1) {
    return -1;
  }
  if (strlen(pIMEI) < 10) {
    ret = -1;
  }
  if (pIMEI[15] == '\"')
    pIMEI[15] = 0;
  return ret;
}

int BSP_LTE_GetICCID(char *pICCID) {
  char *start = NULL;
  char *end = NULL;
  int ret = 0;
  // while (0 != BSP_LTE_SendCmd(AT_ICCID, DEFAULT_EXPECT, DEFAULT_ERROR,
  //                             LTE_CMD_WAIT_LONG));
  ret = BSP_LTE_SendCmd(AT_ICCID, DEFAULT_EXPECT, DEFAULT_ERROR,
                        LTE_CMD_WAIT_LONG);
  if(ret != 0){
    return -1;
  }
  if(rt_strstr((const char *)lte_dev.at_buf, "+ICCID:") != NULL){
    start =
      rt_strstr((const char *)lte_dev.at_buf, "+ICCID:") + rt_strlen("+ICCID:") + 1;
  }
  if(start == RT_NULL){
    return -1;
  }
  end = start;
  while (*end != '\0' && *end != '\r' && *end != '\n') end++;
  rt_size_t len = end - start;
  if(len >= 30){
    return -1;
  }
  rt_memcpy(pICCID, start, len);
  pICCID[len] = '\0';

  if (strlen(pICCID) < 10) {
    ret = -1;
  }
  return ret;
}

#define CSQ_CMD_RESP "+CSQ:"
int8_t BSP_LTE_GetCSQ(void) {
  int8_t ret = 0;
  char *start;

  if (0 != BSP_LTE_SendCmd(AT_CSQ, DEFAULT_EXPECT, DEFAULT_ERROR,
                           LTE_CMD_WAIT_LONG)) {
    return -1;
  }

  start = rt_strstr((const char *)lte_dev.at_buf, CSQ_CMD_RESP);
  if (start == RT_NULL) {
    return -1;
  }

  start += rt_strlen(CSQ_CMD_RESP) + 1;

  while (*start >= '0' && *start <= '9') {
    ret = ret * 10 + (*start - '0');
    start++;
  }

  return ret;
}

int16_t BSP_LTE_SendATCPIN(int16_t retry) {
  do {
    if (0 ==
        BSP_LTE_SendCmd(AT_CPIN, "READY", DEFAULT_ERROR, LTE_CMD_WAIT_NORMAL)) {
      return 0;
    } else if (NULL != strstr((char *)lte_dev.at_buf, "ERROR: 10")) {
      // No SimCard
      return 1;
    }

    retry--;
  } while (retry);

  return -1;
}

int16_t BSP_LTE_GetCEREG(int16_t retry) {
  do {
    if (0 ==
        BSP_LTE_SendCmd(AT_CEREG, CEREG_OK, DEFAULT_ERROR, LTE_CMD_WAIT_LONG)) {
      return 0;
    } else if (0 == BSP_LTE_SendCmd(AT_CEREG, "+CEREG: 0,5\r\n\r\nOK",
                                    DEFAULT_ERROR, LTE_CMD_WAIT_LONG)) {
      return 0;
    } else if (0 == BSP_LTE_SendCmd(AT_CEREG, CEREG_OK_2, DEFAULT_ERROR,
                                    LTE_CMD_WAIT_LONG)) {
      return 0;
    } else if (0 == BSP_LTE_SendCmd(AT_CEREG, DEFAULT_EXPECT, DEFAULT_ERROR,
                                    LTE_CMD_WAIT_LONG)) {
      return 0;
    }
    retry--;
  } while (retry);
  return -1;
}

static rt_err_t lte_com_rx_cb(rt_device_t dev, rt_size_t size) {
  lte_diag.uart2_rx_events++;
  if (lte_dev.com_dev_rx_sem != RT_NULL) {
    rt_sem_release(lte_dev.com_dev_rx_sem);
  }
  return RT_EOK;
}

void BSP_LET_Register_Com(rt_device_t com_dev) {
  if (lte_dev.com_dev_rx_sem == RT_NULL) {
    lte_dev.com_dev_rx_sem = rt_sem_create("lteRx", 0, RT_IPC_FLAG_PRIO);
  }

  lte_dev.com_dev = com_dev;
  if (lte_dev.data_tx_mutex == RT_NULL) {
    lte_dev.data_tx_mutex = rt_mutex_create("lteTx", RT_IPC_FLAG_PRIO);
  }
  BSP_LTE_SetDataTxPaused(false);
}

/*
函数功能：配置EC800K
*/
void BSP_LTE_Config(void) {
  int res = 0;

  rt_device_set_rx_indicate(lte_dev.com_dev, lte_com_rx_cb);

  uint8_t c = 0;

  //rt_thread_mdelay(3000);
  BSP_LTE_SendData((uint8_t *)"+++", 3);
  rt_thread_mdelay(2000);
  BSP_LTE_SendData((uint8_t *)"+++", 3);
  rt_thread_mdelay(2000);
  while (rt_device_read(lte_dev.com_dev, 0, &c, 1) == 1);

  while (0 != BSP_LTE_SendATE(3)) {
    rt_thread_mdelay(500);
    LOG_I("BSP_LTE_SendATE error\n");
  }

  /* Allow the network to update the module clock after registration. */
  BSP_LTE_SendCmd(AT_CTZU, DEFAULT_EXPECT, DEFAULT_ERROR, LTE_CMD_WAIT_NORMAL);

  /*查询模块信息*/
  if (lte_dev.dev_init_flag == true) {
    BSP_LTE_SendCmd(AT_ATI, DEFAULT_EXPECT, DEFAULT_ERROR, LTE_CMD_WAIT_NORMAL);
  }
  /*查询SIM卡是否存在*/
  res = BSP_LTE_SendATCPIN(3);
  if (res == 1) {
    return;
  }

  /*请求移动设备的识别码*/
  if (lte_dev.dev_init_flag == true) {
    if (BSP_LTE_GetIMEI(lte_dev.imei) == -1) {
      return;
    }

    /*请求sim卡号码*/
    if (BSP_LTE_GetICCID(lte_dev.iccid) == -1) {
      return;
    }
  }
  /*查询信号强度*/
  res = BSP_LTE_GetCSQ();
  if (res != -1) lte_dev.csq = res;

  /*查询网络注册状态*/
  res = BSP_LTE_GetCEREG(3);
  if(res == -1){
    return;
  }
  /*配置应用场景*/
  BSP_LTE_SendCmd(AT_QICSGP, DEFAULT_EXPECT, DEFAULT_ERROR, LTE_CMD_WAIT_LONG);
  //BSP_LTE_SendCmd(AT_QICSGP_CTIOT, DEFAULT_EXPECT, DEFAULT_ERROR, LTE_CMD_WAIT_LONG);
  //BSP_LTE_SendCmd(AT_QICSGP_CMTDS, DEFAULT_EXPECT, DEFAULT_ERROR, LTE_CMD_WAIT_LONG);
  /*定义 PDP 上下文*/
  BSP_LTE_SendCmd("AT+CGDCONT?\r\n", DEFAULT_EXPECT, DEFAULT_ERROR,
                  LTE_CMD_WAIT_NORMAL);
  //+CGDCONT: 1,"IP","cmiot","0.0.0.0",0,0,0,0,0,0....OK

  lte_dev.config_sta = true;
  lte_dev.dev_init_flag = false;
}
//------------------End of File----------------------------