#include "soft_uart.h"
#include "string.h"
#include "soft_flash.h"
#include "soft_crc.h"
#include "usart.h"

extern UART_HandleTypeDef huart2;
bool fmu_version_ack = false;
void uart2_send_msg(uint8_t *data, uint8_t size)
{
    static uint32_t send_time = 0;

    send_time = HAL_GetTick();
    while (HAL_GetTick() - send_time < 1)
        ;
    HAL_UART_Transmit_DMA(&huart2, data, size);
}

uint8_t FMU_uart_buf[MAX_UART_BUF] = {0};
Update update;
void USER_UART_IRQHandler(UART_HandleTypeDef *huart)
{
    uint32_t recv_count = 0;
    if (huart == &huart2)
    {
        if (RESET != __HAL_UART_GET_FLAG(huart, UART_FLAG_IDLE))
        {
            __HAL_UART_CLEAR_IDLEFLAG(huart);
            HAL_UART_AbortReceive(huart);
            recv_count = MAX_UART_BUF - __HAL_DMA_GET_COUNTER(huart->hdmarx);

            // 检测是否是新的一包数据
            if (FMU_uart_buf[0] == 0xFE && FMU_uart_buf[4] == 204 && update.usebuf_flag == false)
            {
                memcpy(update.data, FMU_uart_buf, recv_count);
                update.usebuf_flag = true;
            }
            else if(FMU_uart_buf[5] == 21 && FMU_uart_buf[6] == 26 && FMU_uart_buf[7] == 3)
            {
                fmu_version_ack = true;
            }

            memset(FMU_uart_buf, 0, MAX_UART_BUF);
            HAL_UART_Receive_DMA(huart, FMU_uart_buf, MAX_UART_BUF);
        }
    }
}

uint8_t msg_buf[128] = {0};

uint32_t cur_pack_num = 0;
void send_pmu_version(void)
{
    static int time2_hz = 0;

    if (check_usart_is_ok() != true)
        return;
    if(fmu_version_ack == true)
       return;  
    if(cur_pack_num > 1)
        return;
    if(HAL_GetTick() - time2_hz > 500 && HAL_GetTick() > 2000)
        time2_hz = HAL_GetTick();
    else
        return;

    uint8_t index = 0;
    uint16_t s16 = 0;
    char sn_buf[12] = {0};
    char hardverison_buf[12] = {0};

    memset(msg_buf,0,128);

    msg_buf[index++] = 0xFE;
    msg_buf[index++] = 0;
    msg_buf[index++] = 0;
    msg_buf[index++] = 0x00;
    msg_buf[index++] = 0x00;
    msg_buf[index++] = 26;

    s16 = 3;
    memcpy(&msg_buf[index],&s16,2); //PMU设备号
    index += 2;

    msg_buf[index++] = 1;

    Int2String(pmu_sn,&sn_buf[0],12);
    Int2String(pmu_hardversion,&hardverison_buf[0],12);

    memcpy(&msg_buf[index],&sn_buf[0],10);//sn
    index += 32;
    index += 16;
    memcpy(&msg_buf[index],&hardverison_buf[0],10);//硬件日期
    index += 16;//硬件
    index += 16;//厂商

    msg_buf[1] = index - 6;
    uint16_t uart_crc = Get_Crc16(msg_buf, index);
    memcpy(&msg_buf[index], &uart_crc, 2);
    index += 2;

    uart2_send_msg(msg_buf, index);

}



void Update_ack_fmu(uint8_t msg_id, uint8_t *ackbuf)
{

    int index = 0;
    msg_buf[index++] = 0xFE;
    msg_buf[index++] = 0;
    msg_buf[index++] = 0;
    msg_buf[index++] = 0x00;
    msg_buf[index++] = 204;
    msg_buf[index++] = 21;

    msg_buf[index++] = msg_id;
    msg_buf[index++] = *ackbuf;
    msg_buf[index++] = *(ackbuf + 1);
    msg_buf[index++] = 1;

    msg_buf[1] = index - 6;
    uint16_t uart_crc = Get_Crc16(msg_buf, index);
    memcpy(&msg_buf[index], &uart_crc, 2);
    index += 2;

    uart2_send_msg(msg_buf, index);
}

bool check_usart_is_ok(void)
{
    if (huart2.gState == HAL_UART_STATE_READY && (__HAL_UART_GET_FLAG(&huart2, UART_FLAG_TC) != RESET && __HAL_UART_GET_FLAG(&huart2, UART_FLAG_TXE) != RESET))
    {
    }
    else
    {
        return false;
    }
    return true;
}

uint32_t addr_offset = 0;
bool update_complete = false;
void update_function(void)
{
    uint16_t crc = Get_Crc16(update.data, (uint16_t)update.data[LEN] + 2 + 6);
    int temp_32t = 0;

    if (crc != 0 || check_usart_is_ok() != true)
    {
        update.usebuf_flag = false;
        return;
    }

    switch (update.data[MSGID_ID])
    {
    case UPDATE_START:
        memcpy(&temp_32t, &update.data[PAYLOAD], 4);
        if (temp_32t < 231424 && temp_32t > 112640) //新固件大小在110kb-226kb之间
        {
            if(cur_pack_num > 1) //中途重新升级
                HAL_NVIC_SystemReset();
            
            temp_32t = 0;
            Update_ack_fmu(UPDATE_START, (uint8_t *)&temp_32t);
            addr_offset = 0;
            cur_pack_num = 1;
        }
        break;
    case UPDATE_ING:
        if (cur_pack_num == update.data[PAYLOAD] + update.data[PAYLOAD + 1] * 256)
        {
            temp_32t = Flash_WriteData(FLASH_APP_ADDR + addr_offset, (uint16_t *)&update.data[PAYLOAD + 2], (update.data[LEN] - 2) / 2);
            if (temp_32t == WRITE_SUCCESS)
            {
                cur_pack_num++;
                addr_offset += update.data[LEN] - 2;
                Update_ack_fmu(UPDATE_ING, &update.data[PAYLOAD]);
            }
        }
        else if(cur_pack_num > update.data[PAYLOAD] + update.data[PAYLOAD + 1] * 256)
        {
            Update_ack_fmu(UPDATE_ING, &update.data[PAYLOAD]);
        }
        break;
    case UPDATE_END:
        temp_32t = 0;
        if(update_complete != true)
        {
            update_complete = wirte_update_flag();
            if(update_complete == true)
                Update_ack_fmu(UPDATE_END, (uint8_t *)&temp_32t);
            HAL_Delay(50);
        }
        break;

    default:
        break;
    }
    update.usebuf_flag = false;
    memset(update.data, 0, MAX_UART_BUF);
}

void init_usart(void)
{
    __HAL_UART_ENABLE_IT(&huart2, UART_IT_IDLE); //uart2  空闲中断
	HAL_UART_Receive_DMA(&huart2, (uint8_t *)FMU_uart_buf, MAX_UART_BUF);
	//开启错误处理机制
	__HAL_UART_ENABLE_IT(&huart2, UART_IT_ERR);
}