#include "include.h"
#include <stdbool.h>
#include <stdlib.h>
#include <stdio.h>
#include <stdint.h>
#include <string.h>

#include <ti/sysbios/knl/Clock.h>

#include <driverlib/gpio.h>
#include <driverlib/pin_map.h>
#include <driverlib/rom.h>
#include <driverlib/sysctl.h>
#include <driverlib/timer.h>
#include <inc/hw_ints.h>
#include "inc/hw_uart.h"
#include <inc/hw_memmap.h>
#include <driverlib/uart.h>

#include "driverlib/interrupt.h"
#include "utils/uartstdio.h"
#include "utils/uartstdio.c"

///
/* XDCtools Header files */
#include <xdc/std.h>
#include <xdc/runtime/Error.h>
#include <xdc/runtime/System.h>

/* BIOS Header files */
#include <ti/sysbios/BIOS.h>
#include <ti/sysbios/gates/GateMutex.h>
#include <ti/sysbios/hal/Hwi.h>
#include <ti/sysbios/knl/Semaphore.h>
#include <ti/sysbios/knl/Task.h>

#include <stdbool.h>
#include <stdint.h>

/* driverlib Header files */
#include <inc/hw_ints.h>
#include <inc/hw_types.h>
#include <inc/hw_uart.h>

#include <driverlib/rom.h>
#include <driverlib/sysctl.h>
#include <driverlib/usb.h>
#include <inc/hw_memmap.h>
//#include <ti/drivers/UART.h>
/* usblib Header files */
#include <usblib/usb-ids.h>
#include <usblib/usblib.h>
#include <usblib/usbcdc.h>
#include <usblib/device/usbdevice.h>
#include <usblib/device/usbdcdc.h>
#include <usblib/device/usbddfu-rt.h>
#include <usblib/device/usbdcomp.h>

#include "Communication/CommunicationTask.h"


#include <utils/ustdlib.h>
#include "Common/Utilities/Utils.h"

///
#define U0_BAUDRATE 115200
//*****************************************************************************
//
// The Global parameters
//
//*****************************************************************************
int U0_expected_message_size = 0;
int U0_current_message_size = 0;
int U0_size_bar = 0;

/******************  Debug Data  **********************************************/
uint32_t Uart_tx_Counter = 0;
uint32_t Uart_rx_Counter = 0;
uint32_t Uart_rx_TotalCounter = 0;
bool UartResetProcess = false;
//uint32_t uart_INT_OECounter = 0;
//uint32_t uart_INT_BECounter = 0;
//uint32_t uart_INT_PECounter = 0;
//uint32_t uart_INT_FECounter = 0;
uint32_t uart_INT_RTCounter = 0;
uint32_t uart_INT_RXCounter = 0;

//void UART0IntHandler(void)
//uint32_t uDataLength[50] = {0};
//void * DataPointer[50]= {0};
//byte uindex = 0;
uint32_t TxuDataLength[50] = {0};
void * TxDataPointer[50]= {0};
byte Txuindex = 0;
uint8_t oldsize[4];
uint32_t udata[51];
int dataindex=0;


void UARTIntHandler(UArg arg0);

static Clock_Handle UartClock;
static Clock_Params clkParams;
//*****************************************************************************
// ManualClockHandle: clock event handler - initiates trigger for the user profile
//*****************************************************************************
#define UartClockTimeout 5000   // 5 seconds
static void UartClockHandle(UArg arg0)
{
    U0_expected_message_size =0;
    U0_size_bar = 0;

    Clock_setTimeout(UartClock, UartClockTimeout);
    Clock_start(UartClock);
}



//*****************************************************************************
//
// The UART Initialization.
//
//*****************************************************************************
#ifdef EVALUATION_BOARD
#define UART_BASE UART0_BASE
#define UART_INT INT_UART0
#else
#define UART_BASE UART0_BASE
#define UART_INT INT_UART0
#endif
void Init_U0(void)
{
    ROM_IntMasterDisable();
    UARTStdioConfig(0, U0_BAUDRATE, 120000000);

    //
    // Configure and enable UART interrupts.
    //
    ROM_UARTIntClear(UART_BASE, ROM_UARTIntStatus(UART_BASE, false));

    //MAP_UARTIntRegister(UART_INT,UARTIntHandler,0);

    /* Install interrupt handler */
    Error_Block eb;
    Error_init(&eb);
    Hwi_Handle hwi;
    hwi = Hwi_create(UART_INT, UARTIntHandler, NULL, &eb);// int number 21 Embedded.cfg
    if (hwi == NULL)
    {
        System_abort("Can't create UART Hwi");
    }

    Clock_Params_init(&clkParams);
    clkParams.period = 0;
    clkParams.startFlag = FALSE;
    UartClock = Clock_create(UartClockHandle, 0, &clkParams, NULL);
    Clock_setTimeout(UartClock, UartClockTimeout);
    Clock_start(UartClock);

//    ROM_UARTIntEnable(UART_BASE, /*UART_INT_TX |*/ UART_INT_RX );
    ROM_UARTIntEnable(UART_BASE, (UART_INT_RT |  UART_INT_RX));
//    ROM_UARTIntEnable(UART_BASE, (UART_INT_OE | UART_INT_BE | UART_INT_PE |
//          UART_INT_FE | UART_INT_RT /*| UART_INT_TX */| UART_INT_RX));

    ROM_UARTEnable(UART_BASE);

    UARTFIFODisable(UART_BASE);
    //
    // Enable interrupts now that the application is ready to start.
    //
    ROM_IntEnable(UART_INT);

    ROM_IntMasterEnable();
}
//*****************************************************************************
//
// The UART Buffers reset.
//
//*****************************************************************************
void UART_ResetBuffers(void)
{
     ROM_UARTIntClear(UART_BASE, ROM_UARTIntStatus(UART_BASE, false));
     /*
     UartResetProcess = true;
     while (UARTCharsAvail(UART_BASE)) //empty rx buffer
     {
         ;
     }
     ROM_UARTDisable(UART_BASE);
     U0_expected_message_size = 0;
     U0_current_message_size = 0;
     U0_size_bar = 0;
     SysCtlDelay(200000);
     ROM_UARTEnable(UART_BASE);
     UartResetProcess = false;
     */
}
//*****************************************************************************
//
// The UART interrupt handler.
//
//*****************************************************************************
uint32_t U0buffId = 0xFF;

void UARTIntHandler(UArg arg0)
{
    uint32_t ui32Status;
    uint8_t ui8Char;
    static uint8_t size[4];
    //
    // Get the interrrupt status.
    //
    ui32Status = ROM_UARTIntStatus(UART_BASE, true);
//    if (ui32Status&UART_INT_OE)  uart_INT_OECounter++;
//    if (ui32Status&UART_INT_BE)  uart_INT_BECounter++;
//    if (ui32Status&UART_INT_PE)  uart_INT_PECounter++;
//    if (ui32Status&UART_INT_FE)  uart_INT_FECounter++;
    if (ui32Status&UART_INT_RT)  uart_INT_RTCounter++;
    if (ui32Status&UART_INT_RX)  uart_INT_RXCounter++;

    //
    // Clear the asserted interrupts.
    //
    ROM_UARTIntClear(UART_BASE, ui32Status);

     while(ROM_UARTCharsAvail(UART_BASE))
    {
         if (U0_expected_message_size == 0)
         {
             size[U0_size_bar++] = (char)ROM_UARTCharGetNonBlocking(UART_BASE);
             Uart_rx_TotalCounter++;
             if (U0_size_bar == 4)
             {
                 U0_expected_message_size = *(int *)size;
                 udata[dataindex] = U0_expected_message_size;
                 if (dataindex++>=50)
                     dataindex=0;
                 //uDataLength[uindex] = U0_expected_message_size;
                 //if (uindex++>=50)
                 //    uindex = 0;
                 U0buffId = initArray( U0_expected_message_size);
                 if (U0buffId == 0xFF)
                     U0_expected_message_size = 0;
                 U0_size_bar = 0;
                 memcpy (oldsize,size,4);
             }
         }
         else
         {

                 ui8Char = (char)ROM_UARTCharGetNonBlocking(UART_BASE);
                 Uart_rx_TotalCounter++;
                 insertArray(U0buffId,ui8Char);
                 U0_current_message_size++;

             if (U0_current_message_size == U0_expected_message_size)
             {
                 Clock_setTimeout(UartClock, UartClockTimeout);
                 Clock_start(UartClock);
                 Uart_rx_Counter+=(4+U0_current_message_size);
                 CommunicationTaskMessageReceived(U0buffId, U0_current_message_size);
                 U0_expected_message_size = 0;
                 U0_current_message_size = 0;
                 break;
             }

         }
    }

}

//*****************************************************************************
//
// The UART Transmit handler.
//
//*****************************************************************************

uint32_t Uart_Tx(char *buffer,size_t length)
{

    size_t sentlength  = 0;
    uint8_t size[4],i =0;
    size[3] = (length>>24) & 0xFF;
    size[2] = (length>>16) & 0xFF;
    size[1] = (length>>8) & 0xFF;
    size[0] = length & 0xFF;
    //ret = UART_write(0, size, 4);
    //if (ret == 4)
    //    ret = UART_write(0, buffer, length);
    Uart_tx_Counter+=(4+length);
    while (i < 4)
    {
        if (ROM_UARTSpaceAvail(UART_BASE))
        {
            ROM_UARTCharPut(UART_BASE,size[i++]);
        }

    }

    while ((sentlength < length) && (UartResetProcess==false))
    {
        if (ROM_UARTSpaceAvail(UART_BASE))
        {
            ROM_UARTCharPut(UART_BASE,buffer[sentlength++]);
        }

    }
    TxuDataLength[Txuindex] = length+4;
    TxDataPointer[Txuindex] = buffer;
    if (Txuindex++>=50)
    Txuindex = 0;

//    if (ret!=length)
//        return 1;
    return 0;
}