'use strict';

/*@
Ox.Element <function> Basic UI element object
    # Usage --------------------------------------------------------------------
    ([options[, self]]) -> <object:Ox.JQueryElement> Element object
    # Arguments ----------------------------------------------------------------
    options <object|string> Options of the element, or just `element` option
        # Properties
        element <string> Tagname or CSS selector
        tooltip <string|function> Tooltip title, or a function that returns one
            (e) -> <string> tooltip title
            e <object> mouse event
    self    <object> Shared private variable
    # Events -------------------------------------------------------------------
    anyclick    <event> anyclick
        Fires on mouseup, but not on any subsequent mouseup within 250 ms (this
        is useful if one wants to listen for singleclicks, but not doubleclicks,
        since it will fire immediately, and won't fire again in case of a
        doubleclick)
        *           <*> original event properties
    doubleclick <event> doubleclick
        Fires on the second mousedown within 250 ms (this is useful if one wants
        to listen for both singleclicks and doubleclicks, since it will not
        trigger a singleclick event)
        *           <*> original event properties
    drag        <event> drag
        Fires on mousemove after dragstart, stops firing on mouseup
        clientDX    <number> horizontal drag delta in px
        clientDY    <number> vertical drag delta in px
        *           <*> original event properties
    dragend     <event> dragpause
        Fires on mouseup after dragstart
        clientDX    <number> horizontal drag delta in px
        clientDY    <number> vertical drag delta in px
        *           <*> original event properties
    dragenter   <event> dragenter
        Fires when entering an element during drag (this fires on the element
        being dragged -- the target element is the event's target property)
        clientDX    <number> horizontal drag delta in px
        clientDY    <number> vertical drag delta in px
        *           <*> original event properties
    dragleave   <event> dragleave
        Fires when leaving an element during drag (this fires on the element
        being dragged -- the target element is the event's target property)
        clientDX    <number> horizontal drag delta in px
        clientDY    <number> vertical drag delta in px
        *           <*> original event properties
    dragpause   <event> dragpause
        Fires once when the mouse doesn't move for 250 ms during drag (this is
        useful in order to execute operations that are too expensive to be
        attached to the drag event)
        clientDX    <number> horizontal drag delta in px
        clientDY    <number> vertical drag delta in px
        *           <*> original event properties
    mousedown   <event> mousedown
        Fires on mousedown (this is useful if one wants to listen for
        singleclicks, but not doubleclicks or drag events, and wants the event
        to fire as early as possible)
        *           <*> original event properties
    dragstart   <event> dragstart
        Fires when the mouse is down for 250 ms
        *           <*> original event properties
    mouserepeat <event> mouserepeat
        Fires every 50 ms after the mouse was down for 250 ms, stops firing on
        mouseleave or mouseup (this fires like a key that is being pressed and
        held, and is useful for buttons like scrollbars arrows that need to
        react to both clicking and holding)
    singleclick <event> singleclick
        Fires 250 ms after mouseup, if there was no subsequent mousedown (this
        is useful if one wants to listen for both singleclicks and doubleclicks,
        since it will not fire for doubleclicks)
        *           <*> original event properties
@*/

Ox.Element = function(options, self) {

    // create private object
    self = self || {};
    // create defaults and options objects
    self.defaults = {};
    self.options = options || {};
    // allow for Ox.TestElement('<tagname>')
    // or Ox.TestElement('cssSelector')
    if (Ox.isString(self.options)) {
        self.options = {
            element: self.options
        };
    }
    // create event handler
    // (this can be passed as part of self)
    if (!self.$eventHandler) {
        self.$eventHandler = $('<div>');
    }
    // array of callbacks bound to any event
    self.eventCallbacks = [];
    // stack of callbacks bound to option updates
    self.updateCallbacks = [];

    // create public object
    var that = new Ox.JQueryElement($(self.options.element || '<div>'))
            .addClass('OxElement')
            .mousedown(mousedown);

    setTooltip();

    function bind(event, callback, once) {
        self.$eventHandler[
            once ? 'one' : 'on'
        ]('ox_' + event, function(event, data) {
            call(callback, data, event);
        });
    }

    function call(callback, data, event) {
        event.ox_type = event.type.replace(/^ox_/, '');
        callback.call(that, data || {}, event);
    }

    function mousedown(e) {
        /*
        better mouse events
        mousedown:
            trigger mousedown
        within 250 msec:
            mouseup: trigger anyclick
            mouseup + mousedown: trigger doubleclick
        after 250 msec:
            mouseup + no mousedown within 250 msec: trigger singleclick
            no mouseup within 250 msec:
                trigger mouserepeat every 50 msec
                trigger dragstart
                    mousemove: trigger drag
                    no mousemove for 250 msec:
                        trigger dragpause
                    mouseup: trigger dragend
        "anyclick" is not called "click" since this would collide with the click
        events of some widgets
        */
        var clientX, clientY,
            dragTimeout = 0,
            mouseInterval = 0;
        if (!self._mouseTimeout) {
            // first mousedown
            that.triggerEvent('mousedown', e);
            self._drag = false;
            self._mouseup = false;
            self._mouseTimeout = setTimeout(function() {
                // 250 ms later, no subsequent click
                self._mouseTimeout = 0;
                if (self._mouseup) {
                    // mouse went up, trigger singleclick
                    that.triggerEvent('singleclick', e);
                } else {
                    // mouse is still down, trigger mouserepeat
                    // every 50 ms until mouseleave or mouseup
                    mouserepeat();
                    mouseInterval = setInterval(mouserepeat, 50);
                    that.one('mouseleave', function() {
                        clearInterval(mouseInterval);
                    });
                    // trigger dragstart, set up drag events
                    that.triggerEvent('dragstart', e);
                    $('*').on({
                        mouseenter: dragenter,
                        mouseleave: dragleave
                    });
                    clientX = e.clientX;
                    clientY = e.clientY;
                    Ox.UI.$window
                        .off('mouseup', mouseup)
                        .mousemove(mousemove)
                        .one('mouseup', function(e) {
                            // stop checking for mouserepeat
                            clearInterval(mouseInterval);
                            // stop checking for dragpause
                            clearTimeout(dragTimeout);
                            // stop checking for drag
                            Ox.UI.$window.off('mousemove', mousemove);
                            // stop checking for dragenter and dragleave
                            $('*').off({
                                mouseenter: dragenter,
                                mouseleave: dragleave
                            });
                            // trigger dragend
                            that.triggerEvent('dragend', extend(e));
                        });
                    self._drag = true;
                }
            }, 250);
        } else {
            // second mousedown within 250 ms, trigger doubleclick
            clearTimeout(self._mouseTimeout);
            self._mouseTimeout = 0;
            that.triggerEvent('doubleclick', e);
        }
        Ox.UI.$window.one('mouseup', mouseup);
        function dragenter(e) {
            that.triggerEvent('dragenter', extend(e));
        }
        function dragleave(e) {
            that.triggerEvent('dragleave', extend(e));
        }
        function extend(e) {
            return Ox.extend({
                clientDX: e.clientX - clientX,
                clientDY: e.clientY - clientY
            }, e);
        }
        function mousemove(e) {
            e = extend(e);
            clearTimeout(dragTimeout);
            dragTimeout = setTimeout(function() {
                // mouse did not move for 250 ms, trigger dragpause
                that.triggerEvent('dragpause', e);
            }, 250);
            that.triggerEvent('drag', e);
        }
        function mouserepeat(e) {
            that.triggerEvent('mouserepeat', e);
        }
        function mouseup(e) {
            if (!self._mouseup && !self._drag) {
                // mouse went up for the first time, trigger anyclick
                that.triggerEvent('anyclick', e);
                self._mouseup = true;
            }
        }
    }

    function mouseenter(e) {
        that.$tooltip.show(e);
    }

    function mouseleave(e) {
        that.$tooltip.hide();
    }

    function mousemove(e) {
        that.$tooltip.options({
            title: self.options.tooltip(e)
        }).show(e);
    }

    // FIXME: in other widgets, use this,
    // rather than some self.$tooltip that
    // will not get garbage collected
    function setTooltip() {
        if (self.options.tooltip) {
            if (Ox.isString(self.options.tooltip)) {
                that.$tooltip = Ox.Tooltip({
                    title: self.options.tooltip
                });
                that.on({
                    mouseenter: mouseenter
                }).off({
                    mousemove: mousemove
                });
            } else {
                that.$tooltip = Ox.Tooltip({
                    animate: false
                });
                that.on({
                    mousemove: mousemove
                }).off({
                    mouseenter: mouseenter
                });
            }
            that.on({
                mouseleave: mouseleave
            });
        } else {
            if (that.$tooltip) {
                that.$tooltip.remove();
                that.off({
                    mouseenter: mouseenter,
                    mousemove: mousemove,
                    mouseleave: mouseleave
                });
            }
        }
    }

    function update(key, value) {
        // update is called whenever an option is modified or added
        Ox.loop(self.updateCallbacks.length - 1, -1, -1, function(i) {
            self.updateCallbacks[i](key, value) === false && Ox.Break();
        });
    }

    /*@
    bindEvent <function> Binds a function to an event
        (callback)               -> <o> This element
        (event, callback)        -> <o> This element
        ({event: callback, ...}) -> <o> This element
        callback <f> Callback function
            data <o> event data (key/value pairs)
        event <s> Event name
            Event names can be namespaced, like <code>'click.foo'</code>
    @*/
    that.bindEvent = function() {
        if (Ox.typeOf(arguments[0]) == 'function') {
            self.eventCallbacks.push(arguments[0]);
        } else {
            Ox.forEach(Ox.makeObject(arguments), function(callback, event) {
                bind(event, callback);
            });
        }
        return that;
    };

    /*@
    bindEventOnce <function> Binds a function to an event, once
        (event, callback)        -> <obj> This element object
        ({event: callback, ...}) -> <obj> This element object
        callback <f> Callback function
            data <o> event data (key/value pairs)
        event <s> Event name
            Event names can be namespaced, like <code>'click.foo'</code>
    @*/
    that.bindEventOnce = function() {
        Ox.forEach(Ox.makeObject(arguments), function(callback, event) {
            bind(event, callback, true);
        });
        return that;
    };

    /*@
    bindKeyboard <f> bind keyboard
        () -> <o> object
    @*/
    that.bindKeyboard = function() {
        Ox.Keyboard.bind(that.oxid);
        return that;
    };

    /*@
    defaults <function> Gets or sets the default options for an element object
    ({key: value, ...}) -> <obj> This element object
    key     <str> The name of the default option
    value   <val> The value of the default option
    @*/
    that.defaults = function() {
        var ret;
        if (arguments.length == 0) {
            ret = self.defaults;
        } else if (Ox.isString(arguments[0])) {
            ret = self.defaults[arguments[0]];
        } else {
            self.defaults = arguments[0];
            self.options = Ox.clone(self.defaults);
            ret = that;
        }
        return ret;
    };

    /*@
    gainFocus <function> Makes an element object gain focus
    () -> <obj> This element object
    @*/
    that.gainFocus = function() {
        Ox.Focus.focus(that.oxid);
        return that;
    };

    /*@
    hasFocus <function> Returns true if an element object has focus
    () -> <boolean> True if the element has focus
    @*/
    that.hasFocus = function() {
        return Ox.Focus.focused() == that.oxid;
    };

    /*@
    loseFocus <function> Makes an element object lose focus
    () -> <object> This element object
    @*/
    that.loseFocus = function() {
        Ox.Focus.blur(that.oxid);
        return that;
    };

    /*@
    options <function> Gets or sets the options of an element object
        # Usage
        ()                  -> <obj> all options
        (key)               -> <any> the value of option[key]
        (key, value)        -> <obj> this element
            Sets options[key] to value and calls update(key, value)
            if the key/value pair was added or modified
        ({key: value, ...}) -> <obj> this element
            Sets multiple options and calls update(key, value)
            for every key/value pair that was added or modified
        # Arguments
        key     <str> the name of the option
        value   <val> the value of the option
    @*/
    that.options = function() {
        return Ox.getset(self.options, arguments, update, that);
    };

    /*@
    removeElement <function> Removes an element object and its event handler
        () -> <obj> This element
    @*/
    that.remove = function(remove) {
        remove !== false && that.find('.OxElement').each(function() {
            var oxid = $(this).data('oxid'),
                element = Ox.UI.elements[oxid];
            element && element.remove(false);
        });
        Ox.Focus.remove(that.oxid);
        Ox.Keyboard.unbind(that.oxid);
        delete self.$eventHandler;
        delete Ox.UI.elements[that.oxid];
        that.$tooltip && that.$tooltip.remove();
        remove !== false && that.$element.remove();
        return that;
    };

    /*@
    setElement <f> set $element
        ($element) -> <o> This element
    @*/
    that.setElement = function($element) {
        $element.addClass('OxElement').data({oxid: that.oxid});
        that.$element.replaceWith($element);
        that.$element = $element;
        that[0] = that.$element[0];
        return that;
    };

    /*@
    toggleOption <f> Toggle boolean option(s)
        (key[, key[, ...]]) -> <o> This element
    @*/
    that.toggleOption = function() {
        var options = {};
        Ox.toArray(arguments).forEach(function(key) {
            options[key] == !self.options[key];
        });
        that.options(options);
        return that;
    };

    /*@
    triggerEvent <function> Triggers an event
        (event) -> <object> This element object
        (event, data) -> <object> This element object
        ({event: data, ...}) -> <object> This element object
        event <string> Event name
        data <object> Event data (key/value pairs)
    @*/
    that.triggerEvent = function() {
        Ox.forEach(Ox.makeObject(arguments), function(data, event) {
            var type = 'ox_' + event;
            if ([
                'mousedown', 'mouserepeat', 'anyclick', 'singleclick', 'doubleclick',
                'dragstart', 'drag', 'dragenter', 'dragleave', 'dragpause', 'dragend',
                'draganddropstart', 'draganddrop', 'draganddropenter', 'draganddropleave', 'draganddropend',
                'playing', 'position', 'progress', 'request'
            ].indexOf(event) == -1) {
                if (!/^pandora_/.test(event)) {
                    Ox.Log('EVENT', that.oxid, self.options.id, 'trigger', event, data);
                }
            }
            // it is necessary to check if self.$eventHandler exists,
            // since, for example, when removing the element on click,
            // singleclick will fire after the removal of the event handler
            self.$eventHandler && self.$eventHandler.trigger(type, data);
            self.eventCallbacks.forEach(function(callback) {
                call(callback, data, {type: type});
            });
        });
        return that;
    };

    /*@
    unbindEvent <function> Unbinds all callbacks from an event
        To unbind a specific handler, use namespaced events, like
        <code>bindEvent('click.foo', callback)</code>, and then
        <code>unbindEvent('click.foo')</code>.
        () -> <object> This element
            Unbinds all callbacks from all events
        (callback) -> <o> This element
            Unbinds one callback from all events
        (event) -> <o> This element
            Unbinds all callbacks from one event
        (event, callback) -> <o> This element
            Unbinds one callback from one event
        ({event: callback}, ...) -> <o> This element
            Unbinds multiple callbacks from multiple events
        event <string> Event name
    @*/
    that.unbindEvent = function() {
        var callback = arguments[0];
        if (arguments.length == 0) {
            self.eventCallbacks = [];
            self.$eventHandler.off();
        } else if (Ox.typeOf(callback) == 'function') {
            self.eventCallbacks = self.eventCallbacks.filter(function(fn) {
                return fn !== callback;
            });
        } else {
            Ox.makeObject(arguments).forEach(function(callback, event) {
                self.$eventHandler.off('ox_' + event, callback);
            });
        }
        return that;
    };

    /*@
    unbindKeyboard <f> unbind keyboard
        () -> <o> object
    @*/
    that.unbindKeyboard = function() {
        Ox.Keyboard.unbind(that.oxid);
        return that;
    };

    /*@
    update <f> Adds one or more handlers for options updates
    (callback) -> <o> that
    (key, callback) -> <o> that
    ({key: callback, ...}) -> <o> that
    @*/
    that.update = function() {
        var callbacks;
        if (Ox.typeOf(arguments[0]) == 'function') {
            self.updateCallbacks.push(arguments[0]);
        } else {
            callbacks = Ox.makeObject(arguments);
            self.updateCallbacks.push(function(key) {
                if (callbacks[key]) {
                    return callbacks[key]();
                }
            });
        }
        return that;
    };

    /*@
    value <f> Shortcut to get or set self.options.value
    @*/
    that.value = function() {
        return that.options(
            arguments.length == 0 ? 'value' : {value: arguments[0]}
        );
    };

    that.update({
        tooltip: setTooltip
    });

    return that;

};