// Compilation command:
// - release: gcc main.c -Wall -O2 -m64 -lncurses -o ttt
// - debug  : gcc main.c -Wall -g3 -m64 -lncurses -o ttt


#include <assert.h>
#include <errno.h>
#include <inttypes.h>
#include <ncurses.h>
#include <stdbool.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>

#define STR_(X) #X				// Convert to string.
#define STR(X) STR_(X)			// Force argument expansions before converting to string.

#define MAX_TASK_NAME 127
#define FIRST_DAY_OF_WEEK 1		// (0-6, Sunday = 0)

#define LOG_FILE_NAME "log.txt"
#define DB_BIN_PATH_NAME "./database.bin"
#define DB_CSV_PATH_NAME "./database.csv"




typedef struct {
	char		name[MAX_TASK_NAME+1];	// Allow space for null termination char.
	uint32_t	time[7];
	uint8_t		state;
} task_t;


const char* DB_BIN_FILE_SIGNATURE = "TTBF:1.0";
const uint8_t DB_BIN_FILE_SIGNATURE_SIZE = sizeof(DB_BIN_FILE_SIGNATURE);
const size_t SIZEOF_TASK_T = sizeof(task_t);
const char* DAYS_OF_WEEK[] = { "sun", "mon", "tue", "wed", "thu", "fri", "sat" };
const uint8_t DAYS_ON_WEEK = sizeof(DAYS_OF_WEEK)/sizeof(char*);

task_t* tasks = NULL;
uint32_t tasks_count = 0;
uint32_t tasks_capacity = 0;
uint32_t selected_task = -1;


// Given an UTF8 encoded string, truncate it to length without breaking any UTF8 character.
// The string should have, at least length number of items.
// The terminating null byte ('\0') is included in length.
// The function returns the amount of items that got discarded counting from length.
size_t truncate_string_utf8(uint8_t* string, size_t length) {
	
	size_t idx = length - 1;
	
	// Check for special case where no truncation is required.
	if (string[idx] == '\0') {
		return 0;
	}
	
	// Search for a non-UTF8-sequence-item so we can truncate the string.
	while(idx > 0 && ((string[idx] & 0xC0) == 0x80)) {
		idx--;
	}
	
	string[idx] = '\0';
	
#if DEBUG
	// TODO Check if there is a null byte before the place where we terminated the string.
	size_t idx_dbd = idx - 1;
	while(idx_dbd >= 0) {
		assert(string[idx_dbd] != '\0' && "Found unexpected null byte. The user is at fault.");
		idx_dbd--;
	}
#endif
	
	return length - idx;
}

char* replace_char(char* string, char find, char replace){
	char *idx = string;
	while((idx = strchr(idx, find)) != NULL) {
		*idx = replace;
		*idx++;
    }
    return string;
}

void print_task(const task_t* task) {
	printf("name: '%s'\n", task->name);
	printf("t[0]: '%" PRIu32 "'\n", task->time[0]);
	printf("t[1]: '%" PRIu32 "'\n", task->time[1]);
	printf("t[2]: '%" PRIu32 "'\n", task->time[2]);
	printf("t[3]: '%" PRIu32 "'\n", task->time[3]);
	printf("t[4]: '%" PRIu32 "'\n", task->time[4]);
	printf("t[5]: '%" PRIu32 "'\n", task->time[5]);
	printf("t[6]: '%" PRIu32 "'\n", task->time[6]);
}

void store_database(const task_t* database, uint32_t number_of_entries, const uint8_t* path_name) {
	
	assert(database != NULL);
	assert(path_name != NULL);
	
	// Open file.
	FILE* file = fopen(path_name, "w");
	if (file == NULL) {
		fprintf(stderr, "Failed to open database file: %s.\n", strerror(errno)); // TODO Fix message.
		return;
	}
	
	fwrite(DB_BIN_FILE_SIGNATURE, sizeof(char), DB_BIN_FILE_SIGNATURE_SIZE, file);
	fwrite(&number_of_entries, sizeof(number_of_entries), 1, file);
	fwrite(database, SIZEOF_TASK_T, number_of_entries, file);
	
	fclose(file);
}

uint32_t load_database(task_t** database, const char* path_name) {
	
	assert(database != NULL);
	assert(path_name != NULL);
	
	// Open file.
	FILE* file = fopen(path_name, "r");
	if (file == NULL) {
		fprintf(stderr, "Failed to open database file '%s': %s.\n", path_name, strerror(errno)); // TODO Fix message.
		return 0;
	}
	
	// Validate file signature.
	char file_signature[DB_BIN_FILE_SIGNATURE_SIZE];
	fread(&file_signature, sizeof(char), DB_BIN_FILE_SIGNATURE_SIZE, file);
	if (strncmp(file_signature, DB_BIN_FILE_SIGNATURE, DB_BIN_FILE_SIGNATURE_SIZE) != 0) {
		fprintf(stderr, "Invalid file signature.\n");
		return 0;
	}
	
	// Read number of entries.
	uint32_t number_of_entries;
	fread(&number_of_entries, sizeof(number_of_entries), 1, file);
	
	// Read database entries.
	*database = calloc(number_of_entries, SIZEOF_TASK_T);
	fread(*database, SIZEOF_TASK_T, number_of_entries, file);
	
	// Make sure we are reading all the file.
	assert(fgetc(file) == EOF);
	
	fclose(file);
	
	return number_of_entries;
}

void export_database(const task_t* database, uint32_t number_of_entries, const char* path_name) {
	
	assert(database != NULL);
	assert(path_name != NULL);
	
	FILE* file = fopen(path_name, "w");
	if (file == NULL) {
		fprintf(stderr, "Failed to open database file '%s': %s.\n", path_name, strerror(errno)); // TODO Fix message.
		return;
	}
	
	fprintf(file, "%s,%s,%s,%s,%s,%s,%s,%s\n",
		"task",
		DAYS_OF_WEEK[0],
		DAYS_OF_WEEK[1],
		DAYS_OF_WEEK[2],
		DAYS_OF_WEEK[3],
		DAYS_OF_WEEK[4],
		DAYS_OF_WEEK[5],
		DAYS_OF_WEEK[6]
	);
	
	for (uint32_t idx = 0; idx < number_of_entries; idx++) {
		const task_t* task = &database[idx];
		fprintf(file, "%s,%" PRIu32 ",%" PRIu32 ",%" PRIu32 ",%" PRIu32 ",%" PRIu32 ",%" PRIu32 ",%" PRIu32 "\n",
			task->name,
			task->time[0],
			task->time[1],
			task->time[2],
			task->time[3],
			task->time[4],
			task->time[5],
			task->time[6]
		);
	}
	
	fclose(file);
}

uint32_t import_database(task_t** database, const char* path_name) {
	
	assert(database != NULL);
	assert(path_name != NULL);
	
	FILE* file = fopen(path_name, "r");
	if (file == NULL) {
		fprintf(stderr, "Failed to open database file '%s': %s.\n", path_name, strerror(errno)); // TODO Fix message.
		return 0;
	}
	
	uint32_t number_of_entries = 0;
	uint32_t capacity = 0;
	task_t task;
	int error;
	
	fscanf(file, "%*[^\n]\n"); // Skip header line.
	scan_csv: {
		
		error = fscanf(file,
			"%" STR(MAX_TASK_NAME) "[^,],%" SCNu32 ",%" SCNu32 ",%" SCNu32 ",%" SCNu32 ",%" SCNu32 ",%" SCNu32 ",%" SCNu32 "\n",
			task.name,
			&task.time[0],
			&task.time[1],
			&task.time[2],
			&task.time[3],
			&task.time[4],
			&task.time[5],
			&task.time[6]
		);
		
		if (error != EOF)
		{
			number_of_entries++;
			
			// Expand tasks capacity if required.
			if (number_of_entries > capacity) {
				capacity = capacity == 0 ? 16 : capacity << 1;
				*database = realloc(*database, capacity * SIZEOF_TASK_T);
				if (errno != 0 || errno == ENOMEM) {
					; // TODO realloc failed
				}
			}
			memcpy(&((*database)[number_of_entries-1]), &task, SIZEOF_TASK_T);
			
			goto scan_csv;
		}
	}
	
	assert(number_of_entries == 3);
	*database = realloc(*database, number_of_entries * SIZEOF_TASK_T);
	// TODO check for allocation errors.
// 	if (error != EOF) {
// 		fprintf(stderr, "Failed to parse database file: %s.\n", strerror(errno));
// 	}
	
	
	fclose(file);
	
	return number_of_entries;
}


void prt(uint8_t* str, uint8_t size) { // TODO Debug function... to be removed.
	fprintf(stderr, ">");
	int count = 0;
	for (uint8_t idx = 0; idx < size; idx++) {
		if (idx % 2 == 0) {
			fprintf(stderr, " ");
		}
		fprintf(stderr, "%02x", str[idx]);
	}
	fprintf(stderr, "\n");
}

void prototype() {
	
	int count;
	uint8_t size = 20;
	uint8_t* test_string;
	test_string = calloc(size, sizeof(uint8_t));
	fprintf(stderr, "%s", "çéº𒐫\n");				// C3 A7 - C3 A9 - C2 BA - F0 92 90 AB 
	sprintf(test_string, "%s", "çéº𒐫\nxpto ");
	
	prt(test_string, size);
// 	test_string[10] = '\0';
// 	prt(test_string, size);
	uint8_t trunc = truncate_string_utf8(test_string, 3);
	prt(test_string, size);
	fprintf(stderr, ">>> %d : '%s'\n", trunc, test_string);
	
	
	FILE* file = fopen("./test.txt", "w");
	
	uint8_t length = strlen(test_string);
	fwrite(test_string, sizeof(uint8_t), length, file);
	
// 	fwrite(test_string, sizeof(uint8_t), size, file);
	
	fclose(file);
// 	truncate_string(test_string, 8);
// 	fprintf(stderr, "%s", (char*)test_string);
	return;
	
	
	
	const char* done = "# -- done -- -- -- /\n";
	
	///////////////////////////////////////////////////////////////////////////
	// Get current UTC time.
	
	fprintf(stderr, "# current UTC time --------------------------- \\\n");
	time_t x = time(NULL);
	printf("%s", ctime(&x));
	fprintf(stderr, done);
	
	
	///////////////////////////////////////////////////////////////////////////
	// Get current day of the week.
	
	fprintf(stderr, "# current day of the week --------------------- \\\n");
	time_t now_ut = time(NULL);
	uint8_t week_day = localtime(&now_ut)->tm_wday;
	fprintf(stderr, "%d\n", week_day);
	fprintf(stderr, done);
	
	
	///////////////////////////////////////////////////////////////////////////
	// Prepare some data for testing.
	
	tasks_count = 3;
	tasks = calloc(tasks_count, SIZEOF_TASK_T);
	
	task_t tmp[] = {
		{
			.name = "TASK-00 : Sample task name.",
			.time = { 3,2,1,0,1,2,3 },
		},
		{
			.name = "TASK-01 : A wild task appears",
			.time = { 1,2,3,4,5,6,7 },
		},
		{
			.name = "BAZINGA : Not a task!",
			.time = { 11,22,33,44,55,66,77 },
		}
	};	
	memcpy(tasks, &tmp, SIZEOF_TASK_T * tasks_count);
	
	
	///////////////////////////////////////////////////////////////////////////
	// Store database from memory to binary file.
	
	fprintf(stderr, "# store database ------------------------------ \\\n");
	store_database(tasks, tasks_count, DB_BIN_PATH_NAME);
	fprintf(stderr, done);
	
	
	///////////////////////////////////////////////////////////////////////////
	// Load database from binary file to memory.
	
	fprintf(stderr, "# load database ------------------------------- \\\n");
	task_t* task_load = NULL;
	uint32_t number_of_entries_load = load_database(&task_load, DB_BIN_PATH_NAME);
	
	fprintf(stderr, "loaded %" PRIu32 " entries.\n", number_of_entries_load);
	for (uint32_t idx = 0; idx < number_of_entries_load; idx++) {
		print_task(&task_load[idx]);
	}
	free(task_load);
	fprintf(stderr, done);
	
	
	///////////////////////////////////////////////////////////////////////////
	// Export database to CSV file.
	
	fprintf(stderr, "# export to CSV ------------------------------- \\\n");
	export_database(tasks, tasks_count, DB_CSV_PATH_NAME);
	fprintf(stderr, done);
	
	
	///////////////////////////////////////////////////////////////////////////
	// Import database from CSV file.
	
	fprintf(stderr, "# import from CSV ----------------------------- \\\n");
	task_t* task_import = NULL;
	uint32_t number_of_entries_import = import_database(&task_import, DB_CSV_PATH_NAME);
	
	fprintf(stderr, "imported %" PRIu32 " entries.\n", number_of_entries_import);
	for (uint32_t idx = 0; idx < number_of_entries_import; idx++) {
		print_task(&task_import[idx]);
	}
	free(task_import);
	fprintf(stderr, done);
	
	
	///////////////////////////////////////////////////////////////////////////
	// Release memory and exit.
	
// 	free(tasks);
// 	return;
}


char* line_buffer;
int size_x, size_y;
uint8_t selected_layout = 0;

#define TABLE_HEADERS_SIZE 9

typedef struct {
	int table_size;
	int table_headers_size;
	char* table_headers[TABLE_HEADERS_SIZE];
} layout_t;

layout_t* layouts = NULL;


void initialize_layouts() {
	layout_t* layout = NULL;
	
	layouts = calloc(2, sizeof(layout_t));
	
	// Layout : 0 : normal.
	layout = &layouts[0];
	layout->table_size = 8;
	layout->table_headers_size = TABLE_HEADERS_SIZE;
	// TODO Headers must be dynamic according to FIRST_DAY_OF_WEEK
	layout->table_headers[0] = " Task ";
	layout->table_headers[1] = " Mon ";
	layout->table_headers[2] = " Tue ";
	layout->table_headers[3] = " Wed ";
	layout->table_headers[4] = " Thu ";
	layout->table_headers[5] = " Fri ";
	layout->table_headers[6] = " Sat ";
	layout->table_headers[7] = " Sun ";
	layout->table_headers[8] = " Total ";
// 	layout->table_headers = { " Task ", " Mon ", " Tue ", " Wed ", " Thu ", " Fri ", " Sat ", " Sun ", " Total " };
	
	// Layout : 1 : compact.
	layout = &layouts[1];
	layout->table_size = 6;
	layout->table_headers_size = TABLE_HEADERS_SIZE;
	// TODO Headers must be dynamic according to FIRST_DAY_OF_WEEK
	layout->table_headers[0] = " Task ";
	layout->table_headers[1] = " M ";
	layout->table_headers[2] = " T ";
	layout->table_headers[3] = " W ";
	layout->table_headers[4] = " T ";
	layout->table_headers[5] = " F ";
	layout->table_headers[6] = " S ";
	layout->table_headers[7] = " S ";
	layout->table_headers[8] = "  #  ";
// 	layout->table_headers = { " T ", " M ", " T ", " W ", " T ", " F ", " S ", " S ", "  #  " };
}

void free_memory() {
	free(line_buffer);
	free(tasks); // TODO Deallocate tasks.
	free(layouts);
}

void draw_header() {
	
	layout_t* layout = &layouts[selected_layout];
	int table_size = layout->table_size;
	char** table_headers = layout->table_headers;
	
	mvaddch(0, 0, ACS_ULCORNER);
	for (int idx = 1; idx < size_x-1; idx++) {
		addch(ACS_HLINE);
	}
	addch(ACS_URCORNER);
	
	int start_columns = size_x - 1 - 8*table_size - 2;
	int columns[] = {
		0,
		start_columns+(table_size*0),
		start_columns+(table_size*1),
		start_columns+(table_size*2),
		start_columns+(table_size*3),
		start_columns+(table_size*4),
		start_columns+(table_size*5),
		start_columns+(table_size*6),
		start_columns+(table_size*7),
	};
	
	mvaddstr(0, columns[0]+2, table_headers[0]);
	for (int idx = 1; idx < 9; idx++) {
		mvaddch(0, columns[idx], ACS_TTEE);
		mvaddstr(0, columns[idx]+2, table_headers[idx]);
	}
}

void draw_table() {
	task_t* task;
	int x, y;
	
	layout_t* layout = &layouts[selected_layout];
	int table_size = layout->table_size;
	char** table_headers = layout->table_headers;
	
	// TODO Colors
	start_color();
	init_pair(1, COLOR_BLACK, COLOR_CYAN);
	
	
	int start_columns = size_x - 1 - 8*table_size - 2;
	int columns[] = {
		0,
		start_columns+(table_size*0),
		start_columns+(table_size*1),
		start_columns+(table_size*2),
		start_columns+(table_size*3),
		start_columns+(table_size*4),
		start_columns+(table_size*5),
		start_columns+(table_size*6),
		start_columns+(table_size*7),
		size_x-1,
	};
	
	move(1, 0);
	for (uint32_t idx = 0; idx < tasks_count; idx++){
		
		task = &tasks[idx];
		
		// Enable highlight color on selected entry.
		if (idx == selected_task) {
			attron(COLOR_PAIR(1));
		}
		
		// Clear line_buffer and add string termination.
		memset(line_buffer, ' ', size_x * sizeof(char));
		line_buffer[size_x-1] = '\0';
		
		// Check maximum available space for task name and print it accordingly.
		size_t task_name_length = strlen(task->name)*sizeof(char);
		size_t max_column_length = start_columns - 2;
		size_t copy_length = task_name_length < max_column_length ? task_name_length : max_column_length;
		memcpy(line_buffer+2, task->name, copy_length);
		addstr(line_buffer);

		// Disable highlight color on selected entry.
		if (idx == selected_task) {
			attroff(COLOR_PAIR(1));
		}
		
		// Print columns separators.
		getyx(stdscr,y,x);
		for (int c_idx = 0; c_idx < sizeof(columns)/sizeof(int); c_idx++) {
			mvaddch(y, columns[c_idx], ACS_VLINE);
		}
		
		// Go to next line.
		y++;
		move(y, 0);
	}
}

void draw_footer() {
	const char *app_name = "Task Tracker";
	const char *app_version = "v1.0";
	
	int row, col;                        /* to store the number of rows and the number of colums of the screen */
	initscr();							/* start the curses mode */
	getmaxyx(stdscr,row,col);			/* get the number of rows and columns */
	
	mvaddch(row-1, 0, ACS_LLCORNER);
	addch(' ');
	printw(app_name);
	addch(' ');
	for (int idx = strlen(app_name) + 3; idx < col - strlen(app_version) - 3; idx ++) {
		addch(ACS_HLINE);
	}
	addch(' ');
	printw(app_version);
	addch(' ');
	addch(ACS_LRCORNER);
}

WINDOW *create_newwin(int height, int width, int starty, int startx);
void destroy_win(WINDOW *local_win);

int main(int argc, char *argv[]) {
	
	// TODO Parse commands using: https://stackoverflow.com/questions/9642732/parsing-command-line-arguments-in-c
	if (argc > 1) {
// 		const char* command_version = { "--version", "-v" };
		
		for (int idx = 1; idx < argc; idx++) {
			if (strncmp(argv[idx], "-v", 2) == 0 || strncmp(argv[idx], "--version", 9) == 0) {
				fprintf(stdout, "Task Time Tracker v1.0\n");
				return EXIT_SUCCESS;
			}
		}

	
		fprintf(stdout, "Unkown command '%s'.\nUse '%s --help' for list of commands.\n", argv[1], argv[0]);
		return EXIT_FAILURE;
	}
	
	
	
	prototype(); // TODO
	return EXIT_FAILURE;
	initialize_layouts();
	
	WINDOW *my_win;
	int startx, starty, width, height;
	int ch;

	initscr();			/* Start curses mode 		*/
	cbreak();			/* Line buffering disabled, Pass on
					 * everty thing to me 		*/
	keypad(stdscr, TRUE);		/* I need that nifty F1 	*/
    curs_set(0);        // Set cursor invisible.

	height = 3;
	width = 10;
	starty = (LINES - height) / 2;	/* Calculating for a center placement */
	startx = (COLS - width) / 2;	/* of the window		*/
	printw("Press F1 to exit");
	refresh();
	my_win = create_newwin(height, width, starty, startx);
    
	int rows;
	int colums;
	
	ch = KEY_RESIZE;
	do {
        switch(ch)
		{
			case KEY_RESIZE:
				erase();
				if (line_buffer != NULL) {
					free(line_buffer);
				}
				getmaxyx(stdscr, size_y, size_x);
				line_buffer = malloc(size_x * sizeof(char));
				break;
			
			case KEY_LEFT:
				destroy_win(my_win);
				my_win = create_newwin(height, width, starty,--startx);
				break;
			
			case KEY_RIGHT:
				destroy_win(my_win);
				my_win = create_newwin(height, width, starty,++startx);
				break;
			
			case KEY_UP:
				selected_task = selected_task == 0 ? 0 : selected_task - 1;
				destroy_win(my_win);
				my_win = create_newwin(height, width, --starty,startx);
				break;
			
			case KEY_DOWN:
				selected_task = (selected_task+1) == tasks_count ? selected_task : selected_task + 1;
				destroy_win(my_win);
				my_win = create_newwin(height, width, ++starty,startx);
				break;	
		}
		
		selected_layout = size_x > 100 ? 0 : 1;

		if (size_x >= 60 && size_y > 2) {
			draw_header();
			draw_table();
			draw_footer();
		}
		else {
			const char* INVALID_WINDOW_MESSAGE = "Please expand window.";
			mvaddstr(size_y / 2, (size_x - strlen(INVALID_WINDOW_MESSAGE)) / 2, INVALID_WINDOW_MESSAGE);
		}
	
	} while((ch = getch()) != KEY_F(1));
	
	free_memory();
	endwin();
	return EXIT_SUCCESS;
}

WINDOW *create_newwin(int height, int width, int starty, int startx) {
	WINDOW *local_win;

	local_win = newwin(height, width, starty, startx);
	box(local_win, 0 , 0);		/* 0, 0 gives default characters 
					 * for the vertical and horizontal
					 * lines			*/
	wrefresh(local_win);		/* Show that box 		*/

	return local_win;
}

void destroy_win(WINDOW *local_win) {
	/* box(local_win, ' ', ' '); : This won't produce the desired
	 * result of erasing the window. It will leave it's four corners 
	 * and so an ugly remnant of window. 
	 */
	wborder(local_win, ' ', ' ', ' ',' ',' ',' ',' ',' ');
	/* The parameters taken are 
	 * 1. win: the window on which to operate
	 * 2. ls: character to be used for the left side of the window 
	 * 3. rs: character to be used for the right side of the window 
	 * 4. ts: character to be used for the top side of the window 
	 * 5. bs: character to be used for the bottom side of the window 
	 * 6. tl: character to be used for the top left corner of the window 
	 * 7. tr: character to be used for the top right corner of the window 
	 * 8. bl: character to be used for the bottom left corner of the window 
	 * 9. br: character to be used for the bottom right corner of the window
	 */
	wrefresh(local_win);
	delwin(local_win);
}