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/test.png");

     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);

 }