/*
 * jQuery UI Accordion 1.7.2
 *
 * Copyright (c) 2009 AUTHORS.txt (http://jqueryui.com/about)
 * Dual licensed under the MIT (MIT-LICENSE.txt)
 * and GPL (GPL-LICENSE.txt) licenses.
 *
 * http://docs.jquery.com/UI/Accordion
 *
 * Depends:
 *	ui.core.js
 */
(function($) {

$.widget("ui.accordion", {

    _init: function() {

        var o = this.options, self = this;
        this.running = 0;

        // if the user set the alwaysOpen option on init
        // then we need to set the collapsible option
        // if they set both on init, collapsible will take priority
        if (o.collapsible == $.ui.accordion.defaults.collapsible &&
            o.alwaysOpen != $.ui.accordion.defaults.alwaysOpen) {
            o.collapsible = !o.alwaysOpen;
        }

        if ( o.navigation ) {
            var current = this.element.find("a").filter(o.navigationFilter);
            if ( current.length ) {
                if ( current.filter(o.header).length ) {
                    this.active = current;
                } else {
                    this.active = current.parent().parent().prev();
                    current.addClass("ui-accordion-content-active");
                }
            }
        }

        this.element.addClass("ui-accordion ui-widget ui-helper-reset");

        // in lack of child-selectors in CSS we need to mark top-LIs in a UL-accordion for some IE-fix
        if (this.element[0].nodeName == "UL") {
            this.element.children("li").addClass("ui-accordion-li-fix");
        }

        this.headers = this.element.find(o.header).addClass("ui-accordion-header ui-helper-reset ui-state-default ui-corner-all")
            .bind("mouseenter.accordion", function(){ $(this).addClass('ui-state-hover'); })
            .bind("mouseleave.accordion", function(){ $(this).removeClass('ui-state-hover'); })
            .bind("focus.accordion", function(){ $(this).addClass('ui-state-focus'); })
            .bind("blur.accordion", function(){ $(this).removeClass('ui-state-focus'); });

        this.headers
            .next()
                .addClass("ui-accordion-content ui-helper-reset ui-widget-content ui-corner-bottom");

        this.active = this._findActive(this.active || o.active).toggleClass("ui-state-default").toggleClass("ui-state-active").toggleClass("ui-corner-all").toggleClass("ui-corner-top");
        this.active.next().addClass('ui-accordion-content-active');

        //Append icon elements
        $("<span/>").addClass("ui-icon " + o.icons.header).prependTo(this.headers);
        this.active.find(".ui-icon").toggleClass(o.icons.header).toggleClass(o.icons.headerSelected);

        // IE7-/Win - Extra vertical space in lists fixed
        if ($.browser.msie) {
            this.element.find('a').css('zoom', '1');
        }

        this.resize();

        //ARIA
        this.element.attr('role','tablist');

        this.headers
            .attr('role','tab')
            .bind('keydown', function(event) { return self._keydown(event); })
            .next()
            .attr('role','tabpanel');

        this.headers
            .not(this.active || "")
            .attr('aria-expanded','false')
            .attr("tabIndex", "-1")
            .next()
            .hide();

        // make sure at least one header is in the tab order
        if (!this.active.length) {
            this.headers.eq(0).attr('tabIndex','0');
        } else {
            this.active
                .attr('aria-expanded','true')
                .attr('tabIndex', '0');
        }

        // only need links in taborder for Safari
        if (!$.browser.safari)
            this.headers.find('a').attr('tabIndex','-1');

        if (o.event) {
            this.headers.bind((o.event) + ".accordion", function(event) { return self._clickHandler.call(self, event, this); });
        }

    },

    destroy: function() {
        var o = this.options;

        this.element
            .removeClass("ui-accordion ui-widget ui-helper-reset")
            .removeAttr("role")
            .unbind('.accordion')
            .removeData('accordion');

        this.headers
            .unbind(".accordion")
            .removeClass("ui-accordion-header ui-helper-reset ui-state-default ui-corner-all ui-state-active ui-corner-top")
            .removeAttr("role").removeAttr("aria-expanded").removeAttr("tabindex");

        this.headers.find("a").removeAttr("tabindex");
        this.headers.children(".ui-icon").remove();
        var contents = this.headers.next().css("display", "").removeAttr("role").removeClass("ui-helper-reset ui-widget-content ui-corner-bottom ui-accordion-content ui-accordion-content-active");
        if (o.autoHeight || o.fillHeight) {
            contents.css("height", "");
        }
    },

    _setData: function(key, value) {
        if(key == 'alwaysOpen') { key = 'collapsible'; value = !value; }
        $.widget.prototype._setData.apply(this, arguments);
    },

    _keydown: function(event) {

        var o = this.options, keyCode = $.ui.keyCode;

        if (o.disabled || event.altKey || event.ctrlKey)
            return;

        var length = this.headers.length;
        var currentIndex = this.headers.index(event.target);
        var toFocus = false;

        switch(event.keyCode) {
            case keyCode.RIGHT:
            case keyCode.DOWN:
                toFocus = this.headers[(currentIndex + 1) % length];
                break;
            case keyCode.LEFT:
            case keyCode.UP:
                toFocus = this.headers[(currentIndex - 1 + length) % length];
                break;
            case keyCode.SPACE:
            case keyCode.ENTER:
                return this._clickHandler({ target: event.target }, event.target);
        }

        if (toFocus) {
            $(event.target).attr('tabIndex','-1');
            $(toFocus).attr('tabIndex','0');
            toFocus.focus();
            return false;
        }

        return true;

    },

    resize: function() {

        var o = this.options, maxHeight;

        if (o.fillSpace) {

            if($.browser.msie) { var defOverflow = this.element.parent().css('overflow'); this.element.parent().css('overflow', 'hidden'); }
            maxHeight = this.element.parent().height();
            if($.browser.msie) { this.element.parent().css('overflow', defOverflow); }

            this.headers.each(function() {
                maxHeight -= $(this).outerHeight();
            });

            var maxPadding = 0;
            this.headers.next().each(function() {
                maxPadding = Math.max(maxPadding, $(this).innerHeight() - $(this).height());
            }).height(Math.max(0, maxHeight - maxPadding))
            .css('overflow', 'auto');

        } else if ( o.autoHeight ) {
            maxHeight = 0;
            this.headers.next().each(function() {
                maxHeight = Math.max(maxHeight, $(this).outerHeight());
            }).height(maxHeight);
        }

    },

    activate: function(index) {
        // call clickHandler with custom event
        var active = this._findActive(index)[0];
        this._clickHandler({ target: active }, active);
    },

    _findActive: function(selector) {
        return selector
            ? typeof selector == "number"
                ? this.headers.filter(":eq(" + selector + ")")
                : this.headers.not(this.headers.not(selector))
            : selector === false
                ? $([])
                : this.headers.filter(":eq(0)");
    },

    _clickHandler: function(event, target) {

        var o = this.options;
        if (o.disabled) return false;

        // called only when using activate(false) to close all parts programmatically
        if (!event.target && o.collapsible) {
            this.active.removeClass("ui-state-active ui-corner-top").addClass("ui-state-default ui-corner-all")
                .find(".ui-icon").removeClass(o.icons.headerSelected).addClass(o.icons.header);
            this.active.next().addClass('ui-accordion-content-active');
            var toHide = this.active.next(),
                data = {
                    options: o,
                    newHeader: $([]),
                    oldHeader: o.active,
                    newContent: $([]),
                    oldContent: toHide
                },
                toShow = (this.active = $([]));
            this._toggle(toShow, toHide, data);
            return false;
        }

        // get the click target
        var clicked = $(event.currentTarget || target);
        var clickedIsActive = clicked[0] == this.active[0];

        // if animations are still active, or the active header is the target, ignore click
        if (this.running || (!o.collapsible && clickedIsActive)) {
            return false;
        }

        // switch classes
        this.active.removeClass("ui-state-active ui-corner-top").addClass("ui-state-default ui-corner-all")
            .find(".ui-icon").removeClass(o.icons.headerSelected).addClass(o.icons.header);
        this.active.next().addClass('ui-accordion-content-active');
        if (!clickedIsActive) {
            clicked.removeClass("ui-state-default ui-corner-all").addClass("ui-state-active ui-corner-top")
                .find(".ui-icon").removeClass(o.icons.header).addClass(o.icons.headerSelected);
            clicked.next().addClass('ui-accordion-content-active');
        }

        // find elements to show and hide
        var toShow = clicked.next(),
            toHide = this.active.next(),
            data = {
                options: o,
                newHeader: clickedIsActive && o.collapsible ? $([]) : clicked,
                oldHeader: this.active,
                newContent: clickedIsActive && o.collapsible ? $([]) : toShow.find('> *'),
                oldContent: toHide.find('> *')
            },
            down = this.headers.index( this.active[0] ) > this.headers.index( clicked[0] );

        this.active = clickedIsActive ? $([]) : clicked;
        this._toggle(toShow, toHide, data, clickedIsActive, down);

        return false;

    },

    _toggle: function(toShow, toHide, data, clickedIsActive, down) {

        var o = this.options, self = this;

        this.toShow = toShow;
        this.toHide = toHide;
        this.data = data;

        var complete = function() { if(!self) return; return self._completed.apply(self, arguments); };

        // trigger changestart event
        this._trigger("changestart", null, this.data);

        // count elements to animate
        this.running = toHide.size() === 0 ? toShow.size() : toHide.size();

        if (o.animated) {

            var animOptions = {};

            if ( o.collapsible && clickedIsActive ) {
                animOptions = {
                    toShow: $([]),
                    toHide: toHide,
                    complete: complete,
                    down: down,
                    autoHeight: o.autoHeight || o.fillSpace
                };
            } else {
                animOptions = {
                    toShow: toShow,
                    toHide: toHide,
                    complete: complete,
                    down: down,
                    autoHeight: o.autoHeight || o.fillSpace
                };
            }

            if (!o.proxied) {
                o.proxied = o.animated;
            }

            if (!o.proxiedDuration) {
                o.proxiedDuration = o.duration;
            }

            o.animated = $.isFunction(o.proxied) ?
                o.proxied(animOptions) : o.proxied;

            o.duration = $.isFunction(o.proxiedDuration) ?
                o.proxiedDuration(animOptions) : o.proxiedDuration;

            var animations = $.ui.accordion.animations,
                duration = o.duration,
                easing = o.animated;

            if (!animations[easing]) {
                animations[easing] = function(options) {
                    this.slide(options, {
                        easing: easing,
                        duration: duration || 700
                    });
                };
            }

            animations[easing](animOptions);

        } else {

            if (o.collapsible && clickedIsActive) {
                toShow.toggle();
            } else {
                toHide.hide();
                toShow.show();
            }

            complete(true);

        }

        toHide.prev().attr('aria-expanded','false').attr("tabIndex", "-1").blur();
        toShow.prev().attr('aria-expanded','true').attr("tabIndex", "0").focus();

    },

    _completed: function(cancel) {

        var o = this.options;

        this.running = cancel ? 0 : --this.running;
        if (this.running) return;

        if (o.clearStyle) {
            this.toShow.add(this.toHide).css({
                height: "",
                overflow: ""
            });
        }

        this._trigger('change', null, this.data);
    }

});


$.extend($.ui.accordion, {
    version: "1.7.2",
    defaults: {
        active: null,
        alwaysOpen: true, //deprecated, use collapsible
        animated: 'slide',
        autoHeight: true,
        clearStyle: false,
        collapsible: false,
        event: "click",
        fillSpace: false,
        header: "> li > :first-child,> :not(li):even",
        icons: {
            header: "ui-icon-triangle-1-e",
            headerSelected: "ui-icon-triangle-1-s"
        },
        navigation: false,
        navigationFilter: function() {
            return this.href.toLowerCase() == location.href.toLowerCase();
        }
    },
    animations: {
        slide: function(options, additions) {
            options = $.extend({
                easing: "swing",
                duration: 300
            }, options, additions);
            if ( !options.toHide.size() ) {
                options.toShow.animate({height: "show"}, options);
                return;
            }
            if ( !options.toShow.size() ) {
                options.toHide.animate({height: "hide"}, options);
                return;
            }
            var overflow = options.toShow.css('overflow'),
                percentDone,
                showProps = {},
                hideProps = {},
                fxAttrs = [ "height", "paddingTop", "paddingBottom" ],
                originalWidth;
            // fix width before calculating height of hidden element
            var s = options.toShow;
            originalWidth = s[0].style.width;
            s.width( parseInt(s.parent().width(),10) - parseInt(s.css("paddingLeft"),10) - parseInt(s.css("paddingRight"),10) - (parseInt(s.css("borderLeftWidth"),10) || 0) - (parseInt(s.css("borderRightWidth"),10) || 0) );

            $.each(fxAttrs, function(i, prop) {
                hideProps[prop] = 'hide';

                var parts = ('' + $.css(options.toShow[0], prop)).match(/^([\d+-.]+)(.*)$/);
                showProps[prop] = {
                    value: parts[1],
                    unit: parts[2] || 'px'
                };
            });
            options.toShow.css({ height: 0, overflow: 'hidden' }).show();
            options.toHide.filter(":hidden").each(options.complete).end().filter(":visible").animate(hideProps,{
                step: function(now, settings) {
                    // only calculate the percent when animating height
                    // IE gets very inconsistent results when animating elements
                    // with small values, which is common for padding
                    if (settings.prop == 'height') {
                        percentDone = (settings.now - settings.start) / (settings.end - settings.start);
                    }

                    options.toShow[0].style[settings.prop] =
                        (percentDone * showProps[settings.prop].value) + showProps[settings.prop].unit;
                },
                duration: options.duration,
                easing: options.easing,
                complete: function() {
                    if ( !options.autoHeight ) {
                        options.toShow.css("height", "");
                    }
                    options.toShow.css("width", originalWidth);
                    options.toShow.css({overflow: overflow});
                    options.complete();
                }
            });
        },
        bounceslide: function(options) {
            this.slide(options, {
                easing: options.down ? "easeOutBounce" : "swing",
                duration: options.down ? 1000 : 200
            });
        },
        easeslide: function(options) {
            this.slide(options, {
                easing: "easeinout",
                duration: 700
            });
        }
    }
});

})(jQuery);