/**
 * FreeRDP: A Remote Desktop Protocol Implementation
 * X11 Windows
 *
 * Licensed under the Apache License, Version 2.0 (the "License");n
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

#include <X11/Xlib.h>
#include <X11/Xutil.h>
#include <X11/Xatom.h>
#include <X11/extensions/shape.h>
#include <X11/extensions/Xfixes.h>
#include <X11/cursorfont.h>

#include "xf_floatbar.h"
#include "resource/close.xbm"
#include "resource/lock.xbm"
#include "resource/unlock.xbm"
#include "resource/minimize.xbm"
#include "resource/restore.xbm"

#define TAG CLIENT_TAG("x11")

#define FLOATBAR_HEIGHT				26
#define FLOATBAR_DEFAULT_WIDTH		576
#define FLOATBAR_MIN_WIDTH			200
#define FLOATBAR_BORDER				24
#define FLOATBAR_BUTTON_WIDTH		24
#define FLOATBAR_COLOR_BACKGROUND 	"RGB:31/6c/a9"
#define FLOATBAR_COLOR_BORDER 		"RGB:75/9a/c8"
#define FLOATBAR_COLOR_FOREGROUND 	"RGB:FF/FF/FF"

#ifdef WITH_DEBUG_X11
#define DEBUG_X11(...) WLog_DBG(TAG, __VA_ARGS__)
#else
#define DEBUG_X11(...) do { } while (0)
#endif

#define XF_FLOATBAR_MODE_NONE 			0
#define XF_FLOATBAR_MODE_DRAGGING 		1
#define XF_FLOATBAR_MODE_RESIZE_LEFT 	2
#define XF_FLOATBAR_MODE_RESIZE_RIGHT 	3


#define XF_FLOATBAR_BUTTON_CLOSE 	1
#define XF_FLOATBAR_BUTTON_RESTORE 	2
#define XF_FLOATBAR_BUTTON_MINIMIZE 3
#define XF_FLOATBAR_BUTTON_LOCKED 	4

typedef struct xf_floatbar_button xfFloatbarButton;

struct xf_floatbar
{
	int x;
	int y;
	int width;
	int height;
	int mode;
	int last_motion_x_root;
	int last_motion_y_root;
	bool locked;
	xfFloatbarButton* buttons[4];
	Window handle;
};

struct xf_floatbar_button
{
	int x;
	int y;
	int type;
	bool focus;
	bool clicked;
	OnClick onclick;
	Window handle;
};

static void xf_floatbar_button_onclick_close(xfContext* xfc)
{
	ExitProcess(EXIT_SUCCESS);
}

static void xf_floatbar_button_onclick_minimize(xfContext* xfc)
{
	xf_SetWindowMinimized(xfc, xfc->window);
}

static void xf_floatbar_button_onclick_restore(xfContext* xfc)
{
	xf_toggle_fullscreen(xfc);
}

static void xf_floatbar_button_onclick_locked(xfContext* xfc)
{
	xfFloatbar* floatbar;
	floatbar = xfc->window->floatbar;
	floatbar->locked = (floatbar->locked) ? FALSE : TRUE;
}

void xf_floatbar_set_root_y(xfContext* xfc, int y)
{
	xfFloatbar* floatbar;
	floatbar = xfc->window->floatbar;
	floatbar->last_motion_y_root = y;
}

void xf_floatbar_hide_and_show(xfContext* xfc)
{
	xfFloatbar* floatbar;
	floatbar = xfc->window->floatbar;

	if (!floatbar->locked)
	{
		if ((floatbar->mode == 0) && (floatbar->last_motion_y_root > 10) &&
		    (floatbar->y > (FLOATBAR_HEIGHT * -1)))
		{
			floatbar->y = floatbar->y - 1;
			XMoveWindow(xfc->display, floatbar->handle, floatbar->x, floatbar->y);
		}
		else if (floatbar->y < 0 && (floatbar->last_motion_y_root < 10))
		{
			floatbar->y = floatbar->y + 1;
			XMoveWindow(xfc->display, floatbar->handle, floatbar->x, floatbar->y);
		}
	}
}

void xf_floatbar_toggle_visibility(xfContext* xfc, bool visible)
{
	xfFloatbar* floatbar;
	int i, size;
	floatbar = xfc->window->floatbar;

	if (visible)
	{
		XMapWindow(xfc->display, floatbar->handle);
		size = ARRAYSIZE(floatbar->buttons);

		for (i = 0; i < size; i++)
		{
			XMapWindow(xfc->display, floatbar->buttons[i]->handle);
		}
	}
	else
	{
		XUnmapSubwindows(xfc->display, floatbar->handle);
		XUnmapWindow(xfc->display, floatbar->handle);
	}
}

static xfFloatbarButton* xf_floatbar_new_button(xfContext* xfc, xfFloatbar* floatbar, int type)
{
	xfFloatbarButton* button;
	button = (xfFloatbarButton*) calloc(1, sizeof(xfFloatbarButton));
	button->type = type;

	switch (type)
	{
		case XF_FLOATBAR_BUTTON_CLOSE:
			button->x = floatbar->width - FLOATBAR_BORDER - FLOATBAR_BUTTON_WIDTH * type;
			button->onclick = xf_floatbar_button_onclick_close;
			break;

		case XF_FLOATBAR_BUTTON_RESTORE:
			button->x = floatbar->width - FLOATBAR_BORDER - FLOATBAR_BUTTON_WIDTH * type;
			button->onclick = xf_floatbar_button_onclick_restore;
			break;

		case XF_FLOATBAR_BUTTON_MINIMIZE:
			button->x = floatbar->width - FLOATBAR_BORDER - FLOATBAR_BUTTON_WIDTH * type;
			button->onclick = xf_floatbar_button_onclick_minimize;
			break;

		case XF_FLOATBAR_BUTTON_LOCKED:
			button->x = FLOATBAR_BORDER;
			button->onclick = xf_floatbar_button_onclick_locked;
			break;

		default:
			break;
	}

	button->y = 0;
	button->focus = FALSE;
	button->handle = XCreateWindow(xfc->display, floatbar->handle, button->x, 0, FLOATBAR_BUTTON_WIDTH,
	                               FLOATBAR_BUTTON_WIDTH, 0, CopyFromParent, InputOutput, CopyFromParent, 0, NULL);
	XSelectInput(xfc->display, button->handle, ExposureMask | ButtonPressMask | ButtonReleaseMask |
	             FocusChangeMask | LeaveWindowMask | EnterWindowMask | StructureNotifyMask);
	return button;
}

xfFloatbar* xf_floatbar_new(xfContext* xfc, Window window)
{
	xfFloatbar* floatbar;
	XWindowAttributes attr;
	int i, width;
	if (!xfc)
		return NULL;

	floatbar = (xfFloatbar*) calloc(1, sizeof(xfFloatbar));
	floatbar->locked = TRUE;
	XGetWindowAttributes(xfc->display, window, &attr);

	for (i = 0; i < xfc->vscreen.nmonitors; i++)
	{
		if (attr.x >= xfc->vscreen.monitors[i].area.left && attr.x <= xfc->vscreen.monitors[i].area.right)
		{
			width = xfc->vscreen.monitors[i].area.right - xfc->vscreen.monitors[i].area.left;
			floatbar->x = width / 2 + xfc->vscreen.monitors[i].area.left - FLOATBAR_DEFAULT_WIDTH / 2;
		}
	}

	floatbar->y = 0;
	floatbar->handle = XCreateWindow(xfc->display, window, floatbar->x, 0, FLOATBAR_DEFAULT_WIDTH,
	                                 FLOATBAR_HEIGHT, 0,
	                                 CopyFromParent, InputOutput, CopyFromParent, 0, NULL);
	floatbar->width = FLOATBAR_DEFAULT_WIDTH;
	floatbar->height = FLOATBAR_HEIGHT;
	floatbar->mode = XF_FLOATBAR_MODE_NONE;
	floatbar->buttons[0] = xf_floatbar_new_button(xfc, floatbar, XF_FLOATBAR_BUTTON_CLOSE);
	floatbar->buttons[1] = xf_floatbar_new_button(xfc, floatbar, XF_FLOATBAR_BUTTON_RESTORE);
	floatbar->buttons[2] = xf_floatbar_new_button(xfc, floatbar, XF_FLOATBAR_BUTTON_MINIMIZE);
	floatbar->buttons[3] = xf_floatbar_new_button(xfc, floatbar, XF_FLOATBAR_BUTTON_LOCKED);
	XSelectInput(xfc->display, floatbar->handle, ExposureMask | ButtonPressMask | ButtonReleaseMask |
	             PointerMotionMask | FocusChangeMask | LeaveWindowMask | EnterWindowMask | StructureNotifyMask |
	             PropertyChangeMask);
	return floatbar;
}

static unsigned long xf_floatbar_get_color(xfContext* xfc, char* rgb_value)
{
	Colormap cmap;
	XColor color;
	cmap = DefaultColormap(xfc->display, XDefaultScreen(xfc->display));
	XParseColor(xfc->display, cmap, rgb_value, &color);
	XAllocColor(xfc->display, cmap, &color);
	XFreeColormap(xfc->display, cmap);
	return color.pixel;
}

static void xf_floatbar_event_expose(xfContext* xfc, XEvent* event)
{
	GC gc, shape_gc;
	Pixmap pmap;
	XPoint shape[5], border[5];
	xfFloatbar* floatbar;
	int len;
	floatbar = xfc->window->floatbar;
	/* create the pixmap that we'll use for shaping the window */
	pmap = XCreatePixmap(xfc->display, floatbar->handle, floatbar->width, floatbar->height, 1);
	gc = XCreateGC(xfc->display, floatbar->handle, 0, 0);
	shape_gc = XCreateGC(xfc->display, pmap, 0, 0);
	/* points for drawing the floatbar */
	shape[0].x = 0;
	shape[0].y = 0;
	shape[1].x = floatbar->width;
	shape[1].y = 0;
	shape[2].x = shape[1].x - FLOATBAR_BORDER;
	shape[2].y = FLOATBAR_HEIGHT;
	shape[3].x = shape[0].x + FLOATBAR_BORDER;
	shape[3].y = FLOATBAR_HEIGHT;
	shape[4].x = shape[0].x;
	shape[4].y = shape[0].y;
	/* points for drawing the border of the floatbar */
	border[0].x = shape[0].x;
	border[0].y = shape[0].y - 1;
	border[1].x = shape[1].x - 1;
	border[1].y = shape[1].y - 1;
	border[2].x = shape[2].x;
	border[2].y = shape[2].y - 1;
	border[3].x = shape[3].x - 1;
	border[3].y = shape[3].y - 1;
	border[4].x = border[0].x;
	border[4].y = border[0].y;
	/* Fill all pixels with 0 */
	XSetForeground(xfc->display, shape_gc, 0);
	XFillRectangle(xfc->display, pmap, shape_gc, 0, 0, floatbar->width,
	               floatbar->height);
	/* Fill all pixels which should be shown with 1 */
	XSetForeground(xfc->display, shape_gc, 1);
	XFillPolygon(xfc->display, pmap, shape_gc, shape, 5, 0, CoordModeOrigin);
	XShapeCombineMask(xfc->display, floatbar->handle, ShapeBounding, 0, 0, pmap, ShapeSet);
	/* draw the float bar */
	XSetForeground(xfc->display, gc, xf_floatbar_get_color(xfc, FLOATBAR_COLOR_BACKGROUND));
	XFillPolygon(xfc->display, floatbar->handle, gc, shape, 4, 0, CoordModeOrigin);
	/* draw an border for the floatbar */
	XSetForeground(xfc->display, gc, xf_floatbar_get_color(xfc, FLOATBAR_COLOR_BORDER));
	XDrawLines(xfc->display, floatbar->handle, gc, border, 5, CoordModeOrigin);
	/* draw the host name connected to */
	len = strlen(xfc->context.settings->ServerHostname);
	XSetForeground(xfc->display, gc, xf_floatbar_get_color(xfc, FLOATBAR_COLOR_FOREGROUND));
	XDrawString(xfc->display, floatbar->handle, gc, floatbar->width / 2 - len * 2, 15,
	            xfc->context.settings->ServerHostname, len);
	XFreeGC(xfc->display, gc);
	XFreeGC(xfc->display, shape_gc);
}

static xfFloatbarButton* xf_floatbar_get_button(xfContext* xfc, XEvent* event)
{
	xfFloatbar* floatbar;
	int i, size;
	size = ARRAYSIZE(floatbar->buttons);
	floatbar = xfc->window->floatbar;

	for (i = 0; i < size; i++)
	{
		if (floatbar->buttons[i]->handle == event->xany.window)
		{
			return floatbar->buttons[i];
		}
	}

	return NULL;
}

static void xf_floatbar_button_update_positon(xfContext* xfc, XEvent* event)
{
	xfFloatbar* floatbar;
	xfFloatbarButton* button;
	int i, size;
	floatbar = xfc->window->floatbar;
	size = ARRAYSIZE(floatbar->buttons);

	for (i = 0; i < size; i++)
	{
		button = floatbar->buttons[i];

		switch (button->type)
		{
			case XF_FLOATBAR_BUTTON_CLOSE:
				button->x = floatbar->width - FLOATBAR_BORDER - FLOATBAR_BUTTON_WIDTH * button->type;
				break;

			case XF_FLOATBAR_BUTTON_RESTORE:
				button->x = floatbar->width - FLOATBAR_BORDER - FLOATBAR_BUTTON_WIDTH * button->type;
				break;

			case XF_FLOATBAR_BUTTON_MINIMIZE:
				button->x = floatbar->width - FLOATBAR_BORDER - FLOATBAR_BUTTON_WIDTH * button->type;
				break;

			default:
				break;
		}

		XMoveWindow(xfc->display, button->handle, button->x, button->y);
		xf_floatbar_event_expose(xfc, event);
	}
}

static void xf_floatbar_button_event_expose(xfContext* xfc, XEvent* event)
{
	xfFloatbar* floatbar;
	xfFloatbarButton* button;
	static unsigned char* bits;
	GC gc;
	Pixmap pattern;
	button = xf_floatbar_get_button(xfc, event);

	if (!button)
		return;

	gc = XCreateGC(xfc->display, button->handle, 0, 0);
	floatbar = xfc->window->floatbar;

	switch (button->type)
	{
		case XF_FLOATBAR_BUTTON_CLOSE:
			bits = close_bits;
			break;

		case XF_FLOATBAR_BUTTON_RESTORE:
			bits = restore_bits;
			break;

		case XF_FLOATBAR_BUTTON_MINIMIZE:
			bits = minimize_bits;
			break;

		case XF_FLOATBAR_BUTTON_LOCKED:
			if (floatbar->locked)
				bits = lock_bits;
			else
				bits = unlock_bits;

			break;

		default:
			break;
	}

	pattern = XCreateBitmapFromData(xfc->display, button->handle, (const char*)bits,
	                                FLOATBAR_BUTTON_WIDTH, FLOATBAR_BUTTON_WIDTH);

	if (!(button->focus))
		XSetForeground(xfc->display, gc, xf_floatbar_get_color(xfc, FLOATBAR_COLOR_BACKGROUND));
	else
		XSetForeground(xfc->display, gc, xf_floatbar_get_color(xfc, FLOATBAR_COLOR_BORDER));

	XSetBackground(xfc->display, gc, xf_floatbar_get_color(xfc, FLOATBAR_COLOR_FOREGROUND));
	XCopyPlane(xfc->display, pattern, button->handle, gc, 0, 0, FLOATBAR_BUTTON_WIDTH,
	           FLOATBAR_BUTTON_WIDTH, 0, 0, 1);
	XFreePixmap(xfc->display, pattern);
	XFreeGC(xfc->display, gc);
}

static void xf_floatbar_button_event_buttonpress(xfContext* xfc, XEvent* event)
{
	xfFloatbarButton* button;
	button = xf_floatbar_get_button(xfc, event);

	if (button)
		button->clicked = TRUE;
}

static void xf_floatbar_button_event_buttonrelease(xfContext* xfc, XEvent* event)
{
	xfFloatbarButton* button;
	button = xf_floatbar_get_button(xfc, event);

	if (button)
	{
		if (button->clicked)
			button->onclick(xfc);
	}
}

static void xf_floatbar_event_buttonpress(xfContext* xfc, XEvent* event)
{
	xfFloatbar* floatbar;
	floatbar = xfc->window->floatbar;

	switch (event->xbutton.button)
	{
		case Button1:
			if (event->xmotion.x <= FLOATBAR_BORDER)
				floatbar->mode = XF_FLOATBAR_MODE_RESIZE_LEFT;
			else if	(event->xmotion.x >= (floatbar->width - FLOATBAR_BORDER))
				floatbar->mode = XF_FLOATBAR_MODE_RESIZE_RIGHT;
			else
				floatbar->mode = XF_FLOATBAR_MODE_DRAGGING;

			break;

		default:
			break;
	}
}

static void xf_floatbar_event_buttonrelease(xfContext* xfc, XEvent* event)
{
	switch (event->xbutton.button)
	{
		case Button1:
			xfc->window->floatbar->mode = XF_FLOATBAR_MODE_NONE;
			break;

		default:
			break;
	}
}

static void xf_floatbar_resize(xfContext* xfc, XEvent* event)
{
	xfFloatbar* floatbar;
	floatbar = xfc->window->floatbar;
	int x, width, movement;
	/* calculate movement which happened on the root window */
	movement = event->xmotion.x_root - floatbar->last_motion_x_root;

	/* set x and width depending if movement happens on the left or right  */
	if (floatbar->mode == XF_FLOATBAR_MODE_RESIZE_LEFT)
	{
		x = floatbar->x + movement;
		width = floatbar->width + movement * -1;
	}
	else
	{
		x = floatbar->x;
		width = floatbar->width + movement;
	}

	/* only resize and move window if still above minimum width */
	if (FLOATBAR_MIN_WIDTH < width)
	{
		XMoveResizeWindow(xfc->display, floatbar->handle, x, 0, width, floatbar->height);
		floatbar->x = x;
		floatbar->width = width;
	}
}

static void xf_floatbar_dragging(xfContext* xfc, XEvent* event)
{
	xfFloatbar* floatbar;
	floatbar = xfc->window->floatbar;
	int x, movement;
	/* calculate movement and new x position */
	movement = event->xmotion.x_root - floatbar->last_motion_x_root;
	x = floatbar->x + movement;

	/* do nothing if floatbar would be moved out of the window */
	if (x < 0 || (x + floatbar->width) > xfc->window->width)
		return;

	/* move window to new x position */
	XMoveWindow(xfc->display, floatbar->handle, x, 0);
	/* update struct values for the next event */
	floatbar->last_motion_x_root = floatbar->last_motion_x_root + movement;
	floatbar->x = x;
}

static void xf_floatbar_event_motionnotify(xfContext* xfc, XEvent* event)
{
	int mode;
	xfFloatbar* floatbar;
	Cursor cursor;
	mode = xfc->window->floatbar->mode;
	floatbar = xfc->window->floatbar;
	cursor = XCreateFontCursor(xfc->display, XC_arrow);

	if ((event->xmotion.state & Button1Mask) && (mode > XF_FLOATBAR_MODE_DRAGGING))
	{
		xf_floatbar_resize(xfc, event);
	}
	else if ((event->xmotion.state & Button1Mask) && (mode == XF_FLOATBAR_MODE_DRAGGING))
	{
		xf_floatbar_dragging(xfc, event);
	}
	else
	{
		if (event->xmotion.x <= FLOATBAR_BORDER ||
		    event->xmotion.x >= xfc->window->floatbar->width - FLOATBAR_BORDER)
			cursor = XCreateFontCursor(xfc->display, XC_sb_h_double_arrow);
	}

	XDefineCursor(xfc->display, xfc->window->handle, cursor);
	XFreeCursor(xfc->display, cursor);
	xfc->window->floatbar->last_motion_x_root = event->xmotion.x_root;
}

static void xf_floatbar_button_event_focusin(xfContext* xfc, XEvent* event)
{
	xfFloatbarButton* button;
	button = xf_floatbar_get_button(xfc, event);

	if (button)
	{
		button->focus = TRUE;
		xf_floatbar_button_event_expose(xfc, event);
	}
}

static void xf_floatbar_button_event_focusout(xfContext* xfc, XEvent* event)
{
	xfFloatbarButton* button;
	button = xf_floatbar_get_button(xfc, event);

	if (button)
	{
		button->focus = FALSE;
		button->clicked = FALSE;
		xf_floatbar_button_event_expose(xfc, event);
	}
}

static void xf_floatbar_event_focusout(xfContext* xfc, XEvent* event)
{
	Cursor cursor;
	cursor = XCreateFontCursor(xfc->display, XC_arrow);
	XDefineCursor(xfc->display, xfc->window->handle, cursor);
	XFreeCursor(xfc->display, cursor);
}

BOOL xf_floatbar_check_event(xfContext* xfc, XEvent* event)
{
	xfFloatbar* floatbar;
	xfFloatbarButton* button;
	size_t i, size;

	if (!xfc || !event || !xfc->window)
		return FALSE;

	floatbar = xfc->window->floatbar;

	if (event->xany.window == floatbar->handle)
		return TRUE;

	size = ARRAYSIZE(floatbar->buttons);

	for (i = 0; i < size; i++)
	{
		button = floatbar->buttons[i];

		if (event->xany.window == button->handle)
			return TRUE;
	}

	return FALSE;
}

BOOL xf_floatbar_event_process(xfContext* xfc, XEvent* event)
{
	xfFloatbar* floatbar;

	if (!xfc || !xfc->window || !event)
		return FALSE;

	floatbar = xfc->window->floatbar;

	switch (event->type)
	{
		case Expose:
			if (event->xany.window == floatbar->handle)
				xf_floatbar_event_expose(xfc, event);
			else
				xf_floatbar_button_event_expose(xfc, event);

			break;

		case MotionNotify:
			xf_floatbar_event_motionnotify(xfc, event);
			break;

		case ButtonPress:
			if (event->xany.window == floatbar->handle)
				xf_floatbar_event_buttonpress(xfc, event);
			else
				xf_floatbar_button_event_buttonpress(xfc, event);

			break;

		case ButtonRelease:
			if (event->xany.window == floatbar->handle)
				xf_floatbar_event_buttonrelease(xfc, event);
			else
				xf_floatbar_button_event_buttonrelease(xfc, event);

			break;

		case EnterNotify:
		case FocusIn:
			if (event->xany.window != floatbar->handle)
				xf_floatbar_button_event_focusin(xfc, event);

			break;

		case LeaveNotify:
		case FocusOut:
			if (event->xany.window == floatbar->handle)
				xf_floatbar_event_focusout(xfc, event);
			else
				xf_floatbar_button_event_focusout(xfc, event);

			break;

		case ConfigureNotify:
			if (event->xany.window == floatbar->handle)
				xf_floatbar_button_update_positon(xfc, event);

			break;

		case PropertyNotify:
			if (event->xany.window == floatbar->handle)
				xf_floatbar_button_update_positon(xfc, event);

			break;

		default:
			break;
	}

	return floatbar->handle == event->xany.window;
}

static void xf_floatbar_button_free(xfContext* xfc, xfFloatbarButton* button)
{
	if (!button)
		return;

	if (button->handle)
	{
		XUnmapWindow(xfc->display, button->handle);
		XDestroyWindow(xfc->display, button->handle);
	}

	free(button);
}

void xf_floatbar_free(xfContext* xfc, xfWindow* window, xfFloatbar* floatbar)
{
	size_t i, size;
	size = ARRAYSIZE(floatbar->buttons);

	if (!floatbar)
		return;

	if (window->floatbar == floatbar)
		window->floatbar = NULL;

	for (i = 0; i < size; i++)
	{
		xf_floatbar_button_free(xfc, floatbar->buttons[i]);
		floatbar->buttons[i] = NULL;
	}

	if (floatbar->handle)
	{
		XUnmapWindow(xfc->display, floatbar->handle);
		XDestroyWindow(xfc->display, floatbar->handle);
	}

	free(floatbar);
}