using System;
using System.Drawing;
using System.Collections.Generic;

using OpenTK.Graphics;
using OpenTK.Graphics.OpenGL;
using OpenTK;

using org.niclasundharald.engine;
using org.niclasundharald.engine.graphics;
using org.niclasundharald.engine.graphics.primitives;

namespace nhengine
{

	public class OpenGLWindow : GameWindow
	{
		private Point mouseCapturePosition;
		private bool mouseCaptured;

		private float arcUpDown,
					arcLeftRight;

		private	Vector3	lookAt;
		private float	lookDistance;

		private Cube cube,
		c1, c2, c3;


		GLCamera	sceneCamera;
		GLScene		scene;

		public OpenGLWindow()
			:base(800, 600,
			      GraphicsMode.Default, 
			      "nhEngine", 
			      GameWindowFlags.Default, 
			      DisplayDevice.Default, 
			      3, 3,
			      GraphicsContextFlags.ForwardCompatible)
		{
			VSync = VSyncMode.On;
			sceneCamera = new GLCamera();
			scene = new GLScene(sceneCamera);
		}

		protected override void OnLoad(EventArgs e)
		{
			base.OnLoad(e);
			GL.ClearColor(0.05f, 0.05f, 0.05f, 0.0f);
			GL.Enable(EnableCap.DepthTest);
			GL.Enable(EnableCap.Normalize);
			GL.Enable(EnableCap.Blend);
			GL.BlendFunc(BlendingFactorSrc.SrcAlpha,BlendingFactorDest.OneMinusSrcAlpha);

			cube = new Cube(new Vector3(0,0,512), 128.0f);
			c1 = new Cube(new Vector3(512,0,512), 128.0f);
			c2 = new Cube(new Vector3(0,512,512), 128.0f);
			c3 = new Cube(new Vector3(512,512,512), 128.0f);

			lookAt = new Vector3(0,0,0);
			lookDistance = 2048;
			arcUpDown = MathHelper.PiOver6;
			arcLeftRight = MathHelper.PiOver4;

//			sceneCamera.Position = new Vector3(1000,-1000,1000);
//			sceneCamera.View = new Vector3(0f,1.0f,0.0f);
			sceneCamera.Top = new Vector3(0,0,1);
			sceneCamera.setFoV(MathHelper.PiOver4);

			setupCamera();

			scene.RootObject.addChild( cube );
			scene.RootObject.addChild( c1 );
			scene.RootObject.addChild( c2 );
			scene.RootObject.addChild( c3 );

		}

		protected override void OnResize(EventArgs e)
		{
			base.OnResize(e);

			GL.Viewport(ClientRectangle.X, ClientRectangle.Y, ClientRectangle.Width, ClientRectangle.Height);
			sceneCamera.setViewport(ClientRectangle.Width, ClientRectangle.Height);
		}

		protected override void OnRenderFrame(FrameEventArgs e)
		{
			base.OnRenderFrame(e);
			GL.Clear(ClearBufferMask.ColorBufferBit | ClearBufferMask.DepthBufferBit);

			scene.draw();

			SwapBuffers();
		}

		private void captureMouse(){
			mouseCapturePosition = new Point(Mouse.X, Mouse.Y);
			mouseCaptured = true;
			CursorVisible = false;
		}

		private void releaseMouse(){
			mouseCaptured = false;
			CursorVisible = true;
		}

		protected override void OnMouseMove(OpenTK.Input.MouseMoveEventArgs e)
		{
			if (mouseCaptured){
				Point delta = new Point(e.X - mouseCapturePosition.X, e.Y - mouseCapturePosition.Y);
				onMouseCapturedMove(delta);
				mouseCapturePosition = e.Position;
			}
		}

		protected virtual void onMouseCapturedMove(Point delta){
            rotateLeftRight(((float)delta.X) / 20.0f);
            rotateUpDown(((float)delta.Y) / 20.0f);
		}

		protected override void OnMouseDown(OpenTK.Input.MouseButtonEventArgs e)
		{
			switch (e.Button){
				case OpenTK.Input.MouseButton.Left:
					break;		
				case OpenTK.Input.MouseButton.Right:
					captureMouse();
					break;		
			}
		}

		protected override void OnMouseUp(OpenTK.Input.MouseButtonEventArgs e)
		{
			releaseMouse();
		}

		protected override void OnMouseWheel(OpenTK.Input.MouseWheelEventArgs e)
		{
			lookDistance *= 1.0f - ( e.DeltaPrecise / 16 );
			MathHelper.Clamp( lookDistance, 512, 8192 );
			setupCamera();
		}

		protected override void OnKeyPress(KeyPressEventArgs e)
		{
		}

		protected override void OnKeyDown(OpenTK.Input.KeyboardKeyEventArgs e)
		{
			switch (e.Key){
				case OpenTK.Input.Key.Up:
					rotateUpDown(-MathHelper.Pi / 180.0f);
					break;
				case OpenTK.Input.Key.Down:
                    rotateUpDown(MathHelper.Pi / 180.0f);
					break;
				case OpenTK.Input.Key.Left:
					rotateLeftRight(MathHelper.Pi / 90.0f);
					break;
				case OpenTK.Input.Key.Right:
					rotateLeftRight(-MathHelper.Pi / 90.0f);
					break;
				case OpenTK.Input.Key.W:
					walk(250.0f);
					break;
				case OpenTK.Input.Key.S:
					walk(-250.0f);
					break;
					
			}	
		}

		public void rotateUpDown(float arc)
		{
			arcUpDown += arc;
			arcUpDown = MathHelper.Clamp(arcUpDown,MathHelper.Pi / 8,MathHelper.PiOver2-0.00001f);
			setupCamera();
		}
		public void rotateLeftRight(float arc)
		{
			arcLeftRight += arc;
			arcLeftRight %= MathHelper.TwoPi;
			setupCamera();
		}
		
		public void walk(float distance){
			lookAt += (new Vector3(sceneCamera.View.Xy)).Normalized() * distance;
			setupCamera();
		}

		protected override void OnKeyUp(OpenTK.Input.KeyboardKeyEventArgs e)
		{
		}

		private void setupCamera(){
			Vector3 view = (Matrix4.CreateRotationZ(arcLeftRight) * Matrix4.CreateRotationX(arcUpDown) * Vector4.UnitY).Xyz;
			view.Normalize();

			Vector3 pos = lookAt - (view * lookDistance);

			sceneCamera.View = view;
			sceneCamera.Position = pos;
		}

		public GLScene Scene {
			get { return this.scene; }
		}


	}
}