/*******************************************************************************
 * 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_DBG, (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;
}

/*******************************************************************************
 * 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);
        }
    }
#if 0
    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);
        }
    }
    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);
}