/*

    SDL - Simple DirectMedia Layer

    Copyright (C) 1997-2006 Sam Lantinga

    This library is free software; you can redistribute it and/or

    modify it under the terms of the GNU Lesser General Public

    License as published by the Free Software Foundation; either

    version 2.1 of the License, or (at your option) any later version.

    This library 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

    Lesser General Public License for more details.

    You should have received a copy of the GNU Lesser General Public

    License along with this library; if not, write to the Free Software

    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA

    Sam Lantinga

    slouken@libsdl.org

*/

#include "SDL_config.h"

#include <unistd.h>

#include <sys/time.h>

#include <ctype.h>

#include "SDL_stdinc.h"

#include "SDL_fbvideo.h"

#include "SDL_fbelo.h"

/*

	calibration default values

	values are read from the following environment variables:

	SDL_ELO_MIN_X

	SDL_ELO_MAX_X

	SDL_ELO_MIN_Y

	SDL_ELO_MAX_Y

*/

static int ELO_MIN_X = 400;

static int ELO_MAX_X = 3670;

static int ELO_MIN_Y = 500;

static int ELO_MAX_Y = 3540;

#define ELO_SNAP_SIZE 6

#define ELO_TOUCH_BYTE		'T'	

#define ELO_ID			'I'

#define ELO_MODE		'M'

#define ELO_PARAMETER		'P'

#define ELO_REPORT		'B'

#define ELO_ACK			'A'	

#define ELO_INIT_CHECKSUM	0xAA

#define ELO_BTN_PRESS		0x01	

#define ELO_STREAM		0x02

#define ELO_BTN_RELEASE		0x04

#define ELO_TOUCH_MODE		0x01

#define ELO_STREAM_MODE		0x02

#define ELO_UNTOUCH_MODE	0x04

#define ELO_RANGE_CHECK_MODE	0x40

#define ELO_TRIM_MODE		0x02

#define ELO_CALIB_MODE		0x04

#define ELO_SCALING_MODE	0x08

#define ELO_TRACKING_MODE	0x40

#define ELO_SERIAL_MASK		0xF8

#define ELO_SERIAL_IO		'0'

#define ELO_MAX_TRIALS	3

#define ELO_MAX_WAIT		100000

#define ELO_UNTOUCH_DELAY	5

#define ELO_REPORT_DELAY	1

/*	eloParsePacket

*/

int eloParsePacket(unsigned char* mousebuf, int* dx, int* dy, int* button_state) {

	static int elo_button = 0;

	static int last_x = 0;

	static int last_y = 0;

	int x,y;

	/* Check if we have a touch packet */

	if (mousebuf[1] != ELO_TOUCH_BYTE) {

		return 0;

	}

	x = ((mousebuf[4] << 8) | mousebuf[3]);

	y = ((mousebuf[6] << 8) | mousebuf[5]);

	if((SDL_abs(x - last_x) > ELO_SNAP_SIZE) || (SDL_abs(y - last_y) > ELO_SNAP_SIZE)) {

		*dx = ((mousebuf[4] << 8) | mousebuf[3]);

		*dy = ((mousebuf[6] << 8) | mousebuf[5]);

	}

	else {

		*dx = last_x;

		*dy = last_y;

	}

	last_x = *dx;

	last_y = *dy;

	if ( (mousebuf[2] & 0x07) == ELO_BTN_PRESS ) {

		elo_button = 1;

	}

	if ( (mousebuf[2] & 0x07) == ELO_BTN_RELEASE ) {

		elo_button = 0;

	}

	*button_state = elo_button;

	return 1;

}

/*	Convert the raw coordinates from the ELO controller

	to a screen position.

*/

void eloConvertXY(_THIS, int *dx,  int *dy) {

	int input_x = *dx;

	int input_y = *dy;

	int width = ELO_MAX_X - ELO_MIN_X;

	int height = ELO_MAX_Y - ELO_MIN_Y;

	*dx = ((int)cache_vinfo.xres - ((int)cache_vinfo.xres * (input_x - ELO_MIN_X)) / width);

	*dy = (cache_vinfo.yres * (input_y - ELO_MIN_Y)) / height;

}

/*	eloGetPacket

*/

int eloGetPacket(unsigned char* buffer, int* buffer_p, int* checksum, int fd) {

	int num_bytes;

	int ok;

	if(fd == 0) {

		num_bytes = ELO_PACKET_SIZE;

	}

	else {

		num_bytes = read(fd,

			(char *) (buffer + *buffer_p),

			ELO_PACKET_SIZE - *buffer_p);

	}

	if (num_bytes < 0) {

#ifdef DEBUG_MOUSE

		fprintf(stderr, "System error while reading from Elographics touchscreen.\n");

#endif

		return 0;

	}

	while (num_bytes) {

		if ((*buffer_p == 0) && (buffer[0] != ELO_START_BYTE)) {

			SDL_memcpy(&buffer[0], &buffer[1], num_bytes-1);

		}

		else {

			if (*buffer_p < ELO_PACKET_SIZE-1) {

				*checksum = *checksum + buffer[*buffer_p];

				*checksum = *checksum % 256;

			}

			(*buffer_p)++;

		}

		num_bytes--;

	}

	if (*buffer_p == ELO_PACKET_SIZE) {

		ok = (*checksum == buffer[ELO_PACKET_SIZE-1]);

		*checksum = ELO_INIT_CHECKSUM;

		*buffer_p = 0;

		if (!ok) {

			return 0;

		}

		return 1;

	}

	else {

		return 0;

	}

}

/* eloSendPacket

*/

int eloSendPacket(unsigned char* packet, int fd)

{

	int i, result;

	int sum = ELO_INIT_CHECKSUM;

	packet[0] = ELO_START_BYTE;

	for (i = 0; i < ELO_PACKET_SIZE-1; i++) {

		sum += packet[i];

		sum &= 0xFF;

	}

	packet[ELO_PACKET_SIZE-1] = sum;

	result = write(fd, packet, ELO_PACKET_SIZE);

	if (result != ELO_PACKET_SIZE) {

#ifdef DEBUG_MOUSE

		printf("System error while sending to Elographics touchscreen.\n");

#endif

		return 0;

	}

	else {

		return 1;

	}

}

/*	eloWaitForInput

 */

int eloWaitForInput(int fd, int timeout)

{

	fd_set readfds;

	struct timeval to;

	int r;

	FD_ZERO(&readfds);

	FD_SET(fd, &readfds);

	to.tv_sec = 0;

	to.tv_usec = timeout;

	r = select(FD_SETSIZE, &readfds, NULL, NULL, &to);

	return r;

}

/*	eloWaitReply

 */

int eloWaitReply(unsigned char type, unsigned char *reply, int fd) {

	int ok;

	int i, result;

	int reply_p = 0;

	int sum = ELO_INIT_CHECKSUM;

	i = ELO_MAX_TRIALS;

	do {

		ok = 0;

		result = eloWaitForInput(fd, ELO_MAX_WAIT);

		if (result > 0) {

			ok = eloGetPacket(reply, &reply_p, &sum, fd);

			if (ok && reply[1] != type && type != ELO_PARAMETER) {

#ifdef DEBUG_MOUSE

				fprintf(stderr, "Wrong reply received\n");

#endif

				ok = 0;

			}

		}

		else {

#ifdef DEBUG_MOUSE

			fprintf(stderr, "No input!\n");

#endif

		}

		if (result == 0) {

			i--;

		}

	} while(!ok && (i>0));

	return ok;

}

/*	eloWaitAck

 */

int eloWaitAck(int fd) {

	unsigned char packet[ELO_PACKET_SIZE];

	int i, nb_errors;

	if (eloWaitReply(ELO_ACK, packet, fd)) {

		for (i = 0, nb_errors = 0; i < 4; i++) {

			if (packet[2 + i] != '0') {

				nb_errors++;

			}

		}

		if (nb_errors != 0) {

#ifdef DEBUG_MOUSE

			fprintf(stderr, "Elographics acknowledge packet reports %d errors\n", nb_errors);

#endif

		}

		return 1;

	}

	else {

		return 0;

	}

}

/*	eloSendQuery --

*/

int eloSendQuery(unsigned char *request, unsigned char* reply, int fd) {

	int ok;

	if (eloSendPacket(request, fd)) {

		ok = eloWaitReply(toupper(request[1]), reply, fd);

		if (ok) {

			ok = eloWaitAck(fd);

		}

		return ok;

	}

	else {

		return 0;

	}

}

/*	eloSendControl

*/

int eloSendControl(unsigned char* control, int fd) {

	if (eloSendPacket(control, fd)) {

		return eloWaitAck(fd);

	}

	else {

		return 0;

	}

}

/*	eloInitController

*/

int eloInitController(int fd) {

	unsigned char req[ELO_PACKET_SIZE];

	unsigned char reply[ELO_PACKET_SIZE];

	const char *buffer = NULL;

	int result = 0;

	struct termios mouse_termios;

	/* try to read the calibration values */

	buffer = SDL_getenv("SDL_ELO_MIN_X");

	if(buffer) {

		ELO_MIN_X = SDL_atoi(buffer);

	}

	buffer = SDL_getenv("SDL_ELO_MAX_X");

	if(buffer) {

		ELO_MAX_X = SDL_atoi(buffer);

	}

	buffer = SDL_getenv("SDL_ELO_MIN_Y");

	if(buffer) {

		ELO_MIN_Y = SDL_atoi(buffer);

	}

	buffer = SDL_getenv("SDL_ELO_MAX_Y");

	if(buffer) {

		ELO_MAX_Y = SDL_atoi(buffer);

	}

#ifdef DEBUG_MOUSE

	fprintf( stderr, "ELO calibration values:\nmin_x: %i\nmax_x: %i\nmin_y: %i\nmax_y: %i\n",

		ELO_MIN_X,

		ELO_MAX_X,

		ELO_MIN_Y,

		ELO_MAX_Y);

#endif

	/* set comm params */

	SDL_memset(&mouse_termios, 0, sizeof(mouse_termios));

	mouse_termios.c_cflag = B9600 | CS8 | CREAD | CLOCAL;

	mouse_termios.c_cc[VMIN] = 1;

	result = tcsetattr(fd, TCSANOW, &mouse_termios);

	if (result < 0) {

#ifdef DEBUG_MOUSE

		fprintf( stderr, "Unable to configure Elographics touchscreen port\n");

#endif

		return 0;

	}

	SDL_memset(req, 0, ELO_PACKET_SIZE);

	req[1] = tolower(ELO_PARAMETER);

	if (!eloSendQuery(req, reply, fd)) {

#ifdef DEBUG_MOUSE

		fprintf( stderr, "Not at the specified rate or model 2310, will continue\n");

#endif

	}

	SDL_memset(req, 0, ELO_PACKET_SIZE);

	req[1] = tolower(ELO_ID);

	if (eloSendQuery(req, reply, fd)) {

#ifdef DEBUG_MOUSE

		fprintf(stderr, "Ok, controller configured!\n");

#endif

	}

	else {

#ifdef DEBUG_MOUSE

		fprintf( stderr, "Unable to ask Elographics touchscreen identification\n");

#endif

		return 0;

	}

	SDL_memset(req, 0, ELO_PACKET_SIZE);

	req[1] = ELO_MODE;

	req[3] = ELO_TOUCH_MODE | ELO_STREAM_MODE | ELO_UNTOUCH_MODE;

	req[4] = ELO_TRACKING_MODE;

	if (!eloSendControl(req, fd)) {

#ifdef DEBUG_MOUSE

		fprintf( stderr, "Unable to change Elographics touchscreen operating mode\n");

#endif

		return 0;

	}

	SDL_memset(req, 0, ELO_PACKET_SIZE);

	req[1] = ELO_REPORT;

	req[2] = ELO_UNTOUCH_DELAY;

	req[3] = ELO_REPORT_DELAY;

	if (!eloSendControl(req, fd)) {

#ifdef DEBUG_MOUSE

		fprintf( stderr, "Unable to change Elographics touchscreen reports timings\n");

#endif

		return 0;

	}

	return 1;

}

int eloReadPosition(_THIS, int fd, int* x, int* y, int* button_state, int* realx, int* realy) {

        unsigned char buffer[ELO_PACKET_SIZE];

        int pointer = 0;

        int checksum = ELO_INIT_CHECKSUM;

        while(pointer < ELO_PACKET_SIZE) {

                if(eloGetPacket(buffer, &pointer, &checksum, fd)) {

                        break;

                }

        }

        if(!eloParsePacket(buffer, realx, realy, button_state)) {

                return 0;

        }

        *x = *realx;

        *y = *realy;

        eloConvertXY(this, x, y);

	return 1;

}