#include "by_frame.h"

#include <stdint.h>
#include <string.h>

#include "zf_common_headfile.h"
#include "lwrb.h"
#include "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 大小减一
    uart_init(BY_FRAME_UART_INDEX, BY_FRAME_UART_BAUDRATE, BY_FRAME_UART_TX_PIN, BY_FRAME_UART_RX_PIN);
    uart_rx_interrupt(BY_FRAME_UART_INDEX, ENABLE);
}

void by_frame_send(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_1;
    frame_buffer_send[1] = BY_FRAME_HEAD_2;

    // 当传入数组不足时，会发生越界情况
    memcpy(frame_buffer_send + 2, data_array, 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);

    uart_write_buffer(BY_FRAME_UART_INDEX, frame_buffer_send, 4 + data_byte_num);
}

/**
 * @brief
 *
 * @param data_num
 * @param data_array
 * @todo 将其中写死的数据长度按照宏定义给出
 */
void by_frame_parse(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)) {
        // 当前要求缓冲区满
        // (x) 缓冲区内长度小于帧长度，直接返回
        // 要是每次读的时候缓冲区内就只有前一帧的尾部和后一帧的头部，岂不是很尴尬
        // 是不是应该正确解析之后再把过的部分清空？但是是异步操作，实际上缓冲区内已经是新数据了
        // 可是直接读取 fifo 的话也是异步操作
        // 发的慢的话就很有可能有同步问题，导致一直解析不出来
        // 喵的，为啥不直接丢中断里解析算了

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

    // 从环形缓冲区里读取数据
    lwrb_read(&lwrb_ctx, buf, len);

    // 递归解析有效帧
    while (1) {
        if (0 == status) // 没找到帧头
        {
            // 读到最后一个元素还没找到帧头
            if (frame_start >= len - 2) {
                return;
            }
            // printf("finding frame head, now frame_start %d\r\n", frame_start);
            uint16_t temp = (buf[frame_start] | (buf[frame_start + 1] << 8));
            frame_start++;
            // printf("now find %02X\r\n", temp);

            // 递归寻找帧头，直接俩拼起来找 注意比较的时候低位在前
            if ((BY_FRAME_HEAD_2 << 8 | BY_FRAME_HEAD_1) == temp) {
                status = 1; // 找到了好耶
                // printf("frame head found!!!!!!!!!\r\n");
            }
            continue;
        }

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

                // for (uint8_t i = 0; i < 12; i++) {
                //     printf("%02X", frame_buf[i]);
                // }
                // printf("\r\n");

                status = 2;
            }
            continue;
        }

        if (2 == status) // 校验 CRC
        {
            if ((frame_buf[2 + data_byte_num] << 8 | frame_buf[2 + data_byte_num + 1]) == crc16_check(frame_buf, 2 + data_byte_num)) {
                // 解析成功了✌
                // printf("parsed done!!!!!!!!\r\n");

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

    return;
}

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

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