/*
 * Copyright (C) 2007, 2008, 2009
 *       pancake <youterm.com>
 *
 * dietline is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * dietline is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with dietline; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 *
 */

#include "dietline.h"

/* dietline is a lighweight and portable library similar to GNU readline */

#if RADARE_CORE
#include "main.h"
#else
static void cons_set_raw(int b);
static int cons_get_real_columns();
#define __UNIX__ 1
#endif

#include <string.h>
#include <stdlib.h>

#if __WINDOWS__
#include <windows.h>
#else
#include <sys/ioctl.h>
#include <termios.h>
#include <signal.h>
#endif

/* line input */
int dl_echo = 1;
const char *dl_prompt = "> ";
const char *dl_clipboard = NULL;
static char *dl_nullstr = "";
static char dl_buffer[DL_BUFSIZE];
static int dl_buffer_len = 0;
static int dl_buffer_idx = 0;

/* autocompletion callback */
char **(*dl_callback)(const char *text, int start, int end) = NULL;

/* history */
char **dl_history = NULL;
int dl_histsize = DL_HISTSIZE;
int dl_histidx = 0;
int dl_autosave = 0; // TODO
int dl_disable = 0; // TODO use fgets..no autocompletion

// TODO : FULL READLINE COMPATIBILITY
// rl_attempted_completion_function = rad_autocompletion;
// char **rad_autocompletion(const char *text, int start, int end)
// return  matches = rl_completion_matches (text, rad_offset_matches);

int dl_readchar()
{
	char buf[2];
#if __WINDOWS__
	LPDWORD out;
	BOOL ret;
	DWORD mode;
	HANDLE h = GetStdHandle(STD_INPUT_HANDLE);

	GetConsoleMode(h, &mode);
	SetConsoleMode(h, 0); // RAW
	ret = ReadConsole(h, buf,1, &out, NULL);
	if (!ret) {
		// wine hack-around
		if (read(0,buf,1) == 1)
			return buf[0];
		return -1;
	}
	SetConsoleMode(h, mode);
#else
	int ret = read(0,buf,1);
	if (ret <1)
		return -1;
#endif
	return buf[0];
}

/* scripting */

#define BLOCK 4096
static char *labels = NULL;
static unsigned int size = 0;
static unsigned int lsize = 0;

static int label_get(const char *name)
{
	int i, n;
	for(i=0;i<size;i++) {
		if (!strcmp(name, labels+i+4)) {
			memcpy(&n, labels+i, 4);
			return n;
		}
		i+=strlen(labels+i+4)+4;
	}
	return -1;
}

static void label_add (const char *str) {
	unsigned int size = dl_histidx;
	unsigned int len = strlen(str)-1;

	//eprintf("New label(%s)\n",str);
	memset(labels+lsize+4, '\0', BLOCK-((lsize+len+4)%BLOCK));
	memcpy(labels+lsize, &size, 4);
	memcpy(labels+lsize+4, str, len);
	lsize+=len+4+1;
}

void dl_label_show()
{
	unsigned int i, p, n = 0;
	for(i=0;i<lsize;i++,n++) {
		memcpy(&p, labels+i, 4);
		printf(" %03d %03d  %s\n", i, p, labels+i+4);
		i+=strlen(labels+i+4)+4;
	}
}

static void label_reset()
{
	lsize = 0;
	free(labels);
	labels = NULL;
}

static int is_label(const char *str)
{
	/* crappy hack */
	return 0;

	if (str[0]=='\0')
		return 0;
	if (str[strlen(str)-1]==':') {
		if (str[0]==':') {
			dl_label_show();
			return 2;
		}
		return 1;
	}
	return 0;
}

/* history stuff */

int dl_hist_label(const char *label, void (*cb)(const char*))
{
	int i;
#if 1
	/* labelling stuff */
	if (label[0]=='.') {
		if (!is_label(label+1))
			return 0;
	} else {
		switch(is_label(label)) {
		case 0:
		case 2:
			return 0;
		}
	}

	i = label_get(label);
	if (i == -1) {
		label_add(label);
		return 1;
	}
#endif
	if (dl_history != NULL)
	for(i=0; i<dl_histsize; i++) {
		if (dl_history[i] == NULL)
			break;
		fprintf(stderr, "%s\n", dl_history[i]);
		if (cb != NULL)
			cb(dl_history[i]);
		else	fprintf(stderr, "%s\n", dl_history[i]);
	}

	return 1;
}

int dl_hist_add(const char *line)
{
#if HAVE_LIB_READLINE
	add_history(line);
#endif
	if (dl_histidx>=dl_histsize)
		dl_histidx = 0; // workaround
	if (*line) { // && dl_histidx < dl_histsize) {
		dl_history[dl_histidx++] = strdup(line);
		return 1;
	}
	return 0;
//#endif
}

int dl_hist_up()
{
	if (dl_histidx>0) {
		strncpy(dl_buffer, dl_history[--dl_histidx], DL_BUFSIZE-1);
		dl_buffer_idx=
		dl_buffer_len = strlen(dl_buffer);
		return 1;
	}
	return 0;
}

int dl_hist_down()
{
	dl_buffer_idx=0;
	if (dl_histidx<dl_histsize) {
		if (dl_history[dl_histidx] == NULL) {
			dl_buffer[0]='\0';
			dl_buffer_idx = dl_buffer_len = 0;
			return 0;
		}
		strncpy(dl_buffer, dl_history[dl_histidx++], DL_BUFSIZE-1);
		dl_buffer_idx=
		dl_buffer_len = strlen(dl_buffer);
		return 1;
	}
	return 0;
}

int dl_hist_list()
{
	int i = 0;

	if (dl_history != NULL)
	for(i=0;i<dl_histsize; i++) {
		if (dl_history[i] == NULL)
			break;
		printf("%.3d  %s\n", i, dl_history[i]);
	}

	return i;
}

int dl_hist_free()
{
	int i;
	if (dl_history != NULL)
	for(i=0;i<dl_histsize; i++) {
		free(dl_history[i]);
		dl_history[i] = NULL;
	}
	return dl_histidx=0, dl_histsize;
}

void dl_free()
{
	printf("Bye!\n");
	dl_hist_free();
	label_reset();
	free(dl_history);
}

/* load history from file. if file == NULL load from ~/.<prg>.history or so */
int dl_hist_load(const char *file)
{
#if HAVE_LIB_READLINE
	rad_readline_init();
	return 0;
#else
	char buf[1024];
	FILE *fd;

	snprintf(buf, 1023, "%s/%s", get_home_directory(), file);
	fd = fopen(buf, "r");
	if (fd == NULL)
		return 0;

	fgets(buf, 1023, fd);
	while (!feof(fd)) {
		buf[strlen(buf)-1]='\0';
		dl_hist_add(buf);
		fgets(buf, 1023, fd);
	}
	fclose(fd);

	return 1;
#endif
}

int dl_hist_save(const char *file)
{
#if HAVE_LIB_READLINE
	rad_readline_finish();
#else
	char buf[1024];
	FILE *fd;
	int i;

	snprintf(buf, 1023, "%s/%s", get_home_directory(), file);
	fd = fopen(buf, "w");
	if (fd == NULL)
		return 0;
	for(i=0;i<dl_histidx;i++) {
		fputs(dl_history[i], fd);
		fputs("\n", fd);
	}
	fclose(fd);
	
	return 1;
#endif
}

int dl_hist_chop(const char *file, int limit)
{
	/* TODO */
	return 0;
}

/* initialize history stuff */
int dl_init()
{
#if HAVE_LIB_READLINE
	rad_readline_init();
#endif
	if (labels==NULL)
		labels = malloc(BLOCK);
	dl_history = (char **)malloc(dl_histsize*sizeof(char *));
	if (dl_history==NULL)
		return 0;
	memset(dl_history, '\0', dl_histsize*sizeof(char *));
	dl_histidx = 0;
	dl_histsize = DL_HISTSIZE;
	dl_histidx = 0;
	dl_autosave = 0;
	dl_disable = 0;
	return 1;
}

/* test */
int dl_printchar()
{
	unsigned char buf[10];

	cons_set_raw(1);
	buf[0]=dl_readchar();

	switch(buf[0]) {
		case 226:
		case 197:
		case 195:
		case 194:
			buf[0] = dl_readchar();
			printf("unicode-%02x-%02x\n", buf[0],buf[1]);
			break;
		case 8: // wtf is 127?
		case 127: printf("backspace\n"); break;
		case 32: printf("space\n"); break;
		case 27:
			read(0, buf, 5);
			printf("esc-%02x-%02x-%02x-%02x\n",
					buf[0],buf[1],buf[2],buf[3]);
			break;
		case 12: printf("^L\n"); break;
		case 13: printf("intro\n"); break;
		case 18: printf("^R\n"); break;
		case 9: printf("tab\n"); break;
		case 3: printf("control-c\n"); break;
		case 0: printf("control-space\n"); break;
		default:
			printf("(code:%d)\n", buf[0]);
			break;
	}

	cons_set_raw(0);

	return buf[0];
}

/* main readline function */
char *dl_readline(int argc, const char **argv)
{
	int buf[10];
	int i, len = 0;
	int opt = 0;
	int columns = cons_get_real_columns()-2;

	dl_buffer_idx = dl_buffer_len = 0;
	dl_buffer[0]='\0';

#if RADARE_CORE
	dl_echo = config.verbose;
#endif

	if (dl_disable) {
		dl_buffer[0]='\0';
		fgets(dl_buffer, DL_BUFSIZE-1, stdin);
		dl_buffer[strlen(dl_buffer)] = '\0';
		return (*dl_buffer)? dl_buffer : NULL;
	}

	memset(&buf,0,sizeof buf);
	cons_set_raw(1);

	if (dl_echo) {
		printf("%s", dl_prompt);
		fflush(stdout);
	}

#if __UNIX__
	if (feof(stdin))
		return NULL;
#endif

	while(1) {
#if 0
		if (dl_echo) {
			printf("  (");
			for(i=1;i<argc;i++) {
				if (dl_buffer_len==0||!strncmp(argv[i], dl_buffer, dl_buffer_len)) {
					len+=strlen(argv[i])+1;
					if (len+dl_buffer_len+4 >= columns) break;
					printf("%s ", argv[i]);
				}
			}
			printf(")");
			fflush(stdout);
		}
#endif

		dl_buffer[dl_buffer_len]='\0';
		buf[0] = dl_readchar();
		
//		printf("\x1b[K\r");
		columns = cons_get_real_columns()-2;
		if (columns <1)
			columns = 40;
		if (dl_echo)
		printf("\r%*c\r", columns, ' ');

		switch(buf[0]) {
			case -1:
				return NULL;
			case 0: // control-space
				/* ignore atm */
				break;
			case 1: // ^A
				dl_buffer_idx = 0;
				break;
			case 5: // ^E
				dl_buffer_idx = dl_buffer_len;
				break;
			case 3: // ^C 
				if (dl_echo)
					printf("\n^C\n");
				dl_buffer[dl_buffer_idx = dl_buffer_len = 0] = '\0';
				goto _end;
			case 4: // ^D
				if (dl_echo)
					printf("^D\n");
				if (!dl_buffer[0]) { /* eof */
					cons_set_raw(0);
					return NULL;
				}
				break;
			case 10: // ^J -- ignore
				return dl_buffer;
			case 11: // ^K -- ignore
				break;
			case 19: // ^S -- backspace
				dl_buffer_idx = dl_buffer_idx?dl_buffer_idx-1:0;
				break;
			case 12: // ^L -- right
				dl_buffer_idx = dl_buffer_idx<dl_buffer_len?dl_buffer_idx+1:dl_buffer_len;
				if (dl_echo)
					printf("\x1b[2J\x1b[0;0H");
				fflush(stdout);
				break;
			case 21: // ^U - cut
				dl_clipboard = strdup(dl_buffer);
				dl_buffer[0]='\0';
				dl_buffer_len = 0;
				dl_buffer_idx = 0;
				break;
			case 23: // ^W
				if (dl_buffer_idx>0) {
					for(i=dl_buffer_idx-1;i&&dl_buffer[i]==' ';i--);
					for(;i&&dl_buffer[i]!=' ';i--);
					for(;i>0&&dl_buffer[i]==' ';i--);
					if (i>1) {
						if (dl_buffer[i+1]==' ')
						i+=2;
					} else if (i<0) i=0;
					strcpy(dl_buffer+i, dl_buffer+dl_buffer_idx);
					dl_buffer_len = strlen(dl_buffer);
					dl_buffer_idx = i;
				}
				break;
			case 25: // ^Y - paste
				if (dl_clipboard != NULL) {
					dl_buffer_len += strlen(dl_clipboard);
					// TODO: support endless strings
					if (dl_buffer_len < DL_BUFSIZE) {
						dl_buffer_idx = dl_buffer_len;
						strcat(dl_buffer, dl_clipboard);
					} else dl_buffer_len -= strlen(dl_clipboard);
				}
				break;
			case 16:
				dl_hist_up();
				break;
			case 14:
				dl_hist_down();
				break;
			case 27: //esc-5b-41-00-00
				buf[0] = dl_readchar();
				buf[1] = dl_readchar();
				if (buf[0]==0x5b) {
					switch(buf[1]) {
					case 0x33: // supr
						if (dl_buffer_idx<dl_buffer_len)
							strcpy(dl_buffer, dl_buffer+1);
						break;
					/* arrows */
					case 0x41:
						dl_hist_up();
						break;
					case 0x42:
						dl_hist_down();
						break;
					case 0x43:
						dl_buffer_idx = dl_buffer_idx<dl_buffer_len?dl_buffer_idx+1:dl_buffer_len;
						break;
					case 0x44:
						dl_buffer_idx = dl_buffer_idx?dl_buffer_idx-1:0;
						break;
					}
				}

				break;
			case 8:
			case 127:
				if (dl_buffer_idx < dl_buffer_len) {
					if (dl_buffer_idx>0) {
						dl_buffer_idx--;
						memcpy(dl_buffer+dl_buffer_idx, dl_buffer+dl_buffer_idx+1,strlen(dl_buffer+dl_buffer_idx));
					}
				} else {
					dl_buffer_idx = --dl_buffer_len;
					if (dl_buffer_len<0) dl_buffer_len=0;
					dl_buffer[dl_buffer_len]='\0';
				}
				if (dl_buffer_idx<0)
					dl_buffer_idx = 0;
				break;
			case 9:// tab
				/* autocomplete */
				// XXX does not autocompletes correctly
				// XXX needs to check if valid results have the same prefix (from 1 to N)
				if (dl_callback != NULL) {
					//const char *from = strrchr(dl_buffer, ' ');
					//char **res = dl_callback(dl_buffer, (from==NULL)?dl_buffer_idx:from-dl_buffer, dl_buffer_len);
					/* TODO: manage res */
				} else {
					if (dl_buffer_idx>0)
					for(i=1,opt=0;i<argc;i++)
						if (!strncmp(argv[i], dl_buffer, dl_buffer_idx))
							opt++;

					if (dl_buffer_len>0&&opt==1)
						for(i=1;i<argc;i++) {
							if (!strncmp(dl_buffer, argv[i], dl_buffer_len)) {
								strcpy(dl_buffer, argv[i]);
								dl_buffer_idx = dl_buffer_len = strlen(dl_buffer);
								// TODO: if only 1 keyword hits:
								//		if (argv[i][dl_buffer_len]=='\0') {
								//			strcat(dl_buffer, " ");
								//			dl_buffer_len++;
								//		}
								break;
							}
						}

					/* show options */
					if (dl_buffer_idx==0 || opt>1) {
						if (dl_echo)
							printf("%s%s\n",dl_prompt,dl_buffer);
						for(i=1;i<argc;i++) {
							if (dl_buffer_len==0||!strncmp(argv[i], dl_buffer, dl_buffer_len)) {
								len+=strlen(argv[i]);
					//			if (len+dl_buffer_len+4 >= columns) break;
								if (dl_echo)
									printf("%s ", argv[i]);
							}
						}
						if (dl_echo)
							printf("\n");
					}
					fflush(stdout);
				}
				break;
			case 18:
				// TODO: SUPPORT FOR ^R (search command in history)
				break;
			case 13: 
				goto _end;
#if 0
				// force command fit
				for(i=1;i<argc;i++) {
					if (dl_buffer_len==0 || !strncmp(argv[i], dl_buffer, dl_buffer_len)) {
						printf("%*c", columns, ' ');
						printf("\r");
						printf("\n\n(%s)\n\n", dl_buffer);
						cons_set_raw(0);
						return dl_buffer;
					}
				}
#endif
			default:
				/* XXX use ^A & ^E */
				if (dl_buffer_idx<dl_buffer_len) {
					for(i = ++dl_buffer_len;i>dl_buffer_idx;i--)
						dl_buffer[i] = dl_buffer[i-1];
					dl_buffer[dl_buffer_idx] = buf[0];
				} else {
					dl_buffer[dl_buffer_len]=buf[0];
					dl_buffer_len++;
					if (dl_buffer_len>1000)
						dl_buffer_len--;
					dl_buffer[dl_buffer_len]='\0';
				}
				dl_buffer_idx++;
				break;
		}
		if (dl_echo) {
			printf("\r%s%s", dl_prompt, dl_buffer);
			printf("\r%s", dl_prompt);
		
			for(i=0;i<dl_buffer_idx;i++)
				printf("%c", dl_buffer[i]);
			fflush(stdout);
		}
	}

_end:
	cons_set_raw(0);
	if (dl_echo) {
		printf("\r%s%s\n", dl_prompt, dl_buffer);
		fflush(stdout);
	}

	if (dl_buffer[0]=='!' && dl_buffer[1]=='\0') {
		dl_hist_list();
		return dl_nullstr;
	}
	//write(1,"\n",1);
	return dl_buffer;
}

#ifndef RADARE_CORE


#if __UNIX__
static struct termios tio_old, tio_new;
#include "main.h"
#include <stdarg.h>
#include <termios.h>
#include <sys/ioctl.h>
#include <sys/wait.h>
#include <sys/socket.h>
#endif

static void cons_set_raw(int b)
{
#if __UNIX__
	if (b) {
		tcgetattr(0, &tio_old);
		memcpy ((char *)&tio_new, (char *)&tio_old, sizeof(struct termios));
		tio_new.c_iflag &= ~(BRKINT|PARMRK|ISTRIP|INLCR|IGNCR|ICRNL|IXON);
		tio_new.c_lflag &= ~(ECHO|ECHONL|ICANON|ISIG|IEXTEN);
		tio_new.c_cflag &= ~(CSIZE|PARENB);
		tio_new.c_cflag |= CS8;
		tio_new.c_cc[VMIN]=1; // Solaris stuff hehe
		tcsetattr(0, TCSANOW, &tio_new);
		fflush(stdout);
		return;
	}

	tcsetattr(0, TCSANOW, &tio_old);
	fflush(stdout);
#endif
}

static int cons_get_real_columns()
{
#if __WINDOWS__
        return 78;
#endif
        struct winsize win;

        if (ioctl(1, TIOCGWINSZ, &win)) {
                /* default values */
//                win.ws_col = 80;
 //               win.ws_row = 23;
        }

        return win.ws_col;
}

int main(int argc, const char **argv)
{
	char *ret;

	dl_histsize = 100;
	dl_prompt = "$ ";
	dl_init();

	dl_printchar();

	do {
		ret = dl_readline(argc, argv);
		if (ret) {
			printf(" [line] '%s'\n", ret);
			dl_hist_add(ret);
		}
	} while(ret!=NULL);
	dl_free();
	return 0;
}

#endif