/*
 * Terminal.c
 *
 *  Created on: Jul 13, 2021
 *      Author: angoosh
 */
#include "Terminal.h"
#include "main.h"


void myprintf(const char *fmt, ...);
FRESULT ls_files (char*);

uint8_t pointr = 0;
uint8_t RX[1];
uint8_t termRxBuffer[TERM_BUFFER_SIZE];


FATFS FatFs; 	//Fatfs handle
FIL fil; 		//File handle
DIR dir;		//Directory handle
FRESULT fres; //Result after operations
char currentDir[128];
char lastDir[128];

UART_HandleTypeDef huart3;
RTC_HandleTypeDef hrtc;


uint8_t msgOk[] = {"\nOK\n"};
uint8_t msgBlank[] = {"> "};
uint8_t msgNoGpioPort[] = {"\nNo such GPIO port\n"};
uint8_t msgUnknownParameter[] = {"\nUnknown parameter\n"};
uint8_t msgNL = '\n';

/**
 * @brief Callback for uart byte by byte receive
 */
void HAL_UART_RxCpltCallback(UART_HandleTypeDef *huart){
	termRxBuffer[pointr] = RX[0];
	pointr++;
	HAL_UART_Receive_IT(&huart3, RX, 1);
}

/**
 * @brief Readout whole receive buffer, for debug
 */
void PrintRxBuffer(){
	for(int l = 0; l<sizeof(termRxBuffer); l++){
		HAL_UART_Transmit(&huart3, &termRxBuffer[l], 1, 0xFFFF);
		termRxBuffer[l] = 0;
	}
	pointr = 0;
}

/**
 * @brief Printf function implementation
 */
void myprintf(const char *fmt, ...) {
  static char buffer[256];
  va_list args;
  va_start(args, fmt);
  vsnprintf(buffer, sizeof(buffer), fmt, args);
  va_end(args);

  int len = strlen(buffer);
  HAL_UART_Transmit(&huart3, (uint8_t*)buffer, len, -1);
}

char dateChar[9];
char timeChar[9];

/**
 * @brief Get time function
 * @param return string containing time
 * @param return string containing date
 */
void get_time(char* timeChar, char* dateChar)
{
 RTC_DateTypeDef gDate;
 RTC_TimeTypeDef gTime;

 HAL_RTC_GetTime(&hrtc, &gTime, RTC_FORMAT_BIN);
 HAL_RTC_GetDate(&hrtc, &gDate, RTC_FORMAT_BIN);

 sprintf((char*)timeChar,"%02d:%02d:%02d",gTime.Hours, gTime.Minutes, gTime.Seconds);
 sprintf((char*)dateChar,"%02d-%02d-%2d",gDate.Date, gDate.Month, 2000 + gDate.Year);
}
/**
 * @brief Read rx buffer and parse commands
 *
 * commands:
 * mount/umount - mount unmount sd card
 * ls - list fatfs drive
 * mkdir - make fatfs directory
 * touch - create fatfs file
 * rm - remove file
 * echo - print contents of file / write to file
 * cd - change directory
 * reset - reset MCU
 * gpio - gpio operations as set, reset, input, output
 * time - print local time
 * errls - list all errors
 * errclr - clear all errors
 * help - print all commands
 */
void ReadBuffer(){

	char reset[] = {"reset"};
	char gpio[] = {"gpio"};
	char help[] = {"help"};
	char time[] = {"time"};
	char ls[] = {"ls"};
	char mount[] = {"mount"};
	char umount[] = {"umount"};
	char touch[] = {"touch"};
	char mkdir[] = {"mkdir"};
	char cd[] = {"cd"};
	char rm[] = {"rm"};
	char echo[] = {"echo"};

	for(int i = 0; i < TERM_BUFFER_SIZE; i++){
		char chachar[TERM_BUFFER_SIZE];
		for(int i = 0; i < TERM_BUFFER_SIZE; i++){
			chachar[i] = 0;
		}
		for(int j = 0; j < (TERM_BUFFER_SIZE - i); j++){
			chachar[j] = termRxBuffer[j+i];
		}
		if(chachar[0] == '\n'){}
		else if(strncmp(reset, chachar, 5) == 0){
			i+=5;
			HAL_UART_Transmit(&huart3, msgOk, 3, 0xFFFF);
			HAL_NVIC_SystemReset();
		}
		else if(strncmp(gpio, chachar, 4) == 0){
			i+=4;
			char pinStr[2];
			uint pin;
			uint pinBinary = 1;
			GPIO_InitTypeDef GPIO_ReInitStruct = {0};
			char pinState[2];

			uint8_t msgGpioHelp[] = {"\nUsage:\ngpio -[SWITCH]\n\nSwitch structure:\n-[s,r,i,o,g][GPIO port A-D][GPIO pin 0-15]\n-s GPIO set pin HIGH\n-r GPIO reset pin to LOW\n-i GPIO set pin as INPUT\n-o GPIO set pin as OUTPUT\n-g Read GPIO pin\n"};
			uint8_t msgGpioRead[] = {"\nGPIO pin state is: "};
			uint8_t msgGpioSet[] = {"\nGPIO pin set\n"};
			uint8_t msgGpioReset[] = {"\nGPIO pin reset\n"};
			uint8_t msgGpioSetIn[] = {"\nGPIO pin set input\n"};
			uint8_t msgGpioSetOut[] = {"\nGPIO pin set output\n"};

			if(chachar[5] == '-'){
				switch(chachar[6]){
				case 's':
					pinStr[0] = chachar[8];
					pinStr[1] = chachar[9];
					sscanf(pinStr, "%u", &pin);

					switch(chachar[7]){
					case 'A':
						HAL_GPIO_WritePin(GPIOA, (pinBinary << pin), 1);
						HAL_UART_Transmit(&huart3, msgGpioSet, sizeof(msgGpioSet)-1, 0xFFFF);
						break;
					case 'B':
						HAL_GPIO_WritePin(GPIOB, (pinBinary << pin), 1);
						HAL_UART_Transmit(&huart3, msgGpioSet, sizeof(msgGpioSet)-1, 0xFFFF);
						break;
					case 'C':
						HAL_GPIO_WritePin(GPIOC, (pinBinary << pin), 1);
						HAL_UART_Transmit(&huart3, msgGpioSet, sizeof(msgGpioSet)-1, 0xFFFF);
						break;
					case 'D':
						HAL_GPIO_WritePin(GPIOD, (pinBinary << pin), 1);
						HAL_UART_Transmit(&huart3, msgGpioSet, sizeof(msgGpioSet)-1, 0xFFFF);
						break;
					default:
						HAL_UART_Transmit(&huart3, msgNoGpioPort, sizeof(msgNoGpioPort)-1, 0xFFFF);
						break;
					}
					break;
				case 'r':
					pinStr[0] = chachar[8];
					pinStr[1] = chachar[9];
					sscanf(pinStr, "%u", &pin);

					switch(chachar[7]){
					case 'A':
						HAL_GPIO_WritePin(GPIOA, (pinBinary << pin), 0);
						HAL_UART_Transmit(&huart3, msgGpioReset, sizeof(msgGpioReset)-1, 0xFFFF);
						break;
					case 'B':
						HAL_GPIO_WritePin(GPIOB, (pinBinary << pin), 0);
						HAL_UART_Transmit(&huart3, msgGpioReset, sizeof(msgGpioReset)-1, 0xFFFF);
						break;
					case 'C':
						HAL_GPIO_WritePin(GPIOC, (pinBinary << pin), 0);
						HAL_UART_Transmit(&huart3, msgGpioReset, sizeof(msgGpioReset)-1, 0xFFFF);
						break;
					case 'D':
						HAL_GPIO_WritePin(GPIOD, (pinBinary << pin), 0);
						HAL_UART_Transmit(&huart3, msgGpioReset, sizeof(msgGpioReset)-1, 0xFFFF);
						break;
					default:
						HAL_UART_Transmit(&huart3, msgNoGpioPort, sizeof(msgNoGpioPort)-1, 0xFFFF);
						break;
					}
					break;
				case 'i':
					pinStr[0] = chachar[8];
					pinStr[1] = chachar[9];
					sscanf(pinStr, "%u", &pin);

					GPIO_ReInitStruct.Pin = (pinBinary << pin);
					GPIO_ReInitStruct.Mode = GPIO_MODE_INPUT;
					GPIO_ReInitStruct.Pull = GPIO_PULLUP;
					GPIO_ReInitStruct.Speed = GPIO_SPEED_FREQ_LOW;

					switch(chachar[7]){
					case 'A':
						HAL_GPIO_DeInit(GPIOA, (pinBinary << pin));
						HAL_GPIO_Init(GPIOA, &GPIO_ReInitStruct);
						HAL_UART_Transmit(&huart3, msgGpioSetIn, sizeof(msgGpioSetIn)-1, 0xFFFF);
						break;
					case 'B':
						HAL_GPIO_DeInit(GPIOB, (pinBinary << pin));
						HAL_GPIO_Init(GPIOB, &GPIO_ReInitStruct);
						HAL_UART_Transmit(&huart3, msgGpioSetIn, sizeof(msgGpioSetIn)-1, 0xFFFF);
						break;
					case 'C':
						HAL_GPIO_DeInit(GPIOC, (pinBinary << pin));
						HAL_GPIO_Init(GPIOC, &GPIO_ReInitStruct);
						HAL_UART_Transmit(&huart3, msgGpioSetIn, sizeof(msgGpioSetIn)-1, 0xFFFF);
						break;
					case 'D':
						HAL_GPIO_DeInit(GPIOD, (pinBinary << pin));
						HAL_GPIO_Init(GPIOD, &GPIO_ReInitStruct);
						HAL_UART_Transmit(&huart3, msgGpioSetIn, sizeof(msgGpioSetIn)-1, 0xFFFF);
						break;
					default:
						HAL_UART_Transmit(&huart3, msgNoGpioPort, sizeof(msgNoGpioPort)-1, 0xFFFF);
						break;
					}
					break;
				case 'o':
					pinStr[0] = chachar[8];
					pinStr[1] = chachar[9];
					sscanf(pinStr, "%u", &pin);

					GPIO_ReInitStruct.Pin = (pinBinary << pin);
					GPIO_ReInitStruct.Mode = GPIO_MODE_OUTPUT_PP;
					GPIO_ReInitStruct.Pull = GPIO_NOPULL;
					GPIO_ReInitStruct.Speed = GPIO_SPEED_FREQ_LOW;

					switch(chachar[7]){
					case 'A':
						HAL_GPIO_DeInit(GPIOA, (pinBinary << pin));
						HAL_GPIO_Init(GPIOA, &GPIO_ReInitStruct);
						HAL_UART_Transmit(&huart3, msgGpioSetOut, sizeof(msgGpioSetOut)-1, 0xFFFF);
						break;
					case 'B':
						HAL_GPIO_DeInit(GPIOB, (pinBinary << pin));
						HAL_GPIO_Init(GPIOB, &GPIO_ReInitStruct);
						HAL_UART_Transmit(&huart3, msgGpioSetOut, sizeof(msgGpioSetOut)-1, 0xFFFF);
						break;
					case 'C':
						HAL_GPIO_DeInit(GPIOC, (pinBinary << pin));
						HAL_GPIO_Init(GPIOC, &GPIO_ReInitStruct);
						HAL_UART_Transmit(&huart3, msgGpioSetOut, sizeof(msgGpioSetOut)-1, 0xFFFF);
						break;
					case 'D':
						HAL_GPIO_DeInit(GPIOD, (pinBinary << pin));
						HAL_GPIO_Init(GPIOD, &GPIO_ReInitStruct);
						HAL_UART_Transmit(&huart3, msgGpioSetOut, sizeof(msgGpioSetOut)-1, 0xFFFF);
						break;
					default:
						HAL_UART_Transmit(&huart3, msgNoGpioPort, sizeof(msgNoGpioPort)-1, 0xFFFF);
						break;
					}
					break;
				case 'g':
					pinStr[0] = chachar[8];
					pinStr[1] = chachar[9];
					sscanf(pinStr, "%u", &pin);

					switch(chachar[7]){
					case 'A':
						sprintf(pinState, "%u", HAL_GPIO_ReadPin(GPIOA, (pinBinary << pin)));
						HAL_UART_Transmit(&huart3, msgGpioRead, sizeof(msgGpioRead)-1, 0xFFFF);
						HAL_UART_Transmit(&huart3, pinState, 1, 0xFFFF);
						HAL_UART_Transmit(&huart3, &msgNL, sizeof(msgNL), 0xFFFF);
						break;
					case 'B':
						sprintf(pinState, "%u", HAL_GPIO_ReadPin(GPIOB, (pinBinary << pin)));
						HAL_UART_Transmit(&huart3, msgGpioRead, sizeof(msgGpioRead)-1, 0xFFFF);
						HAL_UART_Transmit(&huart3, pinState, 1, 0xFFFF);
						HAL_UART_Transmit(&huart3, &msgNL, sizeof(msgNL), 0xFFFF);
						break;
					case 'C':
						sprintf(pinState, "%u", HAL_GPIO_ReadPin(GPIOC, (pinBinary << pin)));
						HAL_UART_Transmit(&huart3, msgGpioRead, sizeof(msgGpioRead)-1, 0xFFFF);
						HAL_UART_Transmit(&huart3, pinState, 1, 0xFFFF);
						HAL_UART_Transmit(&huart3, &msgNL, sizeof(msgNL), 0xFFFF);
						break;
					case 'D':
						sprintf(pinState, "%u", HAL_GPIO_ReadPin(GPIOD, (pinBinary << pin)));
						HAL_UART_Transmit(&huart3, msgGpioRead, sizeof(msgGpioRead)-1, 0xFFFF);
						HAL_UART_Transmit(&huart3, pinState, 1, 0xFFFF);
						HAL_UART_Transmit(&huart3, &msgNL, sizeof(msgNL), 0xFFFF);
						break;
					default:
						HAL_UART_Transmit(&huart3, msgNoGpioPort, sizeof(msgNoGpioPort)-1, 0xFFFF);
						break;
					}
					break;
				case 'h':
					HAL_UART_Transmit(&huart3, msgGpioHelp, sizeof(msgGpioHelp)-1, 0xFFFF);
					break;
				default:
					HAL_UART_Transmit(&huart3, msgUnknownParameter, sizeof(msgUnknownParameter)-1, 0xFFFF);
					break;
				}
			}
			HAL_UART_Transmit(&huart3, msgBlank, sizeof(msgBlank)-1, 0xFFFF);
		}
		else if(strncmp(help, chachar, 4) == 0){
			i+=4;
			uint8_t msgHelp[] = {"\ncommands:\n\
* mount/umount - mount unmount sd card\n\
* ls - list fatfs drive\n\
* mkdir - make fatfs directory\n\
* touch - create fatfs file\n\
* rm - remove file\n\
* echo - print contents of file / write to file\n\
* cd - change directory\n\
* reset - reset MCU\n\
* gpio - gpio operations as set, reset, input, output\n\
* time - print local time\n\
* errls - list all errors\n\
* errclr - clear all errors\n\
* help - print all commands\n"};
			HAL_UART_Transmit(&huart3, msgHelp, sizeof(msgHelp)-1, 0xFFFF);
			HAL_UART_Transmit(&huart3, msgBlank, sizeof(msgBlank)-1, 0xFFFF);
		}
		else if(strncmp(time, chachar, 4) == 0){
			i+=4;
			uint8_t msgSystime[] = {"\nSystem time: "};
			uint8_t msgSysdate[] = {"\nSystem date: "};

			get_time(timeChar, dateChar);
			HAL_UART_Transmit(&huart3, msgSystime, sizeof(msgSystime)-1, 0xFFFF);
			HAL_UART_Transmit(&huart3, timeChar, sizeof(timeChar)-1, 0xFFFF);
			HAL_UART_Transmit(&huart3, msgSysdate, sizeof(msgSysdate)-1, 0xFFFF);
			HAL_UART_Transmit(&huart3, dateChar, sizeof(dateChar)-1, 0xFFFF);
			HAL_UART_Transmit(&huart3, &msgNL, sizeof(msgNL), 0xFFFF);
			HAL_UART_Transmit(&huart3, msgBlank, sizeof(msgBlank)-1, 0xFFFF);
		}
		else if(strncmp(mount, chachar, 5) == 0){
			i+=5;
			strcpy(currentDir, "/");
			fres = f_mount(&FatFs, "/", 1); //1=mount now
			if (fres != FR_OK) {
				myprintf("\nf_mount error (%i)\r\n> ", fres);
			}
			else{
				myprintf("\nMMC mounted\n> ");
			}
		}
		else if(strncmp(umount, chachar, 6) == 0){
			i+=6;
			f_mount(NULL, "", 0);
			myprintf("\nMMC unmounted\n> ");
		}
		else if(strncmp(ls, chachar, 2) == 0){
			i+=2;
			myprintf("\n");
			char buff[256];
			strcpy(buff, currentDir);
			fres = ls_files(buff);
			myprintf("\n> ");
		}
		else if(strncmp(touch, chachar, 5) == 0){
			i+=5;
			char filename[64];
			char filebuff[64];
			for(int j = 0; j < 64; j++){
				filename[j] = 0;
				filebuff[j] = 0;
			}
			for(int j = 0; j < 64; j++){
				if(chachar[6+j] != 0){
					filebuff[j] = chachar[6+j];
				}
			}
			sscanf(filebuff, "%s", filename);
			fres = f_open(&fil, filename, FA_CREATE_NEW);
			myprintf("\nFile created\n> ");
			f_close(&fil);
		}
		else if(strncmp(mkdir, chachar, 5) == 0){
			i+=5;
			char dirname[64];
			char dirbuff[64];
			for(int j = 0; j < 64; j++){
				dirname[j] = 0;
				dirbuff[j] = 0;
			}
			for(int j = 0; j < 64; j++){
				if(chachar[6+j] != 0){
					dirbuff[j] = chachar[6+j];
				}
			}
			sscanf(dirbuff, "%s", dirname);
			fres = f_mkdir(dirname);
			myprintf("\nDirectory created\n> ");
		}
		else if(strncmp(cd, chachar, 2) == 0){
			i+=2;
			char path[64];
			char pathbuff[64];
			for(int j = 0; j < 64; j++){
				path[j] = 0;
				pathbuff[j] = 0;
			}
			for(int j = 0; j < 64; j++){
				if(chachar[2+j] != 0){
					pathbuff[j] = chachar[2+j];
				}
			}
			sscanf(pathbuff, "%s", path);
			fres = f_chdir(path);
			if(fres == FR_OK){
				myprintf("\nDirectory changed\n> ");
				strcpy(currentDir, path);
			}
			else{
				myprintf("\nf_mount error (%i)\r\n> ", fres);
			}
		}
		else if(strncmp(rm, chachar, 2) == 0){
			i+=2;
			char path[64];
			char pathbuff[64];
			for(int j = 0; j < 64; j++){
				path[j] = 0;
				pathbuff[j] = 0;
			}
			for(int j = 0; j < 64; j++){
				if(chachar[2+j] != 0){
					pathbuff[j] = chachar[2+j];
				}
			}
			sscanf(pathbuff, "%s", path);
			fres = f_unlink(path);
			if(fres == FR_OK){
				myprintf("\nRemoved\n> ");
			}
			else{
				myprintf("\nf_mount error (%i)\r\n> ", fres);
			}
		}
		else if(strncmp(echo, chachar, 4) == 0){
			char srcbuff[256];
			char destbuff[256];
			char dest[256];
			char src[256];
			uint8_t srcSize = 0;

			for(int j = 0; j < 256; j++){
				srcbuff[j] = 0;
				destbuff[j] = 0;
			}

			if(chachar[5] != 0){
				for(int j = 0; j < 250; j++){
					if(chachar[6+j] != '"'){
						srcbuff[j] = chachar[6+j];
						srcSize++;
					}
					else{
						break;
					}
				}
				for(int j = 0; j < (251-3-srcSize); j++){
					if(chachar[6+srcSize+j] != 0){
						destbuff[j] = chachar[6+3+srcSize+j];
					}
				}
				sscanf(destbuff, "%s", dest);
				if(chachar[6+srcSize+2] == '>'){
					fres = f_open(&fil, dest, FA_OPEN_APPEND | FA_WRITE);
					if(fres == FR_OK){
						int len = strlen(srcbuff);
						uint bytesWrote;
						fres = f_puts(srcbuff, &fil);
						if(fres > 0){
							myprintf("\nSuccess\n> ");
							fres = f_putc('\n', &fil);
							f_close(&fil);
						}
						else{
							myprintf("\f_write error (%i)\r\n> ", fres);
						}
					}
					else{
						myprintf("\nf_open error (%i)\r\n> ", fres);
					}

				}
				else if(chachar[6+srcSize+2] == 0){
					sscanf(srcbuff, "%s", src);
					fres = f_open(&fil, src, FA_READ);
					if(fres == FR_OK){
						char readBuffer[256];
						for(int j = 0; j < 256; j++){
							readBuffer[j] = 0;
						}
						TCHAR * ptrchck = 1;
						while(ptrchck != NULL){
							ptrchck = f_gets((TCHAR*)readBuffer,256,&fil);
							myprintf("%s", readBuffer);
						}
						f_close(&fil);
						myprintf("\n> ");
					}
					else{
						myprintf("\nFile: %s", src);
						myprintf("\nf_open error (%i)\r\n> ", fres);
					}
				}
				else{
					myprintf("\n %d %d", chachar[6+srcSize+2], srcSize);
					myprintf("\nNothing to echo\n> ");
				}
			}
			else{
				myprintf("\nNothing to echo\n> ");
			}
		}
	}
	for(int i = 0; i < TERM_BUFFER_SIZE; i++){
		termRxBuffer[i] = 0;
	}
}

/**
 * @brief Initialize terminal
 */
void TerminalInit(){
	uint8_t msgWelcome[] = {"\nWelcome to terminal utility by Angoosh\nLIBRARY VERSION: "};
	uint8_t msgTermVersion[] = {LIB_VERSION};
	uint8_t msgSwVerHeader[] = {"\nSOFTWARE VERSION: "};
#ifdef SOFTWARE_VERSION
	uint8_t msgSoftwareVersion[] = ;
#else
	uint8_t msgSoftwareVersion[] = {"unknown"};
#endif
	uint8_t msgTalk[] = {"\n\nFor list of avaiable commands type help"};

	HAL_UART_Transmit(&huart3, msgWelcome, sizeof(msgWelcome)-1, 0xFFFF);
	HAL_UART_Transmit(&huart3, msgTermVersion, sizeof(msgTermVersion)-1, 0xFFFF);
	HAL_UART_Transmit(&huart3, msgSwVerHeader, sizeof(msgSwVerHeader)-1, 0xFFFF);
	HAL_UART_Transmit(&huart3, msgSoftwareVersion, sizeof(msgSoftwareVersion)-1, 0xFFFF);
	HAL_UART_Transmit(&huart3, msgTalk, sizeof(msgTalk)-1, 0xFFFF);
	HAL_UART_Transmit(&huart3, &msgNL, sizeof(msgNL), 0xFFFF);
	HAL_UART_Transmit(&huart3, &msgNL, sizeof(msgNL), 0xFFFF);
	HAL_UART_Transmit(&huart3, msgBlank, sizeof(msgBlank)-1, 0xFFFF);
}


//FATFS

/**
 * @brief list files
 */
FRESULT ls_files (
    char* path        /* Start node to be scanned (***also used as work area***) */
)
{
    FRESULT res;
    DIR dir;
    UINT i;
    static FILINFO fno;


    res = f_opendir(&dir, path);                       /* Open the directory */
    if (res == FR_OK) {
        for (;;) {
            res = f_readdir(&dir, &fno);                   /* Read a directory item */
            if (res != FR_OK || fno.fname[0] == 0) break;  /* Break on error or end of dir */
            if (fno.fattrib & AM_DIR) {                    /* It is a directory */
                i = strlen(path);
                sprintf(&path[i], "/%s", fno.fname);
                res = ls_files(path);                    /* Enter the directory */
                if (res != FR_OK) break;
                path[i] = 0;
            } else {                                       /* It is a file. */
                myprintf("%s/%s\n", path, fno.fname);
            }
        }
        f_closedir(&dir);
    }

    return res;
}