/*
 * Copyright 2012 Intel Corporation
 * Copyright 2017-2018 Collabora, Ltd.
 * Copyright 2017-2018 General Electric Company
 *
 * Permission is hereby granted, free of charge, to any person obtaining a
 * copy of this software and associated documentation files (the "Software"),
 * to deal in the Software without restriction, including without limitation
 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
 * and/or sell copies of the Software, and to permit persons to whom the
 * Software is furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice (including the next
 * paragraph) shall be included in all copies or substantial portions of the
 * Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
 * DEALINGS IN THE SOFTWARE.
 */

#include "config.h"

#include <stdint.h>
#include <stdbool.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <cairo.h>
#include <math.h>
#include <assert.h>
#include <getopt.h>
#include <errno.h>

#include <wayland-client.h>

#include "clients/window.h"
#include "shared/helpers.h"
#include <libweston/matrix.h>

#include "weston-touch-calibration-client-protocol.h"

enum exit_code {
	CAL_EXIT_SUCCESS = 0,
	CAL_EXIT_ERROR = 1,
	CAL_EXIT_CANCELLED = 2,
};

static int debug_;
static int verbose_;

#define pr_ver(...) do { \
	if (verbose_) \
		printf(__VA_ARGS__); \
} while (0)

#define pr_dbg(...) do { \
	if (debug_) \
		fprintf(stderr, __VA_ARGS__); \
} while (0)

static void
pr_err(const char *fmt, ...) WL_PRINTF(1, 2);

/* Our points for the calibration must be not be on a line */
static const struct {
	float x_ratio, y_ratio;
} test_ratios[] =  {
	{ 0.15, 0.10 }, /* three points for calibration */
	{ 0.85, 0.13 },
	{ 0.20, 0.80 },
	{ 0.70, 0.75 }  /* and one for verification */
};

#define NR_SAMPLES ((int)ARRAY_LENGTH(test_ratios))

struct point {
	double x;
	double y;
};

struct sample {
	int ind;
	struct point drawn;	/**< drawn point, pixels */
	struct weston_touch_coordinate *pending;
	struct point drawn_cal;	/**< drawn point, converted */
	bool conv_done;
	struct point touched;	/**< touch point, normalized */
	bool touch_done;
};

struct poly {
	struct color {
		double r, g, b, a;
	} color;
	int n_verts;
	const struct point *verts;
};

/** Touch event handling state machine
 *
 * Only a complete down->up->frame sequence should be accepted with user
 * feedback "right", and anything that deviates from that (invalid_touch,
 * cancel, multiple touch-downs) needs to undo the current sample and
 * possibly show user feedback "wrong".
 *
 * <STATE>
 * - <triggers>: <actions>
 *
 * IDLE
 * - touch down: sample, -> DOWN
 * - touch up: no-op
 * - frame: no-op
 * - invalid_touch: (undo), wrong, -> WAIT
 * - cancel: no-op
 * DOWN (first touch down)
 * - touch down: undo, wrong, -> WAIT
 * - touch up: -> UP
 * - frame: no-op
 * - invalid_touch: undo, wrong, -> WAIT
 * - cancel: undo, -> IDLE
 * UP (first touch was down and up)
 * - touch down: undo, wrong, -> WAIT
 * - touch up: no-op
 * - frame: right, touch finish, -> WAIT
 * - invalid_touch: undo, wrong, -> WAIT
 * - cancel: undo, -> IDLE
 * WAIT (show user feedback)
 * - touch down: no-op
 * - touch up: no-op
 * - frame, cancel, timer: if num_tp == 0 && timer_done -> IDLE
 * - invalid_touch: no-op
 */
enum touch_state {
	STATE_IDLE,
	STATE_DOWN,
	STATE_UP,
	STATE_WAIT
};

struct calibrator {
	struct sample samples[NR_SAMPLES];
	int current_sample;

	struct display *display;
	struct weston_touch_calibration *calibration;
	struct weston_touch_calibrator *calibrator;
	struct window *window;
	struct widget *widget;

	int n_devices_listed;
	char *match_name;
	char *device_name;

	int width;
	int height;

	bool cancelled;

	const struct poly *current_poly;
	bool exiting;

	struct toytimer wait_timer;
	bool timer_pending;
	enum touch_state state;

	int num_tp;		/* touch points down count */
};

static struct sample *
current_sample(struct calibrator *cal)
{
	return &cal->samples[cal->current_sample];
}

static void
sample_start(struct calibrator *cal, int i)
{
	struct sample *s = &cal->samples[i];

	assert(i >= 0 && i < NR_SAMPLES);

	s->ind = i;
	s->drawn.x = round(test_ratios[i].x_ratio * cal->width);
	s->drawn.y = round(test_ratios[i].y_ratio * cal->height);
	s->pending = NULL;
	s->conv_done = false;
	s->touch_done = false;

	cal->current_sample = i;
}

static struct point
wire_to_point(uint32_t xu, uint32_t yu)
{
	struct point p = {
		.x = (double)xu / 0xffffffff,
		.y = (double)yu / 0xffffffff
	};

	return p;
}

static void
sample_touch_down(struct calibrator *cal, uint32_t xu, uint32_t yu)
{
	struct sample *s = current_sample(cal);

	s->touched = wire_to_point(xu, yu);
	s->touch_done = true;

	pr_dbg("Down[%d] (%f, %f)\n", s->ind, s->touched.x, s->touched.y);
}

static void
coordinate_result_handler(void *data, struct weston_touch_coordinate *interface,
			  uint32_t xu, uint32_t yu)
{
	struct sample *s = data;

	weston_touch_coordinate_destroy(s->pending);
	s->pending = NULL;

	s->drawn_cal = wire_to_point(xu, yu);
	s->conv_done = true;

	pr_dbg("Conv[%d] (%f, %f)\n", s->ind, s->drawn_cal.x, s->drawn_cal.y);
}

struct weston_touch_coordinate_listener coordinate_listener = {
	coordinate_result_handler
};

static void
sample_undo(struct calibrator *cal)
{
	struct sample *s = current_sample(cal);

	pr_dbg("Undo[%d]\n", s->ind);

	s->touch_done = false;
	s->conv_done = false;
	if (s->pending) {
		weston_touch_coordinate_destroy(s->pending);
		s->pending = NULL;
	}
}

static void
sample_finish(struct calibrator *cal)
{
	struct sample *s = current_sample(cal);

	pr_dbg("Finish[%d]\n", s->ind);

	assert(!s->pending && !s->conv_done);

	s->pending = weston_touch_calibrator_convert(cal->calibrator,
						     (int32_t)s->drawn.x,
						     (int32_t)s->drawn.y);
	weston_touch_coordinate_add_listener(s->pending,
					     &coordinate_listener, s);

	if (cal->current_sample + 1 < NR_SAMPLES) {
		sample_start(cal, cal->current_sample + 1);
	} else {
		pr_dbg("got all touches\n");
		cal->exiting = true;
	}
}

/*
 * Calibration algorithm:
 *
 * The equation we want to apply at event time where x' and y' are the
 * calibrated co-ordinates.
 *
 * x' = Ax + By + C
 * y' = Dx + Ey + F
 *
 * For example "zero calibration" would be A=1.0 B=0.0 C=0.0, D=0.0, E=1.0,
 * and F=0.0.
 *
 * With 6 unknowns we need 6 equations to find the constants:
 *
 * x1' = Ax1 + By1 + C
 * y1' = Dx1 + Ey1 + F
 * ...
 * x3' = Ax3 + By3 + C
 * y3' = Dx3 + Ey3 + F
 *
 * In matrix form:
 *
 * x1'   x1 y1 1      A
 * x2' = x2 y2 1  x   B
 * x3'   x3 y3 1      C
 *
 * So making the matrix M we can find the constants with:
 *
 * A            x1'
 * B = M^-1  x  x2'
 * C            x3'
 *
 * (and similarly for D, E and F)
 *
 * For the calibration the desired values x, y are the same values at which
 * we've drawn at.
 *
 */
static int
compute_calibration(struct calibrator *cal, float *result)
{
	struct weston_matrix m;
	struct weston_matrix inverse;
	struct weston_vector x_calib;
	struct weston_vector y_calib;
	int i;

	assert(NR_SAMPLES >= 3);

	/*
	 * x1 y1  1  0
	 * x2 y2  1  0
	 * x3 y3  1  0
	 *  0  0  0  1
	 */
	weston_matrix_init(&m);
	for (i = 0; i < 3; i++) {
		m.d[i + 0] = cal->samples[i].touched.x;
		m.d[i + 4] = cal->samples[i].touched.y;
		m.d[i + 8] = 1.0f;
	}
	m.type = WESTON_MATRIX_TRANSFORM_OTHER;

	if (weston_matrix_invert(&inverse, &m) < 0) {
		pr_err("non-invertible matrix during computation\n");
		return -1;
	}

	for (i = 0; i < 3; i++) {
		x_calib.f[i] = cal->samples[i].drawn_cal.x;
		y_calib.f[i] = cal->samples[i].drawn_cal.y;
	}
	x_calib.f[3] = 0.0f;
	y_calib.f[3] = 0.0f;

	/* Multiples into the vector */
	weston_matrix_transform(&inverse, &x_calib);
	weston_matrix_transform(&inverse, &y_calib);

	for (i = 0; i < 3; i++)
		result[i] = x_calib.f[i];
	for (i = 0; i < 3; i++)
		result[i + 3] = y_calib.f[i];

	return 0;
}

static int
verify_calibration(struct calibrator *cal, const float *r)
{
	double thr = 0.1; /* accepted error radius */
	struct point e; /* expected value; error */
	const struct sample *s = &cal->samples[3];

	/* transform raw touches through the matrix */
	e.x = r[0] * s->touched.x + r[1] * s->touched.y + r[2];
	e.y = r[3] * s->touched.x + r[4] * s->touched.y + r[5];

	/* compute error */
	e.x -= s->drawn_cal.x;
	e.y -= s->drawn_cal.y;

	pr_dbg("calibration test error: %f, %f\n", e.x, e.y);

	if (e.x * e.x + e.y * e.y < thr * thr)
		return 0;

	pr_err("Calibration verification failed, too large error.\n");
	return -1;
}

static void
send_calibration(struct calibrator *cal, float *values)
{
	struct wl_array matrix;
	float *f;
	int i;

	wl_array_init(&matrix);
	for (i = 0; i < 6; i++) {
		f = wl_array_add(&matrix, sizeof *f);
		*f = values[i];
	}
	weston_touch_calibration_save(cal->calibration,
				      cal->device_name, &matrix);
	wl_array_release(&matrix);
}

static const struct point cross_verts[] = {
	{ 0.1, 0.2 },
	{ 0.2, 0.1 },
	{ 0.5, 0.4 },
	{ 0.8, 0.1 },
	{ 0.9, 0.2 },
	{ 0.6, 0.5 },
	{ 0.9, 0.8 },
	{ 0.8, 0.9 },
	{ 0.5, 0.6 },
	{ 0.2, 0.9 },
	{ 0.1, 0.8 },
	{ 0.4, 0.5 },
};

/* a red cross, for "wrong" */
static const struct poly cross = {
	.color = { 0.7, 0.0, 0.0, 1.0 },
	.n_verts = ARRAY_LENGTH(cross_verts),
	.verts = cross_verts
};

static const struct point check_verts[] = {
	{ 0.5, 0.7 },
	{ 0.8, 0.1 },
	{ 0.9, 0.1 },
	{ 0.55, 0.8 },
	{ 0.45, 0.8 },
	{ 0.3, 0.5 },
	{ 0.4, 0.5 }
};

/* a green check mark, for "right" */
static const struct poly check = {
	.color = { 0.0, 0.7, 0.0, 1.0 },
	.n_verts = ARRAY_LENGTH(check_verts),
	.verts = check_verts
};

static void
draw_poly(cairo_t *cr, const struct poly *poly)
{
	int i;

	cairo_set_source_rgba(cr, poly->color.r, poly->color.g,
			      poly->color.b, poly->color.a);
	cairo_move_to(cr, poly->verts[0].x, poly->verts[0].y);
	for (i = 1; i < poly->n_verts; i++)
		cairo_line_to(cr, poly->verts[i].x, poly->verts[i].y);
	cairo_close_path(cr);
	cairo_fill(cr);
}

static void
feedback_show(struct calibrator *cal, const struct poly *what)
{
	cal->current_poly = what;
	widget_schedule_redraw(cal->widget);

	toytimer_arm_once_usec(&cal->wait_timer, 1000 * 1000);
	cal->timer_pending = true;
}

static void
feedback_hide(struct calibrator *cal)
{
	cal->current_poly = NULL;
	widget_schedule_redraw(cal->widget);
}

static void
try_enter_state_idle(struct calibrator *cal)
{
	if (cal->num_tp != 0)
		return;

	if (cal->timer_pending)
		return;

	cal->state = STATE_IDLE;

	feedback_hide(cal);

	if (cal->exiting)
		display_exit(cal->display);
}

static void
enter_state_wait(struct calibrator *cal)
{
	assert(cal->timer_pending);
	cal->state = STATE_WAIT;
}

static void
wait_timer_done(struct toytimer *tt)
{
	struct calibrator *cal = container_of(tt, struct calibrator, wait_timer);

	assert(cal->state == STATE_WAIT);
	cal->timer_pending = false;
	try_enter_state_idle(cal);
}

static void
redraw_handler(struct widget *widget, void *data)
{
	struct calibrator *cal = data;
	struct sample *s = current_sample(cal);
	struct rectangle allocation;
	cairo_surface_t *surface;
	cairo_t *cr;

	widget_get_allocation(cal->widget, &allocation);
	assert(allocation.width == cal->width);
	assert(allocation.height == cal->height);

	surface = window_get_surface(cal->window);
	cr = cairo_create(surface);
	cairo_set_operator(cr, CAIRO_OPERATOR_SOURCE);
	cairo_set_source_rgba(cr, 1.0, 1.0, 1.0, 1.0);
	cairo_paint(cr);

	if (!cal->current_poly) {
		cairo_translate(cr, s->drawn.x, s->drawn.y);
		cairo_set_line_width(cr, 2.0);
		cairo_set_source_rgb(cr, 0.7, 0.0, 0.0);
		cairo_move_to(cr, 0, -10.0);
		cairo_line_to(cr, 0, 10.0);
		cairo_stroke(cr);
		cairo_move_to(cr, -10.0, 0);
		cairo_line_to(cr, 10.0, 0.0);
		cairo_stroke(cr);
	} else {
		cairo_scale(cr, allocation.width, allocation.height);
		draw_poly(cr, cal->current_poly);
	}

	cairo_destroy(cr);
	cairo_surface_destroy(surface);
}

static struct calibrator *
calibrator_create(struct display *display, const char *match_name)
{
	struct calibrator *cal;

	cal = zalloc(sizeof *cal);
	if (!cal)
		abort();

	cal->match_name = match_name ? strdup(match_name) : NULL;
	cal->window = window_create_custom(display);
	cal->widget = window_add_widget(cal->window, cal);
	window_inhibit_redraw(cal->window);
	window_set_title(cal->window, "Touchscreen calibrator");
	cal->display = display;

	widget_set_redraw_handler(cal->widget, redraw_handler);

	toytimer_init(&cal->wait_timer, CLOCK_MONOTONIC,
		      display, wait_timer_done);

	cal->state = STATE_IDLE;
	cal->num_tp = 0;

	return cal;
}

static void
configure_handler(void *data, struct weston_touch_calibrator *interface,
		  int32_t width, int32_t height)
{
	struct calibrator *cal = data;

	pr_dbg("Configure calibrator window to size %ix%i\n", width, height);
	cal->width = width;
	cal->height = height;
	window_schedule_resize(cal->window, width, height);
	window_uninhibit_redraw(cal->window);

	sample_start(cal, 0);
	widget_schedule_redraw(cal->widget);
}

static void
cancel_calibration_handler(void *data, struct weston_touch_calibrator *interface)
{
	struct calibrator *cal = data;

	pr_dbg("calibration cancelled by the display server, quitting.\n");
	cal->cancelled = true;
	display_exit(cal->display);
}

static void
invalid_touch_handler(void *data, struct weston_touch_calibrator *interface)
{
	struct calibrator *cal = data;

	pr_dbg("invalid touch\n");

	switch (cal->state) {
	case STATE_IDLE:
	case STATE_DOWN:
	case STATE_UP:
		sample_undo(cal);
		feedback_show(cal, &cross);
		enter_state_wait(cal);
		break;
	case STATE_WAIT:
		/* no-op */
		break;
	}
}

static void
down_handler(void *data, struct weston_touch_calibrator *interface,
	     uint32_t time, int32_t id, uint32_t xu, uint32_t yu)
{
	struct calibrator *cal = data;

	cal->num_tp++;

	switch (cal->state) {
	case STATE_IDLE:
		sample_touch_down(cal, xu, yu);
		cal->state = STATE_DOWN;
		break;
	case STATE_DOWN:
	case STATE_UP:
		sample_undo(cal);
		feedback_show(cal, &cross);
		enter_state_wait(cal);
		break;
	case STATE_WAIT:
		/* no-op */
		break;
	}

	if (cal->current_poly)
		return;
}

static void
up_handler(void *data, struct weston_touch_calibrator *interface,
	   uint32_t time, int32_t id)
{
	struct calibrator *cal = data;

	cal->num_tp--;
	if (cal->num_tp < 0) {
		pr_dbg("Unmatched touch up.\n");
		cal->num_tp = 0;
	}

	switch (cal->state) {
	case STATE_DOWN:
		cal->state = STATE_UP;
		break;
	case STATE_IDLE:
	case STATE_UP:
	case STATE_WAIT:
		/* no-op */
		break;
	}
}

static void
motion_handler(void *data, struct weston_touch_calibrator *interface,
	       uint32_t time, int32_t id, uint32_t xu, uint32_t yu)
{
	/* motion is ignored */
}

static void
frame_handler(void *data, struct weston_touch_calibrator *interface)
{
	struct calibrator *cal = data;

	switch (cal->state) {
	case STATE_IDLE:
	case STATE_DOWN:
		/* no-op */
		break;
	case STATE_UP:
		feedback_show(cal, &check);
		sample_finish(cal);
		enter_state_wait(cal);
		break;
	case STATE_WAIT:
		try_enter_state_idle(cal);
		break;
	}
}

static void
cancel_handler(void *data, struct weston_touch_calibrator *interface)
{
	struct calibrator *cal = data;

	cal->num_tp = 0;

	switch (cal->state) {
	case STATE_IDLE:
		/* no-op */
		break;
	case STATE_DOWN:
	case STATE_UP:
		sample_undo(cal);
		try_enter_state_idle(cal);
		break;
	case STATE_WAIT:
		try_enter_state_idle(cal);
		break;
	}
}

struct weston_touch_calibrator_listener calibrator_listener = {
	configure_handler,
	cancel_calibration_handler,
	invalid_touch_handler,
	down_handler,
	up_handler,
	motion_handler,
	frame_handler,
	cancel_handler
};

static void
calibrator_show(struct calibrator *cal)
{
	struct wl_surface *surface = window_get_wl_surface(cal->window);

	cal->calibrator =
		weston_touch_calibration_create_calibrator(cal->calibration,
							   surface,
							   cal->device_name);
	weston_touch_calibrator_add_listener(cal->calibrator,
					     &calibrator_listener, cal);
}

static void
calibrator_destroy(struct calibrator *cal)
{
	toytimer_fini(&cal->wait_timer);
	if (cal->calibrator)
		weston_touch_calibrator_destroy(cal->calibrator);
	if (cal->calibration)
		weston_touch_calibration_destroy(cal->calibration);
	if (cal->widget)
		widget_destroy(cal->widget);
	if (cal->window)
		window_destroy(cal->window);
	free(cal->match_name);
	free(cal->device_name);
	free(cal);
}

static void
touch_device_handler(void *data, struct weston_touch_calibration *c,
		     const char *device, const char *head)
{
	struct calibrator *cal = data;

	cal->n_devices_listed++;

	if (!cal->match_name) {
		printf("device \"%s\" - head \"%s\"\n", device, head);
		return;
	}

	if (cal->device_name)
		return;

	if (strcmp(cal->match_name, device) == 0 ||
	    strcmp(cal->match_name, head) == 0)
		cal->device_name = strdup(device);
}

struct weston_touch_calibration_listener touch_calibration_listener = {
	touch_device_handler
};

static void
global_handler(struct display *display, uint32_t name,
	       const char *interface, uint32_t version, void *data)
{
	struct calibrator *cal = data;

	if (strcmp(interface, "weston_touch_calibration") == 0) {
		cal->calibration = display_bind(display, name,
						&weston_touch_calibration_interface, 1);
		weston_touch_calibration_add_listener(cal->calibration,
						      &touch_calibration_listener,
						      cal);
	}
}

static int
calibrator_run(struct calibrator *cal)
{
	struct wl_display *dpy;
	struct sample *s;
	bool wait;
	int i;
	int ret;
	float result[6];

	calibrator_show(cal);
	display_run(cal->display);

	if (cal->cancelled)
		return CAL_EXIT_CANCELLED;

	/* remove the window, no more input events */
	widget_destroy(cal->widget);
	cal->widget = NULL;
	window_destroy(cal->window);
	cal->window = NULL;

	/* wait for all conversions to return */
	dpy = display_get_display(cal->display);
	do {
		wait = false;

		for (i = 0; i < NR_SAMPLES; i++)
			if (cal->samples[i].pending)
				wait = true;

		if (wait) {
			ret = wl_display_roundtrip(dpy);
			if (ret < 0)
				return CAL_EXIT_ERROR;
		}
	} while (wait);

	for (i = 0; i < NR_SAMPLES; i++) {
		s = &cal->samples[i];
		if (!s->conv_done || !s->touch_done)
			return CAL_EXIT_ERROR;
	}

	if (compute_calibration(cal, result) < 0)
		return CAL_EXIT_ERROR;

	if (verify_calibration(cal, result) < 0)
		return CAL_EXIT_ERROR;

	pr_ver("Calibration values:");
	for (i = 0; i < 6; i++)
		pr_ver(" %f", result[i]);
	pr_ver("\n");

	send_calibration(cal, result);
	ret = wl_display_roundtrip(dpy);
	if (ret < 0)
		return CAL_EXIT_ERROR;

	return CAL_EXIT_SUCCESS;
}

static void
pr_err(const char *fmt, ...)
{
	va_list argp;

	va_start(argp, fmt);
	fprintf(stderr, "%s error: ", program_invocation_short_name);
	vfprintf(stderr, fmt, argp);
	va_end(argp);
}

static void
help(void)
{
	fprintf(stderr, "Compute a touchscreen calibration matrix for "
		"a Wayland compositor by\n"
		"having the user touch points on the screen.\n\n");
	fprintf(stderr, "Usage: %s [options...] name\n\n",
		program_invocation_short_name);
	fprintf(stderr,
		"Where 'name' can be a touch device sys path or a head name.\n"
		"If 'name' is not given, all devices available for "
		"calibration will be listed.\n"
		"If 'name' is given, it must be exactly as listed.\n"
		"Options:\n"
		"  --debug         Print messages to help debugging.\n"
		"  -h, --help      Display this help message\n"
		"  -v, --verbose   Print list header and calibration result.\n");
}

int
main(int argc, char *argv[])
{
	struct display *display;
	struct calibrator *cal;
	int c;
	char *match_name = NULL;
	int exit_code = CAL_EXIT_SUCCESS;
	static const struct option opts[] = {
		{ "help",    no_argument,       NULL,      'h' },
		{ "debug",   no_argument,       &debug_,   1 },
		{ "verbose", no_argument,       &verbose_, 1 },
		{ 0,         0,                 NULL,      0  }
	};

	while ((c = getopt_long(argc, argv, "hv", opts, NULL)) != -1) {
		switch (c) {
		case 'h':
			help();
			return CAL_EXIT_SUCCESS;
		case 'v':
			verbose_ = 1;
			break;
		case 0:
			break;
		default:
			return CAL_EXIT_ERROR;
		}
	}

	if (optind < argc)
		match_name = argv[optind++];

	if (optind < argc) {
		pr_err("extra arguments given.\n\n");
		help();
		return CAL_EXIT_ERROR;
	}

	display = display_create(&argc, argv);
	if (!display)
		return CAL_EXIT_ERROR;

	cal = calibrator_create(display, match_name);
	if (!cal)
		return CAL_EXIT_ERROR;

	display_set_user_data(display, cal);
	display_set_global_handler(display, global_handler);

	if (!match_name)
		pr_ver("Available touch devices:\n");

	/* Roundtrip to get list of available touch devices,
	 * first globals, then touch_device events */
	wl_display_roundtrip(display_get_display(display));
	wl_display_roundtrip(display_get_display(display));

	if (!cal->calibration) {
		exit_code = CAL_EXIT_ERROR;
		pr_err("the Wayland server does not expose the calibration interface.\n");
	} else if (cal->device_name) {
		exit_code = calibrator_run(cal);
	} else if (match_name) {
		exit_code = CAL_EXIT_ERROR;
		pr_err("\"%s\" was not found.\n", match_name);
	} else if (cal->n_devices_listed == 0) {
		fprintf(stderr, "No devices listed.\n");
	}

	calibrator_destroy(cal);
	display_destroy(display);

	return exit_code;
}