/*
 * Accordion 1.5 - jQuery menu widget
 *
 * Copyright (c) 2007 Jörn Zaefferer, Frank Marcia
 *
 * http://bassistance.de/jquery-plugins/jquery-plugin-accordion/
 *
 * Dual licensed under the MIT and GPL licenses:
 *   http://www.opensource.org/licenses/mit-license.php
 *   http://www.gnu.org/licenses/gpl.html
 *
 * Revision: $Id: jquery.accordion.js 2951 2007-08-28 07:21:13Z joern.zaefferer $
 *
 */

(function($) {

$.ui = $.ui || {}

$.ui.accordion = {};
$.extend($.ui.accordion, {
    defaults: {
        selectedClass: "selected",
        alwaysOpen: true,
        animated: 'slide',
        event: "click",
        header: "a"
    },
    animations: {
        slide: function(settings, additions) {
            settings = $.extend({
                easing: "swing",
                duration: 300
            }, settings, additions);
            if ( !settings.toHide.size() ) {
                settings.toShow.animate({height: "show"}, {
                    duration: settings.duration,
                    easing: settings.easing,
                    complete: settings.finished
                });
                return;
            }
            var hideHeight = settings.toHide.height(),
                showHeight = settings.toShow.height(),
                difference = showHeight / hideHeight;
            settings.toShow.css({ height: 0, overflow: 'hidden' }).show();
            settings.toHide.filter(":hidden").each(settings.finished).end().filter(":visible").animate({height:"hide"},{
                step: function(n){
                    settings.toShow.height(Math.ceil( (hideHeight - (n)) * difference ));
                },
                duration: settings.duration,
                easing: settings.easing,
                complete: settings.finished
            });
        },
        bounceslide: function(settings) {
            this.slide(settings, {
                easing: settings.down ? "bounceout" : "swing",
                duration: settings.down ? 1000 : 200
            });
        },
        easeslide: function(settings) {
            this.slide(settings, {
                easing: "easeinout",
                duration: 700
            })
        }
    }
});

$.fn.extend({
    nextUntil: function(expr) {
        var match = [];
    
        // We need to figure out which elements to push onto the array
        this.each(function(){
            // Traverse through the sibling nodes
            for( var i = this.nextSibling; i; i = i.nextSibling ) {
                // Make sure that we're only dealing with elements
                if ( i.nodeType != 1 ) continue;
    
                // If we find a match then we need to stop
                if ( $.filter( expr, [i] ).r.length ) break;
    
                // Otherwise, add it on to the stack
                match.push( i );
            }
        });
    
        return this.pushStack( match );
    },
    // the plugin method itself
    accordion: function(settings) {
        if ( !this.length )
            return this;
    
        // setup configuration
        settings = $.extend({}, $.ui.accordion.defaults, settings);
        
        if ( settings.navigation ) {
            var current = this.find("a").filter(function() { return this.href == location.href; });
            if ( current.length ) {
                if ( current.filter(settings.header).length ) {
                    settings.active = current;
                } else {
                    settings.active = current.parent().parent().prev();
                    current.addClass("current");
                }
            }
        }
        
        // calculate active if not specified, using the first header
        var container = this,
            headers = container.find(settings.header),
            active = findActive(settings.active),
            running = 0;

        if ( settings.fillSpace ) {
            var maxHeight = this.parent().height();
            headers.each(function() {
                maxHeight -= $(this).outerHeight();
            });
            var maxPadding = 0;
            headers.nextUntil(settings.header).each(function() {
                maxPadding = Math.max(maxPadding, $(this).innerHeight() - $(this).height());
            }).height(maxHeight - maxPadding);
        } else if ( settings.autoheight ) {
            var maxHeight = 0;
            headers.nextUntil(settings.header).each(function() {
                maxHeight = Math.max(maxHeight, $(this).height());
            }).height(maxHeight);
        }

        headers
            .not(active || "")
            .nextUntil(settings.header)
            .hide();
        active.parent().andSelf().addClass(settings.selectedClass);
        
        
        function findActive(selector) {
            return selector != undefined
                ? typeof selector == "number"
                    ? headers.filter(":eq(" + selector + ")")
                    : headers.not(headers.not(selector))
                : selector === false
                    ? $("<div>")
                    : headers.filter(":eq(0)");
        }
        
        function toggle(toShow, toHide, data, clickedActive, down) {
            var finished = function(cancel) {
                running = cancel ? 0 : --running;
                if ( running )
                    return;
                // trigger custom change event
                container.trigger("change", data);
            };
            
            // count elements to animate
            running = toHide.size() == 0 ? toShow.size() : toHide.size();
            
            if ( settings.animated ) {
                if ( !settings.alwaysOpen && clickedActive ) {
                    toShow.slideToggle(settings.animated);
                    finished(true);
                } else {
                    $.ui.accordion.animations[settings.animated]({
                        toShow: toShow,
                        toHide: toHide,
                        finished: finished,
                        down: down
                    });
                }
            } else {
                if ( !settings.alwaysOpen && clickedActive ) {
                    toShow.toggle();
                } else {
                    toHide.hide();
                    toShow.show();
                }
                finished(true);
            }
        }
        
        function clickHandler(event) {
            // called only when using activate(false) to close all parts programmatically
            if ( !event.target && !settings.alwaysOpen ) {
                active.toggleClass(settings.selectedClass);
                var toHide = active.nextUntil(settings.header);
                var toShow = active = $([]);
                toggle( toShow, toHide );
                return;
            }
            // get the click target
            var clicked = $(event.target);
            
            // due to the event delegation model, we have to check if one
            // of the parent elements is our actual header, and find that
            if ( clicked.parents(settings.header).length )
                while ( !clicked.is(settings.header) )
                    clicked = clicked.parent();
            
            var clickedActive = clicked[0] == active[0];
            
            // if animations are still active, or the active header is the target, ignore click
            if(running || (settings.alwaysOpen && clickedActive) || !clicked.is(settings.header))
                return;

            // switch classes
            active.parent().andSelf().toggleClass(settings.selectedClass);
            if ( !clickedActive ) {
                clicked.parent().andSelf().addClass(settings.selectedClass);
            }

            // find elements to show and hide
            var toShow = clicked.nextUntil(settings.header),
                toHide = active.nextUntil(settings.header),
                data = [clicked, active, toShow, toHide],
                down = headers.index( active[0] ) > headers.index( clicked[0] );
            
            active = clickedActive ? $([]) : clicked;
            toggle( toShow, toHide, data, clickedActive, down );

            return !toShow.length;
        };
        function activateHandler(event, index) {
            // IE manages to call activateHandler on normal clicks
            if ( arguments.length == 1 )
                return;
            // call clickHandler with custom event
            clickHandler({
                target: findActive(index)[0]
            });
        };

        return container
            .bind(settings.event, clickHandler)
            .bind("activate", activateHandler);
    },
    activate: function(index) {
        return this.trigger('activate', [index]);
    }
});

})(jQuery);