/*
 * multi ir daemon for android -
 * Copyright (C) 2015-2018 AllwinnerTech
 *
 * 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 2 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, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 *
 */
#include <unistd.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdint.h>
#include <dirent.h>
#include <fcntl.h>
#include <sys/ioctl.h>
#include <sys/inotify.h>
#include <sys/poll.h>
#include <utils/Log.h>
#include <linux/input.h>
#include <linux/uinput.h>
#include <sys/types.h>
#include <errno.h>

#include "multiir.h"
#include "virtual_input.h"

#define	uinput_debug(fmt, arg...) 				\
do { 											\
	if (print_flags & PRINT_DEBUG)				\
		fprintf(stdout, "[D] " fmt"\n", ##arg);	\
} while(0)

#define	uinput_warning(fmt, arg...) 			\
do { 											\
	if (print_flags & PRINT_WARN)				\
		fprintf(stdout, "[W] " fmt"\n", ##arg);	\
} while(0)

#define	uinput_error(fmt, arg...) 				\
do { 											\
	if (print_flags & PRINT_ERROR)				\
		fprintf(stderr, "[E] " fmt"\n", ##arg);	\
} while(0)

enum {
    PRINT_ERROR	 = 1U << 0,
    PRINT_WARN	 = 1U << 1,
    PRINT_DEBUG	 = 1U << 2,
};

#define UINPUT_NAME		"/dev/uinput"
static int g_uinputfd = -1;
int g_mousefd = -1;
static int print_flags = 0;

static struct uinput_user_dev virtual_inputdev;
static struct uinput_user_dev virtual_mousedev;


int nfds = 0;

static int is_devname_match(const char *devpath, const char *tname)
{
	int fd;
	char name[80];

	if (!devpath || !tname)
		return 0;

	fd = open(devpath, O_RDWR);
	if (fd<0) {
		uinput_error("could not open '%s', %s",
			devpath, strerror(errno));
		return 0;
	}
	name[sizeof(name)-1] = '\0';
	if(ioctl(fd, EVIOCGNAME(sizeof(name) - 1), &name) < 1) {
		uinput_error("could not get device name for '%s', %s",
			devpath, strerror(errno));
		name[0] = '\0';
		goto notmatch;
	}
	if (!strcmp(name, tname)) {
		uinput_debug("find match device '%s'", devpath);
		close(fd);
		return 1;
	}

notmatch:
	close(fd);
	uinput_debug("device not match or ioctl error, %s(%s)", devpath, name);
	return 0;
}

int try_to_find_device(const char *devname, char *path)
{
	const char *dirname = "/dev/input";
    char devpath[PATH_MAX];
    char *p;
    DIR *dir;
    struct dirent *de;

	if (!devname || !path)
		return -1;

	path[0] = '\0';
    dir = opendir(dirname);
    if(dir == NULL)
        return -1;
    strcpy(devpath, dirname);
    p = devpath + strlen(devpath);
    *p++ = '/';
    while((de = readdir(dir))) {
        if(de->d_name[0] == '.' &&
           (de->d_name[1] == '\0' ||
            (de->d_name[1] == '.' && de->d_name[2] == '\0')))
            continue;

		strcpy(p, de->d_name);
		if (is_devname_match(devpath, devname)) {
			strcpy(path, devpath);
			break;
		}
    }
    closedir(dir);
    return 0;
}

struct inputdev_info *open_device(const char *devpath, struct pollfd *ufds)
{
	struct inputdev_info *info;

	if (!devpath)
		goto errout;

	info = (inputdev_info *)calloc(sizeof(*info), sizeof(char));
	if (!info) {
		uinput_error("could not malloc, %s", strerror(errno));
		goto errout;
	}

	info->fd = open(devpath, O_RDWR);
	if (info->fd < 0) {
		uinput_error("could not open device '%s', %s",
			devpath, strerror(errno));
		free(info);
		goto errout;
	}

	strcpy(info->devpath, devpath);
	if (ioctl(info->fd, EVIOCGVERSION, &info->version)) {
		uinput_warning("could not get driver version for '%s', %s",
			devpath, strerror(errno));
	}
	if (ioctl(info->fd, EVIOCGID, &info->id)) {
		uinput_warning("could not get driver id for '%s', %s",
			devpath, strerror(errno));
    }

	if (ioctl(info->fd, EVIOCGNAME(sizeof(info->name)-1), info->name) < 1) {
		uinput_warning("could not get device name for %s, %s",
			devpath, strerror(errno));
	}
	if (ioctl(info->fd, EVIOCGPHYS(sizeof(info->location)-1), info->location) < 1) {
		uinput_warning("could not get location for %s, %s",
			devpath, strerror(errno));
	}
	if (ioctl(info->fd, EVIOCGUNIQ(sizeof(info->idstr) - 1), info->idstr) < 1) {
		uinput_warning("could not get idstring for %s, %s",
			devpath, strerror(errno));
    }

	if (print_flags & PRINT_DEBUG) {
		fprintf(stdout, "    devpath:  %s\n", info->devpath);
		fprintf(stdout, "    bus:      %04x\n"
					 	"    vendor    %04x\n"
						"    product   %04x\n"
						"    version   %04x\n",
						info->id.bustype, info->id.vendor,
						info->id.product, info->id.version);
		fprintf(stdout, "    name:     \"%s\"\n", info->name);
		fprintf(stdout, "    location: \"%s\"\n"
						"    id:       \"%s\"\n", info->location, info->idstr);
		fprintf(stdout, "    version:  %d.%d.%d\n",
						info->version >> 16,
						(info->version >> 8) & 0xff,
						info->version & 0xff);
	}

	ufds[INPUT_FD_INDEX].fd = info->fd;
	ufds[INPUT_FD_INDEX].events = POLLIN;
	nfds++;
	uinput_debug("add device '%s' to poll", devpath);
	return info;
errout:
	uinput_error("could open device '%s'!", devpath);
	return NULL;
}

static void close_device(struct inputdev_info * sourcedev, const char *devpath, struct pollfd *ufds)
{
	if (!sourcedev)
		return;

	if (!strcmp(sourcedev->devpath, devpath)) {
		close(sourcedev->fd);
		free(sourcedev);
		sourcedev = NULL;

		nfds--;
		ufds[nfds].fd = -1;
		ufds[nfds].events = 0;
		uinput_debug("close device '%s'", devpath);
	} else {
		uinput_debug("device '%s' not open, ignore", devpath);
	}
}

int notify_process(struct inputdev_info * sourcedev, char *device_name, const char *dirname, int nfd, struct pollfd *ufds)
{
	int res;
	char devpath[PATH_MAX];
	char *p;
	char event_buf[512];
	int event_size;
	int event_pos = 0;
	struct inotify_event *event;

	res = read(nfd, event_buf, sizeof(event_buf));
	if (res < (int)sizeof(*event)) {
		if (errno == EINTR)
			return 0;
		uinput_error("could not get event, %s", strerror(errno));
		return 1;
	}
	uinput_debug("got %d bytes of event information", res);

	strcpy(devpath, dirname);
	p = devpath + strlen(devpath);
	*p++ = '/';

	while(res >= (int)sizeof(*event)) {
		event = (struct inotify_event *)(event_buf + event_pos);
		uinput_debug("%d: %08x \"%s\"",
			event->wd, event->mask, event->len ? event->name : "");

		if (event->len) {
			strcpy(p, event->name);
			if (event->mask & IN_CREATE) {
				if (!sourcedev && is_devname_match(devpath, device_name)) {
					uinput_debug("find target device, path=%s", devpath);
					sourcedev = open_device(devpath, ufds);
				}
			} else {
				close_device(sourcedev, devpath, ufds);
			}
		}

		event_size = sizeof(*event) + event->len;
		res -= event_size;
		event_pos += event_size;
	}

	return 0;
}

int input_event_process(int nfd, struct input_event *event)
{
	int res;

	res = read(nfd, event, sizeof(struct input_event));
	if (res < (int)sizeof(struct input_event)) {
		uinput_error("could not get event");
		return -1;
	}

//	ALOGD("%04x %04x %08x", event->type, event->code, event->value);
	return 0;
}

int create_virtual_mouse_dev(char *mouse_dev) {
    int uinputfd = -1;

    if (g_mousefd >= 0) {
        ALOGD("multiir had enter mouse mode");
        return 0;
    }

    ALOGD("multi_ir open uinput dev");

    uinputfd = open(UINPUT_NAME, O_WRONLY | O_NDELAY);
    if (uinputfd <= 0) {
        ALOGE("could not open '%s', %s\n", UINPUT_NAME, strerror(errno));
        return uinputfd;
    }

    memset(&virtual_mousedev, 0, sizeof(virtual_mousedev));
    strncpy(virtual_mousedev.name, mouse_dev, UINPUT_MAX_NAME_SIZE);
    virtual_mousedev.id.version = 0x0111;
    virtual_mousedev.id.bustype = BUS_USB;
    virtual_mousedev.id.vendor = 0x093a;
    virtual_mousedev.id.product = 0x2521;

    /* setup mouse coordinate event */
    if (ioctl(uinputfd, UI_SET_EVBIT,  EV_REL) < 0) ALOGE("set evbit rel fail : %s", strerror(errno));
    if (ioctl(uinputfd, UI_SET_EVBIT,  EV_KEY) < 0) ALOGE("set evbit key fail : %s", strerror(errno));
    if (ioctl(uinputfd, UI_SET_RELBIT, REL_X) < 0) ALOGE("set relbit x fail : %s", strerror(errno));
    if (ioctl(uinputfd, UI_SET_RELBIT, REL_Y) < 0) ALOGE("set relbit y fail : %s", strerror(errno));

    /* setup mouse button event */
    if (ioctl(uinputfd, UI_SET_KEYBIT, BTN_MOUSE) < 0) ALOGE("set keybit mouse fail : %s", strerror(errno));

    /* create input device into input subsystem */
    write(uinputfd, &virtual_mousedev, sizeof(virtual_mousedev));
    if (ioctl(uinputfd, UI_DEV_CREATE)) {
        ALOGE("could not create uinput device, %s\n", strerror(errno));
        close(uinputfd);
        uinputfd = -1;
        return uinputfd;
    }

    g_mousefd = uinputfd;
    setMouseMode(1);
    return 0;
}

int destory_virtual_mouse_dev(void) {
    if (g_mousefd == -1) {
        ALOGD("multiir had exit mouse mode");
        return 0;
    }

    if (ioctl(g_mousefd, UI_DEV_DESTROY)) {
        ALOGD("could not destory virtual mouse: %s", strerror(errno));
        close(g_mousefd);
        g_mousefd = -1;
        return -1;
    }
    close(g_mousefd);
    g_mousefd = -1;
    setMouseMode(0);
    return 0;
}

int setup_virtual_input_dev(char *inputdev_name)
{
    int i;
    int uinputfd = -1;

    ALOGD("multi_ir open uinput dev");

    uinputfd = open(UINPUT_NAME, O_WRONLY | O_NDELAY);
    if (uinputfd <= 0) {
        ALOGE("could not open '%s', %s\n", UINPUT_NAME, strerror(errno));
        return uinputfd;
    }

    memset(&virtual_inputdev, 0, sizeof(virtual_inputdev));
    strncpy(virtual_inputdev.name, inputdev_name, UINPUT_MAX_NAME_SIZE);
    virtual_inputdev.id.version = 4;
    virtual_inputdev.id.bustype = BUS_HOST;
    ioctl(uinputfd, UI_SET_EVBIT, EV_KEY);
   	ioctl(uinputfd, UI_SET_EVBIT, EV_MSC);
   	ioctl(uinputfd, UI_SET_EVBIT, EV_REP);

    /* register a cursor device */
    ioctl(uinputfd, UI_SET_KEYBIT, BTN_MOUSE);
    ioctl(uinputfd, UI_SET_RELBIT, REL_X);
    ioctl(uinputfd, UI_SET_RELBIT, REL_Y);
    ioctl(uinputfd, UI_SET_EVBIT,  EV_REL);
#if 0
	/* setup mouse coordinate event */
    ioctl(uinputfd, UI_SET_EVBIT,  EV_REL);
    ioctl(uinputfd, UI_SET_RELBIT, REL_X);
    ioctl(uinputfd, UI_SET_RELBIT, REL_Y);

    /* setup mouse button event */
    ioctl(uinputfd, UI_SET_KEYBIT, BTN_MOUSE);
    ioctl(uinputfd, UI_SET_KEYBIT, BTN_TOUCH);
    ioctl(uinputfd, UI_SET_KEYBIT, BTN_LEFT);
    ioctl(uinputfd, UI_SET_KEYBIT, BTN_RIGHT);
    ioctl(uinputfd, UI_SET_KEYBIT, BTN_MIDDLE);
#endif

    for (i = KEYCODE_MIN; i < KEYCODE_CNT; i++)
        ioctl(uinputfd, UI_SET_KEYBIT, i);

    /* create input device into input subsystem */
    write(uinputfd, &virtual_inputdev, sizeof(virtual_inputdev));
    if (ioctl(uinputfd, UI_DEV_CREATE)) {
        ALOGE("could not create uinput device, %s\n", strerror(errno));
        close(uinputfd);
        uinputfd = -1;
        return uinputfd;
    }

    g_uinputfd = uinputfd;
    return uinputfd;
}

void report_key_event(int uinputfd, struct input_event *event, int sync)
{
    struct input_event temp_event;

    write(uinputfd, event, sizeof(struct input_event));

    if (sync) {
        memset(&temp_event, 0, sizeof(struct input_event));
        temp_event.type = EV_SYN;
        temp_event.code = SYN_REPORT;
        temp_event.value = 0;
        write(uinputfd, &temp_event, sizeof(struct input_event));
    }
}

#define POWER_KEY	(0x74)
void report_standby_request(void)
{
	int uinputfd = g_uinputfd;
	struct input_event event;

	if (uinputfd<0)
		return;

	memset(&event, 0, sizeof(event));
	gettimeofday(&event.time, NULL);
	event.type = EV_KEY;
	event.code = POWER_KEY;
	event.value = 1;
	write(uinputfd, &event, sizeof(event));

	event.type = EV_SYN;
	event.code = SYN_REPORT;
	event.value = 0;
	write(uinputfd, &event, sizeof(event));

	memset(&event, 0, sizeof(event));
	gettimeofday(&event.time, NULL);
	event.type = EV_KEY;
	event.code = POWER_KEY;
	event.value = 0;
	write(uinputfd, &event, sizeof(event));

	event.type = EV_SYN;
	event.code = SYN_REPORT;
	event.value = 0;
	write(uinputfd, &event, sizeof(event));
}