#include "by_frame.h"

#include "at32f403a_407.h"
#include "lwrb.h"
#include "by_crc16.h"

uint8_t frame_buffer_recv[(2 * (4 + BY_FRAME_DATA_NUM * sizeof(uint32_t))) + 1];
uint8_t frame_buffer_send[4 + BY_FRAME_DATA_NUM * sizeof(uint32_t)];
uint8_t frame_parse_busy;
lwrb_t lwrb_ctx;

void by_frame_init(void)
{
  lwrb_init(&lwrb_ctx, frame_buffer_recv, sizeof(frame_buffer_recv)); // lwrb 最大元素数量为 buff 大小减一
}

void by_frame_send(uint8_t cmd, uint32_t *data_array)
{
  uint16_t crc_cal            = 0;
  const uint8_t data_byte_num = BY_FRAME_DATA_NUM * sizeof(uint32_t);

  frame_buffer_send[0] = BY_FRAME_HEAD;
  frame_buffer_send[1] = cmd;

  // 当传入数组不足时，会发生越界情况
  memcpy(frame_buffer_send + 2, data_array, data_byte_num);
  crc_cal = by_crc16_calculate(frame_buffer_send, 2 + data_byte_num);
  //   crc_cal = crc16_check(frame_buffer_send, 2 + data_byte_num);

  frame_buffer_send[2 + data_byte_num] = (uint8_t)(crc_cal >> 8);
  frame_buffer_send[3 + data_byte_num] = (uint8_t)(crc_cal);

  for (uint8_t i = 0; i < 4 + data_byte_num; i++) {
    while (RESET == usart_flag_get(BY_FRAME_UART_INDEX, USART_TDBE_FLAG))
      ;
    usart_data_transmit(BY_FRAME_UART_INDEX, frame_buffer_send[i]);
  }
}

/**
 * @brief
 *
 * @param data_num
 * @param data_array
 * @todo 将其中写死的数据长度按照宏定义给出
 */
uint8_t by_frame_parse(uint8_t *cmd, uint32_t *data_array)
{
  uint32_t len                                                = lwrb_get_full(&lwrb_ctx); // 缓冲区大小
  uint8_t status                                              = 0;                        // 状态 0-未找到帧头 1-找到帧头 2-校验
  uint16_t frame_start                                        = 0;                        // 帧起始位置
  uint8_t frame_buf[4 + BY_FRAME_DATA_NUM * sizeof(uint32_t)] = {0};                      // 帧
  uint8_t buf[(4 + BY_FRAME_DATA_NUM * sizeof(uint32_t)) * 2] = {0};                      // 用于解析的数据块
  const uint8_t data_byte_num                                 = BY_FRAME_DATA_NUM * sizeof(uint32_t);

  //   if (len < 2 * (4 + data_byte_num)) { // FIXME 当传递相对值时会出现问题
  //     // 当前要求缓冲区满
  //     // (x) 缓冲区内长度小于帧长度，直接返回
  //     // 要是每次读的时候缓冲区内就只有前一帧的尾部和后一帧的头部，岂不是很尴尬
  //     // 是不是应该正确解析之后再把过的部分清空？但是是异步操作，实际上缓冲区内已经是新数据了
  //     // 可是直接读取 fifo 的话也是异步操作
  //     // 发的慢的话就很有可能有同步问题，导致一直解析不出来
  //     // 喵的，为啥不直接丢中断里解析算了

  //     // 目前的解决办法大概是缓冲区开两帧长的大小，然后一次性读完
  //     // 读取的时候不清除，等待新帧覆盖
  //     // 用 lwrb 的话就只能清除了
  //     return 1;
  //   }

  lwrb_sz_t valid_num   = 0;
  lwrb_sz_t invalid_num = 0;
  uint8_t frame_head    = BY_FRAME_HEAD;

  //   lwrb_find(&lwrb_ctx, &frame_head, 1, 0, &invalid_num);
  //   lwrb_skip(&lwrb_ctx, invalid_num);
  //   // TODO 优化逻辑，先找 0xEF，判断缓冲区里帧头后的长度足够则进入解析
  //   //  从环形缓冲区里读取数据，仅读取一个帧长
  //   lwrb_read(&lwrb_ctx, buf, 4 + BY_FRAME_DATA_NUM * sizeof(uint32_t));

  // 如果没找到帧头，跳出
  if (!lwrb_find(&lwrb_ctx, &frame_head, 1, 0, &invalid_num)) {
    lwrb_skip(&lwrb_ctx, len);
    return 1;
  }

  valid_num = len - invalid_num; // 从帧头开始，剩下的数据长度
  lwrb_skip(&lwrb_ctx, invalid_num);

  // 如果没有足够的数据，跳出
  if (valid_num < 4 + data_byte_num) {
    return 1;
  }

  lwrb_read(&lwrb_ctx, buf, 4 + data_byte_num);

  // 递归解析有效帧
  while (1) {
    if (0 == status) // 没找到帧头
    {
      // 读到最后一个元素还没找到帧头
      if (frame_start >= len - 2) {
        return 1;
      }
      uint16_t temp = (buf[frame_start] | (buf[frame_start + 1] << 8));
      frame_start++;

      // 递归寻找帧头，现在只有一个帧头了，摆大烂不想改就这样了
      if (BY_FRAME_HEAD == (uint8_t)(temp & 0xFF)) {
        status = 1; // 找到了好耶
      }
      continue;
    }

    // 开始读数据
    if (1 == status) {
      // 剩下的数据不够组成一帧
      if ((frame_start + 4 + data_byte_num - 1) > len) {
        // 解析出错，缓冲区中没有有效帧
        return 1;
      } else {
        // 复制到帧缓冲区，减一是因为之前多加了一次
        memcpy(frame_buf, buf + frame_start - 1, 4 + data_byte_num);
        status = 2;
      }
      continue;
    }

    if (2 == status) // 校验 CRC
    {
      uint16_t crc_cal = by_crc16_calculate(frame_buf, 2 + data_byte_num);
      if ((frame_buf[2 + data_byte_num] << 8 | frame_buf[2 + data_byte_num + 1]) == crc_cal) {
        // 解析成功了✌

        // 复制数据
        if (NULL != (frame_buf + 2)) {
          *cmd = frame_buf[1];
          memcpy(data_array, frame_buf + 2, data_byte_num);
        }
        return 0;
      } else {
        status = 0;
        // 这样无法应对连续帧之间缺字节的的问题，但是减少了重新遍历寻找帧头的时间
        // frame_start += (8 - 1);
        // 从上一个帧头之后开始解析
        frame_start += (2 - 1);
        continue;
      }
    }
  }

  return 1;
}

void by_frame_parse_uart_handle(uint8_t data)
{
  lwrb_write(&lwrb_ctx, &data, 1);
}

/**
 * @brief 定时器回调，用于接收超时判断 1ms 调用一次
 *
 */
void by_frame_parse_timer_handle(void)
{
}