var brand = {};

/**
 * Brand extensions of generic.flash
 */
generic.flash.playerversion = (generic.env.isMac) ? "10.0.0" : generic.flash.playerversion;
// generic.flash.cart.add Brand-specific feature(s): 
// - Send result.data.trans_data & result.data.ac_results back to flash (vs. just ac_results)
generic.flash.cart.add = function (args) {
    var options = Object.extend( {
        movieName : "",
        callback: "",
        skus: [],
        quantity: 1
    }, args);
    if ( options.skus.length < 1 ) {
        return null;
    }
    if ( !generic.checkout || !generic.checkout.cart ) {
        return null;
    }
    //console.log("args passed from flash: "+Object.toJSON(options));
    var cartObj = generic.checkout.cart;
    var catId = options.catId;
    if (catId) {
        var match = catId.split("CAT");
        catId = (match ? match[1] : catId);
    }
    var callbackFn = function(options, responseObj) {
        if ( options.movieName && (options.movieName.length > 1) && $(options.movieName) ) {
            var flashObject = $(options.movieName);
            var externalCallback = options.callback;
            if (externalCallback && typeof flashObject[externalCallback] === "function" ) {
                // send result.data.trans_data & result.data.ac_results
                var responseData = responseObj.getData();
                if (responseData) {
                    flashObject[externalCallback]({trans_data: responseData.trans_data, ac_results: responseData.ac_results});
                } else if (responseObj.getError()) {
                    //console.log("generic.flash.cart.add callback: sending error/messages "+Object.toJSON(responseObj.getMessages()) );
                    externalCallback(responseObj.getMessages());
                }
            } else {
                console.log("generic.flash.cart.add callback: failure on callback argument = ",flashObject[externalCallback]);
            }
        }
    }.curry(options);
    cartObj.updateCart({
        params: {
            skus: options.skus,            
            INCREMENT: 1,
            CAT_BASE_ID: catId
        },
        onSuccess: callbackFn,
        onFailure: callbackFn
    });         
};


/**
 * Takes a hex value and returns equivalent rgb value
 * @param {String} hex  
 * @memberOf brand
 * @example
    generic.hexToRGB("#FFFDF4");
 */
brand.hexToRGB = function(hex) {
    var rgb = [];
    if(!hex) return [0, 0, 0];
    var h = cutHex(hex);
    rgb.push( parseInt( h.substring(0,2),16) );
    rgb.push( parseInt( h.substring(2,4),16) );
    rgb.push( parseInt( h.substring(4,6),16) ); 
    //console.log("hexToRGB: "+hex+" = "+rgb[0]+" "+rgb[1]+" "+rgb[2]);
    return rgb;
    
    function cutHex(h) {return (h.charAt(0)=="#") ? h.substring(1,7):h} 
}

/**
 * brand.updateProperties.apply
 * Needed for cases where Object.extend doesn't return what's expected
 * @memberOf brand
 * @example
    brand.updateProperties.apply(this, [args]);
 */
brand.updateProperties = function(obj) {   
    if (!obj) return;
    for (prop in obj) {  
        this[prop] = obj[prop];
    }  
}


/**
 * brand.tabs
 * Tabbed Container
 * Use this class IF you have created the html manually
 * and you just want to wrap it with the class object.
 * @memberOf brand
 */
brand.tabs = Class.create(Control.Tabs,
{
    // default Control.Tab options
    options: {
        activeClassName: 'tab-active',
        setClassOnContainer: true
    },
       
    initialize: function($super, containerId, args) {
        var options = this.options;
        Object.extend(options, args || {});
        Object.extend(this, args || {});

        if (args.scrollbar) this.initScrolling();        
        $super(containerId, options);
        if (args.useImageHeaders) this.initHeaders();
    },
  
    setActiveTab: function($super, link) {
        if (link.id === this.activeLink.id) return;
        if (this.beforeShow) this.beforeShow(link);
        if (this.scrollbar && this.tabContainer) {
            this.tabContainer.removeClassName(this.scrollbar.enabledClass); // start w/ scrollbar hidden
        }
        if (this.imgHeaders) {
            var linkImg = this.imgHeaders[link.id];
            if (linkImg) linkImg.changeSrc("on");
            var activeLinkImg = this.imgHeaders[this.activeLink.id];
            if (activeLinkImg) activeLinkImg.changeSrc("off");
        }
        
        $super(link);
        this.resetScrolling();
    },

    onContentRefresh: function() {
        this.resetScrolling();
    },

    initHeaders: function() {
        var imgs = {}
        this.links.each(function(link) {
            var imgNode = link.select('img')[0];
            if (imgNode) imgs[link.id] = new brand.img(imgNode, ["on", "off"]);
        });
        this.imgHeaders = imgs;
    },
    
    initScrolling: function() {
        var contentNode = this.scrollbar.contentNode;
        var handleId = this.scrollbar.handleId;
        var trackId = this.scrollbar.trackId;
        if (!contentNode || !handleId || !trackId) return;
        
        // scroll the element vertically based on its width and the slider maximum value
        var scroll= function(value) {
            contentNode.scrollTop = Math.round(value / scrollbar.maximum * (contentNode.scrollHeight - contentNode.offsetHeight) );
        }
        
        var scrollbar = new Control.Slider(handleId, trackId, {
            axis: 'vertical',
            onSlide: scroll,
            onChange: scroll
        });
        
        this.scrollbarObj = scrollbar;
        this.scrollbarNode = this.scrollbar.containerNode;
    },
    
    resetScrolling: function() {
        var scrollbarObj = this.scrollbarObj;
        if (!this.scrollbar || !scrollbarObj) return;
        var contentNode = this.scrollbar.contentNode;
        var scrollbarNode = this.scrollbar.containerNode;
        // disable/enable scrolling depending on overflow/height of scrollable content
        scrollbarObj.setValue(0);
        if (contentNode.scrollHeight <= contentNode.offsetHeight) {
            scrollbarNode.hide();
            //scrollbarObj.setDisabled();
        } else {
            //scrollbarObj.setEnabled();
            scrollbarNode.show();
            //this.tabContainer.addClassName(this.scrollbar.enabledClass);
        }
    },
    
    updateTab: function(tabId, html) {
        var containerNode = $(tabId);
        if ( containerNode ) {
            containerNode.update ( html );
        }
    }

});

/**
 * brand.bottomFixed
 * simulate fixed bottom position
 * @memberOf brand
 */ 
brand.bottomFixed = Class.create({  
    node: null,  // node: DOM element to position 
    minTop: 0, // minTop: Number minimum pixels for node.style.top 
    isLoaded: false,

    initialize: function(args) {
        if (!args.node) return false;
        this.node = args.node;
        this.s = this.node.style;
        var observeResize = (args.observeResize == false ? false : true);
        if (args.bottom) {
            this.fromBottom = args.bottom;
        } else {
            this.fromBottom = parseInt(this.node.getStyle("bottom"), 10);
        }
        if (isNaN(this.fromBottom)) { 
            console.log("brand.bottomFixed: bottom is NaN");
            return;
        }        
        if (args.minTop) {
            this.minTop = args.minTop;
            this.hasMinTop = true;
        } else {
            this.hasMinTop = false;
        }
        
        // initial top position
        if (args.startingTopPosition == 0 || args.startingTopPosition) {
            this.s.top = args.startingTopPosition + "px";
        } else {
            this.position();
            this.s.bottom = '';
            this.s.visibility = "visible";
        }
        
        // set scroll events
        var self = this;
        Event.observe(window, 'scroll', function() {
            self.onScroll();
        });
        if (observeResize) {
            Event.observe(window, 'resize', function() {
                self.onScroll();
            });
        }

        this.isLoaded = true;
    },
    position: function() {  
        var h = window.pageYOffset ||
        document.documentElement.scrollTop;
        h = (h ? h : 0);
        var shiftY = ((h + document.documentElement.clientHeight) - (this.node.offsetHeight + this.fromBottom));
        if (isNaN(shiftY)) return;
        if (this.currentY != shiftY) {  
            var changeBy = shiftY;      
            if (this.hasMinTop && (changeBy <= this.minTop)) {
                changeBy = this.minTop;
            }
            this.currentY = changeBy;
            this.s.top = (changeBy + 'px');  
        }   
    },
    onScroll: function() {   
        this.position();
    }
});