#include <stdio.h>
#include <stdlib.h>
#include <gc/gc.h>
#include <stdarg.h>
#include <unistd.h>
#include <string.h>
#include <sys/types.h>
#include <sys/time.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <netinet/ip.h>
#include <netinet/tcp.h>
#include <fcntl.h>
#include <time.h>
#include <event.h>
#include <netdb.h>
#include <signal.h>
#define DEBUG
#include <debug.h>
#include <rbtree.h>
#include "network.h"
#include "telnet.h"
#include "client.h"

static void telnet_send_req(DESC * client, int how, int request);
static void telnet_send_subop(DESC * client, int how, int option);
static void telnet_handle_will(DESC * client, int option);
static void telnet_handle_wont(DESC * client, int option);
static int telnet_handle_subop(DESC * client, unsigned char *buffer,
							   int length);

int telnet_init(DESC * client)
{
	dprintk("telnet initializing.");
	strncpy(client->termtype, "vt100", 16);
	client->telnet_win_width = 80;
	client->telnet_win_height = 25;

	telnet_send_req(client, TELNET_DO, TELNET_OPT_TERMTYPE);
	telnet_send_req(client, TELNET_DO, TELNET_OPT_WINSIZE);
	return 1;
}

/* Client Ring Buffer Handling */
static void telnet_send_req(DESC * client, int how, int request)
{
	unsigned char buffer[16] = { TELNET_IAC, how, request };
	network_write(client, (void *) buffer, 3);
}
static void telnet_send_subop(DESC * client, int option, int how)
{
	unsigned char buffer[16] =
		{ TELNET_IAC, TELNET_SB, option, how, TELNET_IAC, TELNET_SE };
	network_write(client, (void *) buffer, 6);
}

static void telnet_handle_will(DESC * client, int option)
{
	switch (option) {
	case TELNET_OPT_TERMTYPE:
		client->telnet_has_termtype = TSTATE_SUP;
		dprintk("client acknowledged TERMTYPE");
		break;
	case TELNET_OPT_WINSIZE:
		client->telnet_has_winsize = TSTATE_SUP;
		dprintk("client acknowledged WINSIZE");
		break;
	}
}

static void telnet_handle_wont(DESC * client, int option)
{
	switch (option) {
	case TELNET_OPT_TERMTYPE:
		client->telnet_has_termtype = TSTATE_UNSUP;
		strncpy(client->termtype, "vt100", 16);
		break;
	case TELNET_OPT_WINSIZE:
		client->telnet_has_winsize = TSTATE_UNSUP;
		client->telnet_win_width = 80;
		client->telnet_win_height = 25;
		break;
	}
}

static void telnet_check_options(DESC * client)
{
	if(client->telnet_has_termtype == TSTATE_SUP) {
		client->telnet_has_termtype = TSTATE_REQUEST;
		telnet_send_subop(client, TELNET_OPT_TERMTYPE, TELNET_SUB_REQUIRED);
	} else if(client->telnet_has_termtype == TSTATE_REQUEST) {
		client->telnet_has_termtype = TSTATE_UNSUP;
	}

	if(client->telnet_has_winsize == TSTATE_SUP) {
		client->telnet_has_winsize = TSTATE_REQUEST;
		telnet_send_subop(client, TELNET_OPT_WINSIZE, TELNET_SUB_REQUIRED);
	} else if(client->telnet_has_winsize == TSTATE_REQUEST) {
		client->telnet_has_termtype = TSTATE_UNSUP;
	}
}

static int telnet_handle_subop(DESC * client, unsigned char *buffer,
							   int length)
{
	int iter;
	if(buffer[1] != TELNET_SUB_SUPPLIED)
		dfail("unexpected reply in telnet suboption negotiation.");
	iter = 2;
	switch (buffer[0]) {
	case TELNET_OPT_TERMTYPE:
		memset(client->termtype, 0, 16);
		for(iter = 2; iter < length && iter < 18 && buffer[iter] != 0xFF;
			iter++) {
			client->termtype[iter - 2] = buffer[iter];
		}
		iter++;
		dprintk("Received Terminal Type '%s'", client->termtype);
		client->telnet_has_termtype = TSTATE_REPLIED;
		break;
	case TELNET_OPT_WINSIZE:
		client->telnet_win_width = buffer[2];
		client->telnet_win_height = buffer[4];
		iter = 6;
		dprintk("Received Window Size %dx%d", client->telnet_win_width,
				client->telnet_win_height);
		client->telnet_has_winsize = TSTATE_REPLIED;
		break;
	default:
		dfail("unexpected reply in telnet usboption negotiation.");
	}
	return iter;
}

#define ring_avail(client) (client->ringtail > client->ringhead ? RING_LENGTH - client->ringtail + client->ringhead : \
        client->ringhead - client->ringtail)
#define ring_char(client, x) (client->ringbuffer[(client->ringhead+x)%RING_LENGTH])
#define ring_length(client) (client->ringtail >= client->ringhead ? client->ringtail - client->ringhead : \
        RING_LENGTH - client->ringhead + client->ringtail)
#define ring_eat(client, x) (client->ringhead = (client->ringhead+x) % RING_LENGTH)

void telnet_read_ring(DESC * client)
{
	int iter, complete;
	unsigned char subopt_buffer[32];

	dprintk
		("Ring Read started, input length = %d, ringhead = %d, ringtail = %d. ",
		 ring_length(client), client->ringhead, client->ringtail);

	while (ring_length(client) > 0) {
		dprintk
			("Parsing data 0x%02x,  %d bytes in ring, ringhead = %d, ringtail = %d",
			 ring_char(client, 0), ring_length(client), client->ringhead,
			 client->ringtail);
		switch (ring_char(client, 0)) {
		case TELNET_IAC:
			if(ring_length(client) < 2)
				return;
			dprintk("TELNET COMMADN %d", ring_char(client, 1));
			switch ((unsigned char) ring_char(client, 1)) {
			case TELNET_WILL:
				telnet_handle_will(client, ring_char(client, 2));
				ring_eat(client, 3);
				break;
			case TELNET_WONT:
				telnet_handle_wont(client, ring_char(client, 2));
				ring_eat(client, 3);
				break;
			case TELNET_SB:
				complete = 0;
				for(iter = 2; !complete && iter < ring_avail(client); iter++) {
					subopt_buffer[iter - 2] = ring_char(client, iter);
					if(ring_char(client, iter) == TELNET_SE) {
						telnet_handle_subop(client, subopt_buffer, iter - 2);
						complete = 1;
						ring_eat(client, iter + 1);
					}
				}
				if(!complete)
					return;
				break;
			case TELNET_IAC:
				client->inputbuffer[client->inputtail++] = TELNET_IAC;
			default:
				ring_eat(client, 2);
				break;
			}
			break;
		case 0:
			ring_eat(client, 1);
			break;
		case '\r':
		case '\n':
			if(ring_length(client) > 1 && (ring_char(client, 1) == '\r' ||
										   ring_char(client, 1) == '\n')) {
				ring_eat(client, 1);
			}
			if(client->inputtail == 0) {
				ring_eat(client, 1);
				continue;
			}
			client->inputbuffer[client->inputtail] = 0;
			client_accept_input(client);
			dprintk("Would Parse: %s", client->inputbuffer);
			client->inputtail = 0;
			ring_eat(client, 1);
			break;
		default:
			client->inputbuffer[client->inputtail++] = ring_char(client, 0);
			ring_eat(client, 1);
			break;
		}
	}
	if(client->ringhead == client->ringtail) {
		client->ringhead = client->ringtail = 0;
	}

	telnet_check_options(client);
	dprintk
		("Ring Read finished. RingState = { head = %d, tail = %d }, InputState = { tail = %d }",
		 client->ringhead, client->ringtail, client->inputtail);
}

void telnet_disconnect(DESC * client)
{
	network_disconnect(client);
}

void telnet_write(DESC * client, char *buffer, int length)
{
	dprintk("telnet_write");
	// Color translation should occur here.
	network_write(client, buffer, length);
}