/*

YUI 3.10.3 (build 2fb5187)

Copyright 2013 Yahoo! Inc. All rights reserved.

Licensed under the BSD License.

http://yuilibrary.com/license/

*/

YUI.add('gesture-simulate', function (Y, NAME) {

/**

 * Simulate high-level user gestures by generating a set of native DOM events.

 *

 * @module gesture-simulate

 * @requires event-simulate, async-queue, node-screen

 */

var NAME = "gesture-simulate",

    // phantomjs check may be temporary, until we determine if it really support touch all the way through, like it claims to (http://code.google.com/p/phantomjs/issues/detail?id=375)

    SUPPORTS_TOUCH = ((Y.config.win && ("ontouchstart" in Y.config.win)) && !(Y.UA.phantomjs) && !(Y.UA.chrome && Y.UA.chrome < 6)),

    gestureNames = {

        tap: 1,

        doubletap: 1,

        press: 1,

        move: 1,

        flick: 1,

        pinch: 1,

        rotate: 1

    },

    touchEvents = {

        touchstart: 1,

        touchmove: 1,

        touchend: 1,

        touchcancel: 1

    },

    document = Y.config.doc,

    emptyTouchList,

    EVENT_INTERVAL = 20,        // 20ms

    START_PAGEX,                // will be adjusted to the node element center

    START_PAGEY,                // will be adjusted to the node element center

    // defaults that user can override.

    DEFAULTS = {

        // tap gestures

        HOLD_TAP: 10,           // 10ms

        DELAY_TAP: 10,          // 10ms

        // press gesture

        HOLD_PRESS: 3000,       // 3sec

        MIN_HOLD_PRESS: 1000,   // 1sec

        MAX_HOLD_PRESS: 60000,  // 1min

        // move gesture

        DISTANCE_MOVE: 200,     // 200 pixels

        DURATION_MOVE: 1000,    // 1sec

        MAX_DURATION_MOVE: 5000,// 5sec

        // flick gesture

        MIN_VELOCITY_FLICK: 1.3,

        DISTANCE_FLICK: 200,     // 200 pixels

        DURATION_FLICK: 1000,    // 1sec

        MAX_DURATION_FLICK: 5000,// 5sec

        // pinch/rotation

        DURATION_PINCH: 1000     // 1sec

    },

    TOUCH_START = 'touchstart',

    TOUCH_MOVE = 'touchmove',

    TOUCH_END = 'touchend',

    GESTURE_START = 'gesturestart',

    GESTURE_CHANGE = 'gesturechange',

    GESTURE_END = 'gestureend',

    MOUSE_UP    = 'mouseup',

    MOUSE_MOVE  = 'mousemove',

    MOUSE_DOWN  = 'mousedown',

    MOUSE_CLICK = 'click',

    MOUSE_DBLCLICK = 'dblclick',

    X_AXIS = 'x',

    Y_AXIS = 'y';

function Simulations(node) {

    if(!node) {

        Y.error(NAME+': invalid target node');

    }

    this.node = node;

    this.target = Y.Node.getDOMNode(node);

    var startXY = this.node.getXY(),

        dims = this._getDims();

    START_PAGEX = startXY[0] + (dims[0])/2;

    START_PAGEY = startXY[1] + (dims[1])/2;

}

Simulations.prototype = {

    /**

     * Helper method to convert a degree to a radian.

     * 

     * @method _toRadian

     * @private

     * @param {Number} deg A degree to be converted to a radian.

     * @return {Number} The degree in radian. 

     */

    _toRadian: function(deg) {

        return deg * (Math.PI/180);

    },

    /**

     * Helper method to get height/width while accounting for 

     * rotation/scale transforms where possible by using the 

     * bounding client rectangle height/width instead of the 

     * offsetWidth/Height which region uses.

     * @method _getDims

     * @private

     * @return {Array} Array with [height, width]

     */

    _getDims : function() {

        var region,

            width,

            height;

        // Ideally, this should be in DOM somewhere.

        if (this.target.getBoundingClientRect) {

            region = this.target.getBoundingClientRect();

            if ("height" in region) {

                height = region.height;

            } else {

                // IE7,8 has getBCR, but no height.

                height = Math.abs(region.bottom - region.top);

            }

            if ("width" in region) {

                width = region.width;

            } else {

                // IE7,8 has getBCR, but no width.

                width = Math.abs(region.right - region.left);

            }

        } else {

            region = this.node.get("region");

            width = region.width;

            height = region.height;

        }

        return [width, height];

    },

    /**

     * Helper method to convert a point relative to the node element into 

     * the point in the page coordination.

     * 

     * @method _calculateDefaultPoint

     * @private

     * @param {Array} point A point relative to the node element.

     * @return {Array} The same point in the page coordination. 

     */

    _calculateDefaultPoint: function(point) {

        var height;

        if(!Y.Lang.isArray(point) || point.length === 0) {

            point = [START_PAGEX, START_PAGEY];

        } else {

            if(point.length == 1) {

                height = this._getDims[1];

                point[1] = height/2;

            }

            // convert to page(viewport) coordination

            point[0] = this.node.getX() + point[0];

            point[1] = this.node.getY() + point[1];

        }

        return point;

    },

    /**

     * The "rotate" and "pinch" methods are essencially same with the exact same 

     * arguments. Only difference is the required parameters. The rotate method 

     * requires "rotation" parameter while the pinch method requires "startRadius" 

     * and "endRadius" parameters.

     *

     * @method rotate

     * @param {Function} cb The callback to execute when the gesture simulation 

     *      is completed.

     * @param {Array} center A center point where the pinch gesture of two fingers

     *      should happen. It is relative to the top left corner of the target 

     *      node element.

     * @param {Number} startRadius A radius of start circle where 2 fingers are 

     *      on when the gesture starts. This is optional. The default is a fourth of 

     *      either target node width or height whichever is smaller.

     * @param {Number} endRadius A radius of end circle where 2 fingers will be on when

     *      the pinch or spread gestures are completed. This is optional. 

     *      The default is a fourth of either target node width or height whichever is less.

     * @param {Number} duration A duration of the gesture in millisecond.

     * @param {Number} start A start angle(0 degree at 12 o'clock) where the 

     *      gesture should start. Default is 0.  

     * @param {Number} rotation A rotation in degree. It is required.

     */

    rotate: function(cb, center, startRadius, endRadius, duration, start, rotation) {

        var radius,

            r1 = startRadius,   // optional

            r2 = endRadius;     // optional

        if(!Y.Lang.isNumber(r1) || !Y.Lang.isNumber(r2) || r1<0 || r2<0) {

            radius = (this.target.offsetWidth < this.target.offsetHeight)? 

                this.target.offsetWidth/4 : this.target.offsetHeight/4;

            r1 = radius;

            r2 = radius;

        }

        // required

        if(!Y.Lang.isNumber(rotation)) {

            Y.error(NAME+'Invalid rotation detected.');

        }

        this.pinch(cb, center, r1, r2, duration, start, rotation);

    },

    /**

     * The "rotate" and "pinch" methods are essencially same with the exact same 

     * arguments. Only difference is the required parameters. The rotate method 

     * requires "rotation" parameter while the pinch method requires "startRadius" 

     * and "endRadius" parameters.

     *

     * The "pinch" gesture can simulate various 2 finger gestures such as pinch, 

     * spread and/or rotation. The "startRadius" and "endRadius" are required.

     * If endRadius is larger than startRadius, it becomes a spread gesture 

     * otherwise a pinch gesture. 

     *

     * @method pinch

     * @param {Function} cb The callback to execute when the gesture simulation 

     *      is completed.

     * @param {Array} center A center point where the pinch gesture of two fingers

     *      should happen. It is relative to the top left corner of the target 

     *      node element.

     * @param {Number} startRadius A radius of start circle where 2 fingers are 

     *      on when the gesture starts. This paramenter is required.

     * @param {Number} endRadius A radius of end circle where 2 fingers will be on when

     *      the pinch or spread gestures are completed. This parameter is required.

     * @param {Number} duration A duration of the gesture in millisecond.

     * @param {Number} start A start angle(0 degree at 12 o'clock) where the 

     *      gesture should start. Default is 0.  

     * @param {Number} rotation If rotation is desired during the pinch or 

     *      spread gestures, this parameter can be used. Default is 0 degree.  

     */

    pinch: function(cb, center, startRadius, endRadius, duration, start, rotation) {

        var eventQueue,

            i,

            interval = EVENT_INTERVAL,

            touches,

            id = 0,

            r1 = startRadius,   // required

            r2 = endRadius,     // required

            radiusPerStep,

            centerX, centerY,

            startScale, endScale, scalePerStep,

            startRot, endRot, rotPerStep,

            path1 = {start: [], end: []}, // paths for 1st and 2nd fingers. 

            path2 = {start: [], end: []},

            steps,

            touchMove;

        center = this._calculateDefaultPoint(center);

        if(!Y.Lang.isNumber(r1) || !Y.Lang.isNumber(r2) || r1<0 || r2<0) {

            Y.error(NAME+'Invalid startRadius and endRadius detected.');

        }

        if(!Y.Lang.isNumber(duration) || duration <= 0) {

            duration = DEFAULTS.DURATION_PINCH;

        }

        if(!Y.Lang.isNumber(start)) {

            start = 0.0;

        } else {

            start = start%360;

            while(start < 0) {

                start += 360;

            }

        }

        if(!Y.Lang.isNumber(rotation)) {

            rotation = 0.0;

        }

        Y.AsyncQueue.defaults.timeout = interval;

        eventQueue = new Y.AsyncQueue();

        // range determination

        centerX = center[0];

        centerY = center[1];

        startRot = start;

        endRot = start + rotation;

        // 1st finger path

        path1.start = [

            centerX + r1*Math.sin(this._toRadian(startRot)), 

            centerY - r1*Math.cos(this._toRadian(startRot))

        ];

        path1.end   = [

            centerX + r2*Math.sin(this._toRadian(endRot)), 

            centerY - r2*Math.cos(this._toRadian(endRot))

        ];

        // 2nd finger path

        path2.start = [

            centerX - r1*Math.sin(this._toRadian(startRot)), 

            centerY + r1*Math.cos(this._toRadian(startRot))

        ];

        path2.end   = [

            centerX - r2*Math.sin(this._toRadian(endRot)), 

            centerY + r2*Math.cos(this._toRadian(endRot))

        ];

        startScale = 1.0;

        endScale = endRadius/startRadius;

        // touch/gesture start

        eventQueue.add({

            fn: function() {

                var coord1, coord2, coord, touches;

                // coordinate for each touch object.

                coord1 = {

                    pageX: path1.start[0], 

                    pageY: path1.start[1],

                    clientX: path1.start[0], 

                    clientY: path1.start[1]

                };

                coord2 = {

                    pageX: path2.start[0], 

                    pageY: path2.start[1],

                    clientX: path2.start[0], 

                    clientY: path2.start[1]

                };

                touches = this._createTouchList([Y.merge({

                    identifier: (id++)   

                }, coord1), Y.merge({

                    identifier: (id++)

                }, coord2)]);

                // coordinate for top level event

                coord = {

                    pageX: (path1.start[0] + path2.start[0])/2,

                    pageY: (path1.start[0] + path2.start[1])/2,

                    clientX: (path1.start[0] + path2.start[0])/2,

                    clientY: (path1.start[0] + path2.start[1])/2

                };

                this._simulateEvent(this.target, TOUCH_START, Y.merge({

                    touches: touches,

                    targetTouches: touches,

                    changedTouches: touches,

                    scale: startScale,

                    rotation: startRot

                }, coord));

                if(Y.UA.ios >= 2.0) {

                    /* gesture starts when the 2nd finger touch starts.

                    * The implementation will fire 1 touch start event for both fingers,

                    * simulating 2 fingers touched on the screen at the same time.

                    */

                    this._simulateEvent(this.target, GESTURE_START, Y.merge({

                        scale: startScale,

                        rotation: startRot

                    }, coord));

                }

            },

            timeout: 0,

            context: this

        });

        // gesture change