/*
Copyright (C) 2015 Marco "eukara" Hladik
Copyright (C) 1996-1997 Id Software, Inc.

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.

*/
// vid_gdk.c -- general gdk video driver

#include <ctype.h>
#include <sys/time.h>
#include <sys/types.h>
#include <unistd.h>
#include <signal.h>
#include <stdlib.h>
#include <stdio.h>
#include <string.h>

#include <gtk/gtk.h>
#include <gdk/gdk.h>
#include <gdk/gdkx.h>
#include <gdk/gdkkeysyms.h>

#include "globaldef.h"
#include "d_local.h"
#include "editor.h"
#include "../splash.xpm"
#include "../icon.xpm"

viddef_t vid;
unsigned short d_8to16table[256];

static int gdk_initialized = 0;
static int vid_frame[4];

static float mouse_x, mouse_y;
static float old_mouse_x, old_mouse_y;
static qboolean mouse_enabled;
cvar_t	*m_filter;
extern int deathcam_active;
extern vec3_t	deathcam_angles;

GtkWidget *x_win;
GdkGC *x_gc;
GdkRgbCmap *x_cmap = NULL;
static GdkDisplay *display = NULL;
static GdkScreen *screen = NULL;

static unsigned char *x_framebuffer = NULL;

static int verbose = 0;
static long X11_highhunkmark;
static long X11_buffersize;

static int vid_surfcachesize;
void *vid_surfcache;
static int vid_center_x, vid_center_y;
static int vid_mouseposx, vid_mouseposy;

void (*vid_menudrawfn) (void);
void (*vid_menukeyfn) (int key);
void VID_MenuKey(int key);

void VID_HandleDeath(int signal_num)
{
    Sys_Error("[VIDEO] This death brought to you by the number %d\n", signal_num);
}

void VID_ResetFrameBuffer(void)
{
	if (d_pzbuffer) 
	{
		D_FlushCaches();
		Hunk_FreeToHighMark(X11_highhunkmark);
		d_pzbuffer = NULL;
    	}
    	X11_highhunkmark = Hunk_HighMark();

	/* alloc an extra line in case we want to wrap, and allocate the z-buffer */
    	X11_buffersize = vid.width * vid.height * sizeof(*d_pzbuffer);
    	vid_surfcachesize = D_SurfaceCacheForRes(vid.width, vid.height);
    	X11_buffersize += vid_surfcachesize;
    	d_pzbuffer = Hunk_HighAllocName(X11_buffersize, "video");

    	if (d_pzbuffer == NULL)
		Sys_Error ("[VIDEO] Not enough memory for video mode\n");

    	vid_surfcache = (byte *) d_pzbuffer + vid.width * vid.height * sizeof(*d_pzbuffer);

    	D_InitCaches(vid_surfcache, vid_surfcachesize);

	if (x_framebuffer)
		free(x_framebuffer);

    	x_framebuffer = malloc(vid.width * vid.height * 3);

    	if (!x_framebuffer)
		Sys_Error("[VIDE] Failed to reset framebuffer!\n");

    	vid.buffer = (byte *) (x_framebuffer);
    	vid.conbuffer = vid.buffer;
}

void VID_Init(unsigned char *palette)
{
	int pnum;
    	struct sigaction sa;
    
	vid.width = 640;
    	vid.height = 480;

    	if ((pnum=COM_CheckParm("-winsize")))
	{
		if (pnum >= com_argc-2)
			Sys_Error("[VIDEO] -winsize <width> <height>\n");
		vid.width = Q_atoi(com_argv[pnum+1]);
		vid.height = Q_atoi(com_argv[pnum+2]);
		if (!vid.width || !vid.height)
			Sys_Error("[VIDEO] Bad window width/height\n");
	}
	if ((pnum=COM_CheckParm("-width"))) {
		if (pnum >= com_argc-1)
			Sys_Error("[VIDEO] -width <width>\n");
		vid.width = Q_atoi(com_argv[pnum+1]);
		if (!vid.width)
			Sys_Error("[VIDEO] Bad window width\n");
	}
	if ((pnum=COM_CheckParm("-height"))) {
		if (pnum >= com_argc-1)
			Sys_Error("[VIDEO] -height <height>\n");
		vid.height = Q_atoi(com_argv[pnum+1]);
		if (!vid.height)
			Sys_Error("[VIDEO] Bad window height\n");
	}

    	vid.maxwarpwidth = WARP_WIDTH;
    	vid.maxwarpheight = WARP_HEIGHT;
	vid.maxlowwidth = LOW_WIDTH;
   	vid.maxlowheight = LOW_HEIGHT;
    	vid.numpages = 2;
   	vid.colormap = host_colormap;
    	vid.fullbright = 256 - LittleLong(*((int *) vid.colormap + 2048));
    	srandom(getpid());
    	verbose = COM_CheckParm("-verbose");

    	/* initialize GDK */
    	gtk_init(NULL, NULL);
    	gdk_rgb_init();

    	sigaction(SIGINT, 0, &sa);
    	sa.sa_handler = VID_HandleDeath;
    	sigaction(SIGINT, &sa, 0);
    	sigaction(SIGTERM, &sa, 0);

	display = gdk_display_get_default ();
    	screen = gdk_display_get_default_screen (display);

	/* create the main window */
    	x_win = gtk_window_new(GTK_WINDOW_TOPLEVEL);
	gtk_window_set_title(x_win, "NGUNIX");
	gtk_widget_set_size_request(x_win, vid.width, vid.height);
	gtk_window_set_default_size(x_win, vid.width, vid.height);
	gtk_window_set_position(x_win,GTK_WIN_POS_CENTER_ALWAYS);
	gtk_window_set_resizable(x_win, FALSE);
	g_signal_connect (x_win, "destroy", G_CALLBACK (exit), NULL);
	gtk_widget_set_events(x_win, GDK_BUTTON_PRESS_MASK | GDK_BUTTON_RELEASE_MASK);

	if ((pnum=COM_CheckParm("-noborder")))
		gtk_window_set_decorated(x_win, FALSE);
	
	gtk_widget_realize(x_win);
	/* create the GC */
    	x_gc = gdk_gc_new(gtk_widget_get_window(x_win));
    	if (!x_gc)
		Sys_Error("[VIDEO] Cannot create GC\n");

	/* map the window */
    	gtk_widget_show_all(x_win);
    	VID_ResetFrameBuffer();

    	vid.rowbytes = vid.width;
    	vid.buffer = x_framebuffer;
    	vid.direct = 0;
    	vid.conbuffer = x_framebuffer;
    	vid.conrowbytes = vid.rowbytes;
    	vid.conwidth = vid.width;
    	vid.conheight = vid.height;
    	vid.aspect =
		((float) vid.height / (float) vid.width) * (320.0 / 240.0);
	mouse_enabled = false;
	gdk_window_get_geometry (gtk_widget_get_window(x_win), &vid_frame[0], &vid_frame[1], &vid_frame[2], &vid_frame[3], NULL);
	gdk_window_get_position(gtk_widget_get_window(x_win), &vid_frame[0], &vid_frame[1]);
	vid_center_x = (int)(((float)vid_frame[2] / 2) + vid_frame[0]);
	vid_center_y = (int)(((float)vid_frame[2] / 2) + vid_frame[1]);
	vid_frame[2] += vid_frame[0];
	vid_frame[3] += vid_frame[1];
	gdk_initialized = 1;
}

void VID_SetPalette(unsigned char *palette)
{
    	int i = 768;

    	unsigned char *ptr;
    	unsigned int colors[256];

    	if (x_cmap) 
		gdk_rgb_cmap_free(x_cmap);

    	ptr = palette;

    	for (i = 0; i < 256; i++) {
		unsigned char r, g, b;
		r = *ptr++;
		g = *ptr++;
		b = *ptr++;
		colors[i] = r << 16 | g << 8 | b;
    	}

    	x_cmap = gdk_rgb_cmap_new(colors, 256);
}

void VID_Shutdown(void)
{
    	Con_Printf("[VIDEO] Shutting down...\n");
}

int IN_LateKey(int keysym)
{
    int key = 0;

    switch (keysym) {
    case GDK_Page_Up:
	key = K_PGUP;
	break;
    case GDK_Page_Down:
	key = K_PGDN;
	break;
    case GDK_Home:
	key = K_HOME;
	break;
    case GDK_End:
	key = K_END;
	break;
    case GDK_Left:
	key = K_LEFTARROW;
	break;
    case GDK_Right:
	key = K_RIGHTARROW;
	break;
    case GDK_Down:
	key = K_DOWNARROW;
	break;
    case GDK_Up:
	key = K_UPARROW;
	break;
    case GDK_Escape:
	key = K_ESCAPE;
	break;
    case GDK_Return:
    case GDK_KEY_KP_Enter:
	key = K_ENTER;
	break;
    case GDK_Tab:
	key = K_TAB;
	break;
    case GDK_space:
	key = K_SPACE;
	break;
    case GDK_F1:
	key = K_F1;
	break;
    case GDK_F2:
	key = K_F2;
	break;
    case GDK_F3:
	key = K_F3;
	break;
    case GDK_F4:
	key = K_F4;
	break;
    case GDK_F5:
	key = K_F5;
	break;
    case GDK_F6:
	key = K_F6;
	break;
    case GDK_F7:
	key = K_F7;
	break;
    case GDK_F8:
	key = K_F8;
	break;
    case GDK_F9:
	key = K_F9;
	break;
    case GDK_F10:
	key = K_F10;
	break;
    case GDK_F11:
	key = K_F11;
	break;
    case GDK_F12:
	key = K_F12;
	break;
    case GDK_BackSpace:
    case GDK_Delete:
	key = K_BACKSPACE;
	break;
    case GDK_Pause:
	key = K_PAUSE;
	break;
    case GDK_Shift_L:
    case GDK_Shift_R:
	key = K_SHIFT;
	break;
    case GDK_Execute:
    case GDK_Control_L:
    case GDK_Control_R:
	key = K_CTRL;
	break;
    case GDK_Alt_L:
    case GDK_Meta_L:
    case GDK_Alt_R:
    case GDK_Meta_R:
	key = K_ALT;
	break;
    case GDK_grave:
	key = '`';
	break;
    case GDK_KEY_underscore:
	key = '_';
    	break;
    case GDK_KEY_KP_Multiply:
	key = '*';
    	break;
    case GDK_KEY_KP_Add:
	key = '+';
    	break;
    case GDK_KEY_KP_Subtract:
	key = '-';
    	break;
    case GDK_KEY_KP_Divide:
	key = '/';
    	break;
    case GDK_KEY_KP_Delete:
	key = ',';
    	break;
    case GDK_KEY_KP_0 :
	key = '0';
    	break;
    case GDK_KEY_KP_1 :
	key = '1';
    	break;
    case GDK_KEY_KP_2 :
	key = '2';
    	break;
    case GDK_KEY_KP_3 :
	key = '3';
    	break;
    case GDK_KEY_KP_4:
	key = '4';
    	break;
    case GDK_KEY_KP_5 :
	key = '5';
    	break;
    case GDK_KEY_KP_6 :
	key = '6';
    	break;
    case GDK_KEY_KP_7 :
	key = '7';
    	break;
    case GDK_KEY_KP_8 :
	key = '8';
    	break;
    case GDK_KEY_KP_9 :
	key = '9';
    	break;
    default:
	if (keysym > GDK_space && keysym <= GDK_9)
	    key = keysym;
	if (keysym >= GDK_A && keysym <= GDK_Z)
	    key = keysym - GDK_A + 'a';
	if (keysym >= GDK_a && keysym <= GDK_z)
	    key = keysym - GDK_a + 'a';
	break;
    }
    //printf("keysym: %x, key: %x\n", keysym, key);
    return key;
}

struct {
	int key;
	int down;
} keyq[64];

int keyq_head = 0;
int keyq_tail = 0;
void VID_GetEvent(void)
{
	int w, h;
    	GdkEvent *event;
    	event = gdk_event_get();

    	if (event)
	switch (event->type) {
	case GDK_KEY_PRESS:
	    keyq[keyq_head].key = IN_LateKey(event->key.keyval);
	    keyq[keyq_head].down = true;
	    keyq_head = (keyq_head + 1) & 63;
	    break;
	case GDK_KEY_RELEASE:
	    keyq[keyq_head].key = IN_LateKey(event->key.keyval);
	    keyq[keyq_head].down = false;
	    keyq_head = (keyq_head + 1) & 63;
	    break;
	case GDK_ENTER_NOTIFY:
	    break;
	case GDK_LEAVE_NOTIFY:
	    if(mouse_enabled)
		gdk_display_warp_pointer (display, screen, vid_center_x, vid_center_y);
	    else
	    	IN_DeactivateMouse();
	    break;
	case GDK_CONFIGURE:
	    	gtk_window_get_size(GTK_WINDOW(x_win), &w, &h);
		gdk_window_get_geometry (gtk_widget_get_window(x_win), &vid_frame[0], &vid_frame[1], &vid_frame[2], &vid_frame[3], NULL);
		gdk_window_get_position(gtk_widget_get_window(x_win), &vid_frame[0], &vid_frame[1]);
		vid_center_x = (int)(((float)vid_frame[2] / 2) + vid_frame[0]);
		vid_center_y = (int)(((float)vid_frame[2] / 2) + vid_frame[1]);
		vid_frame[2] += vid_frame[0];
		vid_frame[3] += vid_frame[1];
	    break;
	case GDK_BUTTON_PRESS:
	    	if(event->button.button == 1)
			Key_Event (K_MOUSE1, true);
		if(event->button.button == 3)
			Key_Event (K_MOUSE2, true);
		if(event->button.button == 2)
			Key_Event (K_MOUSE3, true);
		break;
	case GDK_BUTTON_RELEASE:
		if(event->button.button == 1)
			Key_Event (K_MOUSE1, false);
		if(event->button.button == 3)
			Key_Event (K_MOUSE2, false);
		if(event->button.button == 2)
			Key_Event (K_MOUSE3, false);
		break;
	case GDK_SCROLL:
		if(event->scroll.direction == GDK_SCROLL_UP)
		{
			Key_Event (K_MWHEELUP, true);
			Key_Event (K_MWHEELUP, false);
		}
		if(event->scroll.direction == GDK_SCROLL_DOWN){
			Key_Event (K_MWHEELDOWN, true);
			Key_Event (K_MWHEELDOWN, false);
		}
		break;
	    break;
	}
}

// flushes the given rectangles from the view buffer to the screen
void VID_Update(vrect_t * rects)
{
	scr_fullupdate = 0;
    	while (rects) {
		gdk_draw_indexed_image(gtk_widget_get_window(x_win), 
			x_gc, rects->x, rects->y, rects->width, rects->height, GDK_RGB_DITHER_NONE, x_framebuffer, vid.width, x_cmap); 
		rects = rects->pnext;
    	}
}

void VID_Init_Cmds(void)
{
	Cmd_AddCommand ("editor", VID_LaunchEditor);
}

void Sys_SendKeyEvents(void)
{
    	if (!gdk_initialized) 
	    return;

	while (gdk_events_pending()) 
	{
		VID_GetEvent();
	    	while (keyq_head != keyq_tail) 
	    	{
			Key_Event(keyq[keyq_tail].key, keyq[keyq_tail].down);
			keyq_tail = (keyq_tail + 1) & 63;
	    	}
	}
    
}

void D_BeginDirectRect(int x, int y, byte * pbitmap, int width, int height)
{
// direct drawing of the "accessing disk" icon isn't supported under Linux
}

void D_EndDirectRect(int x, int y, int width, int height)
{
// direct drawing of the "accessing disk" icon isn't supported under Linux
}


void VID_HandlePause (qboolean pause)
{
	if (pause)
	{
		IN_DeactivateMouse ();
		IN_ShowMouse ();
	}
	else
	{
		IN_ActivateMouse ();
		IN_HideMouse ();
	}	
}

void IN_Move (usercmd_t *cmd)
{
	vec3_t		tangles; // eukara - deathcam 

	if (m_filter->value) 
	{
		mouse_x = (mouse_x + old_mouse_x) * 0.5;
		mouse_y = (mouse_y + old_mouse_y) * 0.5;
	}

	if (mouse_enabled == true)
	{
		gdk_display_get_pointer (display, NULL, &vid_mouseposx, &vid_mouseposy, NULL);
	
		mouse_x = (float)vid_mouseposx - vid_center_x;
		mouse_y = (float)vid_mouseposy - vid_center_y;
		old_mouse_x = mouse_x;
		old_mouse_y = mouse_y;

		mouse_x *= sensitivity->value;
		mouse_y *= sensitivity->value;
	}

	if (deathcam_active)
	{
		tangles[0] = deathcam_angles[0]; 
		tangles[1] = deathcam_angles[1]; 
		tangles[2] = deathcam_angles[2];
	}
	else
	{
		tangles[0] = cl.viewangles[0];
		tangles[1] = cl.viewangles[1];
		tangles[2] = cl.viewangles[2];
	}

	if ( (in_strafe.state & 1) || (lookstrafe->value && ((in_mlook.state & 1) ^ ((int)m_look->value & 1)) ))
		cmd->sidemove += m_side->value * mouse_x;
	else
		tangles[YAW] -= m_yaw->value * mouse_x;

	if ((in_mlook.state & 1) ^ ((int)m_look->value & 1))
		V_StopPitchDrift ();

	if ( ((in_mlook.state & 1) ^ ((int)m_look->value & 1)) && !(in_strafe.state & 1)) 
	{
		tangles[PITCH] += m_pitch->value * mouse_y;
		if (!deathcam_active)
		{
			if (tangles[PITCH] > m_lockdown->value)
				tangles[PITCH] = m_lockdown->value;
			if (tangles[PITCH] < m_lockup->value)
				tangles[PITCH] = m_lockup->value;
		}
	} 
	else
	{
		if ((in_strafe.state & 1) && noclip_anglehack)
			cmd->upmove -= m_forward->value * mouse_y;
		else
			cmd->forwardmove -= m_forward->value * mouse_y;
	}


	if (deathcam_active)
	{
		deathcam_angles[0] = tangles[0]; 
		deathcam_angles[1] = tangles[1]; 
		deathcam_angles[2] = tangles[2];
	}
	else
	{
		cl.viewangles[0] = tangles[0]; 
		cl.viewangles[1] = tangles[1];  
		cl.viewangles[2] = tangles[2]; 
	}

	if((mouse_x || mouse_y) && mouse_enabled)
		gdk_display_warp_pointer (display, screen, vid_center_x, vid_center_y);

	mouse_x = mouse_y = 0;
}

gboolean VID_KillSplash(gpointer data){
  	gtk_widget_destroy((GtkWidget*)data);
  	gtk_main_quit ();
  	return(FALSE);
}
void VID_CreateSplash()
{
	GdkBitmap *splash_mask;
	GdkPixmap *splash_image;
	GtkWidget *x_splash, *x_splash_image;
	GdkPixbuf *icon_image;

	gtk_init(NULL, NULL);
	icon_image = gdk_pixbuf_new_from_xpm_data(icon_xpm);
	gtk_window_set_default_icon (icon_image);

	x_splash = gtk_window_new (GTK_WINDOW_TOPLEVEL);
  	gtk_widget_set_size_request (x_splash, 440, 116);
  	gtk_window_set_decorated(x_splash, FALSE);
  	gtk_window_set_position(x_splash,GTK_WIN_POS_CENTER_ALWAYS);
  	gtk_window_set_resizable(x_splash, FALSE);
	gtk_widget_realize(x_splash);

  	splash_image = gdk_pixmap_create_from_xpm_d(x_splash->window, &splash_mask, NULL, (gchar **)splash_xpm );
	x_splash_image = gtk_image_new_from_pixmap(splash_image, splash_mask);

  	gtk_container_add(GTK_CONTAINER(x_splash), x_splash_image);
  	gtk_widget_show_all (x_splash);
	g_timeout_add (1000, VID_KillSplash, x_splash);
	gtk_main ();
}

void IN_Init_Cvars()
{
	m_filter = Cvar_Get ("m_filter", "0", CVAR_ARCHIVE|CVAR_ORIGINAL);
}

/*
 * Mouse related functions
 * that have nothing todo with aiming or pushing buttons
 */
void IN_DeactivateMouse (void)
{
	mouse_enabled = false;
	gdk_pointer_ungrab (GDK_CURRENT_TIME);
}

void IN_ActivateMouse (void)
{
	gdk_display_warp_pointer (display, screen, vid_center_x, vid_center_y);
	mouse_enabled = true;
	gdk_pointer_grab(gtk_widget_get_window(x_win), TRUE, (GdkEventMask)(GDK_BUTTON_PRESS_MASK ), (GdkWindow *)NULL, NULL, GDK_CURRENT_TIME);
}

void IN_HideMouse (void) 
{
	GdkCursor* cursor_blank = gdk_cursor_new(GDK_BLANK_CURSOR);
	gdk_window_set_cursor(gtk_widget_get_window(x_win), cursor_blank);
}

void IN_ShowMouse (void)
{
	GdkCursor* cursor_arrow = gdk_cursor_new(GDK_ARROW);
	gdk_window_set_cursor(gtk_widget_get_window(x_win), cursor_arrow);
}

// Command graveyard TODO: Get rid of this
int Sys_OpenWindow(void){return 0;}
void Sys_EraseWindow(int window){}
void Sys_DrawCircle(int window, int x, int y, int r){}
void Sys_DisplayWindow(int window){}
void IN_Init(void){}
void IN_Shutdown(void){}
void IN_Commands(void){}