/* can the bb generic.overlay be used? */
/* it looks to be an amalgam of bb.Lighterbox and bb.overlay */
/* it's close but lacks a number of items */

bb.Lighterbox = Class.create({
    initialize: function(args) {
        var self = this;
        
        this.backgroundNode = $('overlay-background');
        if (!this.backgroundNode) {
            this.backgroundNode = new Element('div', {"class":"overlay-background"});
            this.backgroundNode.setStyle({display: "none"});
            $(document.body).insert(this.backgroundNode);
        }
        this.setContainerNode($(document.body));
        if (args) {
            if (args.foregroundNode) {
                this.setForegroundNode(args.foregroundNode);
            }
            if (args.openButtonNode) {
                this.setOpenButtonNode(args.openButtonNode);
            }
            if (args.closeButtonNode) {
                this.setCloseButtonNode(args.closeButtonNode);
            }
            if (args.containerNode) {
                this.setContainerNode(args.containerNode);
            }
            if (args.contentNode) {
                this.setContentNode(args.contentNode);
            }
            if (args.lockPosition) {
                this.lockPosition = true;
            }
        }
    },

    setOpenButtonNode: function(ele) {
        var self = this;
        if (Object.isElement(ele)) {
            this.openButtonNode = ele;
            this.openButtonNode.observe("click", function(evt){
                self.show();
                evt.preventDefault();
            });
        }
    },
    
    setCloseButtonNode: function(ele) {
        var self = this;
        if (Object.isElement(ele)) {
            this.closeButtonNode = ele;
            this.closeButtonNode.observe("click", function(evt){
                self.hide();
                evt.preventDefault();
            });
        }
    },
    
    setForegroundNode: function(ele) {
        var self = this;
        if (Object.isElement(ele)) {
            this.foregroundNode = ele;
        }
    },
    
    setContainerNode: function(ele) {
        var self = this;
        if (Object.isElement(ele)) {
            this.containerNode = ele;
        }
    },
    
    setContentNode: function(ele) {
        var self = this;
        if (Object.isElement(ele)) {
            this.contentNode = ele;
        }
    },

    show: function() {
        var self = this;
        this.scaleBackgroundToPage();
        this.backgroundNode.show();
        this.scrollHandler = function() {
            self.centerForeground();
        };
        if (!this.lockPosition) { // bb
            Event.observe(window, 'resize', self.scrollHandler);
            Event.observe(window, 'scroll', self.scrollHandler);
        }
        this.foregroundNode.show();
        this.centerForeground();
    },
    
    hide: function() {
        var self = this;
        this.foregroundNode.hide();
        this.backgroundNode.hide();
    },

    redraw: function() {
        var self = this;
        this.centerForeground();
    },
    
    scaleBackgroundToPage: function() {
        if (this.backgroundNode && this.containerNode) {
            var docsize = this.containerNode.getDimensions();
            this.backgroundNode.setStyle({
                height: docsize.height+'px',
                width: docsize.width+'px'
            });
        }
    },
    
    centerForeground: function() {
        var self = this;
        if (this.foregroundNode) {
            //var contentDimensions = this.foregroundNode.getDimensions();

            var containerDimensions = this.foregroundNode.getDimensions();
            var contentNodeDimensions   = this.contentNode.getDimensions();
            var contentDimensions = {};
            contentDimensions.width = (containerDimensions.width > contentNodeDimensions.width) ? containerDimensions.width : contentNodeDimensions.width;
            contentDimensions.height = (containerDimensions.height > contentNodeDimensions.height) ? containerDimensions.height : contentNodeDimensions.height;

            this.foregroundNode.style.position = "absolute";
            var windowScrollOffsets = document.viewport.getScrollOffsets();
            var windowDimensions = document.viewport.getDimensions();
            var yPosition;
            if (windowDimensions.height < contentDimensions.height) {
                yPosition = 0;
            } else {
                yPosition = (windowDimensions.height/2) - (contentDimensions.height/2) + (windowScrollOffsets.top);
            }
            this.foregroundNode.style.top = yPosition + "px";
            var xPosition = (windowDimensions.width/2) - (contentDimensions.width/2) + (windowScrollOffsets.left);
            this.foregroundNode.style.left = xPosition + "px";
            if (windowDimensions.height < contentDimensions.height) {
                this.foregroundNode.scrollTo();
                Event.stopObserving(window, 'scroll', self.scrollHandler);
            }
        }
    }
});

bb.overlay = function() {
    var lighterbox = null;
    var containerNode = null;
    var contentNode = null;
    var isVisible = false;
    var options = {};
    return {

        launch : function(args) {
            var self = this;
            if (!isVisible) {
                if (!containerNode) {
                    containerNode = new Element('div', {id: "overlay-container", style:"display:none"});
                    $(document.body).insert(containerNode);
                }
                if (lighterbox === null) {
                    lighterbox = new bb.Lighterbox({containerNode : $$('.page_wrapper')[0]});
                }
                Object.extend(options, args || {});
                containerNode.setStyle(options.cssStyle);
                while (containerNode.childNodes[0]) {
                    containerNode.removeChild(containerNode.childNodes[0]);
                }
                contentNode = options.content;
                containerNode.appendChild(contentNode);
                lighterbox.setForegroundNode(containerNode);
                lighterbox.setContentNode(contentNode);
                if (options.closeButtonNode && Object.isElement(options.closeButtonNode)) {
                    options.closeButtonNode.observe("click", function(evt){
                        self.hide();
                        evt.preventDefault();
                    });
                }
                lighterbox.show();
                isVisible = true;
            }
        },
        
        hide: function() {
            var self = this;
            if (lighterbox !== null) {
                lighterbox.hide();
                isVisible = false;
                this.restoreSelects();
            }
        },
        
        restoreSelects: function() {
            var selectNodes = $$('select.overlay-hidden');
            selectNodes.each(function(node){
                node.removeClassName("overlay-hidden");
            });
        },

        redraw: function() {
            var self = this;
            if (lighterbox !== null) {
                lighterbox.redraw();
            }
        }

    };
}();

bb.overlay.launchPopover = function(args) {
    var popoverContentElement = args.content;
    var headlineSelectors = args.headlineSelectors;
    var cssStyle = args.cssStyle;
    var lockPosition = args.lockPosition;

    if (Object.isElement(popoverContentElement)) {
        var selectNodes = $$('select');
        selectNodes.each(function(node){
            if (!(node.style.display === 'none' || node.style.display === 'hidden')) {
                node.addClassName("overlay-hidden");
            }
        });
        popoverContentElement.style.display = "block";

        var overlayArgs = {
            content : popoverContentElement
        };
        if (cssStyle) {
            overlayArgs.cssStyle = cssStyle;
        }
        if (lockPosition) {
            overlayArgs.lockPosition = lockPosition;
        }
        bb.overlay.launch(overlayArgs);

        var selectNodes = popoverContentElement.select('select.overlay-hidden');
        selectNodes.each(function(node){
            node.removeClassName("overlay-hidden");
        });
        // bb.sIFR.replaceAll();
        bb.page.replaceSelects();
    }

    if (headlineSelectors) {
        headlineSelectors.each(function(node){
            popoverContentElement.select(node).each(function(ele){
                ele.addClassName("replace");
            });
        });
        bb.sIFR.replaceAll();
    }
};