/*
 * notify.c: Notification implementation
 *
 * Copyright (C) 2017 Frank Morgner <frankmorgner@gmail.com>
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
 * This library 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
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 */

#if HAVE_CONFIG_H
#include "config.h"
#endif

#include "notify.h"

#if defined(ENABLE_NOTIFY) && (defined(__APPLE__) || (defined(GDBUS) && !defined(_WIN32)))

#include "libopensc/log.h"
#include <signal.h>
#include <stdlib.h>
#include <string.h>
#include <sys/wait.h>
#include <unistd.h>

static pid_t child = -1;

void sc_notify_init(void)
{
}

void sc_notify_close(void)
{
	if (child > 0) {
		int i, status;
		for (i = 0; child != waitpid(child, &status, WNOHANG); i++) {
			switch (i) {
				case 0:
					kill(child, SIGKILL);
					break;
				case 1:
					kill(child, SIGTERM);
					break;
				default:
					/* SIGTERM was our last resort */
					return;
			}
			usleep(100);
		}
		child = -1;
	}
}

#endif

#if defined(ENABLE_NOTIFY) && defined(_WIN32)

#include "invisible_window.h"
#include "wchar_from_char_str.h"
#include <shellapi.h>

static const GUID myGUID = {0x23977b55, 0x10e0, 0x4041, {0xb8,
	0x62, 0xb1, 0x95, 0x41, 0x96, 0x36, 0x69}};
HINSTANCE sc_notify_instance = NULL;
HWND hwndNotification = NULL;
BOOL delete_icon = TRUE;
#define IDI_SMARTCARD       102
#define IDI_UNLOCKED        103
#define IDI_LOCKED          104
#define IDI_READER_EMPTY    105
#define IDI_CARD_INSERTED   106
UINT const WMAPP_NOTIFYCALLBACK = WM_APP + 1;
static BOOL RestoreTooltip();

// we need commctrl v6 for LoadIconMetric()
#include <commctrl.h>

LRESULT CALLBACK WndProc(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
{
	if ((message == WM_DESTROY)
			|| (message == WMAPP_NOTIFYCALLBACK
				&& (LOWORD(lParam) == NIN_BALLOONTIMEOUT
					|| LOWORD(lParam) == NIN_BALLOONUSERCLICK))) {
#if 0
		DeleteNotificationIcon();
#else
		RestoreTooltip();
#endif
		return TRUE;
	}

	return DefWindowProc(hwnd, message, wParam, lParam);
}

static const char* lpszClassName = "NOTIFY_CLASS";

static BOOL AddNotificationIcon(void)
{
	NOTIFYICONDATA nid;
	TCHAR path[MAX_PATH]={0};
	BOOL r;

	memset(&nid, 0, sizeof nid);
	nid.cbSize = sizeof nid;
	nid.hWnd = hwndNotification;
	// add the icon, setting the icon, tooltip, and callback message.
	// the icon will be identified with the GUID
	nid.uFlags = NIF_ICON | NIF_TIP | NIF_MESSAGE | NIF_SHOWTIP | NIF_GUID;
	nid.guidItem = myGUID; 
	nid.uCallbackMessage = WMAPP_NOTIFYCALLBACK;
	LoadIconMetric(sc_notify_instance, MAKEINTRESOURCEW(IDI_SMARTCARD), LIM_SMALL, &nid.hIcon);
	if (GetModuleFileName(NULL, path, ARRAYSIZE(path))) {
		const char *basename = strrchr(path, '\\');
		if (basename) {
			basename++;
			if (0 != strcmp(basename, "opensc-notify.exe")) {
				/* Allow creation of sytem tray icon only for
				 * "opensc-notify.exe" to avoid creation of the same icon by
				 * multiple processes. */
				delete_icon = FALSE;
				return FALSE;
			}
		}
		strlcpy(nid.szTip, path, ARRAYSIZE(nid.szTip));
	} else {
		strcpy(nid.szTip, PACKAGE_NAME);
	}

	r  = Shell_NotifyIcon(NIM_ADD, &nid);

    nid.uVersion = NOTIFYICON_VERSION_4;
    r &= Shell_NotifyIcon(NIM_SETVERSION, &nid);

    hwndNotification = create_invisible_window(lpszClassName, WndProc, sc_notify_instance);
	if (!hwndNotification) {
		r = FALSE;
	}

	return r;
}

static BOOL DeleteNotificationIcon(void)
{
	BOOL r;
	NOTIFYICONDATA nid;

	if (!delete_icon) {
		return FALSE;
	}

	memset(&nid, 0, sizeof nid);
	nid.cbSize = sizeof nid;
	nid.uFlags = NIF_GUID;
	nid.guidItem = myGUID; 

	r  = Shell_NotifyIcon(NIM_DELETE, &nid);

	r &= delete_invisible_window(hwndNotification, lpszClassName,
			sc_notify_instance);

	return r;
}

static BOOL RestoreTooltip()
{
    // After the balloon is dismissed, restore the tooltip.
    NOTIFYICONDATA nid;

	memset(&nid, 0, sizeof nid);
	nid.cbSize = sizeof nid;
    nid.uFlags = NIF_SHOWTIP | NIF_GUID;
	nid.guidItem = myGUID; 

    return Shell_NotifyIcon(NIM_MODIFY, &nid);
}

static void notify_shell(struct sc_context *ctx,
		const char *title, const char *text, WORD icon)
{
    NOTIFYICONDATA nid;

	memset(&nid, 0, sizeof nid);
	nid.cbSize = sizeof nid;
    nid.uFlags = NIF_GUID;
    nid.guidItem = myGUID;

	if (title) {
		strlcpy(nid.szInfoTitle, title, ARRAYSIZE(nid.szInfoTitle));
	}
	if (text) {
		nid.uFlags |= NIF_INFO;
		strlcpy(nid.szInfo, text, ARRAYSIZE(nid.szInfo));
	}
	if (icon) {
		nid.dwInfoFlags = NIIF_USER | NIIF_LARGE_ICON;
		LoadIconMetric(sc_notify_instance, MAKEINTRESOURCEW(icon), LIM_LARGE, &nid.hBalloonIcon);
	}

    Shell_NotifyIcon(NIM_MODIFY, &nid);
}

void sc_notify_init(void)
{
	if (!sc_notify_instance) {
		/* returns the HINSTANCE of the exe. If the code executes in a DLL,
		 * sc_notify_instance_notify should be pre-initialized */
		sc_notify_instance = GetModuleHandle(NULL);
	}
	AddNotificationIcon();
}

void sc_notify_close(void)
{
	DeleteNotificationIcon();
}

void sc_notify(const char *title, const char *text)
{
	notify_shell(NULL, title, text, 0);
}

void sc_notify_id(struct sc_context *ctx, struct sc_atr *atr,
		struct sc_pkcs15_card *p15card, enum ui_str id)
{
	const char *title, *text;
	WORD icon;
	title = ui_get_str(ctx, atr, p15card, id);
	text = ui_get_str(ctx, atr, p15card, id+1);

	switch (id) {
		case NOTIFY_CARD_INSERTED:
			icon = IDI_CARD_INSERTED;
			break;
		case NOTIFY_CARD_REMOVED:
			icon = IDI_READER_EMPTY;
			break;
		case NOTIFY_PIN_GOOD:
			icon = IDI_UNLOCKED;
			break;
		case NOTIFY_PIN_BAD:
			icon = IDI_LOCKED;
			break;
		default:
			icon = 0;
			break;
	}

	notify_shell(ctx, title, text, icon);
}

#elif defined(ENABLE_NOTIFY) && defined(__APPLE__)

static void notify_proxy(struct sc_context *ctx,
		const char *title, const char* subtitle,
		const char *text, const char *icon, const char *sound,
		const char *group)
{
	/* terminal-notifier does not reliably activate keychain when clicked on
	 * the notification
	 * (https://github.com/julienXX/terminal-notifier/issues/196), that's why
	 * we're including NotificationProxy which has similar features */
	const char notificationproxy[] = "/Library/Security/tokend/OpenSC.tokend/Contents/Resources/Applications/NotificationProxy.app/Contents/MacOS/NotificationProxy";

	if (child > 0) {
		int status;
		if (0 == waitpid(child, &status, WNOHANG)) {
			kill(child, SIGKILL);
			usleep(100);
			if (0 == waitpid(child, &status, WNOHANG)) {
				sc_log(ctx, "Can't kill %ld, skipping current notification", (long) child);
				return;
			}
		}
	}

	child = fork();
	switch (child) {
		case 0:
			/* child process */

			/* for some reason the user _tokend can call brew's installation of
			 * terminal-notifier, but it cannot call `/usr/bin/open` with
			 * NotificationProxy.app that we're shipping... However, while
			 * `sudo -u _tokend /usr/local/bin/terminal-notifier -title test`
			 * works in the terminal, it hangs when executed from the tokend
			 * process.  For now, we try to deliver the notification anyway
			 * making sure that we are waiting for only one forked process. */
			if (0 > execl(notificationproxy, notificationproxy,
						title ? title : "",
						subtitle ? subtitle : "",
						text ? text : "",
						icon ? icon : "",
						group ? group : "",
						sound ? sound : "",
						(char *) NULL)) {
				perror("exec failed");
				exit(0);
			}
			break;
		case -1:
			sc_log(ctx, "failed to fork for notification");
			break;
		default:
			if (ctx) {
				sc_log(ctx, "Created %ld for notification:", (long) child);
				sc_log(ctx, "%s %s %s %s %s %s %s", notificationproxy,
						title ? title : "",
						subtitle ? subtitle : "",
						text ? text : "",
						icon ? icon : "",
						group ? group : "",
						sound ? sound : "");
			}
			break;
	}
}

void sc_notify(const char *title, const char *text)
{
	notify_proxy(NULL, title, NULL, text, NULL, NULL, NULL);
}

void sc_notify_id(struct sc_context *ctx, struct sc_atr *atr,
		struct sc_pkcs15_card *p15card, enum ui_str id)
{
	const char *title, *text, *icon, *group;
	title = ui_get_str(ctx, atr, p15card, id);
	text = ui_get_str(ctx, atr, p15card, id+1);

	if (p15card && p15card->card && p15card->card->reader) {
		group = p15card->card->reader->name;
	} else {
		group = ctx ? ctx->app_name : NULL;
	}

	switch (id) {
		case NOTIFY_CARD_INSERTED:
			icon = "/System/Library/CoreServices/CoreTypes.bundle/Contents/Resources/VCard.icns";
			break;
		case NOTIFY_CARD_REMOVED:
			icon = "/System/Library/CoreServices/CoreTypes.bundle/Contents/Resources/EjectMediaIcon.icns";
			break;
		case NOTIFY_PIN_GOOD:
			icon = "/System/Library/CoreServices/CoreTypes.bundle/Contents/Resources/UnlockedIcon.icns";
			break;
		case NOTIFY_PIN_BAD:
			icon = "/System/Library/CoreServices/CoreTypes.bundle/Contents/Resources/LockedIcon.icns";
			break;
		default:
			icon = NULL;
			break;
	}

	notify_proxy(ctx, title, NULL, text, icon, NULL, group);
}

#elif defined(ENABLE_NOTIFY) && defined(GDBUS) && !defined(_WIN32)

#include <inttypes.h>
/* save the notification's id for replacement with a new one */
uint32_t message_id = 0;

static void notify_gio(struct sc_context *ctx,
		const char *title, const char *text, const char *icon,
		const char *group)
{
	char message_id_str[22];
	int pipefd[2];
	int pass_to_pipe = 1;
	snprintf(message_id_str, sizeof message_id_str, "%"PRIu32, message_id);

	if (child > 0) {
		int status;
		if (0 == waitpid(child, &status, WNOHANG)) {
			kill(child, SIGKILL);
			usleep(100);
			if (0 == waitpid(child, &status, WNOHANG)) {
				sc_log(ctx, "Can't kill %ld, skipping current notification", (long) child);
				return;
			}
		}
	}

	if (0 == pipe(pipefd)) {
		pass_to_pipe = 1;
	}

	child = fork();
	switch (child) {
		case 0:
			/* child process */
			if (pass_to_pipe) {
				/* close reading end of the pipe */
				close(pipefd[0]);
				/* send stdout to the pipe */
				dup2(pipefd[1], 1);
				/* this descriptor is no longer needed */
				close(pipefd[1]);
			}

			if (0 > execl(GDBUS, GDBUS,
						"call", "--session",
						"--dest", "org.freedesktop.Notifications",
						"--object-path", "/org/freedesktop/Notifications",
						"--method", "org.freedesktop.Notifications.Notify",
						"org.opensc-project",
						message_id_str,
						icon ? icon : "",
						title ? title : "",
						text ? text : "",
						"[]", "{}", "5000",
						(char *) NULL)) {
				perror("exec failed");
				exit(1);
			}
			break;
		case -1:
			sc_log(ctx, "failed to fork for notification");
			break;
		default:
			/* parent process */

			if (ctx) {
				sc_log(ctx, "Created %ld for notification:", (long) child);
				sc_log(ctx, "%s %s %s %s %s %s %s %s %s %s %s %s %s %s %s %s %s", GDBUS,
						"call", "--session",
						"--dest", "org.freedesktop.Notifications",
						"--object-path", "/org/freedesktop/Notifications",
						"--method", "org.freedesktop.Notifications.Notify",
						"org.opensc-project",
						message_id_str,
						icon ? icon : "",
						title ? title : "",
						text ? text : "",
						"[]", "{}", "5000");
			}

			if (pass_to_pipe) {
				/* close the write end of the pipe */
				close(pipefd[1]);
				memset(message_id_str, '\0', sizeof message_id_str);
				if (0 < read(pipefd[0], message_id_str, sizeof(message_id_str))) {
					message_id_str[(sizeof message_id_str) - 1] = '\0';
					sscanf(message_id_str, "(uint32 %"SCNu32",)", &message_id);
				}
				/* close the read end of the pipe */
				close(pipefd[0]);
			}
			break;
	}
}

#elif defined(ENABLE_NOTIFY) && defined(ENABLE_GIO2)

static GtkApplication *application = NULL;

#include <gio/gio.h>

void sc_notify_init(void)
{
	sc_notify_close();
	application = g_application_new("org.opensc-project", G_APPLICATION_FLAGS_NONE);
	if (application) {
		g_application_register(application, NULL, NULL);
	}
}

void sc_notify_close(void)
{
	if (application) {
		g_object_unref(application);
		application = NULL;
	}
}

static void notify_gio(struct sc_context *ctx,
		const char *title, const char *text, const char *icon,
		const char *group)
{
	GIcon *gicon = NULL;
	GNotification *notification = g_notification_new (title);
	if (!notification) {
		return;
	}

	g_notification_set_body (notification, text);
	if (icon) {
		gicon = g_themed_icon_new (icon);
		if (gicon) {
			g_notification_set_icon (notification, gicon);
		}
	}

	g_application_send_notification(application, group, notification);

	if (gicon) {
		g_object_unref(gicon);
	}
	g_object_unref(notification);
}

#else

void sc_notify_init(void) {}
void sc_notify_close(void) {}
void sc_notify(const char *title, const char *text) {}
void sc_notify_id(struct sc_context *ctx, struct sc_atr *atr,
		struct sc_pkcs15_card *p15card, enum ui_str id) {}

#endif

#if defined(ENABLE_NOTIFY) && (defined(ENABLE_GIO2) || defined(GDBUS) && !defined(_WIN32))
void sc_notify(const char *title, const char *text)
{
	notify_gio(NULL, title, text, NULL, NULL);
}

void sc_notify_id(struct sc_context *ctx, struct sc_atr *atr,
		struct sc_pkcs15_card *p15card, enum ui_str id)
{
	const char *title, *text, *icon, *group;
	title = ui_get_str(ctx, atr, p15card, id);
	text = ui_get_str(ctx, atr, p15card, id+1);

	if (p15card && p15card->card && p15card->card->reader) {
		group = p15card->card->reader->name;
	} else {
		group = ctx ? ctx->app_name : NULL;
	}

	switch (id) {
		case NOTIFY_CARD_INSERTED:
			icon = "dialog-information";
			break;
		case NOTIFY_CARD_REMOVED:
			icon = "media-removed";
			break;
		case NOTIFY_PIN_GOOD:
			icon = "changes-allow";
			break;
		case NOTIFY_PIN_BAD:
			icon = "changes-prevent";
			break;
		default:
			icon = NULL;
			break;
	}

	notify_gio(ctx, title, text, icon, group);
}

#endif