/*****************************************************************************
 *
 * grail - Gesture Recognition And Instantiation Library
 *
 * Copyright (C) 2010 Canonical Ltd.
 * Copyright (C) 2010 Henrik Rydberg <rydberg@bitmath.org>
 *
 * This program 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 3 of the License, or (at your
 * option) any later version.
 *
 * This program 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 this program.  If not, see <http://www.gnu.org/licenses/>.
 *
 ****************************************************************************/

#include "grail-inserter.h"
#include "grail-recognizer.h"
#include <grail.h>
#include <string.h>
#include <stdio.h>
#include <unistd.h>
#include <fcntl.h>
#include <malloc.h>
#include <errno.h>
#include "evbuf.h"

struct grail_impl {
	struct touch_dev dev;
	struct touch_engine engine;
	struct evbuf evbuf;
};

static void tp_event(struct touch_engine *engine,
		     const struct input_event *ev)
{
	struct grail *ge = engine->priv;
	struct grail_impl *x = ge->impl;
	evbuf_put(&x->evbuf, ev);
}

static void tp_sync(struct touch_engine *engine,
		    const struct input_event *syn)
{
	struct input_event ev;
	struct grail *ge = engine->priv;
	struct grail_impl *x = ge->impl;
	struct touch_frame *frame = &engine->frame;
	grail_mask_t filtered[DIM_EV_TYPE_BYTES];
	int nevent = 0;
	gin_frame_begin(ge, frame);
	gru_recognize(ge, frame);
	gin_frame_end(ge, filtered, sizeof(filtered), frame);
	if (!ge->event) {
		evbuf_clear(&x->evbuf);
		return;
	}
	while (!evbuf_empty(&x->evbuf)) {
		evbuf_get(&x->evbuf, &ev);
		if (grail_mask_get(filtered, ev.type))
			continue;
		ge->event(ge, &ev);
		nevent++;
	}
	if (nevent)
		ge->event(ge, syn);
}

int grail_open(struct grail *ge, int fd)
{
	struct grail_impl *x;
	int ret;
	x = calloc(1, sizeof(*x));
	if (!x)
		return -ENOMEM;
	ge->impl = x;
	ret = gin_init(ge);
	if (ret)
		goto freemem;
	ret = touch_dev_open(&x->dev, fd);
	if (ret)
		goto freegin;
	ret = gru_init(ge);
	if (ret)
		goto freedev;
	touch_engine_init(&x->engine, tp_event, tp_sync, ge);
	touch_engine_attach(&x->engine, &x->dev);
	return 0;
 freedev:
	touch_dev_close(&x->dev, fd);
 freegin:
	gin_destroy(ge);
 freemem:
	free(x);
	ge->impl = 0;
	return ret;
}

void grail_close(struct grail *ge, int fd)
{
	struct grail_impl *x = ge->impl;
	void *status;
	touch_engine_detach(&x->engine, &x->dev);
	gru_destroy(ge);
	touch_dev_close(&x->dev, fd);
	gin_destroy(ge);
	free(ge->impl);
	ge->impl = 0;
}

int grail_idle(struct grail *ge, int fd, int ms)
{
	struct grail_impl *x = ge->impl;
	return touch_dev_idle(&x->dev, fd, ms);
}

int grail_pull(struct grail *ge, int fd)
{
	struct grail_impl *x = ge->impl;
	return touch_dev_pull(&x->dev, fd);
}

void grail_get_units(struct grail_coord *min, struct grail_coord *max,
		     const struct grail *ge)
{
	const struct touch_dev_caps *caps = &ge->impl->dev.caps;
	min->x = caps->info[TP_POS_X].minimum;
	min->y = caps->info[TP_POS_Y].minimum;
	max->x = caps->info[TP_POS_X].maximum;
	max->y = caps->info[TP_POS_Y].maximum;
}