/// <reference path="../Game.ts" />
/// <reference path="../utils/SpriteUtils.ts" />
/// <reference path="../utils/RectangleUtils.ts" />

/**
* Phaser - Components - InputHandler
*
* Input detection component
*/

module Phaser.Components {

    export class InputHandler {

        /**
         * Sprite Input component constructor
         * @param parent The Sprite using this Input component
         */
        constructor(parent: Phaser.Sprite) {

            this.game = parent.game;
            this._parent = parent;
            this.enabled = false;

        }

        /**
         * Reference to Phaser.Game
         */
        public game: Game;

        /**
         * Local private reference to its parent game object.
         */
        private _parent: Phaser.Sprite;

        private _pointerData;

        /**
         * If enabled the Input component will be updated by the parent Sprite
         * @type {Boolean}
         */
        public enabled: bool;

        /**
         * The PriorityID controls which Sprite receives an Input event first if they should overlap.
         */
        public priorityID: number = 0;

        /**
         * The index of this Input component entry in the Game.Input manager.
         */
        public indexID: number = 0;

        private _dragPoint: Point;
        private _draggedPointerID: number;
        public dragOffset: Point;
        public isDragged: bool = false;
        public dragFromCenter: bool;
        public dragPixelPerfect: bool = false;
        public dragPixelPerfectAlpha: number;

        public allowHorizontalDrag: bool = true;
        public allowVerticalDrag: bool = true;
        public bringToTop: bool = false;

        public snapOnDrag: bool = false;
        public snapOnRelease: bool = false;
        public snapOffset: Point;
        public snapX: number = 0;
        public snapY: number = 0;


        /**
		 * Is this sprite allowed to be dragged by the mouse? true = yes, false = no
		 * @default false
		 */
        public draggable: bool = false;

        /**
		 * A region of the game world within which the sprite is restricted during drag
		 * @default null
		 */
        public boundsRect: Rectangle = null;

        /**
		 * An Sprite the bounds of which this sprite is restricted during drag
		 * @default null
		 */
        public boundsSprite: Phaser.Sprite = null;

        /**
         * The Input component can monitor either the physics body of the Sprite or the frameBounds
         * If checkBody is set to true it will monitor the bounds of the physics body.
         * @type {Boolean}
         */
        public checkBody: bool;

        /**
         * Turn the mouse pointer into a hand image by temporarily setting the CSS style of the Game canvas
         * on Input over. Only works on desktop browsers or browsers with a visible input pointer.
         * @type {Boolean}
         */
        public useHandCursor: bool;

        /**
         * If this object is set to consume the pointer event then it will stop all propogation from this object on.
         * For example if you had a stack of 6 sprites with the same priority IDs and one consumed the event, none of the others would receive it.
         * @type {Boolean}
         */
        public consumePointerEvent: bool = false;

        /**
         * The x coordinate of the Input pointer, relative to the top-left of the parent Sprite.
         * This value is only set when the pointer is over this Sprite.
         * @type {number}
         */
        public pointerX(pointer: number = 0): number {
            return this._pointerData[pointer].x;
        }

        /**
         * The y coordinate of the Input pointer, relative to the top-left of the parent Sprite
         * This value is only set when the pointer is over this Sprite.
         * @type {number}
         */
        public pointerY(pointer: number = 0): number {
            return this._pointerData[pointer].y;
        }

        /**
        * If the Pointer is touching the touchscreen, or the mouse button is held down, isDown is set to true
        * @property isDown
        * @type {Boolean}
        **/
        public pointerDown(pointer: number = 0): bool {
            return this._pointerData[pointer].isDown;
        }

        /**
        * If the Pointer is not touching the touchscreen, or the mouse button is up, isUp is set to true
        * @property isUp
        * @type {Boolean}
        **/
        public pointerUp(pointer: number = 0): bool {
            return this._pointerData[pointer].isUp;
        }

        /**
        * A timestamp representing when the Pointer first touched the touchscreen.
        * @property timeDown
        * @type {Number}
        **/
        public pointerTimeDown(pointer: number = 0): bool {
            return this._pointerData[pointer].timeDown;
        }

        /**
        * A timestamp representing when the Pointer left the touchscreen.
        * @property timeUp
        * @type {Number}
        **/
        public pointerTimeUp(pointer: number = 0): bool {
            return this._pointerData[pointer].timeUp;
        }

        /**
        * Is the Pointer over this Sprite
        * @property isOver
        * @type {Boolean}
        **/
        public pointerOver(pointer: number = 0): bool {
            return this._pointerData[pointer].isOver;
        }

        /**
        * Is the Pointer outside of this Sprite
        * @property isOut
        * @type {Boolean}
        **/
        public pointerOut(pointer: number = 0): bool {
            return this._pointerData[pointer].isOut;
        }

        /**
        * A timestamp representing when the Pointer first touched the touchscreen.
        * @property timeDown
        * @type {Number}
        **/
        public pointerTimeOver(pointer: number = 0): bool {
            return this._pointerData[pointer].timeOver;
        }

        /**
        * A timestamp representing when the Pointer left the touchscreen.
        * @property timeUp
        * @type {Number}
        **/
        public pointerTimeOut(pointer: number = 0): bool {
            return this._pointerData[pointer].timeOut;
        }

        /**
		 * Is this sprite being dragged by the mouse or not?
		 * @default false
		 */
        public pointerDragged(pointer: number = 0): bool {
            return this._pointerData[pointer].isDragged;
        }

        public start(priority: number = 0, checkBody?: bool = false, useHandCursor?: bool = false): Phaser.Sprite {

            //  Turning on
            if (this.enabled == false)
            {
                //  Register, etc
                this.checkBody = checkBody;
                this.useHandCursor = useHandCursor;
                this.priorityID = priority;

                this._pointerData = [];

                for (var i = 0; i < 10; i++)
                {
                    this._pointerData.push({ id: i, x: 0, y: 0, isDown: false, isUp: false, isOver: false, isOut: false, timeOver: 0, timeOut: 0, timeDown: 0, timeUp: 0, downDuration: 0, isDragged: false });
                }

                this.snapOffset = new Point;
                this.enabled = true;

                this.game.input.addGameObject(this._parent);

                //  Create the signals the Input component will emit
                if (this._parent.events.onInputOver == null)
                {
                    this._parent.events.onInputOver = new Phaser.Signal;
                    this._parent.events.onInputOut = new Phaser.Signal;
                    this._parent.events.onInputDown = new Phaser.Signal;
                    this._parent.events.onInputUp = new Phaser.Signal;
                    this._parent.events.onDragStart = new Phaser.Signal;
                    this._parent.events.onDragStop = new Phaser.Signal;
                }
            }

            return this._parent;

        }

        public reset() {

            this.enabled = false;

            for (var i = 0; i < 10; i++)
            {
                this._pointerData[i] = { id: i, x: 0, y: 0, isDown: false, isUp: false, isOver: false, isOut: false, timeOver: 0, timeOut: 0, timeDown: 0, timeUp: 0, downDuration: 0, isDragged: false };
            }

        }

        public stop() {

            //  Turning off
            if (this.enabled == false)
            {
                return;
            }
            else
            {
                //  De-register, etc
                this.enabled = false;
                this.game.input.removeGameObject(this.indexID);
            }

        }

        /**
         * Clean up memory.
         */
        public destroy() {

            if (this.enabled)
            {
                this.enabled = false;
                this.game.input.removeGameObject(this.indexID);
            }

        }

        /**
         * Checks if the given pointer is over this Sprite. All checks are done in world coordinates.
         */
        public checkPointerOver(pointer: Phaser.Pointer): bool {

            if (this.enabled == false || this._parent.visible == false)
            {
                return false;
            }
            else
            {
                return SpriteUtils.overlapsXY(this._parent, pointer.worldX(), pointer.worldY());
            }

        }

        /**
         * Update
         */
        public update(pointer: Phaser.Pointer): bool {

            if (this.enabled == false || this._parent.visible == false)
            {
                this._pointerOutHandler(pointer);
                return false;
            }

            if (this.draggable && this._draggedPointerID == pointer.id)
            {
                return this.updateDrag(pointer);
            }
            else if (this._pointerData[pointer.id].isOver == true)
            {
                if (SpriteUtils.overlapsXY(this._parent, pointer.worldX(), pointer.worldY()))
                {
                    this._pointerData[pointer.id].x = pointer.x - this._parent.x;
                    this._pointerData[pointer.id].y = pointer.y - this._parent.y;
                    return true;
                }
                else
                {
                    this._pointerOutHandler(pointer);
                    return false;
                }
            }

        }

        public _pointerOverHandler(pointer: Pointer) {

            //  { id: i, x: 0, y: 0, isDown: false, isUp: false, isOver: false, isOut: false, timeOver: 0, timeOut: 0, isDragged: false }

            if (this._pointerData[pointer.id].isOver == false)
            {
                this._pointerData[pointer.id].isOver = true;
                this._pointerData[pointer.id].isOut = false;
                this._pointerData[pointer.id].timeOver = this.game.time.now;
                this._pointerData[pointer.id].x = pointer.x - this._parent.x;
                this._pointerData[pointer.id].y = pointer.y - this._parent.y;

                if (this.useHandCursor && this._pointerData[pointer.id].isDragged == false)
                {
                    this.game.stage.canvas.style.cursor = "pointer";
                }

                this._parent.events.onInputOver.dispatch(this._parent, pointer);
            }

        }

        public _pointerOutHandler(pointer: Pointer) {

            this._pointerData[pointer.id].isOver = false;
            this._pointerData[pointer.id].isOut = true;
            this._pointerData[pointer.id].timeOut = this.game.time.now;

            if (this.useHandCursor && this._pointerData[pointer.id].isDragged == false)
            {
                this.game.stage.canvas.style.cursor = "default";
            }

            this._parent.events.onInputOut.dispatch(this._parent, pointer);

        }

        public _touchedHandler(pointer: Pointer): bool {

            if (this._pointerData[pointer.id].isDown == false && this._pointerData[pointer.id].isOver == true)
            {
                this._pointerData[pointer.id].isDown = true;
                this._pointerData[pointer.id].isUp = false;
                this._pointerData[pointer.id].timeDown = this.game.time.now;

                //console.log('touchedHandler: ' + Date.now());
                this._parent.events.onInputDown.dispatch(this._parent, pointer);

                //  Start drag
                //if (this.draggable && this.isDragged == false && pointer.targetObject == null)
                if (this.draggable && this.isDragged == false)
                {
                    this.startDrag(pointer);
                }

                if (this.bringToTop)
                {
                    this._parent.bringToTop();
                    //this._parent.game.world.group.bringToTop(this._parent);
                }

            }

            //  Consume the event?
            return this.consumePointerEvent;

        }

        public _releasedHandler(pointer: Pointer) {

            //  If was previously touched by this Pointer, check if still is AND still over this item
            if (this._pointerData[pointer.id].isDown && pointer.isUp)
            {
                this._pointerData[pointer.id].isDown = false;
                this._pointerData[pointer.id].isUp = true;
                this._pointerData[pointer.id].timeUp = this.game.time.now;
                this._pointerData[pointer.id].downDuration = this._pointerData[pointer.id].timeUp - this._pointerData[pointer.id].timeDown;

                //  Only release the InputUp signal if the pointer is still over this sprite
                if (SpriteUtils.overlapsXY(this._parent, pointer.worldX(), pointer.worldY()))
                {
                    //console.log('releasedHandler: ' + Date.now());
                    this._parent.events.onInputUp.dispatch(this._parent, pointer);
                }
                else
                {
                    //  Pointer outside the sprite? Reset the cursor
                    if (this.useHandCursor)
                    {
                        this.game.stage.canvas.style.cursor = "default";
                    }
                }

                //  Stop drag
                if (this.draggable && this.isDragged && this._draggedPointerID == pointer.id)
                {
                    this.stopDrag(pointer);
                }

            }

        }

        /**
		 * Updates the Pointer drag on this Sprite.
		 */
        private updateDrag(pointer: Pointer): bool {

            if (pointer.isUp)
            {
                this.stopDrag(pointer);
                return false;
            }

            if (this.allowHorizontalDrag)
            {
                this._parent.x = pointer.x + this._dragPoint.x + this.dragOffset.x;
            }

            if (this.allowVerticalDrag)
            {
                this._parent.y = pointer.y + this._dragPoint.y + this.dragOffset.y;
            }

            if (this.boundsRect)
            {
                this.checkBoundsRect();
            }

            if (this.boundsSprite)
            {
                this.checkBoundsSprite();
            }

            if (this.snapOnDrag)
            {
                this._parent.x = Math.floor(this._parent.x / this.snapX) * this.snapX;
                this._parent.y = Math.floor(this._parent.y / this.snapY) * this.snapY;
            }

            return true;
        }

        /**
         * Returns true if the pointer has entered the Sprite within the specified delay time (defaults to 500ms, half a second)
         * @param delay The time below which the pointer is considered as just over.
         * @returns {boolean}
         */
        public justOver(pointer: number = 0, delay?: number = 500): bool {
            return (this._pointerData[pointer].isOver && this.overDuration(pointer) < delay);
        }

        /**
         * Returns true if the pointer has left the Sprite within the specified delay time (defaults to 500ms, half a second)
         * @param delay The time below which the pointer is considered as just out.
         * @returns {boolean}
         */
        public justOut(pointer: number = 0, delay?: number = 500): bool {
            return (this._pointerData[pointer].isOut && (this.game.time.now - this._pointerData[pointer].timeOut < delay));
        }

        /**
         * Returns true if the pointer has entered the Sprite within the specified delay time (defaults to 500ms, half a second)
         * @param delay The time below which the pointer is considered as just over.
         * @returns {boolean}
         */
        public justPressed(pointer: number = 0, delay?: number = 500): bool {
            return (this._pointerData[pointer].isDown && this.downDuration(pointer) < delay);
        }

        /**
         * Returns true if the pointer has left the Sprite within the specified delay time (defaults to 500ms, half a second)
         * @param delay The time below which the pointer is considered as just out.
         * @returns {boolean}
         */
        public justReleased(pointer: number = 0, delay?: number = 500): bool {
            return (this._pointerData[pointer].isUp && (this.game.time.now - this._pointerData[pointer].timeUp < delay));
        }

        /**
         * If the pointer is currently over this Sprite this returns how long it has been there for in milliseconds.
         * @returns {number} The number of milliseconds the pointer has been over the Sprite, or -1 if not over.
         */
        public overDuration(pointer: number = 0): number {

            if (this._pointerData[pointer].isOver)
            {
                return this.game.time.now - this._pointerData[pointer].timeOver;
            }

            return -1;

        }

        /**
         * If the pointer is currently over this Sprite this returns how long it has been there for in milliseconds.
         * @returns {number} The number of milliseconds the pointer has been pressed down on the Sprite, or -1 if not over.
         */
        public downDuration(pointer: number = 0): number {

            if (this._pointerData[pointer].isDown)
            {
                return this.game.time.now - this._pointerData[pointer].timeDown;
            }

            return -1;

        }

        /**
		 * Make this Sprite draggable by the mouse. You can also optionally set mouseStartDragCallback and mouseStopDragCallback
		 * 
		 * @param	lockCenter			If false the Sprite will drag from where you click it minus the dragOffset. If true it will center itself to the tip of the mouse pointer.
		 * @param	bringToTop			If true the Sprite will be bought to the top of the rendering list in its current Group.
		 * @param	pixelPerfect		If true it will use a pixel perfect test to see if you clicked the Sprite. False uses the bounding box.
		 * @param	alphaThreshold		If using pixel perfect collision this specifies the alpha level from 0 to 255 above which a collision is processed (default 255)
		 * @param	boundsRect			If you want to restrict the drag of this sprite to a specific FlxRect, pass the FlxRect here, otherwise it's free to drag anywhere
		 * @param	boundsSprite		If you want to restrict the drag of this sprite to within the bounding box of another sprite, pass it here
		 */
        public enableDrag(lockCenter: bool = false, bringToTop: bool = false, pixelPerfect: bool = false, alphaThreshold: number = 255, boundsRect: Rectangle = null, boundsSprite: Phaser.Sprite = null): void {
            this._dragPoint = new Point;

            this.draggable = true;
            this.bringToTop = bringToTop;

            this.dragOffset = new Point;
            this.dragFromCenter = lockCenter;
            this.dragPixelPerfect = pixelPerfect;
            this.dragPixelPerfectAlpha = alphaThreshold;

            if (boundsRect)
            {
                this.boundsRect = boundsRect;
            }

            if (boundsSprite)
            {
                this.boundsSprite = boundsSprite;
            }
        }

        /**
		 * Stops this sprite from being able to be dragged. If it is currently the target of an active drag it will be stopped immediately. Also disables any set callbacks.
		 */
        public disableDrag(): void {

            if (this._pointerData)
            {
                for (var i = 0; i < 10; i++)
                {
                    this._pointerData[i].isDragged = false;
                }
            }

            this.draggable = false;
            this.isDragged = false;
            this._draggedPointerID = -1;

        }

        /**
		 * Called by Pointer when drag starts on this Sprite. Should not usually be called directly.
		 */
        public startDrag(pointer: Pointer): void {

            this.isDragged = true;
            this._draggedPointerID = pointer.id;
            this._pointerData[pointer.id].isDragged = true;

            if (this.dragFromCenter)
            {
                this._parent.transform.centerOn(pointer.worldX(), pointer.worldY());
                this._dragPoint.setTo(this._parent.x - pointer.x, this._parent.y - pointer.y);
            }
            else
            {
                this._dragPoint.setTo(this._parent.x - pointer.x, this._parent.y - pointer.y);
            }

            this.updateDrag(pointer);

            if (this.bringToTop)
            {
                this._parent.bringToTop();
            }

            this._parent.events.onDragStart.dispatch(this._parent, pointer);

        }

        /**
		 * Called by Pointer when drag is stopped on this Sprite. Should not usually be called directly.
		 */
        public stopDrag(pointer: Pointer): void {

            this.isDragged = false;
            this._draggedPointerID = -1;
            this._pointerData[pointer.id].isDragged = false;

            if (this.snapOnRelease)
            {
                this._parent.x = Math.floor(this._parent.x / this.snapX) * this.snapX;
                this._parent.y = Math.floor(this._parent.y / this.snapY) * this.snapY;
            }

            this._parent.events.onDragStop.dispatch(this._parent, pointer);
            this._parent.events.onInputUp.dispatch(this._parent, pointer);

        }

        /**
		* Restricts this sprite to drag movement only on the given axis. Note: If both are set to false the sprite will never move!
		 * 
		 * @param	allowHorizontal		To enable the sprite to be dragged horizontally set to true, otherwise false
		 * @param	allowVertical		To enable the sprite to be dragged vertically set to true, otherwise false
		 */
        public setDragLock(allowHorizontal: bool = true, allowVertical: bool = true): void {
            this.allowHorizontalDrag = allowHorizontal;
            this.allowVerticalDrag = allowVertical;
        }

        /**
		 * Make this Sprite snap to the given grid either during drag or when it's released.
		 * For example 16x16 as the snapX and snapY would make the sprite snap to every 16 pixels.
		 * 
		 * @param	snapX		The width of the grid cell in pixels
		 * @param	snapY		The height of the grid cell in pixels
		 * @param	onDrag		If true the sprite will snap to the grid while being dragged
		 * @param	onRelease	If true the sprite will snap to the grid when released
		 */
        public enableSnap(snapX: number, snapY: number, onDrag: bool = true, onRelease: bool = false): void {
            this.snapOnDrag = onDrag;
            this.snapOnRelease = onRelease;
            this.snapX = snapX;
            this.snapY = snapY;
        }

        /**
		 * Stops the sprite from snapping to a grid during drag or release.
		 */
        public disableSnap(): void {
            this.snapOnDrag = false;
            this.snapOnRelease = false;
        }

        /**
		 * Bounds Rect check for the sprite drag
		 */
        private checkBoundsRect(): void {
            if (this._parent.x < this.boundsRect.left)
            {
                this._parent.x = this.boundsRect.x;
            }
            else if ((this._parent.x + this._parent.width) > this.boundsRect.right)
            {
                this._parent.x = this.boundsRect.right - this._parent.width;
            }

            if (this._parent.y < this.boundsRect.top)
            {
                this._parent.y = this.boundsRect.top;
            }
            else if ((this._parent.y + this._parent.height) > this.boundsRect.bottom)
            {
                this._parent.y = this.boundsRect.bottom - this._parent.height;
            }
        }

        /**
		 * Parent Sprite Bounds check for the sprite drag
		 */
        private checkBoundsSprite(): void {
            if (this._parent.x < this.boundsSprite.x)
            {
                this._parent.x = this.boundsSprite.x;
            }
            else if ((this._parent.x + this._parent.width) > (this.boundsSprite.x + this.boundsSprite.width))
            {
                this._parent.x = (this.boundsSprite.x + this.boundsSprite.width) - this._parent.width;
            }

            if (this._parent.y < this.boundsSprite.y)
            {
                this._parent.y = this.boundsSprite.y;
            }
            else if ((this._parent.y + this._parent.height) > (this.boundsSprite.y + this.boundsSprite.height))
            {
                this._parent.y = (this.boundsSprite.y + this.boundsSprite.height) - this._parent.height;
            }
        }

    }

}