#include "app_uart.h"
#include "app_ring_buffer.h"
#include "sw_timer.h"



static uart_req_t App_Uart_Read_Req;;


static uint8_t      TxBuffer[APP_UART_TX_BUFFER_SIZE];
static uint8_t      RxBuffer[APP_UART_RX_BUFFER_SIZE];
static uint8_t      RxData;

static RING_BUFFER  Tx_RingBuffer;
static RING_BUFFER  Rx_RingBuffer;
static int32_t      UartError = E_NO_ERROR;




static void App_Uart_Interrupt_Handler(void);
static void App_Uart_Data_Transmit_Check(void);
static void App_Uart_Read_Callback_Initialization(void);
static void App_Uart_Read_Callback(uart_req_t* req, int error);


int fputc( int ch, FILE* f )
{      
    RingBuffer_Enqueue(&Tx_RingBuffer, ch);
    //UART_WriteByte(UART_App_INSTANCE, ch);
    return( ch );
}





int32_t App_Uart_Initialization(void)
{
    mxc_uart_regs_t* uart = APP_UART_INSTANCE;
    const sys_cfg_uart_t sys_uart_cfg = 
    {
        APP_UART_ALTERNATE,
        UART_FLOW_DISABLE,
    };


    /* Initialize the UART */
    uart_cfg_t cfg;
    cfg.parity = UART_PARITY_DISABLE;
    cfg.size = UART_DATA_SIZE_8_BITS;
    cfg.stop = UART_STOP_1;
    cfg.flow = UART_FLOW_CTRL_DIS;
    cfg.pol = UART_FLOW_POL_DIS;
    cfg.baud = APP_UART_BAUDRATE;

    while (!(uart->status & MXC_F_UART_STATUS_TX_EMPTY))
    { 
        ;
    }

    // Initialize the UART     
    if ((UartError = UART_Init(uart, &cfg, &sys_uart_cfg)) != E_NO_ERROR) 
    {
        return UartError;         
    }    

    if(uart == MXC_UART0)
    {
        NVIC_ClearPendingIRQ(UART0_IRQn);
        NVIC_DisableIRQ(UART0_IRQn);
        NVIC_SetVector(UART0_IRQn, App_Uart_Interrupt_Handler);
        NVIC_EnableIRQ(UART0_IRQn);
    }
    else if(uart == MXC_UART1)
    {
        NVIC_ClearPendingIRQ(UART1_IRQn);
        NVIC_DisableIRQ(UART1_IRQn);
        NVIC_SetVector(UART1_IRQn, App_Uart_Interrupt_Handler);
        NVIC_EnableIRQ(UART1_IRQn);
    }   
    
    UART_ClearFlags (uart, 0xFFFFFFFF);        
    //MXC_UART_EnableInt (uart, MXC_F_UART_REVA_INT_EN_RX_FIFO_THRESH|MXC_F_UART_REVA_INT_EN_TX_FIFO_ALMOST_EMPTY);

    RingBuffer_Initialization(&Tx_RingBuffer, true, APP_UART_TX_BUFFER_SIZE, TxBuffer);
    RingBuffer_Initialization(&Rx_RingBuffer, true, APP_UART_RX_BUFFER_SIZE, RxBuffer);

    App_Uart_Read_Callback_Initialization();
    
    SW_Timer_Callback_Register(SW_TIMER_RUN_CONTINUE, 0, App_Uart_Data_Transmit_Check);
    return E_SUCCESS;
}


static void App_Uart_Read_Callback_Initialization(void)
{
    App_Uart_Read_Req.data = &RxData;
    App_Uart_Read_Req.len = 1;
    App_Uart_Read_Req.callback = App_Uart_Read_Callback;
    UART_ReadAsync(APP_UART_INSTANCE, &App_Uart_Read_Req);
}


void App_Uart_Interrupt_Handler(void)
{
    UART_Handler(APP_UART_INSTANCE);
}


static void App_Uart_Read_Callback(uart_req_t* req, int error)
{
    RingBuffer_Enqueue(&Rx_RingBuffer, RxData);    
    App_Uart_Read_Callback_Initialization();
}

static void App_Uart_Data_Transmit_Check(void)
{
    if(RingBuffer_Get_DataSize(&Tx_RingBuffer) != 0 && UART_Busy(APP_UART_INSTANCE) != E_BUSY)
    {
        uint8_t TxData;
        RingBuffer_GetData(&Tx_RingBuffer, &TxData);
        UART_WriteByte(APP_UART_INSTANCE, TxData);
        RingBuffer_PopData(&Tx_RingBuffer);                 
    }   
}


int32_t App_Uart_Transmit(uint8_t TxData)
{
    RingBuffer_Enqueue(&Tx_RingBuffer, TxData);
    return true;
}

int32_t App_Uart_Transmit_Len(uint8_t* pTxBuffer, uint16_t TxLen)
{
    uint32_t i;
    for(i = 0 ; i < TxLen ; i++)
        App_Uart_Transmit(pTxBuffer[i]);
    return true;
}

int32_t App_Uart_Print(uint8_t* pTxBuffer)
{
    uint32_t index = 0;
    while(pTxBuffer[index] != NULL)
    {
        App_Uart_Transmit(pTxBuffer[index]);
        index++;
    }
}


int32_t App_Uart_Get_Last_Error(void)
{
    return UartError;
}

bool App_Uart_Get_Recv_Data(uint8_t* pRxData)
{
    if(RingBuffer_Get_DataSize(&Rx_RingBuffer) == 0)
        return false;
    return RingBuffer_Dequeue(&Rx_RingBuffer, pRxData);
}

int printf_none(const char *fmt, ...)
{
	return 0;
}