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

#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <termios.h>

#include "event.h"
#include "lcd.h"
#include "logging.h"

#define _LCD_DEBUG	1

#define LCD_RESET_TIMEOUT_US	250000				/* 250ms */
#define LCD_RESET_RETRY_TIMEOUT	10				/* 10s */

#define A125_CMD_GETBUTTON	{ 0x4D, 0x06 }			// not tried
#define A125_CMD_SETLINE	{ 0x4D, 0x0C, 0x00, 0x10 }	// [2] is line, append 16 chars
#define A125_CMD_CLEAR		{ 0x4D, 0x0D }			// works, but slow
#define A125_CMD_BACKLIGHT	{ 0x4D, 0x5E, 0x00 }		// [2] is on/off
#define A125_CMD_RESET		{ 0x4D, 0xFF }

#define A125_EVENT_ID		{ 0x53, 0x01 }			// never seen
#define A125_EVENT_BUTTON1	{ 0x53, 0x05, 0x00, 0x01 }
#define A125_EVENT_BUTTON2	{ 0x53, 0x05, 0x00, 0x02 }
#define A125_EVENT_VERSION	{ 0x53, 0x08 }			// never seen
#define A125_EVENT_ACTINFO	{ 0x53, 0xAA }
#define A125_EVENT_INVALID	{ 0x53, 0xFB }			// never seen

enum lcdstate {
	LCD_STATE_NOT_INITIALIZED = 0x00,
	LCD_STATE_INITIALIZING,
	LCD_STATE_INITIALIZING_FAILED,
	LCD_STATE_READY,
};

struct lcddev {
	int fd;
	struct termios oldtio;

	int backlight_time;
	enum lcdstate state;

	int (*button_cb)(struct lcddev *dev, int button, void *privdata);
	void *privdata;

	const char *line_data[2];
	int scrollpos;

	struct event_fd *read_event;
	struct event_timeout *reset_timeout;
	struct event_timeout *backlight_timeout;
	struct event_timeout *scroll_timeout;
};

void lcd_close(struct lcddev *dev)
{
	tcsetattr(dev->fd, TCSANOW, &dev->oldtio);
	close(dev->fd);
}

static int lcd_open(struct lcddev *dev, const char *device)
{
	dev->fd = open(device, O_RDWR);
	if (dev->fd < 0) {
		log_print(LOG_ERROR, "failed to open '%s'", device);
		return -1;
	}

	tcgetattr(dev->fd, &dev->oldtio);

	struct termios newtio;
	memset(&newtio, 0, sizeof(newtio));
	newtio.c_iflag |= IGNBRK;
	newtio.c_lflag &= ~(ISIG | ICANON | ECHO);
	newtio.c_cflag = B1200 | CS8 | CLOCAL | CREAD;
	newtio.c_cc[VMIN] = 1;
	newtio.c_cc[VTIME] = 0;
	cfsetospeed(&newtio, B1200);
	cfsetispeed(&newtio, B1200);

	int err = tcsetattr(dev->fd, TCSAFLUSH, &newtio);
	if (err < 0) {
		log_print(LOG_ERROR, "failed to set termios");
		close(dev->fd);
		return -1;
	}

	return 0;
}

static int lcd_read(struct lcddev *dev, const char *buf, int len)
{
	int retval = 0, i, cnt = 0;
	while (cnt < len) {
		retval = read(dev->fd, (char *)buf + cnt, len - cnt);
		if (retval <= 0)
			break;

		cnt += retval;
	}
#if _LCD_DEBUG
	fprintf(stderr, "lcd_read[%d/%d]: ", cnt, len);
	for (i = 0; i < cnt; i++)
		fprintf(stderr, "0x%X ", (unsigned char)buf[i]);
	fprintf(stderr, "\n");
#endif
	return (cnt != 0) ? cnt : retval;
}

static int lcd_write(struct lcddev *dev, char *buf, int len)
{
	int retval, i;

	retval = write(dev->fd, buf, len);
#if _LCD_DEBUG
	fprintf(stderr, "lcd_write[%d/%d]: ", retval, len);
	for (i = 0; i < retval; i++)
		fprintf(stderr, "0x%X ", (unsigned char)buf[i]);

	if (len == 20) {
		fprintf(stderr, "'%-16s'", buf + 4);
	}

	fprintf(stderr, "\n");
#endif
	return retval;
}

static int lcd_reset_retry_timeout_cb(void *privdata)
{
	struct lcddev *dev = (struct lcddev *)privdata;

	lcd_reset(dev);
	return -1; /* singleshot */
}

static int lcd_reset_timeout_cb(void *privdata)
{
	struct lcddev *dev = (struct lcddev *)privdata;

	log_print(LOG_ERROR, "failed to initalize LCD");
	dev->state = LCD_STATE_INITIALIZING_FAILED;

	struct timeval tv = { .tv_sec = LCD_RESET_RETRY_TIMEOUT };
	dev->reset_timeout = event_add_timeout(&tv, lcd_reset_retry_timeout_cb, dev);

	return -1; /* singleshot */
}

void lcd_reset(struct lcddev *dev)
{
	char cmd[] = A125_CMD_RESET;
	lcd_write(dev, cmd, sizeof(cmd));

	dev->state = LCD_STATE_INITIALIZING;

	struct timeval tv = { .tv_usec = LCD_RESET_TIMEOUT_US };
	dev->reset_timeout = event_add_timeout(&tv, lcd_reset_timeout_cb, dev);
}

static int lcd_backlight(struct lcddev *dev, int mode)
{
	if (dev->state != LCD_STATE_READY)
		return -1;

	char cmd[] = A125_CMD_BACKLIGHT;
	cmd[2] = (mode) ? 0x01 : 0x00;
	lcd_write(dev, cmd, sizeof(cmd));
	return 0;
}

static int lcd_backlight_timeout_cb(void *privdata)
{
	struct lcddev *dev = (struct lcddev *)privdata;
	dev->backlight_timeout = NULL;

	lcd_backlight(dev, 0);
	return -1; /* singleshot */
}

int lcd_trigger_backlight(struct lcddev *dev, int timeout)
{
	if (dev->backlight_timeout != NULL) {
		event_remove_timeout(dev->backlight_timeout);
		dev->backlight_timeout = NULL;
	}

	int retval = lcd_backlight(dev, 1);

	struct timeval tv = { .tv_sec = timeout };
	dev->backlight_timeout = event_add_timeout(&tv, lcd_backlight_timeout_cb, dev);

	return retval;
}

static int lcd_read_cb(int fd, void *privdata)
{
	struct lcddev *dev = (struct lcddev *)privdata;

	char buf[4];
	int size = (dev->state != LCD_STATE_INITIALIZING) ? sizeof(buf) : 2;
	int len = lcd_read(dev, buf, size);

	int retval = 0;
	if (dev->state == LCD_STATE_INITIALIZING) {
		char expect[] = A125_EVENT_ACTINFO;

		if (len != sizeof(expect))
			return 0;

		if (memcmp(buf, expect, sizeof(expect)) == 0) {
			event_remove_timeout(dev->reset_timeout);
			dev->reset_timeout = NULL;

			dev->state = LCD_STATE_READY;

			/* trigger application to set data */
			retval = dev->button_cb(dev, LCD_BUTTON0, dev->privdata);
		}

	} else if (dev->state == LCD_STATE_READY) {
		char expect1[] = A125_EVENT_BUTTON1;
		char expect2[] = A125_EVENT_BUTTON2;

		if (len != sizeof(expect1) && len != sizeof(expect2))
			return 0;

		if (memcmp(buf, expect1, sizeof(buf)) == 0) {
			retval = dev->button_cb(dev, LCD_BUTTON1, dev->privdata);

		} else if (memcmp(buf, expect2, sizeof(buf)) == 0) {
			retval = dev->button_cb(dev, LCD_BUTTON2, dev->privdata);
		}
	}

	if (retval)
		lcd_trigger_backlight(dev, dev->backlight_time);

	return 0;
}

static int lcd_setline(struct lcddev *dev, int line, const char *buf)
{
	if (dev->state != LCD_STATE_READY)
		return -1;

	char cmd[20] = A125_CMD_SETLINE;
	cmd[2] = line;

	memset(cmd +4, ' ', 16);
	int len = strlen(buf);
	memcpy(cmd +4, buf, (len > 16) ? 16 : len);

	lcd_write(dev, cmd, sizeof(cmd));
	return 0;
}

static int lcd_scroll_timeout_cb(void *privdata)
{
	// TODO: scrolling

	return 0; /* periodic */
}

int lcd_setlines(struct lcddev *dev, int scrollspeed, const char *line1, const char *line2)
{
	dev->line_data[0] = line1;
	lcd_setline(dev, 0, line1);

	dev->line_data[1] = line2;
	lcd_setline(dev, 1, line2);

	if (dev->scroll_timeout) {
		event_remove_timeout(dev->scroll_timeout);
		dev->scroll_timeout = NULL;
	}

	if (scrollspeed) {
		struct timeval tv = { .tv_usec = scrollspeed };
		dev->scroll_timeout = event_add_timeout(&tv, lcd_scroll_timeout_cb, dev);
	}

	return 0;
}

struct lcddev * lcd_init(const char *devicename,
			 int backlight_time,
			 int (*button_cb)(struct lcddev *dev, int button, void *privdata),
			 void *privdata)
{
	struct lcddev *dev = malloc(sizeof(struct lcddev));
	if (dev == NULL) {
		log_print(LOG_ERROR, "lcd_init(): out of memory");
		return NULL;
	}

	memset(dev, 0, sizeof(struct lcddev));

	if (lcd_open(dev, devicename) < 0) {
		free(dev);
		return NULL;
	}

	dev->backlight_time = backlight_time;
	dev->button_cb = button_cb;
	dev->privdata = privdata;

	dev->read_event = event_add_readfd(NULL, dev->fd, lcd_read_cb, dev);

	lcd_reset(dev);
	return dev;
}