#include <stdio.h>
#include "freertos/FreeRTOS.h"
#include "freertos/task.h"
#include "driver/gpio.h"
#include "esp_log.h"
#include "led_strip.h"
#include "sdkconfig.h"
#include "driver/uart.h"
#include "esp_intr_alloc.h"
#include "esp32/rom/uart.h"
#include "esp_system.h"
#include "nvs_flash.h"
#include "nvs.h"
#include "ESP32Time.h"

#define BLINK_GPIO GPIO_NUM_2

#define LEDA_PIN GPIO_NUM_15
#define LEDB_PIN GPIO_NUM_4
#define LEDC_PIN GPIO_NUM_5
#define LEDD_PIN GPIO_NUM_18

static const char *TAG = "uart_events";

#define EX_UART_NUM UART_NUM_0
#define BUF_SIZE (1024)
#define RD_BUF_SIZE (BUF_SIZE)
static intr_handle_t handle_console;
uint8_t rxbuf[256];
uint16_t urxlen;

uint8_t packet_received = 0;

#define NOTASK 0

String g_str = "";
String komut = "";
String hedef = "";
String arg1  = "";
String arg2  = "";

nvs_handle_t my_handle;
ESP32Time k_time;

void blink_task(void *pvParameter)
{
		gpio_pad_select_gpio(BLINK_GPIO);
		gpio_set_direction(BLINK_GPIO, GPIO_MODE_OUTPUT);

		gpio_pad_select_gpio(LEDA_PIN);
		gpio_set_direction(LEDA_PIN, GPIO_MODE_OUTPUT);
		gpio_pad_select_gpio(LEDB_PIN);
		gpio_set_direction(LEDB_PIN, GPIO_MODE_OUTPUT);
		gpio_pad_select_gpio(LEDC_PIN);
		gpio_set_direction(LEDC_PIN, GPIO_MODE_OUTPUT);
		gpio_pad_select_gpio(LEDD_PIN);
		gpio_set_direction(LEDD_PIN, GPIO_MODE_OUTPUT);

		while(1)
		{
				gpio_set_level(BLINK_GPIO, 0);
				vTaskDelay(1000 / portTICK_PERIOD_MS);
				gpio_set_level(BLINK_GPIO, 1);
				vTaskDelay(1000 / portTICK_PERIOD_MS);
		}
}

static void IRAM_ATTR uart_intr_handle(void *arg)
{
		uint16_t rx_fifo_len, status;
		uint16_t i;
		uint8_t rx_byte;
		status = UART0.int_st.val; // read UART interrupt Status
		rx_fifo_len = UART0.status.rxfifo_cnt; // read number of bytes in UART buffer

		while(rx_fifo_len)
		{
				rx_byte = UART0.fifo.rw_byte; // read all bytes 
				rx_fifo_len--;
				if(rx_byte==10)
				{
						packet_received = 1;
				}
				else
				{
						g_str+=(char)rx_byte;
				}
		}
		uart_clear_intr_status(EX_UART_NUM, UART_RXFIFO_FULL_INT_CLR|UART_RXFIFO_TOUT_INT_CLR);	
}
/****************************************************************************************/
void serial_task(void *pvParameter)
{
		int ret;
		esp_err_t err;

		esp_log_level_set(TAG, ESP_LOG_INFO);
		uart_config_t uart_config = {
			.baud_rate = 115200,
			.data_bits = UART_DATA_8_BITS,
			.parity = UART_PARITY_DISABLE,
			.stop_bits = UART_STOP_BITS_1,
			.flow_ctrl = UART_HW_FLOWCTRL_DISABLE
		};

		ESP_ERROR_CHECK(uart_param_config(EX_UART_NUM, &uart_config));
		esp_log_level_set(TAG, ESP_LOG_INFO);
		ESP_ERROR_CHECK(uart_set_pin(EX_UART_NUM, UART_PIN_NO_CHANGE, UART_PIN_NO_CHANGE, UART_PIN_NO_CHANGE, UART_PIN_NO_CHANGE));
		ESP_ERROR_CHECK(uart_driver_install(EX_UART_NUM, BUF_SIZE * 2, 0, 0, NULL, 0));
		ESP_ERROR_CHECK(uart_isr_free(EX_UART_NUM));
		ESP_ERROR_CHECK(uart_isr_register(EX_UART_NUM,uart_intr_handle, NULL, ESP_INTR_FLAG_IRAM, &handle_console));
		ESP_ERROR_CHECK(uart_enable_rx_intr(EX_UART_NUM));

		printf("Kamerus\n");

		while(1)
		{
				if(packet_received == 1)
				{
						int i_ptr;
						
						komut=g_str.substring(0,g_str.indexOf(' '));
						i_ptr=komut.length()+1;
						hedef=g_str.substring(i_ptr,g_str.indexOf(' ',i_ptr));
						i_ptr += hedef.length()+1;
						arg1=g_str.substring(i_ptr,g_str.indexOf(' ',i_ptr));
						i_ptr +=arg1.length()+1;
						arg2=g_str.substring(i_ptr,g_str.length());
						
						if(komut.length()>0)
						{
								if(komut.equals("NVS"))
								{
										if(hedef.equals("RD"))
										{
												if(arg1.length()>0)
												{
														int32_t restart_counter = 0; // value will default to 0, if not set yet in NVS
        										err = nvs_get_i32(my_handle, arg1.c_str(), &restart_counter);
														printf("%d",arg1.length());
														switch (err)
														{
																case ESP_OK:
																		printf("Done\n");
																		printf("arg2 = %d\n", restart_counter);
																		break;
																case ESP_ERR_NVS_NOT_FOUND:
																		printf("The value is not initialized yet!\n");
																		break;
																default :
																		printf("Error (%s) reading!\n", esp_err_to_name(err));
        										}
												}
										}
										else if(hedef.equals("WR"))
										{
												if((arg1.length()>0)&&(arg2.length()>0))
												{
														printf(arg1.c_str());
														printf(arg2.c_str());
														err = nvs_set_i32(my_handle, arg1.c_str(), arg2.toDouble());
        										printf((err != ESP_OK) ? "Failed!\n" : "Done\n");
														err = nvs_commit(my_handle);
        										printf((err != ESP_OK) ? "Failed!\n" : "Done\n");
												}
										}
										else if(hedef.equals("CLOSE"))
										{
												nvs_close(my_handle);
										}
								}
								else if(komut.equals("LED"))
								{
										if(hedef.equals("A"))
										{
												if(arg1.equals("ON\n"))					gpio_set_level(LEDA_PIN, 0);				
												else if(arg1.equals("OFF\n"))		gpio_set_level(LEDA_PIN, 1);
										}
										else if(hedef.equals("B"))
										{
												if(arg1.equals("ON\n"))					gpio_set_level(LEDB_PIN, 0);				
												else if(arg1.equals("OFF\n"))		gpio_set_level(LEDB_PIN, 1);
										}
										else if(hedef.equals("C"))
										{
												if(arg1.equals("ON\n"))					gpio_set_level(LEDC_PIN, 0);				
												else if(arg1.equals("OFF\n"))		gpio_set_level(LEDC_PIN, 1);
										}
											else if(hedef.equals("D"))
										{
												if(arg1.equals("ON\n"))					gpio_set_level(LEDD_PIN, 0);				
												else if(arg1.equals("OFF\n"))		gpio_set_level(LEDD_PIN, 1);											
										}
								}
								else if(komut.equals("RTC"))
								{
										if(hedef.equals("GET"))
										{
												printf(k_time.getTimeDate().c_str());
												printf("\n");
										}
										else if(hedef.equals("SET"))
										{
												String tmp_str;
												k_time.k_setTime(
													arg1.substring(0,2).toInt(), arg1.substring(3,5).toInt(),
													arg1.substring(6,8).toInt(), arg1.substring(9,11).toInt(),
													arg1.substring(12,14).toInt(), arg1.substring(15,19).toInt()
												);
										}
								}
						}
						g_str="";
						packet_received = 0;
				}
				vTaskDelay(50 /portTICK_PERIOD_MS);
		}
}
/****************************************************************************************/
extern "C" void app_main()
{
	    // Initialize NVS
    esp_err_t err = nvs_flash_init();
    if (err == ESP_ERR_NVS_NO_FREE_PAGES || err == ESP_ERR_NVS_NEW_VERSION_FOUND) {
        // NVS partition was truncated and needs to be erased
        // Retry nvs_flash_init
        ESP_ERROR_CHECK(nvs_flash_erase());
        err = nvs_flash_init();
    }
    ESP_ERROR_CHECK( err );

    // Open
    printf("\n");
    printf("Opening Non-Volatile Storage (NVS) handle... ");
    err = nvs_open("storage", NVS_READWRITE, &my_handle);
    if (err != ESP_OK)
		{
        printf("Error (%s) opening NVS handle!\n", esp_err_to_name(err));
    }
		else
		{
        printf("Done\n");
		}
		xTaskCreate(&serial_task, "serial_task", 4096, NULL, 5, NULL);
		xTaskCreate(&blink_task, "blink_task", configMINIMAL_STACK_SIZE, NULL, 5, NULL);
}
/****************************************************************************************/