#include "uart_packet.h"
#include "sw_timer.h"
#include "uart1.h"
#include "driver_ds3231_basic.h"
#include "buzzer.h"
#include "action_process.h"


#define PACKET_BUFF_SIZE    100


static void Uart_Packet_Make_Process(void);
static void Uart_Packet_Process(uint8_t* pRxBuff);

static uint8_t Pack_Buff[PACKET_BUFF_SIZE];
static uint8_t Pack_Index;
static uint8_t Pack_CheckSum;
static uint8_t Pack_DataLen;

void Uart_Packet_Initialization(void)
{
    Pack_Index = 0;
    SW_Timer_Callback_Register(SW_TIMER_RUN_CONTINUE, 0, Uart_Packet_Make_Process);
}





static void Uart_Packet_Make_Process(void)
{
    if(Uart1_Get_RecvDataCount() != 0)
    {
        uint8_t RxData = Uart1_Get_RecvData();

        if(Pack_Index == PACK_INDEX_STX && RxData == STX)
        {
            Pack_Buff[Pack_Index++] = RxData;
            Pack_CheckSum = RxData;
            Pack_DataLen = 0;
        }
        else if(Pack_Index == PACK_INDEX_CMD && (RxData >= UART_CMD_SET_TIME && RxData < UART_CMD_MAX))
        {
            Pack_Buff[Pack_Index++] = RxData;
            Pack_CheckSum += RxData;
        }
        else if(Pack_Index == PACK_INDEX_LEN && RxData < (PACKET_BUFF_SIZE - PACK_INDEX_ETX))
        {
            Pack_Buff[Pack_Index++] = RxData;
            Pack_CheckSum += RxData;
            Pack_DataLen = RxData;
        }
        else if(Pack_Index == (PACK_INDEX_CHECKSUM + Pack_DataLen))
        {
            if(RxData != Pack_CheckSum)
            {
                Pack_Index = 0;
            }
            else
            {
                Pack_Buff[Pack_Index++] = RxData;
            }            
        }
        else if(Pack_Index == (PACK_INDEX_ETX + Pack_DataLen))
        {
            if(RxData != ETX)
            {
                Pack_Index = 0;
            }
            else
            {
                Pack_Buff[Pack_Index++] = RxData;
                Uart_Packet_Process(Pack_Buff);
                Pack_Index = 0;
            }
            
        }
        else if(Pack_Index >= PACK_INDEX_DATA && Pack_Index < (PACK_INDEX_DATA + Pack_DataLen))
        {
            Pack_Buff[Pack_Index++] = RxData;
            Pack_CheckSum += RxData;
        }
        else
        {
            Pack_Index = 0;
        }
    }
}


static void Uart_Packet_Process(uint8_t* pRxBuff)
{
    UART_CMD cmd = pRxBuff[PACK_INDEX_CMD];
    uint8_t DataLen = pRxBuff[PACK_INDEX_LEN];

    if(cmd == UART_CMD_SET_TIME && DataLen == 7)
    {
        uint16_t Year;
        uint8_t Month;
        uint8_t Date;
        uint8_t Hour;
        uint8_t Min;
        uint8_t Sec;
        uint8_t index = 0;
        ds3231_time_t set_time;         
        ds3231_basic_get_time(&set_time);

        Year = pRxBuff[PACK_INDEX_DATA + index++] << 8;
        Year += pRxBuff[PACK_INDEX_DATA + index++];
        Month = pRxBuff[PACK_INDEX_DATA + index++];
        Date = pRxBuff[PACK_INDEX_DATA + index++];
        Hour = pRxBuff[PACK_INDEX_DATA + index++];
        Min = pRxBuff[PACK_INDEX_DATA + index++];
        Sec = pRxBuff[PACK_INDEX_DATA + index++];

        set_time.format = DS3231_FORMAT_24H;
        set_time.year = Year;
        set_time.month = Month;
        set_time.date = Date;
        set_time.hour = Hour;
        set_time.minute = Min;
        set_time.second = Sec;       

        // year 2, mon 1, da 1 , h 1, m1, s 1
        ds3231_basic_set_time(&set_time);

        Buzzer_On(100);
    }
    else if(cmd == UART_CMD_SET_THRESHOLD && DataLen == 4)
    {
        uint16_t Max_Threshold;
        uint16_t Min_Threshold;
        uint8_t index = 0;
        
        Max_Threshold = pRxBuff[PACK_INDEX_DATA + index++] << 8;
        Max_Threshold += pRxBuff[PACK_INDEX_DATA + index++];

        Min_Threshold = pRxBuff[PACK_INDEX_DATA + index++] << 8;
        Min_Threshold += pRxBuff[PACK_INDEX_DATA + index++];

        Action_Set_MaxMin_Value(Max_Threshold, Min_Threshold);

        Buzzer_On(100);
    }






}