// **************************************************************
//                       core dom
// **************************************************************
var Core = {};

// W3C DOM 2 Events model
if (document.addEventListener) {
    Core.addEventListener = function(target, type, listener) {
        target.addEventListener(type, listener, false);
    };

    Core.removeEventListener = function(target, type, listener) {
        target.removeEventListener(type, listener, false);
    };

    Core.preventDefault = function(event) {
        event.preventDefault();
    };

    Core.stopPropagation = function(event) {
        event.stopPropagation();
    };
}
// Internet Explorer Events model
else if (document.attachEvent) {
    Core.addEventListener = function(target, type, listener) {
        // prevent adding the same listener twice, since DOM 2 Events ignores
        // duplicates like this
        if (Core._findListener(target, type, listener) != -1) return;

        // listener2 calls listener as a method of target in one of two ways,
        // depending on what this version of IE supports, and passes it the global
        // event object as an argument
        var listener2 = function() {
            var event = window.event;

            if (Function.prototype.call) {
                listener.call(target, event);
            }
            else {
                target._currentListener = listener;
                target._currentListener(event)
                target._currentListener = null;
            }
        };

        // add listener2 using IE's attachEvent method
        target.attachEvent("on" + type, listener2);

        // create an object describing this listener so we can clean it up later
        var listenerRecord =
    {
        target: target,
        type: type,
        listener: listener,
        listener2: listener2
    };

        // get a reference to the window object containing target
        var targetDocument = target.document || target;
        var targetWindow = targetDocument.parentWindow;

        // create a unique ID for this listener
        var listenerId = "l" + Core._listenerCounter++;

        // store a record of this listener in the window object
        if (!targetWindow._allListeners) targetWindow._allListeners = {};
        targetWindow._allListeners[listenerId] = listenerRecord;

        // store this listener's ID in target
        if (!target._listeners) target._listeners = [];
        target._listeners[target._listeners.length] = listenerId;

        // set up Core._removeAllListeners to clean up all listeners on unload
        if (!targetWindow._unloadListenerAdded) {
            targetWindow._unloadListenerAdded = true;
            targetWindow.attachEvent("onunload", Core._removeAllListeners);
        }
    };

    Core.removeEventListener = function(target, type, listener) {
        // find out if the listener was actually added to target
        var listenerIndex = Core._findListener(target, type, listener);
        if (listenerIndex == -1) return;

        // get a reference to the window object containing target
        var targetDocument = target.document || target;
        var targetWindow = targetDocument.parentWindow;

        // obtain the record of the listener from the window object
        var listenerId = target._listeners[listenerIndex];
        var listenerRecord = targetWindow._allListeners[listenerId];

        // remove the listener, and remove its ID from target
        target.detachEvent("on" + type, listenerRecord.listener2);
        target._listeners.splice(listenerIndex, 1);

        // remove the record of the listener from the window object
        delete targetWindow._allListeners[listenerId];
    };

    Core.preventDefault = function(event) {
        event.returnValue = false;
    };

    Core.stopPropagation = function(event) {
        event.cancelBubble = true;
    };

    Core._findListener = function(target, type, listener) {
        // get the array of listener IDs added to target
        var listeners = target._listeners;
        if (!listeners) return -1;

        // get a reference to the window object containing target
        var targetDocument = target.document || target;
        var targetWindow = targetDocument.parentWindow;

        // searching backward (to speed up onunload processing), find the listener
        for (var i = listeners.length - 1; i >= 0; i--) {
            // get the listener's ID from target
            var listenerId = listeners[i];

            // get the record of the listener from the window object
            var listenerRecord = targetWindow._allListeners[listenerId];

            // compare type and listener with the retrieved record
            if (listenerRecord.type == type && listenerRecord.listener == listener) {
                return i;
            }
        }
        return -1;
    };

    Core._removeAllListeners = function() {
        var targetWindow = this;

        for (id in targetWindow._allListeners) {
            var listenerRecord = targetWindow._allListeners[id];
            listenerRecord.target.detachEvent(
          "on" + listenerRecord.type, listenerRecord.listener2);
            delete targetWindow._allListeners[id];
        }
    };

    Core._listenerCounter = 0;
}

Core.addClass = function(target, theClass) {
    if (!Core.hasClass(target, theClass)) {
        if (target.className == "") {
            target.className = theClass;
        }
        else {
            target.className += " " + theClass;
        }
    }
};

Core.getElementsByClass = function(theClass) {
    var elementArray = [];

    if (document.all) {
        elementArray = document.all;
    }
    else {
        elementArray = document.getElementsByTagName("*");
    }

    var matchedArray = [];
    var pattern = new RegExp("(^| )" + theClass + "( |$)");

    for (var i = 0; i < elementArray.length; i++) {
        if (pattern.test(elementArray[i].className)) {
            matchedArray[matchedArray.length] = elementArray[i];
        }
    }

    return matchedArray;
};

Core.hasClass = function(target, theClass) {
    var pattern = new RegExp("(^| )" + theClass + "( |$)");

    if (pattern.test(target.className)) {
        return true;
    }

    return false;
};

Core.removeClass = function(target, theClass) {
    var pattern = new RegExp("(^| )" + theClass + "( |$)");

    target.className = target.className.replace(pattern, "$1");
    target.className = target.className.replace(/ $/, "");
};

Core.getComputedStyle = function(element, styleProperty) {
    var computedStyle = null;

    if (typeof element.currentStyle != "undefined") {
        computedStyle = element.currentStyle;
    }
    else {
        computedStyle = document.defaultView.getComputedStyle(element, null);
    }

    return computedStyle[styleProperty];
};

Core.start = function(runnable) {
    Core.addEventListener(window, "load", runnable.init);
};

// **************************************************************
//                       accordion
// **************************************************************
var Accordion =
{
    init: function() {
        Accordion.frameRate = 25;
        Accordion.duration = 0.5;

        var accordions = Core.getElementsByClass("accordion");

        for (var i = 0; i < accordions.length; i++) {
            var folds = accordions[i].childNodes;
            for (var j = 0; j < folds.length; j++) {
                if (folds[j].nodeType == 1) {
                    var accordionContent = document.createElement("div");
                    accordionContent.className = "accordionContent";

                    for (var k = 0; k < folds[j].childNodes.length; k++) {
                        if (folds[j].childNodes[k].nodeName.toLowerCase() != "h2") {
                            accordionContent.appendChild(folds[j].childNodes[k]);
                            k--;
                        }
                    }

                    folds[j].appendChild(accordionContent);
                    folds[j]._accordionContent = accordionContent;

                    Accordion.collapse(folds[j]);

                    var foldLinks = folds[j].getElementsByTagName("a");
                    var foldTitleLink = foldLinks[0];
                    Core.addEventListener(foldTitleLink, "click", Accordion.clickListener);

                    for (var k = 1; k < foldLinks.length; k++) {
                        Core.addEventListener(foldLinks[k], "focus", Accordion.focusListener);
                    }
                }
            }

            var showSessionLinks = Core.getElementsByClass("showSession");
            for (var l = 0; l < showSessionLinks.length; l++) {
                var showSessionLink = showSessionLinks[l];
                Core.addEventListener(showSessionLink, "click", Accordion.clickListener2);
            }

            if (location.hash.length > 1) {
                var activeFold = document.getElementById(location.hash.substring(1));
                if (activeFold && activeFold.parentNode == accordions[i]) {
                    Accordion.expand(activeFold);
                }
            }
            var accordionContainer = document.getElementById("accordionContainer");
            if (accordionContainer) {
                accordionContainer.className = "show";
                var firstFold = document.getElementById("session0");
                if (firstFold && firstFold.parentNode == accordions[i]) {
                    Accordion.expand(firstFold);
                } 
            }
        }
    },

    collapse: function(fold) {
        Core.removeClass(fold, "expanded");
        Core.addClass(fold, "collapsed");
    },

    collapseAll: function(accordion) {
        var folds = accordion.childNodes;
        for (var i = 0; i < folds.length; i++) {
            if (folds[i].nodeType == 1) {
                Accordion.collapse(folds[i]);
            }
        }
    },

    expand: function(fold) {
        Accordion.collapseAll(fold.parentNode);
        Core.removeClass(fold, "collapsed");
        Core.addClass(fold, "expanded");
    },


    clickListener: function(event) {
        var fold = this.parentNode.parentNode;
        if (Core.hasClass(fold, "collapsed")) {
            Accordion.expand(fold);
        }
        //    else
        //    {
        //      Accordion.collapse(fold);
        //    }  
        Core.preventDefault(event);
    },

    clickListener2: function(event) {
        var theFold = document.getElementById(this.href.split("#")[1]);
        if (Core.hasClass(theFold, "collapsed")) {
            Accordion.expand(theFold);
        }
        Core.preventDefault(event);
    },

    focusListener: function(event) {
        var element = this;
        while (element.parentNode) {
            if (element.parentNode.className == "accordion") {
                Accordion.expand(element);
                return;
            }
            element = element.parentNode;
        }
    }

};

Core.start(Accordion);