#include "chip.h"
#include "string.h"

#define DE		26
#define RX		27
#define TX		16

#define UART_RB_SIZE			64
#define LPC_USART       		LPC_USART1
#define LPC_IRQNUM      		UART1_IRQn
#define LPC_UARTHNDLR   		UART1_IRQHandler
#define UART_BAUDRATE 			19200

STATIC RINGBUFF_T txring, rxring;
static uint8_t rxbuff[UART_RB_SIZE], txbuff[UART_RB_SIZE];

const char inst1[] = "Blocking Test\n";
const char inst2[] = "NonBlocking Test\n";

static void delay(uint32_t cntr) {
    /* very simply delay routine */
    while(cntr>0) { /* burn some cycles */
        cntr--;
        __asm volatile("nop\n");
    }
}

static void Init_UART_PinMux(void)
{
	Chip_Clock_EnablePeriphClock(SYSCTL_CLOCK_SWM);
	Chip_Clock_SetUARTClockDiv(1);
	Chip_SWM_MovablePinAssign(SWM_U1_TXD_O, TX);    //U1 = uart1, options: 0,1,2 for LPC824
	Chip_SWM_MovablePinAssign(SWM_U1_RXD_I, RX);
	Chip_Clock_DisablePeriphClock(SYSCTL_CLOCK_SWM);

    Chip_GPIO_SetPinDIROutput(LPC_GPIO_PORT, 0, DE);
    Chip_GPIO_SetPinState(LPC_GPIO_PORT, 0, DE, false);
}

static void UART_Init(void){
	Init_UART_PinMux();

	Chip_UART_Init(LPC_USART);
	Chip_UART_ConfigData(LPC_USART, UART_CFG_DATALEN_8 | UART_CFG_PARITY_NONE | UART_CFG_STOPLEN_1);
	Chip_Clock_SetUSARTNBaseClockRate((UART_BAUDRATE * 16), true);
	Chip_UART_SetBaud(LPC_USART, UART_BAUDRATE);
	Chip_UART_Enable(LPC_USART);
	Chip_UART_TXEnable(LPC_USART);

	RingBuffer_Init(&rxring, rxbuff, 1, UART_RB_SIZE);
	RingBuffer_Init(&txring, txbuff, 1, UART_RB_SIZE);

	Chip_UART_IntEnable(LPC_USART, UART_INTEN_RXRDY);
	Chip_UART_IntDisable(LPC_USART, UART_INTEN_TXRDY);

	NVIC_EnableIRQ(LPC_IRQNUM);
	Chip_GPIO_SetPinState(LPC_GPIO_PORT, 0, DE, true);
	Chip_UART_SendBlocking(LPC_USART, inst1, sizeof(inst1));
	Chip_UART_SendRB(LPC_USART, &txring, inst2, sizeof(inst2));
	delay(0x800);
	Chip_GPIO_SetPinState(LPC_GPIO_PORT, 0, DE, false);
}

void LPC_UARTHNDLR(void)
{
	/* Want to handle any errors? Do it here. */

	/* Use default ring buffer handler. Override this with your own
	   code if you need more capability. */
	Chip_UART_IRQRBHandler(LPC_USART, &rxring, &txring);
}

void dbg(unsigned long n){//16.7
	char operator = '+';
	if(n > 4294967296/2){
		n = 4294967296 - n;
		operator = '-';
	}
	char tmp[11];
	int i = sizeof(tmp);
	for(int j = 0; j<i-1; j++){
		tmp[j] = '0';
	}

	do
	{
		tmp[--i] = '0' + n % 10;
		n /= 10;
	} while (n);
	Chip_GPIO_SetPinState(LPC_GPIO_PORT, 0, DE, true);
	Chip_UART_SendBlocking(LPC_USART, &operator, 1);
	Chip_UART_SendBlocking(LPC_USART, &tmp, sizeof(tmp));
	delay(0x800);
	Chip_GPIO_SetPinState(LPC_GPIO_PORT, 0, DE, false);
}

void dbg_nl(){
	Chip_UART_SendBlocking(DBG_USART, &"\n", 1);
}

uint8_t intToAscii(uint8_t number){
	if(number > 9){
		return number + 55;
	}
	else{
		return number + 48;
	}
}

void dbg_ASCII(uint8_t *arr, int size){ //array charu nebo char a prevede to na ascii, mysleno hlavne pro HEX
	for(int i = 0; i<size; i++){
		uint8_t lo,hi;
		lo = arr[i] & 0x0f;
		hi = (arr[i] >> 4) & 0x0f;
		hi = intToAscii(hi);
		lo = intToAscii(lo);
		Chip_UART_SendBlocking(DBG_USART, &hi, 1);
		Chip_UART_SendBlocking(DBG_USART, &lo, 1);
		Chip_UART_SendBlocking(DBG_USART, &" ", 1);
	}
	dbg_nl();
}

int main(void) {
    SystemCoreClockUpdate();

    UART_Init();

    while(1) {
    	uint8_t byte;
    	uint8_t rec[UART_RB_SIZE];

    	if(RingBuffer_IsEmpty(&rxring) != 1){
    		for(int i = 0; i<sizeof(rxring); i++){
    			Chip_UART_ReadRB(LPC_USART, &rxring, &byte, 1);
    			rec[i] = byte;
    			delay(0x10);
    		}

    		Chip_GPIO_SetPinState(LPC_GPIO_PORT, 0, DE, true);
    		Chip_UART_SendBlocking(LPC_USART, &rec, sizeof(rec));
    		delay(0x800);
    		Chip_GPIO_SetPinState(LPC_GPIO_PORT, 0, DE, false);

    		RingBuffer_Flush(&rxring); //Flush must be after sending response for @Creys hardware coz RE is enabled nonstop = sent msg is received
    	}
    }
    return 0 ;
}