// DOM.event.move
//
// 2.0.0
//
// Stephen Band
//
// Triggers 'movestart', 'move' and 'moveend' events after
// mousemoves following a mousedown cross a distance threshold,
// similar to the native 'dragstart', 'drag' and 'dragend' events.
// Move events are throttled to animation frames. Move event objects
// have the properties:
//
// pageX:
// pageY:     Page coordinates of pointer.
// startX:
// startY:    Page coordinates of pointer at movestart.
// distX:
// distY:     Distance the pointer has moved since movestart.
// deltaX:
// deltaY:    Distance the finger has moved since last event.
// velocityX:
// velocityY: Average velocity over last few events.


(function(fn) {
    if (typeof define === 'function' && define.amd) {
        define([], fn);
    } else if ((typeof module !== "undefined" && module !== null) && module.exports) {
        module.exports = fn;
    } else {
        fn();
    }
})(function(){
    var assign = Object.assign || window.jQuery && jQuery.extend;

    // Number of pixels a pressed pointer travels before movestart
    // event is fired.
    var threshold = 8;

    // Shim for requestAnimationFrame, falling back to timer. See:
    // see http://paulirish.com/2011/requestanimationframe-for-smart-animating/
    var requestFrame = (function(){
        return (
            window.requestAnimationFrame ||
            window.webkitRequestAnimationFrame ||
            window.mozRequestAnimationFrame ||
            window.oRequestAnimationFrame ||
            window.msRequestAnimationFrame ||
            function(fn, element){
                return window.setTimeout(function(){
                    fn();
                }, 25);
            }
        );
    })();
    
    // Shim for customEvent
    // see https://developer.mozilla.org/en-US/docs/Web/API/CustomEvent/CustomEvent#Polyfill
    (function () {
        if ( typeof window.CustomEvent === "function" ) return false;
        function CustomEvent ( event, params ) {
            params = params || { bubbles: false, cancelable: false, detail: undefined };
            var evt = document.createEvent( 'CustomEvent' );
            evt.initCustomEvent( event, params.bubbles, params.cancelable, params.detail );
            return evt;
        }
        
        CustomEvent.prototype = window.Event.prototype;
        window.CustomEvent = CustomEvent;
    })();

    var ignoreTags = {
            textarea: true,
            input: true,
            select: true,
            button: true
        };

    var mouseevents = {
        move:   'mousemove',
        cancel: 'mouseup dragstart',
        end:    'mouseup'
    };

    var touchevents = {
        move:   'touchmove',
        cancel: 'touchend',
        end:    'touchend'
    };

    var rspaces = /\s+/;


    // DOM Events

    var eventOptions = { bubbles: true, cancelable: true };

    var eventsSymbol = typeof Symbol === "function" ? Symbol('events') : {};

    function createEvent(type) {
        return new CustomEvent(type, eventOptions);
    }

    function getEvents(node) {
        return node[eventsSymbol] || (node[eventsSymbol] = {});
    }

    function on(node, types, fn, data, selector) {
        types = types.split(rspaces);

        var events = getEvents(node);
        var i = types.length;
        var handlers, type;

        function handler(e) { fn(e, data); }

        while (i--) {
            type = types[i];
            handlers = events[type] || (events[type] = []);
            handlers.push([fn, handler]);
            node.addEventListener(type, handler);
        }
    }

    function off(node, types, fn, selector) {
        types = types.split(rspaces);

        var events = getEvents(node);
        var i = types.length;
        var type, handlers, k;

        if (!events) { return; }

        while (i--) {
            type = types[i];
            handlers = events[type];
            if (!handlers) { continue; }
            k = handlers.length;
            while (k--) {
                if (handlers[k][0] === fn) {
                    node.removeEventListener(type, handlers[k][1]);
                    handlers.splice(k, 1);
                }
            }
        }
    }

    function trigger(node, type, properties) {
        // Don't cache events. It prevents you from triggering an event of a
        // given type from inside the handler of another event of that type.
        var event = createEvent(type);
        if (properties) { assign(event, properties); }
        node.dispatchEvent(event);
    }


    // Constructors

    function Timer(fn){
        var callback = fn,
            active = false,
            running = false;

        function trigger(time) {
            if (active){
                callback();
                requestFrame(trigger);
                running = true;
                active = false;
            }
            else {
                running = false;
            }
        }

        this.kick = function(fn) {
            active = true;
            if (!running) { trigger(); }
        };

        this.end = function(fn) {
            var cb = callback;

            if (!fn) { return; }

            // If the timer is not running, simply call the end callback.
            if (!running) {
                fn();
            }
            // If the timer is running, and has been kicked lately, then
            // queue up the current callback and the end callback, otherwise
            // just the end callback.
            else {
                callback = active ?
                    function(){ cb(); fn(); } :
                    fn ;

                active = true;
            }
        };
    }


    // Functions

    function noop() {}

    function preventDefault(e) {
        e.preventDefault();
    }

    function isIgnoreTag(e) {
        return !!ignoreTags[e.target.tagName.toLowerCase()];
    }

    function isPrimaryButton(e) {
        // Ignore mousedowns on any button other than the left (or primary)
        // mouse button, or when a modifier key is pressed.
        return (e.which === 1 && !e.ctrlKey && !e.altKey);
    }

    function identifiedTouch(touchList, id) {
        var i, l;

        if (touchList.identifiedTouch) {
            return touchList.identifiedTouch(id);
        }

        // touchList.identifiedTouch() does not exist in
        // webkit yet… we must do the search ourselves...

        i = -1;
        l = touchList.length;

        while (++i < l) {
            if (touchList[i].identifier === id) {
                return touchList[i];
            }
        }
    }

    function changedTouch(e, data) {
        var touch = identifiedTouch(e.changedTouches, data.identifier);

        // This isn't the touch you're looking for.
        if (!touch) { return; }

        // Chrome Android (at least) includes touches that have not
        // changed in e.changedTouches. That's a bit annoying. Check
        // that this touch has changed.
        if (touch.pageX === data.pageX && touch.pageY === data.pageY) { return; }

        return touch;
    }


    // Handlers that decide when the first movestart is triggered

    function mousedown(e){
        // Ignore non-primary buttons
        if (!isPrimaryButton(e)) { return; }

        // Ignore form and interactive elements
        if (isIgnoreTag(e)) { return; }

        on(document, mouseevents.move, mousemove, e);
        on(document, mouseevents.cancel, mouseend, e);
    }

    function mousemove(e, data){
        checkThreshold(e, data, e, removeMouse);
    }

    function mouseend(e, data) {
        removeMouse();
    }

    function removeMouse() {
        off(document, mouseevents.move, mousemove);
        off(document, mouseevents.cancel, mouseend);
    }

    function touchstart(e) {
        // Don't get in the way of interaction with form elements
        if (ignoreTags[e.target.tagName.toLowerCase()]) { return; }

        var touch = e.changedTouches[0];

        // iOS live updates the touch objects whereas Android gives us copies.
        // That means we can't trust the touchstart object to stay the same,
        // so we must copy the data. This object acts as a template for
        // movestart, move and moveend event objects.
        var data = {
            target:     touch.target,
            pageX:      touch.pageX,
            pageY:      touch.pageY,
            identifier: touch.identifier,

            // The only way to make handlers individually unbindable is by
            // making them unique.
            touchmove:  function(e, data) { touchmove(e, data); },
            touchend:   function(e, data) { touchend(e, data); }
        };

        on(document, touchevents.move, data.touchmove, data);
        on(document, touchevents.cancel, data.touchend, data);
    }

    function touchmove(e, data) {
        var touch = changedTouch(e, data);
        if (!touch) { return; }
        checkThreshold(e, data, touch, removeTouch);
    }

    function touchend(e, data) {
        var touch = identifiedTouch(e.changedTouches, data.identifier);
        if (!touch) { return; }
        removeTouch(data);
    }

    function removeTouch(data) {
        off(document, touchevents.move, data.touchmove);
        off(document, touchevents.cancel, data.touchend);
    }

    function checkThreshold(e, data, touch, fn) {
        var distX = touch.pageX - data.pageX;
        var distY = touch.pageY - data.pageY;

        // Do nothing if the threshold has not been crossed.
        if ((distX * distX) + (distY * distY) < (threshold * threshold)) { return; }

        triggerStart(e, data, touch, distX, distY, fn);
    }

    function triggerStart(e, data, touch, distX, distY, fn) {
        var touches = e.targetTouches;
        var time = e.timeStamp - data.timeStamp;

        // Create a movestart object with some special properties that
        // are passed only to the movestart handlers.
        var template = {
            altKey:     e.altKey,
            ctrlKey:    e.ctrlKey,
            shiftKey:   e.shiftKey,
            startX:     data.pageX,
            startY:     data.pageY,
            distX:      distX,
            distY:      distY,
            deltaX:     distX,
            deltaY:     distY,
            pageX:      touch.pageX,
            pageY:      touch.pageY,
            velocityX:  distX / time,
            velocityY:  distY / time,
            identifier: data.identifier,
            targetTouches: touches,
            finger: touches ? touches.length : 1,
            enableMove: function() {
                this.moveEnabled = true;
                this.enableMove = noop;
                e.preventDefault();
            }
        };

        // Trigger the movestart event.
        trigger(data.target, 'movestart', template);

        // Unbind handlers that tracked the touch or mouse up till now.
        fn(data);
    }


    // Handlers that control what happens following a movestart

    function activeMousemove(e, data) {
        var timer  = data.timer;

        data.touch = e;
        data.timeStamp = e.timeStamp;
        timer.kick();
    }

    function activeMouseend(e, data) {
        var target = data.target;
        var event  = data.event;
        var timer  = data.timer;

        removeActiveMouse();

        endEvent(target, event, timer, function() {
            // Unbind the click suppressor, waiting until after mouseup
            // has been handled.
            setTimeout(function(){
                off(target, 'click', preventDefault);
            }, 0);
        });
    }

    function removeActiveMouse() {
        off(document, mouseevents.move, activeMousemove);
        off(document, mouseevents.end, activeMouseend);
    }

    function activeTouchmove(e, data) {
        var event = data.event;
        var timer = data.timer;
        var touch = changedTouch(e, event);

        if (!touch) { return; }

        // Stop the interface from gesturing
        e.preventDefault();

        event.targetTouches = e.targetTouches;
        data.touch = touch;
        data.timeStamp = e.timeStamp;

        timer.kick();
    }

    function activeTouchend(e, data) {
        var target = data.target;
        var event  = data.event;
        var timer  = data.timer;
        var touch  = identifiedTouch(e.changedTouches, event.identifier);

        // This isn't the touch you're looking for.
        if (!touch) { return; }

        removeActiveTouch(data);
        endEvent(target, event, timer);
    }

    function removeActiveTouch(data) {
        off(document, touchevents.move, data.activeTouchmove);
        off(document, touchevents.end, data.activeTouchend);
    }


    // Logic for triggering move and moveend events

    function updateEvent(event, touch, timeStamp) {
        var time = timeStamp - event.timeStamp;

        event.distX =  touch.pageX - event.startX;
        event.distY =  touch.pageY - event.startY;
        event.deltaX = touch.pageX - event.pageX;
        event.deltaY = touch.pageY - event.pageY;

        // Average the velocity of the last few events using a decay
        // curve to even out spurious jumps in values.
        event.velocityX = 0.3 * event.velocityX + 0.7 * event.deltaX / time;
        event.velocityY = 0.3 * event.velocityY + 0.7 * event.deltaY / time;
        event.pageX =  touch.pageX;
        event.pageY =  touch.pageY;
    }

    function endEvent(target, event, timer, fn) {
        timer.end(function(){
            trigger(target, 'moveend', event);
            return fn && fn();
        });
    }


    // Set up the DOM

    function movestart(e) {
        if (e.defaultPrevented) { return; }
        if (!e.moveEnabled) { return; }

        var event = {
            startX:        e.startX,
            startY:        e.startY,
            pageX:         e.pageX,
            pageY:         e.pageY,
            distX:         e.distX,
            distY:         e.distY,
            deltaX:        e.deltaX,
            deltaY:        e.deltaY,
            velocityX:     e.velocityX,
            velocityY:     e.velocityY,
            identifier:    e.identifier,
            targetTouches: e.targetTouches,
            finger:        e.finger
        };

        var data = {
            target:    e.target,
            event:     event,
            timer:     new Timer(update),
            touch:     undefined,
            timeStamp: e.timeStamp
        };

        function update(time) {
            updateEvent(event, data.touch, data.timeStamp);
            trigger(data.target, 'move', event);
        }

        if (e.identifier === undefined) {
            // We're dealing with a mouse event.
            // Stop clicks from propagating during a move
            on(e.target, 'click', preventDefault);
            on(document, mouseevents.move, activeMousemove, data);
            on(document, mouseevents.end, activeMouseend, data);
        }
        else {
            // In order to unbind correct handlers they have to be unique
            data.activeTouchmove = function(e, data) { activeTouchmove(e, data); };
            data.activeTouchend = function(e, data) { activeTouchend(e, data); };

            // We're dealing with a touch.
            on(document, touchevents.move, data.activeTouchmove, data);
            on(document, touchevents.end, data.activeTouchend, data);
        }
    }

    on(document, 'mousedown', mousedown);
    on(document, 'touchstart', touchstart);
    on(document, 'movestart', movestart);


    // jQuery special events
    //
    // jQuery event objects are copies of DOM event objects. They need
    // a little help copying the move properties across.

    if (!window.jQuery) { return; }

    var properties = ("startX startY pageX pageY distX distY deltaX deltaY velocityX velocityY").split(' ');

    function enableMove1(e) { e.enableMove(); }
    function enableMove2(e) { e.enableMove(); }
    function enableMove3(e) { e.enableMove(); }

    function add(handleObj) {
        var handler = handleObj.handler;

        handleObj.handler = function(e) {
            // Copy move properties across from originalEvent
            var i = properties.length;
            var property;

            while(i--) {
                property = properties[i];
                e[property] = e.originalEvent[property];
            }

            handler.apply(this, arguments);
        };
    }

    jQuery.event.special.movestart = {
        setup: function() {
            // Movestart must be enabled to allow other move events
            on(this, 'movestart', enableMove1);

            // Do listen to DOM events
            return false;
        },

        teardown: function() {
            off(this, 'movestart', enableMove1);
            return false;
        },

        add: add
    };

    jQuery.event.special.move = {
        setup: function() {
            on(this, 'movestart', enableMove2);
            return false;
        },

        teardown: function() {
            off(this, 'movestart', enableMove2);
            return false;
        },

        add: add
    };

    jQuery.event.special.moveend = {
        setup: function() {
            on(this, 'movestart', enableMove3);
            return false;
        },

        teardown: function() {
            off(this, 'movestart', enableMove3);
            return false;
        },

        add: add
    };
});