/**
 * System takes care of updating all the entities (based on their component data)
 * @param apiSystem GameLib.API.System
 * @constructor
 */
GameLib.System.Input = function(
    apiSystem
) {
	GameLib.System.call(
        this,
        apiSystem
    );

	// this.meshMoveMode           = false;
	// this.meshMoveXMode          = false;
	// this.meshMoveYMode          = false;
	// this.meshMoveZMode          = false;

	/**
	 * We need new function pointers with scope bound to this so we can remove the
	 * window event handlers when we need to
	 * @type {function()}
	 */
	this.mouseMove      = null;
	this.mouseDown      = null;
	this.keyDown       	= null;
	this.mouseUp       	= null;
	this.mouseWheel     = null;

	this.selectAll 		= false;

	this.controlLeft	= false;

	this.renderers 	        = [];
	this.editorControls     = [];
	this.touchControls      = [];
	this.keyboardControls   = [];
	this.mouseControls      = [];

    this.touchStart = this.onTouchStart.bind(this);
    this.touchMove = this.onTouchMove.bind(this);
    this.touchEnd = this.onTouchEnd.bind(this);
	this.touchCancel = this.onTouchCancel.bind(this);

};

GameLib.System.Input.prototype = Object.create(GameLib.System.prototype);
GameLib.System.Input.prototype.constructor = GameLib.System.Input;

/**
 *
 */
GameLib.System.Input.prototype.start = function() {

    GameLib.System.prototype.start.call(this);

    this.editorControls = GameLib.EntityManager.Instance.queryComponents(GameLib.D3.Controls.Editor);

    this.touchControls = GameLib.EntityManager.Instance.queryComponents(GameLib.D3.Controls.Touch);

    this.keyboardControls = GameLib.EntityManager.Instance.queryComponents(GameLib.D3.Controls.Keyboard);

    this.mouseControls = GameLib.EntityManager.Instance.queryComponents(GameLib.D3.Controls.Mouse);

    /**
     * If we have editor controls - start behaving like it...
     */



    if (this.editorControls.length > 0) {



    }

    if (this.touchControls.length > 0) {

        this.touchControls.map(
            function(touchControl) {
                touchControl.domElement.instance.addEventListener(
                    'touchstart',
                    this.touchStart,
                    false
                );

                touchControl.domElement.instance.addEventListener(
                    'touchmove',
                    this.touchMove,
                    false
                );
                touchControl.domElement.instance.addEventListener(
                    'touchend',
                    this.touchEnd,
                    false
                );
                touchControl.domElement.instance.addEventListener(
                    'touchcancel',
                    this.touchCancel,
                    false
                );
            }.bind(this)
        )
    } else if (
        this.editorControls.length > 0
    ) {
        this.renderers = GameLib.EntityManager.Instance.queryComponents(GameLib.D3.Renderer);

        this.renderers.map(

            function(renderer) {

                renderer.controls = this.editorControls.reduce(
                    function(result, editorControl) {
                        if (editorControl.renderer === renderer) {
                            result = editorControl;
                        }
                        return result;
                    },
                    null
                );

                renderer.mouseDown = this.onMouseDown(renderer, renderer.controls).bind(this);
                renderer.domElement.instance.addEventListener(
                    'mousedown',
                    renderer.mouseDown,
                    false
                );

                renderer.mouseMove = this.onMouseMove.bind(this);
                renderer.domElement.instance.addEventListener(
                    'mousemove',
                    renderer.mouseMove,
                    false
                );

                renderer.keyDown = this.onKeyDown.bind(this);
                renderer.domElement.instance.addEventListener(
                    'keydown',
                    renderer.keyDown,
                    false
                );

                renderer.keyUp = this.onKeyUp.bind(this);
                renderer.domElement.instance.addEventListener(
                    'keyup',
                    renderer.keyUp,
                    false
                );

                if (renderer.controls) {
                    /**
                     * Create the delayed instance here - it affects the order of event listeners attached to DOM
                     */
                    renderer.controls.instance = renderer.controls.delayedInstance();
                } else {
                    console.warn('no third party controls for renderer : ' + renderer.name);
                }

                renderer.mouseWheel = this.onMouseWheel(renderer.camera).bind(this);
                renderer.domElement.instance.addEventListener(
                    'mousewheel',
                    renderer.mouseWheel,
                    false
                );

                renderer.mouseUp = this.onMouseUp(renderer.camera, renderer.controls).bind(this);
                renderer.domElement.instance.addEventListener(
                    'mouseup',
                    renderer.mouseUp,
                    false
                );
            }.bind(this)
        );
    }


    if (this.keyboardControls.length > 0) {

    }
};

GameLib.System.Input.prototype.onTouchStart = function(event) {

    this.touches = {};

    for (var t = 0; t < event.touches.length; t++) {
        this.touches[event.touches[t].identifier] = {
            left : 0,
            right : 0,
            up : 0,
            down : 0,
            pageX : event.touches[t].pageX,
            pageY : event.touches[t].pageY,
            cancelled : false,
            ended : false
        };
    }

    GameLib.Event.Emit(
        GameLib.Event.TOUCH_START,
        this.touches
    )
};

GameLib.System.Input.prototype.onTouchMove = function(event) {

    for (var t = 0; t < event.changedTouches.length; t++) {

        var id = event.changedTouches[t].identifier;

        var left    = 0;
        var right   = 0;
        var up      = 0;
        var down    = 0;

        if (event.changedTouches[t].pageX > this.touches[id].pageX) {
            right = 1;
        }

        if (event.changedTouches[t].pageX < this.touches[id].pageX) {
            left = 1;
        }

        if (event.changedTouches[t].pageY < this.touches[id].pageY) {
            up = 1;
        }

        if (event.changedTouches[t].pageY > this.touches[id].pageY) {
            down = 1;
        }

        this.touches[id].right += right;
        this.touches[id].left += left;
        this.touches[id].up += up;
        this.touches[id].down += down;
        this.touches[id].pageX = event.changedTouches[t].pageX;
        this.touches[id].pageY = event.changedTouches[t].pageY;
    }

    GameLib.Event.Emit(
        GameLib.Event.TOUCH_MOVE,
        this.touches
    )
};

GameLib.System.Input.prototype.onTouchCancel = function(event) {
    for (var t = 0; t < event.changedTouches.length; t++) {
        this.touches[event.changedTouches[t].identifier].cancelled = true;
        GameLib.Event.Emit(
            GameLib.Event.TOUCH_CANCEL,
            this.touches[event.changedTouches[t].identifier]
        );
        delete this.touches[event.changedTouches[t].identifier];
    }
};

GameLib.System.Input.prototype.onTouchEnd = function(event) {
    for (var t = 0; t < event.changedTouches.length; t++) {
        this.touches[event.changedTouches[t].identifier].ended = true;
        GameLib.Event.Emit(
            GameLib.Event.TOUCH_END,
            this.touches[event.changedTouches[t].identifier]
        );
        delete this.touches[event.changedTouches[t].identifier];
    }
};

GameLib.System.Input.prototype.onKeyDown = function(event) {

	console.log('input system emitted keypress ' + event.code);

	GameLib.Event.Emit(
		GameLib.Event.KEY_DOWN,
		{
			code : event.code
		}
	);

	var meshes = null;

	if (event.code === 'Delete') {

		meshes = GameLib.EntityManager.Instance.queryComponents([GameLib.D3.Mesh]);

		var deletedMeshes = [];

		meshes.map(
			function(mesh) {
				if (mesh.selected) {

					deletedMeshes.push(mesh);

					mesh.removeHelper();

					var scene = mesh.parentScene;
					scene.removeObject(mesh);
					scene.buildIdToObject();
				}
			}.bind(this)
		);

		GameLib.Event.Emit(
			GameLib.Event.MESH_DELETED,
			{
				meshes : deletedMeshes
			}
		);

	}

	if (event.code === 'ControlLeft') {
		this.controlLeft = true;
	}

	if (event.code === 'KeyA') {

		this.selectAll = !this.selectAll;

		meshes = GameLib.EntityManager.Instance.queryComponents([GameLib.D3.Mesh]);

		meshes.map(function(mesh){
			if (this.selectAll) {
				this.selectMesh(mesh);
			} else {
				this.deSelectMesh(mesh);
			}
		}.bind(this));

		GameLib.Event.Emit(
			GameLib.Event.BUILD_GUI,
			null
		)

	}
};

GameLib.System.Input.prototype.onKeyUp = function(event) {

	GameLib.Event.Emit(
		GameLib.Event.KEY_UP,
		{
			code : event.code
		}
	);

	if (event.code === 'ControlLeft') {
		this.controlLeft = false;
	}
};

GameLib.System.Input.prototype.onMouseDown = function(renderer, controls) {

	return function(event) {

		if (event.button === 2) {

			if (this.controlLeft) {
				return;
			}

			renderer.mouse.x =  (event.offsetX / renderer.instance.domElement.width) * 2 - 1;
			renderer.mouse.y = -(event.offsetY / renderer.instance.domElement.height) * 2 + 1;

			var scenes = renderer.scenes;

			var intersects = scenes.reduce(

				function(result, scene) {

					controls.raycaster.instance.setFromCamera(
						renderer.mouse,
						renderer.camera.instance
					);

					intersects = controls.raycaster.getIntersectedObjects(scene.meshes);

					intersects.map(function(intersect){
						result.push(intersect);
					});

					return result;
				}.bind(this),
				[]
			);

			intersects.sort(
				function(a, b) {
					if (a.distance < b.distance) {
						return -1;
					}

					if (a.distance > b.distance) {
						return 1;
					}

					return 0;
				}
			);

			var meshes = intersects.map(function(intersect){
				return intersect.mesh;
			});

			var mesh = meshes[0];

			if (mesh) {

				/**
				 * Prevent default action (like context menu or whatever)
				 */
				event.preventDefault();

				/**
				 * Prevent other event listeners for 'mousedown' from executing their actions
				 */
				event.stopImmediatePropagation();

				if (mesh.selected) {
					this.deSelectMesh(mesh);
				} else {
					this.selectMesh(mesh);
				}

				/**
				 * Notify our GUI system to build a GUI
				 */
				GameLib.Event.Emit(
					GameLib.Event.BUILD_GUI,
					null
				)
			}
		}
	}.bind(this);
};

/**
 *
 * @param event
 */
GameLib.System.Input.prototype.onMouseMove = function(event) {

};

/**
 * Update the camera position etc. after mouse up
 * @param __camera
 * @param __controls
 * @returns {Function}
 */
GameLib.System.Input.prototype.onMouseUp = function(__camera, __controls) {
	return function(event) {

		__camera.position.x = __camera.instance.position.x;
		__camera.position.y = __camera.instance.position.y;
		__camera.position.z = __camera.instance.position.z;

		__camera.quaternion.x = __camera.instance.quaternion.x;
		__camera.quaternion.y = __camera.instance.quaternion.y;
		__camera.quaternion.z = __camera.instance.quaternion.z;
		__camera.quaternion.w = __camera.instance.quaternion.w;

		__camera.lookAt.x = __controls.instance.center.x;
		__camera.lookAt.y = __controls.instance.center.y;
		__camera.lookAt.z = __controls.instance.center.z;

		__camera.lookAt.instance.copy(__controls.instance.center);
	};
};

/**
 * Update our camera position after moving the mouse wheel
 * @param __camera
 * @returns {Function}
 */
GameLib.System.Input.prototype.onMouseWheel = function(__camera) {
	return function(event) {
		__camera.position.x = __camera.instance.position.x;
		__camera.position.y = __camera.instance.position.y;
		__camera.position.z = __camera.instance.position.z;
	}
};

GameLib.System.Input.prototype.selectMesh = function(mesh) {

	/**
	 * If mesh is already selected, do nothing
	 */
	if (mesh.selected === true) {
		return;
	}

	/**
	 * Notify our component as being 'selected'
	 * @type {boolean}
	 */
	mesh.selected = true;

	mesh.createHelper();

	GameLib.Event.Emit(
		GameLib.Event.MESH_SELECTED,
		{
			mesh : mesh
		}
	);
};

GameLib.System.Input.prototype.deSelectMesh = function(mesh) {

	mesh.selected = false;

	mesh.removeHelper();

	GameLib.Event.Emit(
		GameLib.Event.MESH_DESELECTED,
		{
			mesh : mesh
		}
	);
};

/**
 *
 */
GameLib.System.Input.prototype.stop = function() {

    GameLib.System.prototype.stop.call(this);

    if (this.editorControls.length > 0) {
        /**
         * Now remove all input capabilities
         */
        this.renderers.map(

            function(renderer) {

                renderer.domElement.instance.removeEventListener(
                    'mousedown',
                    renderer.mouseDown,
                    false
                );

                renderer.domElement.instance.removeEventListener(
                    'mousemove',
                    renderer.mouseMove,
                    false
                );

                renderer.domElement.instance.removeEventListener(
                    'keydown',
                    renderer.keyDown,
                    false
                );

                renderer.domElement.instance.removeEventListener(
                    'keyup',
                    renderer.keyUp,
                    false
                );

                if (renderer.controls && renderer.controls.instance) {
                    renderer.controls.instance.dispose();
                } else {
                    console.warn('no third party controls to stop for renderer : ' + renderer.name);
                }

                renderer.domElement.instance.removeEventListener(
                    'mousewheel',
                    renderer.mouseWheel,
                    false
                );

                renderer.domElement.instance.removeEventListener(
                    'mouseup',
                    renderer.mouseUp,
                    false
                );
            }.bind(this)
        );
    }


    if (this.touchControls.length > 0) {

        this.touchControls.map(
            function(touchControl) {
                touchControl.domElement.instance.removeEventListener(
                    'touchstart',
                    this.touchStart,
                    false
                );

                touchControl.domElement.instance.removeEventListener(
                    'touchmove',
                    this.touchMove,
                    false
                );

                touchControl.domElement.instance.removeEventListener(
                    'touchend',
                    this.touchEnd,
                    false
                );

                touchControl.domElement.instance.removeEventListener(
                    'touchcancel',
                    this.touchCancel,
                    false
                );
            }.bind(this)
        )
    }

};




//
//     console.log('keypressed ' + event.code);
//
//     if (event.code === 'KeyV') {
//         //todo - change view
//     }
//
//     if (event.code == "KeyQ") {
//
//         this.editor.allSelected = !this.editor.allSelected;
//
//         this.editor.selectedObjects = [];
//
//         if (this.editor.allSelected) {
//             for (var property in this.editor.idToObject) {
//                 if (this.editor.idToObject.hasOwnProperty(property)) {
//                     this.editor.selectedObjects.push(
//                         new GameLib.D3.SelectedObject(
//                             this.graphics,
//                             this.editor.idToObject(property)
//                         )
//                     )
//                 }
//             }
//         }
//
//         if (this.editor.onSelectionChanged) {
//             this.editor.onSelectionChanged(this.editor);
//         }
//     }
//
//     if (event.code == 'KeyG') {
//         if (!this.meshMoveMode) {
//             console.log('move mode');
//             this.meshMoveMode = true;
//         }
//     }
//
//     if (event.code == 'KeyX') {
//         if (this.meshMoveMode) {
//             console.log('move along x');
//             this.meshMoveXMode = true;
//             this.meshMoveYMode = false;
//             this.meshMoveZMode = false;
//         }
//     }
//
//     if (event.code == 'KeyY') {
//         if (this.meshMoveMode) {
//             console.log('move along y');
//             this.meshMoveXMode = false;
//             this.meshMoveYMode = true;
//             this.meshMoveZMode = false;
//         }
//     }
//
//     if (event.code == 'KeyZ') {
//         if (this.meshMoveMode) {
//             console.log('move along z');
//             this.meshMoveXMode = false;
//             this.meshMoveYMode = false;
//             this.meshMoveZMode = true;
//         }
//     }
//
//     if (event.code == 'Escape') {
//         if (this.meshMoveMode) {
//             this.meshMoveMode = false;
//             console.log('TODO: implement restore positions');
//         }
//     }
//
//     if (event.code == 'Enter') {
//         if (this.meshMoveMode) {
//             this.meshMoveMode = false;
//             console.log('TODO: implement apply positions');
//         }
//     }
// };

// GameLib.D3.Input.Editor.prototype.onMouseDown = function(entity) {
//
// 	return function(event) {
//
// 		if (event.button === 2) {
// 			event.cancelBubble = true;
//
// 			event.preventDefault();
//
// 			if (event.stopPropagation) {
// 				event.stopPropagation();
// 			}
//
// 			var meshes = entity.queryComponents(GameLib.D3.Mesh);
//
// 			var intersects = this.raycaster.getIntersectedObjects(meshes);
//
// 			if (intersects.length > 0) {
//
// 				console.log('object(s) instersected');
//
// 				// var index = -1;
// 				//
// 				// for (var s = 0; s < this.editor.selectedObjects.length; s++) {
// 				// 	if (this.editor.selectedObjects[s].object == intersects[0]) {
// 				// 		index = s;
// 				// 		break;
// 				// 	}
// 				// }
// 				//
// 				// if (index == -1) {
// 				// 	/**
// 				// 	 * The object is not selected, select it
// 				// 	 */
// 				// 	this.selectObject(intersects[0]);
// 				//
// 				// } else {
// 				// 	/**
// 				// 	 * De-select the objec
// 				// 	 */
// 				// 	var delta = Date.now() - this.editor.selectedObjects[index].lastUpdate;
// 				// 	if (delta > this.selectDelayMs) {
// 				// 		this.unselectObject(intersects[0]);
// 				// 	}
// 				// }
// 				//
// 				// if (this.editor.onSelectionChanged) {
// 				// 	this.editor.onSelectionChanged(this.editor);
// 				// }
// 			}
//
// 			return false;
// 		}
// 	}
// };

// /**
//  * Mouse click events
//  * @param event
//  * @returns {boolean}
//  */
// GameLib.D3.Input.Editor.prototype.onMouseDown = function(event) {
//
//     if (event.button === 2) {
//
//
//
//
//
//     }
//
//     if (event.button == 0) {
//         if (this.meshMoveMode) {
//             this.meshMoveMode   = false;
//             this.meshMoveXMode  = false;
//             this.meshMoveYMode  = false;
//             this.meshMoveZMode  = false;
//         }
//     }
// };

// /**
//  * Mouse move events
//  * @param event
//  */
// GameLib.D3.Input.Editor.prototype.onMouseMove = function(event) {
//
//     // var clientX = event.clientX - this.widthOffset;
//     // this.mouse.x = ((clientX / (window.innerWidth - this.widthOffset))) * 2 - 1;
//     // this.mouse.y = -(event.clientY / window.innerHeight) * 2 + 1;
//
// 	this.mouse.x = event.clientX;
// 	this.mouse.y = event.clientY;
//
// 	console.log("mouse (" + this.mouse.x + ", " + this.mouse.y + ")");
//
//     this.raycaster.instance.setFromCamera(
//         this.mouse,
//         this.camera.instance
//     );
//
//     if (this.meshMoveMode) {
//
//         var units = event.movementY;
//
//         if (this.meshMoveXMode) {
//             this.moveSelectedObjects('x', units);
//         }
//
//         if (this.meshMoveYMode) {
//             this.moveSelectedObjects('y', units);
//         }
//
//         if (this.meshMoveZMode) {
//             this.moveSelectedObjects('z', units);
//         }
//     }
// };

// /**
//  * Moves selected objects along an axis
//  * @param alongAxis
//  * @param units
//  */
// GameLib.D3.Input.Editor.prototype.moveSelectedObjects = function(alongAxis, units) {
//
//     for (var s = 0; s < this.editor.selectedObjects.length; s++) {
//
//         var object = this.editor.selectedObjects[s].object;
//
//         if (object.position) {
//             if (alongAxis == 'x') {
//                 object.position.x += units;
//             }
//             if (alongAxis == 'y') {
//                 object.position.y += units;
//             }
//             if (alongAxis == 'z') {
//                 object.position.z += units;
//             }
//
//             if (object.updateInstance) {
//                 object.updateInstance();
//             }
//         }
//     }
// };