#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 + 8))];
uint8_t frame_buffer_send[4 + 8];
uint8_t frame_parse_busy;
fifo_struct frame_fifo;

void by_frame_init(void)
{
    fifo_init(&frame_fifo, FIFO_DATA_8BIT, frame_buffer_recv, (2 * (4 + 8)));
    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(uint8_t data_num, uint32_t *data_array)
{
    uint16_t crc_cal     = 0;
    frame_buffer_send[0] = BY_FRAME_HEAD_1;
    frame_buffer_send[1] = BY_FRAME_HEAD_2;

    memcpy(frame_buffer_send + 2, data_array, data_num * sizeof(uint32_t));
    crc_cal = crc16_check(frame_buffer_send, 2 + data_num * sizeof(uint32_t));

    frame_buffer_send[2 + data_num * sizeof(uint32_t)] = (uint8_t)(crc_cal >> 8);
    frame_buffer_send[3 + data_num * sizeof(uint32_t)] = (uint8_t)(crc_cal);

    uart_write_buffer(BY_FRAME_UART_INDEX, frame_buffer_send, 4 + data_num * sizeof(uint32_t));
}

void by_frame_parse(uint8_t data_num, uint32_t *data_array)
{

    uint16_t len                      = (uint16_t)fifo_used(&frame_fifo);
    uint16_t len_cnt                  = len;
    uint8_t status                    = 0;
    uint16_t frame_start              = 0;
    uint8_t frame_buffer[4 + 8]       = {0};
    uint8_t buf[sizeof(frame_buffer)] = {0};

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

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

    fifo_read_buffer(&frame_fifo, buf, &len, FIFO_READ_ONLY);

    while (len_cnt--) {
        if (0 == status) // 没找到帧头
        {
            printf("finding frame head, now frame_start %d\r\n", frame_start);
            uint16_t temp = *((uint16_t *)(buf + (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 + 8) >= len) // 剩下的数据不够组成一帧
            {
                printf("failed! length not enough \r\n");
                return; // 解析出错，缓冲区中没有有效帧
            } else {
                memcpy(frame_buffer, buf + frame_start - 1, 4 + 8); // 复制到帧缓冲区，减一是因为之前多加了一次
                for (uint8_t i = 0; i < 12; i++) {
                    printf("%02X", frame_buffer[i]);
                }

                printf("\r\n");
                status = 2;
            }
            continue;
        }

        if (2 == status) // 校验 CRC
        {
            // TODO 确认一下高低位
            if (*((uint16_t *)(frame_buffer + 2 + 8)) == crc16_check(frame_buffer, 2 + 4 * data_num)) // 暂时用 0xFF 替代 注意比较的时候字节序！！！
            {
                printf("parsed done!!!!!!!!\r\n");                  // 解析成功了✌
                memcpy(data_array, frame_buffer + 2, 4 * data_num); // 复制数据
                return;
            } else {
                status = 0;
                // frame_start += (8 - 1); // 这样无法应对连续帧之间缺字节的的问题，但是减少了重新遍历寻找帧头的时间
                frame_start += (2 - 1); // 从上一个帧头之后开始解析
                continue;
            }
        }
    }

    return;

    // uint8_t cnt                  = 0;
    // uint8_t cnt_crc              = 2;
    // uint8_t cnt_ptr              = 0;
    // uint8_t data                 = 0;
    // uint8_t data_array_temp[100] = {0};
    // uint16_t crc_cal             = 0;
    // uint32_t read_length         = 50;

    // if (fifo_used(&frame_fifo) >= 4 + 4 * data_num) {
    //     fifo_read_buffer(&frame_fifo, frame_buffer_parse, &read_length, FIFO_READ_AND_CLEAN);
    //     while (1) {
    //         if (cnt_ptr < 50) {
    //             data = frame_buffer_parse[cnt_ptr];
    //             cnt_ptr++;
    //         }
    //         // printf("char : %0.2X\r\n", data);

    //         if ((0 == cnt) && (BY_FRAME_HEAD_1 == data)) {
    //             frame_parse_busy   = 1; // 开始解析
    //             cnt                = 1;
    //             data_array_temp[0] = data;
    //             continue;
    //         }

    //         if ((1 == cnt) && (BY_FRAME_HEAD_2 == data)) {
    //             cnt                = 2;
    //             data_array_temp[1] = data;
    //             continue;
    //         }

    //         if ((2 <= cnt) && (cnt < 2 + data_num * sizeof(uint32_t))) {
    //             data_array_temp[cnt] = data;
    //             cnt++;
    //             continue;
    //         }

    //         if (cnt_crc) {
    //             crc_cal |= ((uint16_t)data << (--cnt_crc * 8));
    //             cnt++;
    //             continue;
    //         }

    //         // printf("GET CRC %0.4X\r\n", crc_cal);
    //         // printf("CAL CRC %0.4X\r\n", crc16_check((uint8_t *)data_array_temp, 2 + data_num * sizeof(uint32_t)));

    //         if (!cnt_crc) {
    //             if (crc_cal == crc16_check(data_array_temp, 2 + data_num * sizeof(uint32_t))) {
    //                 memcpy(data_array, data_array_temp + 2, data_num * sizeof(uint32_t));
    //                 fifo_clear(&frame_fifo); // TODO 确认是否有必要清除
    //                 // lwrb_reset(&lwrb_struct); // 处理完直接清空缓冲区，避免堆积产生处理阻塞
    //                 memset(data_array_temp, 0, sizeof(data_array_temp));
    //             }

    //             break;
    //         }
    //     }
    // }
}

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

/**
 * @brief 定时器回调，用于接收超时判断 1ms 调用一次
 *
 */
void by_frame_parse_timer_handle(void)
{
    static uint8_t time_out = 0;
    if (frame_parse_busy) {
        time_out--;
    }
}