// Copyright (c) 2003,2004,2005 Juraj Kolesár <koli@koli.sk>               
#include "tt.h"
/* table input {{{ ************************************************************/
int tt_table_input(POS point, T_CELL *cell, T_TABLE *table) 
{
	bool End = false;
	bool FromList = false;
	int Pos = 0;
	int MaxX, MaxY;
	int BegX, BegY;
	int Status = __TT_ERR;
	int Length;
	WINDOW *win = NULL;
	TT_TABLE *v_table = NULL;
	T_TABLE *f_table = NULL; //Filtered table
	T_COLS *cols = NULL;
	T_CELL a_cell[]={{"","",0,0},{"","",cell->width,0}};
	cols = g_slist_append(cols, &(a_cell[0]));
	cols = g_slist_append(cols, &(a_cell[1]));
	getmaxyx(point.win, MaxY, MaxX);
	getbegyx(point.win, BegY, BegX);
	wmove(GET_POS(point) + 1);
	wrefresh(point.win);
	Status = tt_input();
	OFFSET_POS(point,0,2);
	if (Status == __TT_ENTER) {
		Length = tt_table_input_init(MaxY - (point.y + 1), 
			cell->name, table, &f_table);
		tt_table_init(Length, f_table, &v_table);
	} else return(Status);	//TEMP
	while (!End) {
		if (Length > 0)	{
			win = newwin(Length + 2, cell->width + 2, 
			BegY + point.y, BegX + point.x - 1);
		    box(win,0,0);
			if (FromList) tt_table_draw_list(win, cols, f_table, v_table);
			else tt_table_draw_list(win, cols, NULL, v_table);
		}
		mvwprintw(GET_POS(point) - 1, ">");
		tt_str_draw(point, cell->width, Pos, '_', cell->name);
		Status = tt_str_input(tt_input(), cell->width, &Pos, cell->name);
 		switch (Status) {
			case(__TT_ENTER): 
				if (FromList) {
					g_slist_free(cols);
					cols = f_table->data;	//cols USED AS T_ROW
					strcpy(cell->value, cols->data);
					strcpy(cell->name, (cols->next)->data);
				} 
				else if (tt_table_input_inlist(table, cell)) Status = __TT_TAB;
				else Status = __TT_INS;
				End = true;	
				break;
			case(__TT_DOWN):
				if (FromList) tt_table_next(&f_table, &v_table); 
				else FromList = true;
				break;
			case(__TT_UP):
				if (FromList) tt_table_previous(&f_table, &v_table); 
				else FromList = true;
				break;
			default:
				Length = tt_table_input_init(MaxY - (point.y + 1), 
					cell->name, table, &f_table);
				tt_table_init(Length, f_table, &v_table);
				FromList = false;
				break;
		}
		if (win != NULL) {
			werase(win);wrefresh(win);delwin(win);win = NULL;
		}
	}
	mvwprintw(GET_POS(point) - 1, ".]");
	OFFSET_POS(point, 0, 1);
	tt_str_draw(point, cell->width, Pos, ' ', cell->name);
	touchwin(point.win);
	wrefresh(point.win);
	return(Status);
}
/* }}} */
/* table {{{ ******************************************************************/
int tt_table (POS point, T_TABLE **table, T_COLS *cols) 
{
	bool End = false;
	int MaxX, MaxY;
	int BegX, BegY;
	int Status = __TT_ERR;
	int win_height;
	TT_TABLE *v_table = NULL;	//single list of visible values
	T_TABLE *start = *table;
	WINDOW *win;
	POS m_point;
	if (*table == NULL) return(__TT_OK);
	getmaxyx(point.win, MaxY, MaxX);
	getbegyx(point.win, BegY, BegX);
	win_height = MIN(g_list_length_full(*table) + 2, (MaxY - point.y) + 1);
	win = newwin(win_height, 
		MIN(t_cols_width_sum(cols) + g_slist_length(cols), (MaxX - point.x)),
		BegY + point.y - 1, BegX + point.x);
    box(win,0,0);
	SET_POS(m_point, win, 0, 0);
	tt_table_draw_cols(m_point, cols);
    wrefresh(win);
	tt_table_init(win_height - 2, *table, &v_table);	//4= up+down border
	while (!(End)) { 	//MAIN OBJECT CYCLE
	    tt_table_draw_list(win, cols, *table, v_table);
		Status = tt_input();
		switch (Status) {
			case __TT_DOWN: tt_table_next(table, &v_table);break;
			case __TT_UP: tt_table_previous(table, &v_table);break;
			case __TT_ESC: End = true; *table = start; break;
			case __TT_INS: End = true; break;
			case __TT_TAB: End = true; break;
			case __TT_DEL: End = true; break;
			case __TT_ENTER: tt_table_store(*table, cols);
				End = true;	break;
		}
	}
	werase(win);wrefresh(win);delwin(win);touchwin(point.win);
    return(Status);
}
/* }}} */
/* table qs {{{ ***************************************************************/
int tt_table_qs (WINDOW * win, T_DB *tdb, T_QS *qs, T_COLS *cols) 
{
	bool End = FALSE;
	int Status;
	TT_TABLE *v_table = NULL;	//single list of visible values
	//ACTUAL COLUMN
	char Search[__TT_STR_MAX] = {'\0'};		//search string
	int Col_width;							//culumn width
	int Column = 0;							//column number
	int Pos = 0;							//actual cursor position
	//CURSES
    int win_height;
    int win_width;
    WINDOW *swin_List;
	POS point;	
	//DATA CONTAINING 
	T_MATRIX matrix;
	char SQL_cmd[__T_QS_PARAM_LENGTH * 8] = {'\0'};
	//CURSES UI INIT
	getmaxyx(win, win_height, win_width); 
	getbegyx(win, point.y, point.x);
    swin_List = subwin(win, win_height - 2, win_width, point.y + 2, point.x);		
	SET_POS(point, win, 1, 1);
    box(swin_List,0,0);    
    box(win,0,0);
    wrefresh(win);
	//TABLE INIT			
	t_cols_next(cols, &Column);
	t_cols_get_values(cols, Column, &point.x, &Col_width, Search);
	tdb_qs_set_filter_dynamic(qs, cols, Column);
	tdb_qs_set_order(qs, cols, Column);
    if (tdb_table_fill(tdb, &matrix, tdb_qs(SQL_cmd, qs)) == 0) 
		return(__TT_NULL);
	tt_table_init(win_height - 4, matrix.table, &v_table);
							//4= up+down border, search line, divide line
	while (!(End)) { 	//MAIN OBJECT CYCLE
	    tt_table_draw_list(swin_List, cols, matrix.table, v_table);
		tt_table_draw_filter(win, cols);
		tt_str_draw(point, Col_width, Pos, '_', Search);
		Status = tt_str_input(getch(), Col_width, &Pos, Search);
		switch (Status) {
			case __TT_DOWN: tt_table_next(&matrix.table, &v_table);break;
			case __TT_UP: tt_table_previous(&matrix.table, &v_table);break;
			case __TT_ESC: End = TRUE; break;
			case __TT_INS: End = TRUE; break;
			case __TT_ENTER: tt_table_store(matrix.table, cols);
				End = TRUE;	break;
			case __TT_TAB:
				t_cols_set_value(cols, Column, Col_width, Search);
				t_cols_next(cols, &Column);
				t_cols_get_values(cols, Column, &point.x, &Col_width, Search);
				tdb_qs_set_filter_dynamic(qs, cols, Column);
				tdb_qs_set_order(qs, cols, Column);
			    tdb_table_fill(tdb, &matrix, tdb_qs(SQL_cmd, qs));
				tt_table_init(win_height - 4, matrix.table, &v_table);
				tt_table_search(Search, Column, &matrix.table, &v_table);
				werase(swin_List);
			    box(swin_List,0,0);    
			    box(win,0,0);
				Pos = 0;
				break;
			default: tt_table_find(Search, Column, &matrix.table, &v_table);
		}
	}
	tdb_table_free(&matrix);
    return(Status);
}
/* }}} */
/* table combo {{{ ************************************************************/
int tt_table_combo(POS point, T_TABLE **table, T_COLS *cols) {
	int Status = __TT_ERR;
	wmove(GET_POS(point) + 1);
	wrefresh(point.win);
	Status = tt_input();
	if (Status == __TT_ENTER) {
		Status = tt_table(point, table, cols);
		tt_table_draw_combo(point, cols, *table);
	}
	return(Status);
}
/* }}} */
/* draw {{{ ***************************************************************/
int tt_table_draw (WINDOW *win, T_COLS *cols, T_TABLE *table) 
{
	int MaxX, MaxY;
	TT_TABLE *v_table = NULL;	//single list of visible values
 	T_CELL *cell;
	POS point;
	SET_POS(point,win,0,0);
	if (table == NULL) return(__TT_ERR);
	getmaxyx(win, MaxY, MaxX);
    box(win,0,0);
	tt_table_init(MaxY - 2, table, &v_table);
	tt_table_draw_list(win, cols, table, v_table);
	tt_table_draw_cols(point, cols);
    return(__TT_OK);
}
/* }}} */
/* draw columns {{{ ***********************************************************/
int tt_table_draw_cols (POS point, T_COLS *cols) 
{
 	T_CELL *cell;
	while (cols != NULL) {    			//go through row values
		cell = cols->data;
		if (cell->width != 0) {
			OFFSET_POS(point, 0, 1);
			tt_str_draw(point, strlen(cell->name), 0, ' ', cell->name);
			point.x += cell->width;
		}
		cols = g_slist_next(cols);
	}
    return(__TT_OK);
}
/* }}} */
/* draw row {{{ ***************************************************************/
int tt_table_draw_row (POS point, char separator, T_COLS *cols, T_ROW *row) 
{
 	T_CELL *cell;
	if (cols == NULL) return(__LT_ERR);
	while (row != NULL) {    			//go through row values
		cell = cols->data;
		if (cell->width != 0) {
			wmove(GET_POS(point));
    	    if (separator != 0) waddch(point.win, separator);  //draws separator symbol(e.g.cursor)
			else wvline(point.win,0,1);	
			OFFSET_POS(point, 0, 1);
			switch (cell->type) {
				case (T_CELL_STR):
					tt_str_draw(point, cell->width, 0, ' ', row->data);
					break;
				case (T_CELL_DATE):
					tt_datum_draw(point, row->data);
					break;
			}
			point.x += cell->width;
		}
		row = g_slist_next(row);
		if (cols->next != NULL) cols = g_slist_next(cols);
	}
    return(__TT_OK);
}
/* }}} */
/* draw list {{{ **************************************************************/
int tt_table_draw_list (
	WINDOW * win, 
	T_COLS *cols, 
	T_TABLE *table, 
	TT_TABLE *v_table) 
{
	POS point = {win, 1, 0};	//first window row is a border
	int cursor = point.y;
    while (v_table != NULL) {
		if (table != NULL)
			if (v_table->data == table->data) {
				tt_table_draw_row(point, '>', cols, v_table->data);
				cursor = point.y;
            } else tt_table_draw_row(point, 0, cols, v_table->data);
		else tt_table_draw_row(point, 0, cols, v_table->data);
        point.y++;
        v_table = g_slist_next(v_table);
    }
	point.y = cursor;
	wmove(GET_POS(point));
	wrefresh(win);
    return(__TT_OK);
}
/* }}} */
/* draw combo {{{ *************************************************************/
int tt_table_draw_combo(POS point, T_COLS *cols, T_TABLE *table) {
	if (table != NULL) {
		OFFSET_POS(point,0,2);
		tt_table_draw_row(point, ',', cols, table->data);
		OFFSET_POS(point,0,-2);
		mvwprintw(GET_POS(point), "[v]");
	} else mvwprintw(GET_POS(point), "[ ]");
	return(__TT_OK);
}
/* }}} */
/* draw input {{{ *************************************************************
int tt_table_draw_input(POS point, T_CELL *cell) {
	if (strlen(cell->value) > 0) mvwprintw(GET_POS(point), "[.]");
	else mvwprintw(GET_POS(point), "[ ]");
	return(__TT_OK);
}
/* }}} */
/* draw filter {{{ ************************************************************/
int tt_table_draw_filter (WINDOW *win, GSList *cols) {
	POS point = {win, 1, 0};
	T_CELL *cell;
    while (cols != NULL) {
        cell = cols->data;
		if (cell->width > 0) {
			wmove(win, 1, point.x);
			wvline(win, 0, 1);			
			point.x++;
			tt_str_draw(point, cell->width, 0, ' ', cell->value);
			point.x += cell->width;
		}
		cols = g_slist_next(cols);
	}
    return(__TT_OK);
}
/* }}} */
/* init {{{ *******************************************************************/
int tt_table_init(int rows, T_TABLE *table, TT_TABLE **v_table) {
	register int count = 0;
	int length;
	if (table != NULL) length = g_list_length(table);
	else return(count);
	g_slist_free(*v_table);	
	*v_table = NULL;
	if (length < rows)
		if (g_list_length(g_list_first(table)) > rows)
 			for (count = 0; count < (rows - length); count++)
				table = g_list_previous(table);
		else table = g_list_first(table);
	for (count=0; count < rows; count++) {
		if (table != NULL)
			*v_table = g_slist_append(*v_table, table->data);
		else break;
		if (table->next != NULL) table = g_list_next(table);
		else break;
    }
	return(count);
}
/* }}} */
/* input init{{{ *************************************************************/
int tt_table_input_init(
	int rows, 
	char *filter, 
	T_TABLE *table, 
	T_TABLE **f_table) 
{
	register int i= 0;
	int length;
	int count = 0;
	T_ROW *row;
	if (table != NULL) {
		table = g_list_first(table);
		length = g_list_length(table);
	} else return(__TT_ERR);
	g_list_free(*f_table);	
	*f_table = NULL;
	for (i=0; i < rows; i++) {
		if (table != NULL) {
			row = g_slist_next(table->data);
			if (strncasecmp(filter, row->data, strlen(filter)) == 0) {
				*f_table = g_list_append(*f_table, table->data);
				count++;
			}
		} else break;
		if (table->next != NULL) table = g_list_next(table);
		else break;
    }
	return(count);
}
/* }}} */
/* input inlist {{{ ***********************************************************/
int tt_table_input_inlist(
	T_TABLE *table,
	T_CELL *cell) 
{
	char *pk;
	T_ROW *row;
	if (table != NULL) {
		table = g_list_first(table);
	} else return(false);
	while (table != NULL) {
		row = table->data;
		pk = row->data;
		row = g_slist_next(row);
		if (strcasecmp(row->data, cell->name) == 0) {
			strcpy(cell->value, pk);
			strcpy(cell->name, row->data);
			return(true);
		}
		table = g_list_next(table);
    }
	return(false);
}
/* }}} */
/* store {{{ ******************************************************************/
int tt_table_store(T_TABLE *table, T_COLS *cols) {
	T_ROW *row;
	T_CELL *cell;
	if (table != NULL) {
		row = table->data;
		while (row != NULL) {	
			cell = cols->data;
			strcpy(cell->value, row->data);
			row = g_slist_next(row);	
			if ((cols)->next != NULL) 
				cols = g_slist_next(cols);
			else return(__LT_ERR);
	    }
	} else {
		while (cols != NULL) {	
			cell = cols->data;
			strcpy(cell->value, "");
			cols = g_slist_next(cols);
	    }
	}
	return(__TT_OK);
}
/* }}} */
/* cursor position {{{ ********************************************************/
int tt_table_cursor(T_TABLE *table, TT_TABLE *v_table) {
	int cursor = 1;
	if (table != NULL) 
		while (v_table->data != table->data) {	
			cursor++;
			if (v_table->next != NULL) v_table = g_slist_next(v_table);
			else return(__LT_ERR);
	    }	
	else return(0);
	return(cursor);
}
/* }}} */
/* next {{{ *******************************************************************/
int tt_table_next(T_TABLE **table, TT_TABLE **v_table) {
	if (*table != NULL) 
	//if next row is within v_table then just move to next table item
	if (tt_table_cursor(*table, *v_table) < g_slist_length(*v_table)) 
		*table = g_list_next(*table);	
	else if ((*table)->next != NULL) {
		*table = g_list_next(*table);
		*v_table = g_slist_append(*v_table, (*table)->data);
		*v_table = g_slist_next(*v_table); 
/*	???	just sets the start pointer to second item in list
		does anybody remove the old(first) item from memory ???	*/
	}
	return(__LT_OK);
}
/* }}} */
/* previous {{{ ***************************************************************/
int tt_table_previous(T_TABLE **table, TT_TABLE **v_table) {
	if (*table != NULL) 
	if (tt_table_cursor(*table, *v_table) > 1) 
			*table = g_list_previous(*table);	
	else if ((*table)->prev != NULL) {
		*table = g_list_previous(*table);
		*v_table = g_slist_prepend(*v_table, (*table)->data);
		*v_table = g_slist_remove_last(*v_table);
	}
	return(__LT_OK);
}
/* }}} */
/* search {{{ *****************************************************************/
int tt_table_search(
	char *search, 
	int column,
	T_TABLE **table, 
	TT_TABLE **v_table) 
{
	register int i;					 
	const int length = g_slist_length(*v_table);
	T_ROW * row;
	T_TABLE * m_table = g_list_first(*table);
	if (*table == NULL) return(__LT_OK);
    while (m_table->next != NULL) {	
        row = m_table->data;
		for (i=0; i < column; i++) {	
			if (row->next != NULL) row = g_slist_next(row);	
			else return(__LT_ERR);
		} 
		if (strcasecmp(row->data,search) < 0) m_table = g_list_next(m_table);
		else break;
    }
	*table = m_table;	//sets new table cursor position
	while ((length - 1) > tt_table_init(length, m_table, v_table)) 
		m_table = g_list_previous(m_table);
		// adds missing number of rows and shifts cursor to actual position
    return(__TT_OK);
}
/* }}} */
/* find {{{ *******************************************************************/
int tt_table_find(
	char *search, 
	int column,
	T_TABLE **table, 
	TT_TABLE **v_table) 
{
	register int i;					 
	int n = strlen(search);
	const int length = g_slist_length(*v_table);
	T_ROW * row;
	T_ROW * next_row;
	T_TABLE * m_table = g_list_first(*table);
	if (*table == NULL) return(__LT_OK);
    while (m_table->next != NULL) {	
        row = m_table->data;
		next_row = (m_table->next)->data;
		for (i=0; i < column; i++) {	
			if (row->next != NULL) row = g_slist_next(row);	
			if (next_row->next != NULL) next_row = g_slist_next(next_row);	
			else return(__LT_ERR);
		} 
		if (strcasecmp(row->data,search) < 0) 
			m_table = g_list_next(m_table);
		else break;
    }
	if ((strncasecmp(next_row->data,search, n) > 0) &&
		(strncasecmp(row->data, search, n) == 0))
		strcpy(search,row->data);
	*table = m_table;	//sets new table cursor position
	while ((length - 1) > tt_table_init(length, m_table, v_table)) 
		m_table = g_list_previous(m_table);
		// adds missing number of rows and shifts cursor to actual position
    return(__TT_OK);
}
/* }}} */
/* {{{ edit cell **************************************************************/
int tt_table_edit_cell (	
	WINDOW *win, 
	T_TABLE *table, 
	T_COLS *cols,
	int column) 
{
	bool End = false;
	int X,Y;
	int Status = __TT_ERR;
	int Width;
	int Pos;
	char String[T_CELL_VALUE_WIDTH] = {'\0'};
	POS point;
	T_ROW *row = table->data;
	TT_TABLE *v_table = NULL;
	getmaxyx(win, Y, X);
	tt_table_init(Y-2, table, &v_table);
	t_cols_get_values(cols, column, &X, &Width, String);
	Y = tt_table_cursor(table, v_table);
	SET_POS(point, win, Y, X);
	for (Pos = 0; Pos < column; Pos++)
		if (row->next != NULL) row = g_slist_next(row);
		else return(__TT_ERR);
	return(tt_str_get(point, Width, row->data));
}
/* }}} */