#include <iostream>

#include <stdlib.h> 
#include <stdio.h>
#include <string.h>

#include <X11/Shell.h>
#include <X11/Xmu/StdCmap.h>
#include <X11/keysym.h>

#include <Xm/Xm.h>
#include <Xm/MwmUtil.h>
#include <Xm/XmAll.h>

#include <GL/gl.h>
#include <GL/glu.h>
#include <GL/glx.h>
#include <GL/GLwMDrawA.h>

#include "../mapviewer.h"
using namespace std;

#define SENSITIVITY 500;

Display *display;
Screen *screen;
int screenNumber;
XtAppContext app;
XVisualInfo *visinfo;
GLXContext glxContext;
   
Widget top, form, menu, glxarea;

int isLDown;
int isRDown;
int ox, oy;
int mx, my;

int width = 512, height = 512;
GLfloat light_position[] = {1.0, 1.0, 1.0};

Widget createGLXarea(Widget);
void glxareaInitCallback(Widget, XtPointer, XtPointer);
void glxareaExposeCallback(Widget, XtPointer, XtPointer);
void glxareaResizeCallback(Widget, XtPointer, XtPointer);
void glxareaInputCallback(Widget, XtPointer, XtPointer);
Widget createMenuBar(Widget);

void StartOgl(int argc, char *argv[])
{
	String fallback_resources[] = {
		"*glxarea.width: 512",
		"*glxarea.height: 512",
		"*sgiMode: TRUE",
		"*SgNuseEnhancedFSB: TRUE",
		"*useSchemes: all",
		"keyboardFocusPolicy: POINTER",
		"*glxarea.traversalOn: TRUE",
		NULL
	};

	XtSetLanguageProc(NULL,NULL,NULL); 
	top = XtVaOpenApplication(&app, "glxarea", NULL, 0, &argc, argv, 
		fallback_resources, applicationShellWidgetClass, NULL);
	display = XtDisplay(top);
	screen = XtScreen(top);
	screenNumber = XScreenNumberOfScreen(screen);

	form = XtVaCreateManagedWidget("mainForm", xmFormWidgetClass,
		top, NULL);

	menu = createMenuBar(form);
	XtVaSetValues(menu,
		XmNtopAttachment, XmATTACH_FORM,
		XmNleftAttachment, XmATTACH_FORM,
		XmNrightAttachment, XmATTACH_FORM,
		NULL);

	glxarea = createGLXarea(form);
	XtVaSetValues(glxarea,
		XmNtopAttachment, XmATTACH_WIDGET,
		XmNtopWidget, menu,
		XmNleftAttachment, XmATTACH_FORM,
		XmNrightAttachment, XmATTACH_FORM,
		XmNbottomAttachment, XmATTACH_FORM,
		NULL);

	/* Whatever that does */
	XtAppUnlock(app);
 
	XtRealizeWidget(top);
	GLwDrawingAreaMakeCurrent(glxarea, glxContext);
	RenderScene();
	XtAppMainLoop(app);
}

int getWidth()
{
	return width;
}

int getHeight()
{
	return height;
}

void SwapBuffers()
{
	GLwDrawingAreaSwapBuffers(glxarea);
	if (!glXIsDirect(XtDisplay(glxarea), glxContext))
		glXWaitGL();
	else 
		glXWaitX();
	glFinish();
}

void exitCB(Widget w, XtPointer clientData, XtPointer callData)
{   
	exit(0);
}

void opendffCB(Widget w, XtPointer clientData, XtPointer callData)
{   
	printf("Open Dff\n");
}

void opentxdCB(Widget w, XtPointer clientData, XtPointer callData)
{   
	printf("Open Txd\n");
}

Widget createMenuBar(Widget parent)
{
	Widget menubar, file, view;
	Widget opentxd, opendff, exit;
	Widget top, left, front;
   
	menubar = XmCreateMenuBar(parent, "menubar", NULL, 0);
   
	/* file menu */
	file = XmCreatePulldownMenu(parent, "filemenu", NULL, 0);
	XtVaCreateManagedWidget("File", xmCascadeButtonWidgetClass, menubar,
		XmNsubMenuId, file, NULL);
	opentxd = XtCreateManagedWidget("Open Txd", xmPushButtonWidgetClass,
		file, NULL, 0);
	opendff = XtCreateManagedWidget("Open Dff", xmPushButtonWidgetClass,
		file, NULL, 0);
	exit = XtCreateManagedWidget("Exit", xmPushButtonWidgetClass,
		file, NULL, 0);
	XtAddCallback(opentxd, XmNactivateCallback, opentxdCB, NULL);
	XtAddCallback(opendff, XmNactivateCallback, opendffCB, NULL);
	XtAddCallback(exit, XmNactivateCallback, exitCB, NULL);

	view = XmCreatePulldownMenu(parent, "viewmenu", NULL, 0);
	XtVaCreateManagedWidget("View", xmCascadeButtonWidgetClass, menubar,
		XmNsubMenuId, view, NULL);
	top = XtCreateManagedWidget("Top", xmPushButtonWidgetClass,
		view, NULL, 0);
	left = XtCreateManagedWidget("Left", xmPushButtonWidgetClass,
		view, NULL, 0);
	front = XtCreateManagedWidget("Front", xmPushButtonWidgetClass,
		view, NULL, 0);
    
	XtManageChild(menubar);
	return menubar;
}

Widget createGLXarea(Widget parent)
{
	int visAttribList[] = { 
		GLX_RGBA, 					
		GLX_DOUBLEBUFFER, 
		GLX_RED_SIZE, 8, 
		GLX_GREEN_SIZE,	8,
		GLX_BLUE_SIZE, 8, 
		None};
	Status status;
	XStandardColormap *standardCmaps;
	int i, numCmaps, found_std_colormap = 0;
	Colormap cmap;
	Widget glxarea;

	/* select appropriate visual */
	visinfo = glXChooseVisual(display, screenNumber, visAttribList);

	if (visinfo == NULL) {
		fprintf(stderr, "\nCreateGLXarea: ERROR - no good visual !!\n");
		return NULL;
	}
   
	/* Select Colormap: only work for TrueColor visuals  */
/*
	if (visinfo->class != TrueColor) {
		fprintf(stderr, "Colormap: fatal error!");
		fprintf(stderr, " : no support for non-TrueColor visual\n");
		return NULL;
	}
*/
	status = XmuLookupStandardColormap(display, visinfo->screen,
		visinfo->visualid,
		visinfo->depth, XA_RGB_DEFAULT_MAP, False, True);
	if (status == 1) {
		status = XGetRGBColormaps(display,
			RootWindow(display, visinfo->screen),
			&standardCmaps, &numCmaps, XA_RGB_DEFAULT_MAP);
	if (status == 1) {
		for (i = 0; i < numCmaps; i++) {
			if (standardCmaps[i].visualid == visinfo->visualid) {
				cmap = standardCmaps[i].colormap;
				found_std_colormap = 1;
				XFree(standardCmaps);
				break;
			}
		}
	}
	}
	if (!found_std_colormap) {
		cmap = XCreateColormap(display, RootWindow(display,
			visinfo->screen), visinfo->visual, AllocNone);
	}
	printf("visual id = 0x%lx\n", visinfo->visualid);
   
	glxarea = XtVaCreateManagedWidget( "glxarea",
		glwMDrawingAreaWidgetClass, parent,
		GLwNvisualInfo, visinfo,
		XtNcolormap, cmap,
		XtNwidth, width,
		XtNheight, height,
		NULL );   

	XtAddCallback(glxarea, GLwNginitCallback, glxareaInitCallback, NULL);
	XtAddCallback(glxarea, GLwNexposeCallback, glxareaExposeCallback, NULL);
	XtAddCallback(glxarea, GLwNresizeCallback, glxareaResizeCallback, NULL);
	XtAddCallback(glxarea, GLwNinputCallback, glxareaInputCallback, NULL);
   
	return glxarea;
}

void glxareaInitCallback(Widget w, XtPointer clientData, XtPointer callData )
{
   
	XtAppLock(app);
	glxContext = glXCreateContext(XtDisplay(w), visinfo, NULL, GL_TRUE);
          
	GLwDrawingAreaMakeCurrent(w, glxContext);

	Init();
   	   
	XtAppUnlock(app);
}

void glxareaExposeCallback(Widget w, XtPointer clientData, XtPointer callData)
{     
	GLwDrawingAreaMakeCurrent(w, glxContext);
	glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT);   
	XmUpdateDisplay(w);
	RenderScene();
}

void glxareaResizeCallback(Widget w, XtPointer clientData, XtPointer callData)
{   
	GLwDrawingAreaCallbackStruct *cbs = (GLwDrawingAreaCallbackStruct *)callData;

	GLwDrawingAreaMakeCurrent(w, glxContext);
	width = cbs->width;
	height = cbs->height;
}

void Keypress(int key)
{
	GLfloat phi = 3.14159/32;
	switch(key) {
	case XK_Up:
		planey += dist;
		break;
	case XK_Down:
		planey -= dist;
		break;
	case XK_Left:
		planex += dist;
		break;
	case XK_Right:
		planex -= dist;
		break;
	case XK_bracketright:
		Camera.ChangeFOV(1.0);
		glMatrixMode(GL_PROJECTION);
		glLoadIdentity();
		gluPerspective(Camera.GetFOV(),
		               (GLfloat)(GLView.getWidth())/
		               (GLfloat)(GLView.getHeight()),
			       1.0f, Sky.GetFarClp());
		glMatrixMode(GL_MODELVIEW);
		break;
	case XK_bracketleft:
		Camera.ChangeFOV(-1.0);
		glMatrixMode(GL_PROJECTION);
		glLoadIdentity();
		gluPerspective(Camera.GetFOV(),
		               (GLfloat)(GLView.getWidth())/
		               (GLfloat)(GLView.getHeight()),
			       1.0f, Sky.GetFarClp());
		glMatrixMode(GL_MODELVIEW);
		break;
	case XK_n:
		if (isShiftDown)
			planescale -= 0.1;
		else
			planescale += 0.1;
		break;
	case XK_m:
		cout << "Enter length of Minute in Milliseconds: " << flush;
		cin >> tmp;
		Game.SetMinuteLength(tmp);
		break;
	case XK_o:
		GLView.MakeScreenshot();
		break;
	case XK_p:
		printf("%f %f %f\n", planex, planey, planescale);
		break;
	case XK_Page_Up:
		Camera.MoveUpDown(dist);
		break;
	case XK_Page_Down:
		Camera.MoveUpDown(-dist);
		break;
	case XK_w:
		Camera.MoveForwardBackward(dist);
		break;
	case XK_s:
		Camera.MoveForwardBackward(-dist);
		break;
	case XK_a:
		Camera.StrafeLeftRight(dist);
		break;
	case XK_d:
		Camera.StrafeLeftRight(-dist);
		break;
	case XK_e:
		if (isShiftDown)
			Camera.IncreaseEyeDist(0.1);
		else
			Camera.DecreaseEyeDist(0.1);
		break;
	case XK_i:
		if (isShiftDown)
			World.SetInterior(World.GetInterior()-1);
		else
			World.SetInterior(World.GetInterior()+1);
		cout << "Interior: " << World.GetInterior() << endl;
		break;
	case XK_h:
		if (isShiftDown)
			Clock.TurnBackOneHour();
		else
			Clock.AdvanceOneHour();
		cout << "Time: " << Clock.GetHour() << ":" <<
		  Clock.GetMinute() << endl;
		break;
	case XK_g:
		if (isShiftDown)
			Clock.TurnBackOneMinute();
		else
			Clock.AdvanceOneMinute();
		cout << "Time: " << Clock.GetHour() << ":" <<
		  Clock.GetMinute() << endl;
		break;
	case XK_u:
		if (isShiftDown)
			Sky.PreviousWeather();
		else
			Sky.NextWeather();
		cout << "Weather: " << Sky.GetWeatherSelector() << endl;
		break;
	case XK_l:
		if (isShiftDown)
			World.SetLODmultiplier(World.GetLODmultiplier()-0.05);
		else
			World.SetLODmultiplier(World.GetLODmultiplier()+0.05);
		break;
	case XK_t:
		GLView.ToggleTextures();
		break;
	case XK_v:
		GLView.ToggleVertexColors();
		break;
	case XK_y:
		GLView.ToggleTint();
		break;
	case XK_k:
		Game.ToggleTime();
		break;
	case XK_f:
		GLView.ToggleFog();
		break;
	case XK_c:
		GLView.ToggleStereo();
		break;
	case XK_r:
		GLView.ToggleRadar();
		break;
	case XK_j:
		GLView.ToggleCulling();
		break;
	case XK_Shift_L:
	case XK_Shift_R:
		isShiftDown = 1;
		break;
	case XK_Control_L:
	case XK_Control_R:
		isCtrlDown = 1;
		break;
	case XK_F1:
	case XK_F2:
	case XK_F3:
	case XK_F4:
	case XK_F5:
	case XK_F6:
	case XK_F7:
	case XK_F8:
	case XK_F9:
	case XK_F10:
	case XK_F11:
	case XK_F12:
		if (isShiftDown)
			Camera.SavePosition(key-XK_F1);
		else
			Camera.LoadPosition(key-XK_F1);
		break;

//		KillGlWindow();
//		window.init.isFullScreen = !window.init.isFullScreen;
//		CreateWindowGL(progname);
	case XK_Escape:
                done = true;
                break;
	default:
		break;
        }
}

void glxareaInputCallback(Widget w, XtPointer clientData, XtPointer callData) 
{ 
	GLwDrawingAreaCallbackStruct *cbs = (GLwDrawingAreaCallbackStruct *)callData;
	XEvent *event = cbs->event;
      
	switch (event->type) {                
	case KeyPress:
	{
		XKeyEvent *key_event = (XKeyEvent *)event;
		KeySym keysym_rtn;
		Modifiers mods_rtn;
            
		XtTranslateKeycode(XtDisplay(w), key_event->keycode,
			key_event->state, &mods_rtn, &keysym_rtn);
		Keypress(keysym_rtn & 0xffff);
/*
		switch((keysym_rtn & 0xffff)) {
		case XK_space:
			printf("space bar\n");;
			break;
		case XK_Escape:
		case XK_Cancel:               
			exit(0);
			break;
		default:
			break;
		}
*/
		break;
	}
	case ButtonPress:
	{
		XButtonEvent *button_event = (XButtonEvent *)event;
/*
		if ( button_event->button==1 )
			printf("button 1\n");
*/
		switch (button_event->button) {
		case 1:
/*
			mx = event.xbutton.x;
			my = event.xbutton.y;
*/
			mx = button_event->x;
			my = button_event->y;
			isLDown = 1;
			break;
		case 3:
			isRDown = 1;
			break;
		default:
			break;
		}
		break;
	}
	case ButtonRelease:
	{
		XButtonEvent *button_event = (XButtonEvent *)event;
/*
		if (button_event->button==1)
			printf("button 1\n");
*/
//		 switch(event.xbutton.button) {
		 switch(button_event->button) {
		 case 1:
			 isLDown = 0;
			 break;
		 case 3:
			 isRDown = 0;
			 break;
		 case 5:
			 break;
		 case 6:
			 break;
		 default:
			 break;
		 }
		 break;
	}
	break;
	case MotionNotify:
	{
		XMotionEvent *motion_event = (XMotionEvent *)event;
		int x, y;

/*
		if (motion_event->state & ControlMask)  {
			x = motion_event->x;
			y = cbs->height - motion_event->y - 1;
			printf("x = %d, y = %d\n", x,y);
		}
*/
		if (isLDown) {
			ox = mx;
			oy = my;
			mx = motion_event->x; //event.xbutton.x;
			my = motion_event->y; //event.xbutton.y;
/*
			Camera.TurnLeftRight((float)(ox-mx)/
			  (float)SENSITIVITY);
			Camera.TurnUpDown((float)(oy-my)/
			  (float)SENSITIVITY);
*/
		}
		break;
	}
	default:
		break;
	}
}