var machine;

var renderer;

var gl;

var controller;

var camera;

var cameraSpeed = {"h": 1.0, "v": 1.0, "zoom": 1.0, "pitch": 1.0, "yaw": 1.0, "roll": 1.0};

var keyActionMap = {'A': moveCameraLeft,

		 'D': moveCameraRight,

		 'W': moveCameraUp,

		 'S': moveCameraDown};

var mouseActionMap = {"pitch": [[true, false, false], pitchCamera],

		      "yaw": [[true, false, false], yawCamera],

		      "rotate": [[true, false, false], rotateCamera],

                      "wheel": zoomCamera};

include("scripts/cube.js");

include("scripts/renderer.js");

include("scripts/camera.js");

function main()

{

    var canvas = document.getElementById("machine");

    var context = new Context(canvas);

    context.expand();

    gl = context.gl;

    var scene = createScene(context);   

    gl.clearColor(0.00, 0.0, 0.0, 1.0);

    gl.enable(gl.DEPTH_TEST);

    machine = new Machine(scene);       

    camera = new Camera(cameraSpeed, [0, 0, 20]);

    renderer = new Renderer(camera, context);

    controller = new Controller(keyActionMap, mouseActionMap, camera, machine, renderer);

    update();

    window.onresize = expandContext;

    document.onkeydown = handleKeyDown;

    document.onkeyup = handleKeyUp;

    canvas.onmousedown = handleMouseDown;

    document.onmouseup = handleMouseUp;

    document.onmousemove = handleMouseMove;

    document.onmousewheel = handleMouseWheel;

    //read("config/camera", configureCamera);

}

var textures = [];

function Texture(file)

{

    this.id = textures.length;

    textures.push(this);

    this.hnd = gl.createTexture();

    this.image = new Image();

    this.image.onload = function() { handleLoadedTexture(); }   

    this.image.src = file;

}

function handleLoadedTexture()

{

    var texture = textures[textures.length-1];

    gl.bindTexture(gl.TEXTURE_2D, texture.hnd);

    gl.pixelStorei(gl.UNPACK_FLIP_Y_WEBGL, true);

    gl.texImage2D(gl.TEXTURE_2D, 0, gl.RGBA, gl.RGBA, gl.UNSIGNED_BYTE, texture.image);

    gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.LINEAR);

    gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.LINEAR_MIPMAP_NEAREST);

    gl.generateMipmap(gl.TEXTURE_2D);

    gl.bindTexture(gl.TEXTURE_2D, null);

}

function createScene(context)

{

    var size = 1;

    var texture = new Texture("textures/nehe.gif");

    var vbo = new CubeVbo(size, context, texture);

    var scene = new Node([0, 0, 0], [0, 0, 0], new Cube(vbo));

    var dim = 10;

    var d = size * 4;

    for (var x = 0; x < dim; x += 1) {

	for (var y = 0; y < dim; y += 1) {

	    for (var z = 0; z < dim; z += 1) {		

		var pos = [x * d - dim * d / 2, y * d - dim * d / 2, -z * d];

		scene.children.push(new Node(pos, [0, 0, 0], new Cube(vbo)));

	    }

	}

    }

    return scene;

}

function configureCamera(config) {

    alert(config);

}

function update()

{    

    requestAnimFrame(update);

    controller.update();

    //machine.scene.rotation.x += (random(0, 2) - 2) * 0.001; 

    // machine.scene.rotation.y += (random(0, 3) - 1) * 0.001; 

    // machine.scene.rotation.z += (random(0, 2) - 1) * 0.001;

    machine.update(new Date().getTime());

    camera.update();

    renderer.update(machine.scene);

}

function random(min, max)

{

    return (min + Math.random() * (max - min));

}

function normalize(vectors)

{

    for (var v in vectors) vec3.normalize(v);

}

function Controller(keyActionMap, mouseActionMap, camera, machine, renderer)

{ 

    this.keyboard = new Keyboard(keyActionMap);

    this.mouse = new Mouse(mouseActionMap);   

}

Controller.prototype.update = function()

{

    this.keyboard.handle();

    this.mouse.handle();

}

function Mouse(actionMap)

{

    this.actionMap = actionMap;

    this.pressed = [false, false, false];   

    this.wheelDelta = 0;

    this.posStack = [];

}

Mouse.prototype.buttonDown = function(event)

{

    this.pressed[event.which-1] = true;

}

Mouse.prototype.buttonUp = function(event)

{

    this.pressed[event.which-1] = false;

}

Mouse.prototype.move = function(event)

{

    this.posStack.push([event.clientX, event.clientY]);

    //this.currentPos = [event.clientX, event.clientY];

}

Mouse.prototype.moveWheel = function(event)

{ 

    this.wheelDelta += event.wheelDelta;

}

Mouse.prototype.handle = function()

{

    while (this.posStack.length > 0)

    {

	var pos = this.posStack.pop();

	if (this.lastPos)

	{

	    var delta = [pos[0] - this.lastPos[0], pos[1] - this.lastPos[1], 0];

	    delta = normaliseMoveDelta(delta);

	    var action = this.actionMap["pitch"];

	    if (delta[1] != 0 && action) 

	    {

		for (var i = 0; i < 3; i++)

		{

		    if (this.pressed[i] != action[0][i]) break;

		    if (i == 2) action[1](delta[1]);

		}

	    } 

	    action = this.actionMap["yaw"];

	    if (delta[0] != 0 && action) 

	    {

		for (var i = 0; i < 3; i++)

		{

		    if (this.pressed[i] != action[0][i]) break;

		    if (i == 2) action[1](delta[0]);

	       	}

	    }

	}

	this.lastPos = pos;

    }   

    if (this.wheelDelta != 0)

    {

	var delta = normaliseWheelDelta(this.wheelDelta);

	var action = this.actionMap["wheel"];

	if (delta != 0 && action) action(delta);

	this.wheelDelta = 0;

    } 

}

function normaliseMoveDelta(delta)

{

    var width = renderer.context.canvas.width;

    var height = renderer.context.canvas.height;

    return [delta[0] / width, delta[1] / height, 0];

}

function normaliseWheelDelta(delta)

{

    return delta / 60;

}

function Keyboard(actionMap)

{

    this.actionMap = actionMap;

    this.pressed = {};

}

Keyboard.prototype.keyDown = function(event)

{

    this.pressed[event.keyCode] = true;    

}

Keyboard.prototype.keyUp = function(event)

{

    this.pressed[event.keyCode] = false;

}

Keyboard.prototype.handle = function()

{

    for (key in this.pressed)

    {

	if (this.pressed[key])

	{

	    key = String.fromCharCode(key);

	    if (this.actionMap[key]) this.actionMap[key](); 

	}

    }

}

function Machine(scene)

{

    this.scene = scene;

    this.lastUpdate = 0;

}

Machine.prototype.update = function(time)

{

    this.scene.update(time);

    if (this.lastUpdate != 0)

    {

	var diff = time - this.lastUpdate;

    }

    this.lastUpdate = time;

}

function read(file, handler)

{

    var request = new XMLHttpRequest();

    request.open("GET", file);

    request.onreadystatechange = function() {

	alert(request.readyState);

	if (request.readyState == 4) {

	    handler(request.responseText);

	}

    }

    request.send();

}		

// event handler

function expandContext()

{

    renderer.context.expand();

}

function moveCameraLeft()

{

    camera.moveLeft();

}

function moveCameraRight()

{

    camera.moveRight();

}

function moveCameraUp()

{

    camera.moveUp();

}

function moveCameraDown()

{

    camera.moveDown();

}

function zoomCamera(delta)

{

    camera.zoom(delta);

}

function pitchCamera(delta)

{

    camera.pitch(delta);

}

function yawCamera(delta)

{

    camera.yaw(delta);

}

function rotateCamera(angles)

{

    camera.rotate(angles);

}

function handleKeyDown(event)

{

    controller.keyboard.keyDown(event);

}

function handleKeyUp(event)

{

    controller.keyboard.keyUp(event);

}

function handleMouseDown(event)

{

    controller.mouse.buttonDown(event);

}

function handleMouseUp(event)

{

    controller.mouse.buttonUp(event);

}

function handleMouseMove(event)

{

    controller.mouse.move(event);

}

function handleMouseWheel(event)

{

    controller.mouse.moveWheel(event);

}