/*
  Copyright 2011-2017 David Robillard <http://drobilla.net>
  Copyright 2014 Robin Gareus <robin@gareus.org>

  Permission to use, copy, modify, and/or distribute this software for any
  purpose with or without fee is hereby granted, provided that the above
  copyright notice and this permission notice appear in all copies.

  THIS SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
  WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
  MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
  ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
  WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
  ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
  OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
*/

#include "suil_internal.h"

#include "lv2/options/options.h"
#include "lv2/urid/urid.h"

#include <gtk/gtk.h>
#include <gdk/gdkquartz.h>

#include <string.h>

#ifndef MAC_OS_X_VERSION_10_12
#define MAC_OS_X_VERSION_10_12 101200
#endif

#if MAC_OS_X_VERSION_MAX_ALLOWED < MAC_OS_X_VERSION_10_12
#define NSEventTypeFlagsChanged     NSFlagsChanged
#define NSEventTypeLeftMouseDown    NSLeftMouseDown
#define NSEventTypeLeftMouseDragged NSLeftMouseDragged
#define NSEventTypeLeftMouseUp      NSLeftMouseUp
#define NSEventTypeMouseEntered     NSMouseEntered
#define NSEventTypeMouseExited      NSMouseExited
#define NSEventTypeMouseMoved       NSMouseMoved
#define NSEventTypeRightMouseDown   NSRightMouseDown
#define NSEventTypeRightMouseUp     NSRightMouseUp
#define NSEventTypeScrollWheel      NSScrollWheel
#endif

extern "C" {

#define SUIL_TYPE_COCOA_WRAPPER (suil_cocoa_wrapper_get_type())
#define SUIL_COCOA_WRAPPER(obj) (G_TYPE_CHECK_INSTANCE_CAST((obj), SUIL_TYPE_COCOA_WRAPPER, SuilCocoaWrapper))

typedef struct _SuilCocoaWrapper      SuilCocoaWrapper;
typedef struct _SuilCocoaWrapperClass SuilCocoaWrapperClass;

struct _SuilCocoaWrapper {
	GtkWidget     widget;
	SuilWrapper*  wrapper;
	SuilInstance* instance;

	GdkWindow* flt_win;
	bool       custom_size;
	bool       mapped;
	int        req_width;
	int        req_height;
	int        alo_width;
	int        alo_height;

	const LV2UI_Idle_Interface* idle_iface;
	guint                       idle_id;
	guint                       idle_ms;
};

struct _SuilCocoaWrapperClass {
	GtkWidgetClass parent_class;
};

GType suil_cocoa_wrapper_get_type(void);  // Accessor for SUIL_TYPE_COCOA_WRAPPER

G_DEFINE_TYPE(SuilCocoaWrapper, suil_cocoa_wrapper, GTK_TYPE_WIDGET)

static void
suil_cocoa_wrapper_finalize(GObject* gobject)
{
	SuilCocoaWrapper* const self = SUIL_COCOA_WRAPPER(gobject);

	self->wrapper->impl = NULL;

	G_OBJECT_CLASS(suil_cocoa_wrapper_parent_class)->finalize(gobject);
}

static void
suil_cocoa_realize(GtkWidget* widget)
{
	SuilCocoaWrapper* const self = SUIL_COCOA_WRAPPER(widget);
	g_return_if_fail(self != NULL);

	GTK_WIDGET_SET_FLAGS(widget, GTK_REALIZED);

	GdkWindowAttr attrs;
	attrs.x           = widget->allocation.x;
	attrs.y           = widget->allocation.y;
	attrs.width       = widget->allocation.width;
	attrs.height      = widget->allocation.height;
	attrs.wclass      = GDK_INPUT_OUTPUT;
	attrs.window_type = GDK_WINDOW_CHILD;
	attrs.visual      = gtk_widget_get_visual(widget);
	attrs.colormap    = gtk_widget_get_colormap(widget);
	attrs.event_mask  = gtk_widget_get_events(widget) |
		GDK_EXPOSURE_MASK | GDK_BUTTON_PRESS_MASK |
		GDK_BUTTON_RELEASE_MASK | GDK_POINTER_MOTION_MASK |
		GDK_POINTER_MOTION_HINT_MASK;

	widget->window = gdk_window_new(
		widget->parent->window,
		&attrs,
		GDK_WA_X | GDK_WA_Y | GDK_WA_VISUAL | GDK_WA_COLORMAP);

	widget->style = gtk_style_attach(widget->style, widget->window);

	gdk_window_set_user_data(widget->window, widget);
	gtk_style_set_background(widget->style, widget->window, GTK_STATE_ACTIVE);
	gtk_widget_queue_resize(widget);
}

static void
suil_cocoa_size_request(GtkWidget* widget, GtkRequisition* requisition)
{
	SuilCocoaWrapper* const self = SUIL_COCOA_WRAPPER(widget);
	if (self->custom_size) {
		requisition->width  = self->req_width;
		requisition->height = self->req_height;
	} else {
		NSView* view  = (NSView*)self->instance->ui_widget;
		NSRect  frame = [view frame];
		requisition->width  = CGRectGetWidth(NSRectToCGRect(frame));
		requisition->height = CGRectGetHeight(NSRectToCGRect(frame));
	}
}

static void
suil_cocoa_size_allocate(GtkWidget* widget, GtkAllocation* allocation)
{
	SuilCocoaWrapper* const self = SUIL_COCOA_WRAPPER(widget);
	self->alo_width  = allocation->width;
	self->alo_height = allocation->height;

	if (!self->mapped) {
		return;
	}

	gint xx, yy;
	gtk_widget_translate_coordinates(
		gtk_widget_get_parent(widget), widget, 0, 0, &xx, &yy);

	NSView* view = (NSView*)self->instance->ui_widget;
	[view setFrame:NSMakeRect(xx, yy, self->alo_width, self->alo_height)];
}

static void
suil_cocoa_map(GtkWidget* widget)
{
	SuilCocoaWrapper* const self = SUIL_COCOA_WRAPPER(widget);
	self->mapped = true;

	if (self->alo_width == 0 || self->alo_height ==0) {
		return;
	}

	gint xx, yy;
	gtk_widget_translate_coordinates(
		gtk_widget_get_parent(widget), widget, 0, 0, &xx, &yy);

	NSView* view = (NSView*)self->instance->ui_widget;
	[view setHidden:NO];
	[view setFrame:NSMakeRect(xx, yy, self->alo_width, self->alo_height)];
}

static void
suil_cocoa_unmap(GtkWidget* widget)
{
	SuilCocoaWrapper* const self = SUIL_COCOA_WRAPPER(widget);
	NSView*                 view = (NSView*)self->instance->ui_widget;

	self->mapped = false;
	[view setHidden:YES];
}

static gboolean
suil_cocoa_key_press(GtkWidget* widget, GdkEventKey* event)
{
	SuilCocoaWrapper* const self = SUIL_COCOA_WRAPPER(widget);
	if (!self->instance || !self->wrapper || !self->wrapper->impl) {
		return FALSE;
	}
	NSEvent* nsevent = gdk_quartz_event_get_nsevent((GdkEvent*)event);
	NSView*  view    = (NSView*)self->instance->ui_widget;
	[view keyDown:nsevent];
	return TRUE;
}

static gboolean
suil_cocoa_key_release(GtkWidget* widget, GdkEventKey* event)
{
	SuilCocoaWrapper* const self = SUIL_COCOA_WRAPPER(widget);
	if (!self->instance || !self->wrapper || !self->wrapper->impl) {
		return FALSE;
	}
	NSEvent* nsevent = gdk_quartz_event_get_nsevent((GdkEvent*)event);
	NSView*  view    = (NSView*)self->instance->ui_widget;
	[view keyUp:nsevent];
	return TRUE;
}

static gboolean
suil_cocoa_expose(GtkWidget* widget, GdkEventExpose* event)
{
	SuilCocoaWrapper* const self = SUIL_COCOA_WRAPPER(widget);
	NSView*                 view = (NSView*)self->instance->ui_widget;
	[view drawRect:NSMakeRect(event->area.x,
	                          event->area.y,
	                          event->area.width,
	                          event->area.height)];
	return TRUE;
}

static void
suil_cocoa_wrapper_class_init(SuilCocoaWrapperClass* klass)
{
	GObjectClass* const   gobject_class = G_OBJECT_CLASS(klass);
	GtkWidgetClass* const widget_class  = (GtkWidgetClass*)(klass);

	gobject_class->finalize = suil_cocoa_wrapper_finalize;

	widget_class->realize           = suil_cocoa_realize;
	widget_class->expose_event      = suil_cocoa_expose;
	widget_class->size_request      = suil_cocoa_size_request;
	widget_class->size_allocate     = suil_cocoa_size_allocate;
	widget_class->map               = suil_cocoa_map;
	widget_class->unmap             = suil_cocoa_unmap;
	widget_class->key_press_event   = suil_cocoa_key_press;
	widget_class->key_release_event = suil_cocoa_key_release;
}

static void
suil_cocoa_wrapper_init(SuilCocoaWrapper* self)
{
	self->wrapper     = NULL;
	self->instance    = NULL;
	self->flt_win     = NULL;
	self->custom_size = false;
	self->mapped      = false;
	self->req_width   = self->req_height = 0;
	self->alo_width   = self->alo_height = 0;
	self->idle_iface  = NULL;
	self->idle_ms     = 1000 / 30;  // 30 Hz default
}

static int
wrapper_resize(LV2UI_Feature_Handle handle, int width, int height)
{
	SuilCocoaWrapper* const wrap = SUIL_COCOA_WRAPPER(handle);
	wrap->req_width   = width;
	wrap->req_height  = height;
	wrap->custom_size = true;
	gtk_widget_queue_resize(GTK_WIDGET(handle));
	return 0;
}

static gboolean
suil_cocoa_wrapper_idle(void* data)
{
	SuilCocoaWrapper* const wrap = SUIL_COCOA_WRAPPER(data);
	wrap->idle_iface->idle(wrap->instance->handle);
	return TRUE;  // Continue calling
}

static GdkFilterReturn
event_filter(GdkXEvent* xevent, GdkEvent* event, gpointer data)
{
	SuilCocoaWrapper* wrap = (SuilCocoaWrapper*)data;
	if (!wrap->instance || !wrap->wrapper || !wrap->wrapper->impl) {
		return GDK_FILTER_CONTINUE;
	}

	NSEvent* nsevent = (NSEvent*)xevent;
	NSView*  view    = (NSView*)wrap->instance->ui_widget;
	if (view && nsevent) {
		switch([nsevent type]) {
		case NSEventTypeFlagsChanged:
			[view flagsChanged:nsevent];
			return GDK_FILTER_REMOVE;
#if 0
		case NSEventTypeMouseEntered:
			[view mouseEntered:nsevent];
			return GDK_FILTER_REMOVE;
		case NSEventTypeMouseExited:
			[view mouseExited:nsevent];
			return GDK_FILTER_REMOVE;

		/* Explicitly pass though mouse events.  Needed for mouse-drags leaving
		   the window, and mouse-up after that. */
		case NSEventTypeMouseMoved:
			[view mouseMoved:nsevent];
			break;
		case NSEventTypeLeftMouseDragged:
			[view mouseDragged:nsevent];
			break;
		case NSEventTypeLeftMouseDown:
			[view mouseDown:nsevent];
			break;
		case NSEventTypeLeftMouseUp:
			[view mouseUp:nsevent];
			break;
		case NSEventTypeRightMouseDown:
			[view rightMouseDown:nsevent];
			break;
		case NSEventTypeRightMouseUp:
			[view rightMouseUp:nsevent];
			break;
		case NSEventTypeScrollWheel:
			[view scrollWheel:nsevent];
			break;
#endif
		default:
			break;
		}
	}
	return GDK_FILTER_CONTINUE;
}

static int
wrapper_wrap(SuilWrapper* wrapper, SuilInstance* instance)
{
	SuilCocoaWrapper* const wrap = SUIL_COCOA_WRAPPER(wrapper->impl);

	instance->host_widget = GTK_WIDGET(wrap);
	wrap->wrapper         = wrapper;
	wrap->instance        = instance;

	const LV2UI_Idle_Interface* idle_iface = NULL;
	if (instance->descriptor->extension_data) {
		idle_iface = (const LV2UI_Idle_Interface*)
			instance->descriptor->extension_data(LV2_UI__idleInterface);
	}
	if (idle_iface) {
		wrap->idle_iface = idle_iface;
		wrap->idle_id    = g_timeout_add(
			wrap->idle_ms, suil_cocoa_wrapper_idle, wrap);
	}

	return 0;
}

static void
wrapper_free(SuilWrapper* wrapper)
{
	if (wrapper->impl) {
		SuilCocoaWrapper* const wrap = SUIL_COCOA_WRAPPER(wrapper->impl);
		if (wrap->idle_id) {
			g_source_remove(wrap->idle_id);
			wrap->idle_id = 0;
		}

		gdk_window_remove_filter(wrap->flt_win, event_filter, wrapper->impl);
		gtk_object_destroy(GTK_OBJECT(wrap));
	}
}


SUIL_LIB_EXPORT
SuilWrapper*
suil_wrapper_new(SuilHost*      host,
                 const char*    host_type_uri,
                 const char*    ui_type_uri,
                 LV2_Feature*** features,
                 unsigned       n_features)
{
	GtkWidget* parent = NULL;
	for (unsigned i = 0; i < n_features; ++i) {
		if (!strcmp((*features)[i]->URI, LV2_UI__parent)) {
			parent = (GtkWidget*)(*features)[i]->data;
		}
	}

	if (!GTK_CONTAINER(parent)) {
		SUIL_ERRORF("No GtkContainer parent given for %s UI\n",
		            ui_type_uri);
		return NULL;
	}

	SuilWrapper* wrapper = (SuilWrapper*)calloc(1, sizeof(SuilWrapper));
	wrapper->wrap = wrapper_wrap;
	wrapper->free = wrapper_free;

	SuilCocoaWrapper* const wrap = SUIL_COCOA_WRAPPER(
		g_object_new(SUIL_TYPE_COCOA_WRAPPER, NULL));

	wrapper->impl             = wrap;
	wrapper->resize.handle    = wrap;
	wrapper->resize.ui_resize = wrapper_resize;

	gtk_container_add(GTK_CONTAINER(parent), GTK_WIDGET(wrap));
	gtk_widget_set_can_focus(GTK_WIDGET(wrap), TRUE);
	gtk_widget_set_sensitive(GTK_WIDGET(wrap), TRUE);
	gtk_widget_realize(GTK_WIDGET(wrap));

	GdkWindow* window = gtk_widget_get_window(GTK_WIDGET(wrap));
	wrap->flt_win = gtk_widget_get_window(parent);
	gdk_window_add_filter(wrap->flt_win, event_filter, wrap);

	NSView* parent_view = gdk_quartz_window_get_nsview(window);
	suil_add_feature(features, &n_features, LV2_UI__parent, parent_view);
	suil_add_feature(features, &n_features, LV2_UI__resize, &wrapper->resize);
	suil_add_feature(features, &n_features, LV2_UI__idleInterface, NULL);

	// Scan for URID map and options
	LV2_URID_Map*       map     = NULL;
	LV2_Options_Option* options = NULL;
	for (LV2_Feature** f = *features; *f && (!map || !options); ++f) {
		if (!strcmp((*f)->URI, LV2_OPTIONS__options)) {
			options = (LV2_Options_Option*)(*f)->data;
		} else if (!strcmp((*f)->URI, LV2_URID__map)) {
			map = (LV2_URID_Map*)(*f)->data;
		}
	}

	if (map && options) {
		// Set UI update rate if given
		LV2_URID ui_updateRate = map->map(map->handle, LV2_UI__updateRate);
		for (LV2_Options_Option* o = options; o->key; ++o) {
			if (o->key == ui_updateRate) {
				wrap->idle_ms = 1000.0f / *(const float*)o->value;
				break;
			}
		}
	}

	return wrapper;
}

}  // extern "C"
