/*******************************************************************************
 * File Name         : DBG.c
 * Description       :
 * Created on        : 2018��7��23��
 * Author            : �ż�
 *******************************************************************************/

/*******************************************************************************
 *                              Include Files                                  *
 *******************************************************************************/
#include "stdio.h"
#include "stdarg.h"
#include "string.h"
#include "HIDO_VLQueue.h"
#include "HIDO_Input.h"
#include "HIDO_Timer.h"
#include "HIDO_Util.h"
#include "Uart.h"
#include "DBG.h"
#include "stm32h7xx_hal.h"

/*******************************************************************************
 *                                  Macro                                      *
 *******************************************************************************/
#define OUTPUT_BUF_SIZE 512
#define DBG_UART_RX_BUF_SIZE 2048
#define DBG_UART_TX_BUF_SIZE 2048
#define DBG_UART_TX_QUEUE_MEMBER_CNT 64

/*******************************************************************************
 *                             Local Variable                                  *
 *******************************************************************************/
static HIDO_InputStruct l_stSerialInput = {0};

static HIDO_UINT8 l_au8DBGUartRxBuf[DBG_UART_RX_BUF_SIZE];
static HIDO_UINT8 l_au8DBGUartTxBuf[DBG_UART_TX_BUF_SIZE];

static HIDO_UINT8 l_u8DBGFlag = DBG_FLAG_ON;
static E_DBGMode l_eDBGMode = DBG_MODE_SHELL;
/*******************************************************************************
 *                        Local Function Declaration                           *
 *******************************************************************************/
static HIDO_INT32 DBG_SerialGetChar(HIDO_UINT8 *_pu8Char);
static HIDO_INT32 DBG_SerialPutString(const char *_pcString);
static HIDO_INT32 DBG_SerialPutChar(HIDO_UINT8 _u8Char);

/*******************************************************************************
 *                             Local Function                                  *
 *******************************************************************************/
/*******************************************************************************
 * Function Name     : DBG_SerialGetChar
 * Description       :
 * Input             :
 * Output            :
 * Return            :
 * Author            : �ż�
 * Modified Date:    : 2018��7��23��
 *******************************************************************************/
static HIDO_INT32 DBG_SerialGetChar(HIDO_UINT8 *_pu8Char)
{
    return Uart_GetChar(UART_ID_DBG, _pu8Char);
}

/*******************************************************************************
 * Function Name     : DBG_SerialPrintf
 * Description       :
 * Input             :
 * Output            :
 * Return            :
 * Author            : �ż�
 * Modified Date:    : 2018��7��23��
 *******************************************************************************/
static HIDO_INT32 DBG_SerialPrintf(const HIDO_CHAR *_pcFmt, ...)
{
    va_list ap;
    HIDO_CHAR acOutputBuf[OUTPUT_BUF_SIZE];

    va_start(ap, _pcFmt);
    vsnprintf(acOutputBuf, sizeof(acOutputBuf), _pcFmt, ap);
    va_end(ap);

    return Uart_Send(UART_ID_DBG, (HIDO_UINT8 *)acOutputBuf, strlen(acOutputBuf));
}

/*******************************************************************************
 * Function Name     : DBG_SerialPutString
 * Description       :
 * Input             : _pcString                          ����ַ���
 * Output            :
 * Return            : HIDO_OK                            �ɹ�
 *                     HIDO_ERR                           ʧ��
 * Author            : �ż�
 * Modified Date:    : 2018��7��23��
 *******************************************************************************/
static HIDO_INT32 DBG_SerialPutString(const char *_pcString)
{
    HIDO_INT32 s32Ret = 0;

    s32Ret = Uart_Send(UART_ID_DBG, (HIDO_UINT8 *)_pcString, strlen(_pcString));

    return s32Ret;
}

/*******************************************************************************
 * Function Name     : DBG_SerialPutChar
 * Description       : DBG���һ���ַ�
 * Input             : _u8Char                            ����ַ�
 * Output            :
 * Return            : HIDO_OK                            �ɹ�
 *                     HIDO_ERR                           ʧ��
 * Author            : �ż�
 * Modified Date:    : 2018��7��23��
 *******************************************************************************/
static HIDO_INT32 DBG_SerialPutChar(HIDO_UINT8 _u8Char)
{
    HIDO_INT32 s32Ret = 0;

    s32Ret = Uart_Send(UART_ID_DBG, &_u8Char, 1);

    return s32Ret;
}

/*******************************************************************************
 *                             Global Function                                 *
 *******************************************************************************/
/*******************************************************************************
 * Function Name     : HIDO_Debug
 * Description       :
 * Input             :
 * Output            :
 * Return            :
 * Author            : �ż�
 * Modified Date:    : 2018��7��23��
 *******************************************************************************/
HIDO_INT32 HIDO_Debug(const HIDO_CHAR *_pcFmt, ...)
{
    if (DBG_GetMode() != DBG_MODE_SHELL)
    {
        return HIDO_OK;
    }

    va_list ap;
    HIDO_CHAR acOutputBuf[OUTPUT_BUF_SIZE];
    HIDO_UINT32 u32Len = 0;

    va_start(ap, _pcFmt);
    u32Len = vsnprintf(acOutputBuf, sizeof(acOutputBuf), _pcFmt, ap);
    va_end(ap);

    if (u32Len > (sizeof(acOutputBuf) - 1))
    {
        u32Len = sizeof(acOutputBuf) - 1;
    }

    if (strstr(acOutputBuf, "FIFO_GetFront Error") != HIDO_NULL)
    {
        return HIDO_OK;
    }

    Uart_Send(UART_ID_DBG, (HIDO_UINT8 *)acOutputBuf, u32Len);

    return HIDO_OK;
}
HIDO_INT32 HIDO_Debug2(const HIDO_CHAR *_pcFmt, ...)
{
    va_list ap;
    HIDO_CHAR acOutputBuf[OUTPUT_BUF_SIZE];
    HIDO_UINT32 u32Len = 0;

    va_start(ap, _pcFmt);
    u32Len = vsnprintf(acOutputBuf, sizeof(acOutputBuf), _pcFmt, ap);
    va_end(ap);

    if (u32Len > (sizeof(acOutputBuf) - 1))
    {
        u32Len = sizeof(acOutputBuf) - 1;
    }

    Uart_Send(UART_ID_PYTHON, (HIDO_UINT8 *)acOutputBuf, u32Len);

    return HIDO_OK;
}

/*******************************************************************************
 * Function Name     : HIDO_Debug
 * Description       :
 * Input             :
 * Output            :
 * Return            :
 * Author            : �ż�
 * Modified Date:    : 2018��7��23��
 *******************************************************************************/
HIDO_INT32 HIDO_DebugEx(const HIDO_CHAR *_pcFmt, ...)
{
    if (DBG_GetMode() != DBG_MODE_SHELL)
    {
        return HIDO_OK;
    }

    va_list ap;
    HIDO_CHAR acOutputBuf[OUTPUT_BUF_SIZE];
    HIDO_UINT32 u32Len = 0;
    // ST_RTCDateTime stRTCDateTime;

    /* �����־��ʽ */
    //    RTC_GetDateTime(&stRTCDateTime);
    //    u32Len = HIDO_UtilSnprintf(acOutputBuf, sizeof(acOutputBuf), "%04u-%02u-%02u %02u:%02u:%02u.%03u ",
    //                               stRTCDateTime.m_u16Year, stRTCDateTime.m_u8Month, stRTCDateTime.m_u8Day, stRTCDateTime.m_u8Hour,
    //                               stRTCDateTime.m_u8Min, stRTCDateTime.m_u8Sec, HAL_GetTick() % 1000);

    //    Uart_Send(UART_ID_DBG, (HIDO_UINT8 *)acOutputBuf, u32Len);

    va_start(ap, _pcFmt);
    u32Len = vsnprintf(acOutputBuf, sizeof(acOutputBuf), _pcFmt, ap);
    va_end(ap);

    if (u32Len > (sizeof(acOutputBuf) - 1))
    {
        u32Len = sizeof(acOutputBuf) - 1;
    }

    Uart_Send(UART_ID_DBG, (HIDO_UINT8 *)acOutputBuf, u32Len);

    return HIDO_OK;
}

HIDO_INT32 DBG_Printf(const HIDO_CHAR *_pcFmt, ...)
{
    va_list ap;
    HIDO_CHAR acOutputBuf[OUTPUT_BUF_SIZE];
    HIDO_UINT32 u32Len = 0;

    va_start(ap, _pcFmt);
    u32Len = vsnprintf(acOutputBuf, sizeof(acOutputBuf), _pcFmt, ap);
    va_end(ap);

    if (u32Len > (sizeof(acOutputBuf) - 1))
    {
        u32Len = sizeof(acOutputBuf) - 1;
    }

    return Uart_Send(UART_ID_DBG, (HIDO_UINT8 *)acOutputBuf, u32Len);
}

/*******************************************************************************
 * Function Name     : HIDO_DebugHex
 * Description       :
 * Input             :
 * Output            :
 * Return            :
 * Author            : �ż�
 * Modified Date:    : 2018��7��23��
 *******************************************************************************/
HIDO_INT32 HIDO_DebugHex(const HIDO_UINT8 *_pu8Data, HIDO_UINT32 _u32Len)
{
    if (DBG_GetMode() != DBG_MODE_SHELL)
    {
        return HIDO_OK;
    }

    HIDO_UINT32 u32Len = 0;
    HIDO_CHAR acOutputBuf[64];

    if (l_u8DBGFlag != DBG_FLAG_ON)
    {
        return HIDO_OK;
    }

    do
    {
        if (_u32Len > 16)
        {
            u32Len = 16;
        }
        else
        {
            u32Len = _u32Len;
        }

        memset(acOutputBuf, 0, sizeof(acOutputBuf));
        HIDO_UtilByteArrayToHexString(_pu8Data, u32Len, acOutputBuf, sizeof(acOutputBuf), HIDO_TRUE);
        strcat(acOutputBuf, "\r\n");
        Uart_Send(UART_ID_DBG, (HIDO_UINT8 *)acOutputBuf, strlen(acOutputBuf));

        _u32Len -= u32Len;
        _pu8Data += u32Len;
    } while (_u32Len != 0);

    return HIDO_OK;
}

/*******************************************************************************
 * Function Name     : HIDO_DebugString
 * Description       :
 * Input             :
 * Output            :
 * Return            :
 * Author            : �ż�
 * Modified Date:    : 2018��7��23��
 *******************************************************************************/
HIDO_INT32 HIDO_DebugString(const HIDO_CHAR *_pu8String, HIDO_UINT32 _u32StringLen)
{
    if (DBG_GetMode() != DBG_MODE_SHELL)
    {
        return HIDO_OK;
    }

#if 0
    HIDO_CHAR acOutputBuf[64];
    HIDO_UINT32 u32Len = 0;
    ST_RTCDateTime stRTCDateTime;

    /* �����־��ʽ */
    RTC_GetDateTime(&stRTCDateTime);
    u32Len = HIDO_UtilSnprintf(acOutputBuf, sizeof(acOutputBuf), "%04u-%02u-%02u %02u:%02u:%02u.%03u ",
            stRTCDateTime.m_u16Year, stRTCDateTime.m_u8Month, stRTCDateTime.m_u8Day, stRTCDateTime.m_u8Hour,
            stRTCDateTime.m_u8Min, stRTCDateTime.m_u8Sec, HAL_GetTick() % 1000);
    
    Uart_Send(UART_ID_DBG, (HIDO_UINT8 *) acOutputBuf, u32Len);
#endif
    return Uart_Send(UART_ID_DBG, (HIDO_UINT8 *)_pu8String, _u32StringLen);
}

/*******************************************************************************
 * Function Name     : DBG_SetDebugFlag
 * Description       :
 * Input             :
 * Output            :
 * Return            :
 * Author            : �ż�
 * Modified Date:    : 2018��7��23��
 *******************************************************************************/
HIDO_VOID DBG_SetDebugFlag(HIDO_UINT8 _u8Flag)
{
    l_u8DBGFlag = _u8Flag;
}

/*******************************************************************************
 * Function Name     : DBG_SetMode
 * Description       :
 * Input             :
 * Output            :
 * Return            :
 * Author            : �ż�
 * Modified Date:    : 2018��7��23��
 *******************************************************************************/
HIDO_INT32 DBG_SetMode(E_DBGMode _eMode)
{
    l_eDBGMode = _eMode;

    return HIDO_OK;
}

/*******************************************************************************
 * Function Name     : DBG_SetDebugFlag
 * Description       :
 * Input             :
 * Output            :
 * Return            :
 * Author            : �ż�
 * Modified Date:    : 2018��7��23��
 *******************************************************************************/
E_DBGMode DBG_GetMode(void)
{
    return l_eDBGMode;
}

#ifdef __APP_CODE__

// �������
#define MAX_PACKET_SIZE 1000
#define TIMEOUT_MS 100

typedef struct
{
    uint8_t buffer[MAX_PACKET_SIZE];
    uint16_t length;
    uint32_t last_receive_time;
    uint8_t packet_ready;
} uart_packet_t;

static uart_packet_t g_uart_packet = {0};

//// ��ʼ������ṹ
//void uart_packet_init(void)
//{
//    memset(&g_uart_packet, 0, sizeof(g_uart_packet));
//    g_uart_packet.last_receive_time = HIDO_TimerGetTick();
//    lora_uart_receiver_init();
//}

// ��鳬ʱ�������������ݰ�
void check_timeout_and_process(void)
{
    uint32_t current_time = HIDO_TimerGetTick();

    // ����Ƿ�ʱ�һ�����������
    if ((g_uart_packet.length > 0) &&
        ((current_time - g_uart_packet.last_receive_time) >= TIMEOUT_MS))
    {

        // ������ݰ�����
        g_uart_packet.packet_ready = 1;

        // ������Ե��ô������������磺
        // process_uart_packet(g_uart_packet.buffer, g_uart_packet.length);

        UDPClient_Uploadhex(g_uart_packet.buffer, g_uart_packet.length);
        // ���û�������׼��������һ�����ݰ�
        g_uart_packet.length = 0;
    }
}

//// ��ѭ���еĴ������ݴ�������
// void uart_data_handler(void)
//{
//     uint8_t u8RecvChar;
//
//     // ��鳬ʱ
//     check_timeout_and_process();
//
//     // ��ѯ��ȡ��������
//     while (Uart_GetChar(UART_ID_DBG, &u8RecvChar) == HIDO_OK) {
//         // ����������ʱ��
//         g_uart_packet.last_receive_time = HIDO_TimerGetTick();
//
//         // ��黺�����Ƿ�����
//         if (g_uart_packet.length < MAX_PACKET_SIZE) {
//             // �洢���յ����ַ�
//             g_uart_packet.buffer[g_uart_packet.length++] = u8RecvChar;
//
//         } else {
//             // �������������
//             printf("Buffer overflow!\n");
//             g_uart_packet.length = 0; // ��ջ�����
//         }
//     }
// }

#endif
uint8_t chargedbg_flag;
HIDO_VOID DBG_Poll(void)
{
    // ��5V�����ʱ��Ĭ���Ǹ����Կ�
    if (DBG_GetMode() == DBG_MODE_SHELL)
    {
        HIDO_InputPoll();
    }
    else if (DBG_GetMode() == DBG_MODE_GPS)
    {
        static HIDO_UINT32 l_u32ModeTick = 0;
        HIDO_UINT8 u8RecvChar = 0;
        UART_HandleTypeDef *pstUartHandle = HIDO_NULL;

        Uart_GetHandle(UART_ID_GPS, (HIDO_VOID **)&pstUartHandle);

        while (Uart_GetChar(UART_ID_DBG, &u8RecvChar) == HIDO_OK)
        {
            if (u8RecvChar == 0x03)
            {
                if (l_u32ModeTick != 0)
                {
                    if (HIDO_TimerGetTick() - l_u32ModeTick > 200)
                    {
                        DBG_SetMode(DBG_MODE_SHELL);
                    }
                }
                else
                {
                    l_u32ModeTick = HIDO_TimerGetTick();
                }
            }
            else
            {
                l_u32ModeTick = 0;
            }
            HAL_UART_Transmit(pstUartHandle, &u8RecvChar, 1, 1000);
        }
    }
    else if (DBG_GetMode() == DBG_MODE_CFG)
    {
        static HIDO_UINT32 l_u32ModeTick = 0;
        ;
        HIDO_UINT8 u8RecvChar = 0;
        UART_HandleTypeDef *pstUartHandle = HIDO_NULL;

        Uart_GetHandle(UART_ID_GPS, (HIDO_VOID **)&pstUartHandle);

        while (Uart_GetChar(UART_ID_DBG, &u8RecvChar) == HIDO_OK)
        {
            if (u8RecvChar == 0x03)
            {
                if (l_u32ModeTick != 0)
                {
                    if (HIDO_TimerGetTick() - l_u32ModeTick > 200)
                    {
                        chargedbg_flag = 1;
                        DBG_SetMode(DBG_MODE_SHELL);
                    }
                }
                else
                {
                    l_u32ModeTick = HIDO_TimerGetTick();
                }
            }
            else
            {
                l_u32ModeTick = 0;
            }
            UsartParseDataHandler(u8RecvChar);
            // HAL_UART_Transmit(pstUartHandle, &u8RecvChar, 1, 1000);
        }
    }
    else if (DBG_GetMode() == DBG_MODE_CHARGE)
    {
        static HIDO_UINT32 l_u32ModeTick = 0;
        ;
        HIDO_UINT8 u8RecvChar = 0;
        UART_HandleTypeDef *pstUartHandle = HIDO_NULL;
        while (Uart_GetChar(UART_ID_DBG, &u8RecvChar) == HIDO_OK)
        {
            if (u8RecvChar == 0x03)
            {
                if (l_u32ModeTick != 0)
                {
                    if (HIDO_TimerGetTick() - l_u32ModeTick > 200)
                    {
                        chargedbg_flag = 1;
                        DBG_SetMode(DBG_MODE_SHELL);
                    }
                }
                else
                {
                    l_u32ModeTick = HIDO_TimerGetTick();
                }
            }
            else
            {
                l_u32ModeTick = 0;
            }
            UsartParseDataHandler(u8RecvChar);
            // HAL_UART_Transmit(pstUartHandle, &u8RecvChar, 1, 1000);
        }
    }
#if 0
    else if (DBG_GetMode() == DBG_MODE_LORAWAN)
    {
        static HIDO_UINT32 l_u32ModeTick = 0;
        ;
        HIDO_UINT8 u8RecvChar = 0;
        UART_HandleTypeDef *pstUartHandle = HIDO_NULL;
        check_timeout_and_process();
        while (Uart_GetChar(UART_ID_DBG, &u8RecvChar) == HIDO_OK)
        {
            lora_uart_receive_byte(u8RecvChar);
            if (g_com_map[MODBUS_MODE] == 1)
            {
                g_uart_packet.last_receive_time = HIDO_TimerGetTick();

                // ��黺�����Ƿ�����
                if (g_uart_packet.length < MAX_PACKET_SIZE)
                {
                    // �洢���յ����ַ�
                    g_uart_packet.buffer[g_uart_packet.length++] = u8RecvChar;
                }
                else
                {
                    // �������������
                    printf("Buffer overflow!\n");
                    g_uart_packet.length = 0; // ��ջ�����
                }
            }
            // HAL_UART_Transmit(pstUartHandle, &u8RecvChar, 1, 1000);
        }
    }
#endif
}

/*******************************************************************************
 * Function Name     : DBG_Init
 * Description       : ���Դ�ӡ��ʼ��
 * Input             : None
 * Output            : None
 * Return            : None
 * Author            : �ż�
 * Modified Date:    : 2018��7��23��
 *******************************************************************************/
HIDO_VOID DBG_Init(void)
{
    ST_UartInit stInit;

    memset(&stInit, 0, sizeof(stInit));
    stInit.m_eRxMode = UART_RX_MODE_DMA;
    stInit.m_eTxMode = UART_TX_MODE_DMA;
    stInit.m_pu8RxBuf = l_au8DBGUartRxBuf;
    stInit.m_u32RxBufSize = DBG_UART_RX_BUF_SIZE;
    stInit.m_pu8TxBuf = l_au8DBGUartTxBuf;

    stInit.m_u32TxBufSize = DBG_UART_TX_BUF_SIZE;
    stInit.m_u32TxQueueMemberCnt = DBG_UART_TX_QUEUE_MEMBER_CNT;
    Uart_Init(UART_ID_DBG, &stInit);

    l_stSerialInput.m_fnPrintf = DBG_SerialPrintf;
    l_stSerialInput.m_fnGetc = DBG_SerialGetChar;
    l_stSerialInput.m_fnPutc = DBG_SerialPutChar;
    l_stSerialInput.m_fnPuts = DBG_SerialPutString;
    HIDO_InputRegister(&l_stSerialInput);
}