/**

 * Spacenav lib hack

 * Copyright © 2019 František Kučera (Frantovo.cz, GlobalCode.info)

 *

 * 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

 *

 * 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/>.

 */

#define _GNU_SOURCE

#include <stdio.h>

#include <stdint.h>

#include <dlfcn.h>

#include <stdlib.h>

#include <unistd.h>

#include <pthread.h>

#include <X11/Xlib.h>

#include <spnav.h>

/**

 * The purpose of this hack is to enable 3D mouse in applications that use X11 protocol

 * while our daemon is providing only domain socket and no X11.

 * 

 * Usage:

 * LD_PRELOAD=./spacenav-lib-hack/build/Debug/src/libspnav-lib-hack.so freecad

 * 

 * This hack:

 * 1) Pretends that spnav_x11_open() was successful.

 * 2) Starts a background process (TODO: also terminate it) which reads from the domain socket

 *    and translates spacenav events to X11 events and sends them to the application window.

 * 3) reimplements spnav_x11_event() which is needed, because Atom variables in original library

 *    were not initialized spnav_x11_open() and thus the library funcion is not working.

 * 

 * This solution works and allows using e.g. FreeCAD with domain socket instead of X11, but:

 *  - is very hackish and should be reimplemented as a separate process which will work partly

 *    as a libspnav client and partly emulate spacenavd daemon and will bridge the domain socket

 *    and th X11. Other solution is to emulate the hardware and keep spacenavd and libspnav untouched.

 */

static pthread_t spacenav_hack_thread;

static Window spacenav_hack_win;

// from proto_x11.c (spacenavd)

static Atom xa_event_motion, xa_event_bpress, xa_event_brelease, xa_event_cmd;

static float x11_sens = 1.0;

/**

 * This function is based on proto_x11.c (spacenavd) written by:

 * Copyright (C) 2007-2019 John Tsiombikas <nuclear@member.fsf.org>

 * and published under GNU GPLv3+

 * 

 * @param ev

 * @param dpy

 * @param win

 */

static void send_xevent(spnav_event *ev, Display* dpy, Window win) {

	int i;

	XEvent xevent;

	if (!dpy) return;

	// if(setjmp(jbuf)) return;

	xevent.type = ClientMessage;

	xevent.xclient.send_event = False;

	xevent.xclient.display = dpy;

	xevent.xclient.window = win;

	switch (ev->type) {

		case SPNAV_EVENT_MOTION:

			xevent.xclient.message_type = xa_event_motion;

			xevent.xclient.format = 16;

			for (i = 0; i < 6; i++) {

				float val = (float) ev->motion.data[i] * x11_sens;

				xevent.xclient.data.s[i + 2] = (short) val;

			}

			xevent.xclient.data.s[0] = xevent.xclient.data.s[1] = 0;

			xevent.xclient.data.s[8] = ev->motion.period;

			break;

		case SPNAV_EVENT_BUTTON:

			xevent.xclient.message_type = ev->button.press ? xa_event_bpress : xa_event_brelease;

			xevent.xclient.format = 16;

			xevent.xclient.data.s[2] = ev->button.bnum;

			break;

		default:

			break;

	}

	XSendEvent(dpy, win, False, 0, &xevent);

	XFlush(dpy);

}

static void* spacenav_hack_translate_events(void* arg) {

	fprintf(stderr, "spnav-lib-hack: pthread running, PID=%d\n", getpid());

	spnav_event event;

	Display* dpy = XOpenDisplay(0);

	while (1) {

		if (spnav_wait_event(&event)) {

			send_xevent(&event, dpy, spacenav_hack_win);

		}

	}

}

int spnav_x11_open(Display* dpy, Window win) {

	int result = spnav_open();

	fprintf(stderr, "spnav-lib-hack: instead of spnav_x11_open(%p, 0x%lx) calling spnav_open() = %d\n", dpy, win, result);

	xa_event_motion = XInternAtom(dpy, "MotionEvent", False);

	xa_event_bpress = XInternAtom(dpy, "ButtonPressEvent", False);

	xa_event_brelease = XInternAtom(dpy, "ButtonReleaseEvent", False);

	xa_event_cmd = XInternAtom(dpy, "CommandEvent", False);

	if (result == 0) {

		spacenav_hack_win = win;

		pthread_create(&spacenav_hack_thread, NULL, spacenav_hack_translate_events, NULL);

	}

	return result;

}

/**

 * This function is based on proto_x11.c (spacenavd) written by:

 * Copyright (C) 2007-2019 John Tsiombikas <nuclear@member.fsf.org>

 * and published under GNU GPLv3+

 * 

 * @param dpy

 * @param win

 * @return 

 */

int spnav_x11_event(const XEvent* xev, spnav_event* event) {

	/*

	 * Because real spnav_x11_open() was not called, the library has not initialized xa_event_*

	 * variables and thus will return 0 (= not a spacenav event).

	 */

	int i;

	int xmsg_type;

	if (xev->type != ClientMessage) {

		return 0;

	}

	xmsg_type = xev->xclient.message_type;

	if (xmsg_type != xa_event_motion && xmsg_type != xa_event_bpress &&

			xmsg_type != xa_event_brelease) {

		return 0;

	}

	if (xmsg_type == xa_event_motion) {

		event->type = SPNAV_EVENT_MOTION;

		event->motion.data = &event->motion.x;

		for (i = 0; i < 6; i++) {

			event->motion.data[i] = xev->xclient.data.s[i + 2];

		}

		event->motion.period = xev->xclient.data.s[8];

	} else {

		event->type = SPNAV_EVENT_BUTTON;

		event->button.press = xmsg_type == xa_event_bpress ? 1 : 0;

		event->button.bnum = xev->xclient.data.s[2];

	}

	return event->type;

	// real_spnav_x11_event() is not working (see comment above):

	/*

	static int (*real_spnav_x11_event)(const XEvent*, spnav_event*) = NULL;

	if (!real_spnav_x11_event) real_spnav_x11_event = dlsym(RTLD_NEXT, "spnav_x11_event");

	int result = real_spnav_x11_event(xev, event);

	if (result == SPNAV_EVENT_MOTION || result == SPNAV_EVENT_BUTTON) fprintf(stderr, "spnav-lib-hack: spnav_x11_event() = %d\n", result);

	return result;

	 */

}

/*

int spnav_x11_open(Display* dpy, Window win) {

	static int (*real_spnav_x11_open)(Display*, Window) = NULL;

	if (!real_spnav_x11_open) real_spnav_x11_open = dlsym(RTLD_NEXT, "spnav_x11_open");

	int result = real_spnav_x11_open(dpy, win);

	fprintf(stderr, "spnav-lib-hack: spnav_x11_open() = %d\n", result);

	return result;

}

 */

/*

int spnav_open() {

	static int (*real_spnav_open)() = NULL;

	if (!real_spnav_open) real_spnav_open = dlsym(RTLD_NEXT, "spnav_open");

	int result = real_spnav_open();

	// fprintf(stderr, "spnav-lib-hack: spnav_open() = %d\n", result);

	return result;

}

 */