var machine;

var renderer;

var controller;

var camera;

var cameraSpeed = {"x": 0.1, "y": 0.1, "z": 0.5, "pitch": 0.5, "yaw": 0.5};

var keyActionMap = {'A': moveCameraLeft,

		 'D': moveCameraRight,

		 'W': moveCameraUp,

		 'S': moveCameraDown};

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

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

                      "wheel": zoomCamera};

function main()

{

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

    var context = new Context(canvas);

    context.expand();

    var gl = context.gl;

    var object = new Cube(1, context);

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

    gl.enable(gl.DEPTH_TEST);

    machine = new Machine(object);       

    camera = new Camera(cameraSpeed);

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

}

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

    renderer.update(machine.scene);

}

function random(min, max)

{

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

}

function Camera(speed)

{

    this.x = 0.0;

    this.y = 0.0;

    this.z = 7.0;

    this.pitch = 0.0;

    this.yaw = 0.0;

    this.speed = speed;

}

Camera.prototype.moveLeft = function()

{

    this.x -= this.speed.x;

}

Camera.prototype.moveRight = function()

{

    this.x += this.speed.x;

}

Camera.prototype.moveUp = function()

{

    this.y += this.speed.y;

}

Camera.prototype.moveDown = function()

{

    this.y -= this.speed.y;

}

Camera.prototype.zoom = function(delta) 

{

    this.z += this.speed.z * delta;

}

Camera.prototype.changePitch = function(delta)

{

    this.pitch += this.speed.pitch * delta;

}

Camera.prototype.changeYaw = function(delta)

{

    this.yaw += this.speed.yaw * delta;

}

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;

}

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.currentPos = [event.clientX, event.clientY];

}

Mouse.prototype.moveWheel = function(event)

{ 

    this.wheelDelta += event.wheelDelta;

}

Mouse.prototype.handle = function()

{

    var pos = this.currentPos;

    if (pos && this.lastPos)

    {

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

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

	else 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];

}

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 Renderer(camera, context)

{

    this.camera = camera;

    this.context = context;

    this.gl = context.gl;

    this.matrixStack = [];

}

Renderer.prototype.update = function(scene)

{ 

    var gl = this.context.gl;

    var viewport = this.context.viewport;

    var shader = this.context.shader;

    var mvMatrix = this.context.mvMatrix;

    var pMatrix = this.context.pMatrix;

    var camera = this.camera;

    gl.viewport(0, 0, viewport.width, viewport.height);

    gl.clear(gl.COLOR_BUFFER_BIT | gl.DEPTH_BUFFER_BIT);

    mat4.perspective(45, viewport.width / viewport.height, 0.1, 100.0, pMatrix);

    mat4.identity(mvMatrix);

    mat4.rotate(mvMatrix, -camera.pitch, [1, 0, 0]);

    mat4.rotate(mvMatrix, -camera.yaw, [0, 1, 0]);

    mat4.translate(mvMatrix, [-camera.x, -camera.y, -camera.z]);

    this.pushMatrix(mvMatrix);

    mat4.rotate(mvMatrix, scene.rotation.x, [1, 0, 0]);

    mat4.rotate(mvMatrix, scene.rotation.y, [0, 1, 0]);

    mat4.rotate(mvMatrix, scene.rotation.z, [0, 0, 1]);

    gl.bindBuffer(gl.ARRAY_BUFFER, scene.positionBuffer);

    gl.vertexAttribPointer(shader.vertexPosition, scene.positionBuffer.itemSize, gl.FLOAT, false, 0, 0);

    gl.bindBuffer(gl.ARRAY_BUFFER, scene.colourBuffer);

    gl.vertexAttribPointer(shader.vertexColour, scene.colourBuffer.itemSize, gl.FLOAT, false, 0, 0);

    gl.bindBuffer(gl.ELEMENT_ARRAY_BUFFER, scene.indexBuffer);

    this.context.updateMatrixUniforms();

    gl.drawElements(gl.TRIANGLES, scene.indexBuffer.numItems, gl.UNSIGNED_SHORT, 0);

    //gl.drawArrays(gl.TRIANGLE_STRIP, 0, scene.positionBuffer.numItems);

    mvMatrix = this.popMatrix();

    if (this.next) this.next.draw(scene);

}

Renderer.prototype.pushMatrix = function(matrix)

{

    var copy = mat4.create();

    mat4.set(matrix, copy);

    this.matrixStack.push(copy);

}

Renderer.prototype.popMatrix = function()    

{

    if (this.matrixStack.length > 0) return this.matrixStack.pop();

}

function Machine(scene)

{

    this.scene = scene;

    this.lastUpdate = 0;

}

Machine.prototype.update = function(time)

{

    if (this.lastUpdate != 0)

    {

	var diff = time - this.lastUpdate;

    }

    this.lastUpdate = time;

}

function Context(canvas)

{

    this.canvas = canvas;

    try 

    {

	this.gl = canvas.getContext("experimental-webgl");

	this.viewport = {'width': canvas.width,

			 'height': canvas.height};

    } 

    catch(e) 

    {

	alert(e);

    }

    if (!this.gl) alert("Failed: WebGL init.");

    this.mvMatrix = mat4.create();

    this.pMatrix = mat4.create();

    this.shader = new Shader(this);  

}

Context.prototype.updateMatrixUniforms = function()

{

    var gl = this.gl;

    var program = this.shader;

    var pMatrix = this.pMatrix;

    var mvMatrix = this.mvMatrix;

    gl.uniformMatrix4fv(program.pMatrixUniform, false, pMatrix);

    gl.uniformMatrix4fv(program.mvMatrixUniform, false, mvMatrix);

}

Context.prototype.expand = function()

{ 

    var width = window.innerWidth;

    var height = window.innerHeight;

    this.canvas.width = width;

    this.canvas.height = height;

    this.viewport.width = width;

    this.viewport.height = height;

}

function Shader(context)

{

    var gl = context.gl;

    var fragment = loadShader(gl, "fragment-shader");

    var vertex = loadShader(gl, "vertex-shader");

    this.program = gl.createProgram();

    gl.attachShader(this.program, vertex);

    gl.attachShader(this.program, fragment);

    gl.linkProgram(this.program);

    if (!gl.getProgramParameter(this.program, gl.LINK_STATUS))

    {

	alert("Failed: Shader init.");

    }

    gl.useProgram(this.program);

    this.vertexPosition = gl.getAttribLocation(this.program, "aVertexPosition");

    gl.enableVertexAttribArray(this.vertexPosition);

    this.vertexColour = gl.getAttribLocation(this.program, "aVertexColour");

    gl.enableVertexAttribArray(this.vertexColour);

    this.pMatrixUniform = gl.getUniformLocation(this.program, "uPMatrix");

    this.mvMatrixUniform = gl.getUniformLocation(this.program, "uMVMatrix");

    function loadShader(gl, id)

    {

	var script = document.getElementById(id);

	if (!script) return null;

	var str = "";

	var child = script.firstChild;

	while (child)

	{

	    if (child.nodeType == 3) str += child.textContent;

	    child = child.nextSibling;

	}

	var shader;

	var common = "x-shader/x-";

	if (script.type == common + "fragment") shader = gl.createShader(gl.FRAGMENT_SHADER);

	else if (script.type == common + "vertex") shader = gl.createShader(gl.VERTEX_SHADER);

	else return null;

	gl.shaderSource(shader, str);

	gl.compileShader(shader);

	if (!gl.getShaderParameter(shader, gl.COMPILE_STATUS))

        {

	    alert(gl.getShaderInfoLog(shader));

	    return null;

	}

	return shader;

    }

}

function Cube(size, context)

{

    var gl = context.gl;

    this.size = size || 1;

    this.rotation = {'x': 0.0, 'y': 0.0, 'z': 0.0};

    this.positionBuffer = gl.createBuffer();

    gl.bindBuffer(gl.ARRAY_BUFFER, this.positionBuffer);

    var vertices = [

	     // Front face

            -1.0, -1.0,  1.0,

             1.0, -1.0,  1.0,

             1.0,  1.0,  1.0,

            -1.0,  1.0,  1.0,

            // Back face

            -1.0, -1.0, -1.0,

            -1.0,  1.0, -1.0,

             1.0,  1.0, -1.0,

             1.0, -1.0, -1.0,

            // Top face

            -1.0,  1.0, -1.0,

            -1.0,  1.0,  1.0,

             1.0,  1.0,  1.0,

             1.0,  1.0, -1.0,

            // Bottom face

            -1.0, -1.0, -1.0,

             1.0, -1.0, -1.0,

             1.0, -1.0,  1.0,

            -1.0, -1.0,  1.0,

            // Right face

             1.0, -1.0, -1.0,

             1.0,  1.0, -1.0,

             1.0,  1.0,  1.0,

             1.0, -1.0,  1.0,

            // Left face

            -1.0, -1.0, -1.0,

            -1.0, -1.0,  1.0,

            -1.0,  1.0,  1.0,

            -1.0,  1.0, -1.0];

    gl.bufferData(gl.ARRAY_BUFFER, new Float32Array(vertices), gl.STATIC_DRAW);

    this.positionBuffer.itemSize = 3;

    this.positionBuffer.numItems = 24;

    this.colourBuffer = gl.createBuffer();

    gl.bindBuffer(gl.ARRAY_BUFFER, this.colourBuffer);

    var alpha = 1.0;

    var colours = [[1.0, 0.0, 0.0, alpha],

		   [0.0, 1.0, 0.0, alpha],

		   [0.0, 0.0, 1.0, alpha],

		   [1.0, 0.0, 1.0, alpha],

		   [1.0, 1.0, 0.0, alpha],

		   [0.0, 1.0, 1.0, alpha]];

    var unpackedColours = [];

    for (var i in colours)

    {

	var colour = colours[i];

	for (var j = 0; j < 4; j++)

	{

	    unpackedColours = unpackedColours.concat(colour);

	}

	//colours = colours.concat([0.5, 0.5, 1.0, 1.0]);

    }

    gl.bufferData(gl.ARRAY_BUFFER, new Float32Array(unpackedColours), gl.STATIC_DRAW);

    this.colourBuffer.itemSize = 4;

    this.colourBuffer.numItems = 24;

    this.indexBuffer = gl.createBuffer();

    gl.bindBuffer(gl.ELEMENT_ARRAY_BUFFER, this.indexBuffer);

    var indices = [0, 1, 2, 0, 2, 3,

		   4, 5, 6, 4, 6, 7,

		   8, 9, 10, 8, 10, 11,

		   12, 13, 14, 12, 14, 15,

		   16, 17, 18, 16, 18, 19,

		   20, 21, 22, 20, 22, 23];

    gl.bufferData(gl.ELEMENT_ARRAY_BUFFER, new Uint16Array(indices), gl.STATIC_DRAW);

    this.indexBuffer.itemSize = 1;

    this.indexBuffer.numItems = 36;

}

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.changePitch(delta);

}

function yawCamera(delta)

{

    camera.changeYaw(delta);

}

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

}