var generic = generic || {};
var bb = bb || {};
bb.productView = bb.productView || {}
generic.announcement = generic.announcement || {};


var launchQuickshop = function(args) {
    var view = bb.productView.quickshop({
        productData: args.productData
    });
};

bb.productView.renderWorksWellWith = function(args) {
    var wwwContainerNode = $$("div.related ul")[0];
    if (wwwContainerNode) {
        args.tableData.each(function(productData){
            // TO DO: CoreMetrics QV and VC override for url because it is being used as a WW
            // addMppTag(productData.PRODUCT_ID, productData.PROD_RGN_NAME, productData.PARENT_CAT_ID, "ww");
            // productData.url = productData.url; // ??

            var price_string = bb.productView.formatPriceRange(productData);
            productData.price_range_string = price_string;

            var wwwItemWrapperNode = new Element("div", {"class":"related-item-wrapper"});
            generic.templatefactory.get({path: "/templates/products/works-well-thumb.tmpl"}).evaluateCallback({
                object: productData,
                callback: function(html) {
                    wwwItemWrapperNode.insert(html);
                    wwwContainerNode.insert(wwwItemWrapperNode);
                    
                    var calloutContainer = wwwItemWrapperNode.select('.works-well-callout')[0];
                    if (calloutContainer) {
                        bb.productView.setCallout(calloutContainer, productData);
                    }
                    
                    var quickshopLinkNode = wwwItemWrapperNode.select(".quickshop-link")[0];
                    bb.productView.initQuickshopLink(quickshopLinkNode, productData);
                }
            });
        });
    }                            
}

bb.productView.initQuickshopLink = function(node, productData) {
    if (!Object.isElement(node)) { return; }
    node.observe("click", function(evt){
        evt.preventDefault();
        launchQuickshop({productData: productData});
    });
};

bb.productView.addButton = function (args) {
    var skuBaseId = args.skuBaseId;
    var progressNode = args.progressNode;
    var addButtonNode = args.addButtonNode;
    var descriptionContainerNode = args.descriptionContainerNode;
    var isIncrementMode = args.isIncrementMode;
    var isQuickshop = args.isQuickshop;
    var qtyToAdd = args.qtyToAdd || 1;
    var itemType = args.itemType || 'cart';
    var skuData  = args.skuData;
    var action = args.action || 'add';
    var enabled  = false;
    if (args.skuData && args.skuData.SKU_BASE_ID) {
        skuBaseId = args.skuData.SKU_BASE_ID;
    }
    else if (args.skuBaseId) {
        skuBaseId = args.skuBaseId;
    }
    else {
        return null;
    }
    var _initEvent = function() {
        if (addButtonNode) {
            Event.observe(addButtonNode, 'click', function(evt) {
                _onClick();
                evt.preventDefault();
            });
        }
    };
    var _onClick = function() {
        var item_params = {};
        if (progressNode) {
            progressNode.style.display = "block";
            addButtonNode.style.display = "none";
        }
        var revertButton = function() {
            if (progressNode) {
                progressNode.style.display = "none";
                addButtonNode.style.display = "block";
            }            
        };
        // Send individual parameters based on type
        if (itemType == 'favorites') {
            item_params = {
                'skus': [skuBaseId],
                'itemType': 'favorites',
                'action': action
            }
        } else {
            item_params = {
                skus: [skuBaseId],
                itemType: 'cart',
                INCREMENT: isIncrementMode ? 1 : 0,
                QTY: qtyToAdd
            }
        }
        generic.checkout.cart.updateCart({
            params: item_params,
            onSuccess: function(r) {
                console.log("cart "+action+" success");
                console.log(r.getData());
                var resultData = r.getData();
                revertButton();
                addButtonNode.fire("cartButton:success", resultData);
            },
            onFailure: function(r) {
                revertButton();                
            }
        });
    };
    return {
        setSkuBaseId: function (id) {
            skuBaseId = id;
        },
        getSkuBaseId: function (id) {
            return skuBaseId;
        },        
        setIncrementMode: function(isIncrement) {
            isIncrementMode = isIncrement;
        },
        setQty: function(qty) {
            qtyToAdd = qty;
        },
        getItemType: function() {
            return itemType;
        },
        setSkuData: function (data) {
            skuData = data;
            this.setSkuBaseId(data.SKU_BASE_ID);
        },
        setShoppable: function() {
            if (!skuData) {
                return null;
            }
            var btnImgNode = addButtonNode.select("img")[0];
            var btnOnImg   = '/images/btns/add-to-bag.gif';
            var btnOffImg  = '/images/btns/add-to-bag-off.gif';

            if (bb.productView.isSkuShoppable(skuData)) {
                this.enable();
                btnImgNode.src = btnOnImg;
            } else {
                this.disable();
                btnImgNode.src = btnOffImg;

                // tos indicator
                var tosNode = descriptionContainerNode.select("div.tos-message")[0];
                if (tosNode) {
                    bb.productView.TosMessage.init({domNode: tosNode, addButtonNode: addButtonNode, skuData: skuData, isQuickshop: isQuickshop});
                }
            }
        },
        enable: function() {
            if (!enabled) {
                _initEvent(this);
                enabled = true;
            }
        },
        disable: function() {
            if (enabled) {
                addButtonNode.stopObserving('click');
                Event.observe(addButtonNode, 'click', function(evt) {
                    evt.preventDefault();
                });
                enabled = false;
            }
         }
    };
};

bb.productView.cartOverlay = {
    cartviewContainer : null,
    cartviewLink : null,
    getMessage : function(cartMethod) {
        if (!cartMethod) {
            return null;
        }
        var rbLanguageHash = generic.rb('language');
        var msgs = {
            "add": rbLanguageHash.get("The_following_added_to_cart_txt")
        };
        if (msgs[cartMethod]) {
            return msgs[cartMethod];
        } else {
            return null;
        }
    },
    launch : function(cartResponseObj) {
        
        //lets launch the announcement basket popup if need be
        if ( generic.announcement.basket_announcement_on ) {
            generic.announcement.basket(); 
        }
        
        if (typeof cartResponseObj.getItem !== "function") {
            return;
        }
        var cartItem = cartResponseObj.getItem();        
        cartItem.totalCartItems = cartResponseObj.getCartItemsCount();
        cartItem.subtotal = cartResponseObj.getCartSubtotal();
        
        if (cartItem.subtotal.toFixed) { // check the function is available
            cartItem.subtotal   = cartItem.subtotal.toFixed(2);
            cartItem.UNIT_PRICE = cartItem.UNIT_PRICE.toFixed(2);
        }
        
        var cartMethod = cartResponseObj.getMethod();
        cartItem.cartMessage = this.getMessage(cartMethod);

        offsetFromTop = document.documentElement.scrollTop + document.body.scrollTop;
        
        var leftOffsetValue = cartviewLink.getWidth() - cartviewContainer.getWidth() + 27;
        
        if (offsetFromTop < 30) {
            offsetFromTop = 30;
        }
        else {
            offsetFromTop = offsetFromTop - 29;
        }
                    
        cartviewContainer.clonePosition(cartviewLink, {offsetTop: offsetFromTop, offsetLeft: leftOffsetValue, setWidth: false, setHeight: false});

        if (cartviewContainer) {
            var templateArgs = {
                path : "/templates/cart-popup-overlay.tmpl"
            };
            if (cartItem.product.shaded) {
                templateArgs.query = {
                    SKU_PATH : cartItem.product.sku.PATH
                };
                templateArgs.forceReload = true;
            }
            generic.templatefactory.get(templateArgs).evaluateCallback({
                object: cartItem,
                callback : function(html) {
                    // override generic.overlay.launch
                    cartviewContainer.down('#cart-popup-content').innerHTML = html;
                    this._displaySwatch();
                    setTimeout('bb.productView.cartOverlay.hide()', 15000);
                    cartviewContainer.show();
                }.bind(this)
            });
        }
    },
    _displaySwatch : function() {
        var content = $('cart-popup-content');
        var swatchHolder = $('cart-popup-content').down('.swatches');
        if (!swatchHolder) { return; }

        var hexText = swatchHolder.down('li').innerHTML;
        var hexVals = hexText.strip().split(',');

        var listItemNode = new Element("li");
        var aNode = new Element("a");
        var swatchNode = bb.page.getSwatchNode('#'+hexVals[0]);
        aNode.update(swatchNode);
        listItemNode.update(aNode);
        swatchNode.style.backgroundColor = "#"+hexVals[0];

        swatchHolder.innerHTML = '';
        swatchHolder.insert(listItemNode);
    },
    hide : function() {
        if (cartviewContainer) {
            cartviewContainer.hide();
        }
    },
    init : function() {
        var self = this;
        var headerEle = $('header');
        
        cartviewContainer = headerEle.select("div#shopping_bag_overlay")[0];
        cartviewLink = headerEle.select("a#view_shopping_bag")[0];
        if (cartviewLink && cartviewContainer) {
            
            //Paul moved this to when the cart overlay is launched so we can move down the page as needed so overlay always in view
            //var leftOffsetValue = cartviewLink.getWidth() - cartviewContainer.getWidth() + 35;            
            //cartviewContainer.clonePosition(cartviewLink, {offsetTop: 30, offsetLeft: leftOffsetValue, setWidth: false, setHeight: false});
            
            cartviewLink.observe("click", function() {
               document.location.href = '/checkout/viewcart.tmpl';
            });
            var closeLink = cartviewContainer.select("a.utilitynav-popup-close")[0];
            closeLink.observe("click", function(evt) {
                bb.productView.cartOverlay.hide();
            });
            document.observe("cart:updated", function(cartEvt) {
                var cartResponseObj = cartEvt.memo;
                bb.productView.cartOverlay.launch(cartResponseObj);
            });
        }
    }
};

bb.productView.filterTable = function (args) {
    var initFilterChangeEvent = function(selectNode){
        var self = this;
        selectNode.observe('change', function (evt) {
            // evt.target.fire("table:filter", evt.target);
            that.filter(evt.target);
        });
    };
    var filterNodes = new Hash();
    var sortNode = null;
    var tableData;
    var that = {};
    /**
     * This method builds the HTML select menu node.
     * @methodOf bb.filter
     * @param {Node} args.filterMenuContainerNode the node where the filter menus will be inserted
     */
    that.createMenus = function(args) {
        var self = this;
        var options = Object.extend({
            filterMenuContainerNode: null,
            tableData: null,
            menuMetaData: null,
            menuWidth: 130 }, args || {});
        for (var i in options) {
            if (options[i] === null) {
                return null;
            }
        }
        tableData = options.tableData;
        var getMenuElements = function(){
            var menus = [];
            options.menuMetaData.filters.each(function(filterObj){
                var slct = initFilterMenu({
                    field: filterObj.field,
                    label: filterObj.label
                });
                if (slct) {
                    menus.push({label: "" + filterObj.label + bb.rb.product.get("Filter_by") + ':', node: slct});
                }
            });
            return menus;
        };
        var initFilterMenu = function(menuArgs){
            //args.tableData args.field args.label args.menuWidth
            var fields = menuArgs.field.split('::');
            var menuOptions = getMenuOptions(fields);
            if (menuOptions) {
                return buildFilterMenu({
                    menuOptions: menuOptions,
                    fieldName: menuArgs.field,
                    menuLabel: menuArgs.label });
            } else {
                return null;
            }
        };
        var buildFilterMenu = function(buildArgs) {
            var slct = new Element("select", {
                'class' : "width_" + options.menuWidth,
                id : buildArgs.fieldName,
                name : buildArgs.fieldName
            });
            var opt = new Element("option", { value : "" });
            opt.insert( bb.rb.product.get("All") );
            slct.insert(opt);
            buildArgs.menuOptions.each( function(val) {
                opt = new Element("option", {
                    value : val
                })
                opt.insert(val);
                slct.insert(opt);
            });
            return slct;
        };
        var getMenuOptions = function(fields){
            var menuOptions = [];
            for (var i = 0, len = fields.length; i<len; i++) {
                var fieldName = fields[i];
                options.tableData.each(function(record){
                    var menuVal = record[fieldName];
                    if (menuVal) {
                        menuOptions.push(menuVal);
                    }
                });
                menuOptions = $A(menuOptions).uniq();
                if (menuOptions.length < 2) {
                    return null;
                }
                return menuOptions;
            }
        };

        var filterMenuObjects = getMenuElements();

        if (filterMenuObjects.length > 0) {
            filterMenuObjects.each(function(record){
                var lbl = new Element('label', {'class':'filterby'});
                lbl.insert(record.label);
                options.filterMenuContainerNode.insert(lbl);
                var slct = record.node;
                options.filterMenuContainerNode.insert(slct);
                self.addFilterNode(slct, slct.name);
            });
        }
    }; // createMenus
    that.addFilterNode = function (selectNode, field) {
      // if (this.validateSelectNode(selectNode)) {
        filterNodes.set(field, selectNode);
        // }
        initFilterChangeEvent(selectNode);
    };

    /**
     * This function registers a select menu as a Sort control for the table.
     * @param {Node} selectNode the select node
     * @param {string} field the name of the field on which this menu will filter.
     * The field must be the name of a top-level property of a tableData item. For example,
     * a table displaying Product items might sort on a field Product.PROD_RGN_NAME.
     * The parameter passing in this case would be "PROD_RGN_NAME".
     * @methodOf productPage.FilterTable
     */
    that.addSortNode = function (selectNode, field) {
        sortNode = selectNode;
        initFilterChangeEvent(selectNode);
    };
    
    /**
     * This method creates an HTML select menu node, add options, and insert the select menu
     * in the DOM.
     * @param {Node} args.containerNode the node into which the sort menu will be inserted
     * @param {number} args.menuWidth width in pixels of a custom menu to be rendered
     * the select menu takes this number and assigns the node a class of that width.
     * @param {string} args.selectNodeID the ID that will be given to the the select menu node
     * @param {Array} args.sortMenuArray an array of JS Hash objects. These objects define the options that
     * are inserted into the menu - the format must be { field: *string*, label: *string* } where
     * field is the sorting property and label is the text displayed in the menu.
     * @methodOf productPage.FilterTable
     * @returns {Node} the select menu
     */
    that.buildSortMenu = function(args) {
        if (!args.containerNode) {
            return;
        }
        options = Object.extend({
            menuWidth: 100,
            selectNodeID: "sort-menu"
        }, args || {});
        var slct = new Element("select", {
            'class': "width_" + options.menuWidth,
            id: options.selectNodeID,
            name: options.selectNodeID });
        options.sortMenuArray.each(function(sortMenuRecord){
            slct.insert(new Element("option", {
                value: sortMenuRecord.field,
                selected: "selected" }).insert(sortMenuRecord.label));
        });
        options.containerNode.insert(slct);
        return slct;
    };
    
    
    
    /**
     * This function reads the values from filtering and sorting menus, puts the
     * requested items into an array and then passes that array to the build function.
     * It is called when the user changes a filter or sort criteria menu.
     * @methodOf productPage.FilterTable
     */
    that.filter = function() {
        var self = this;
        var filterFunctions = function(field){
            return function(valueToFind, valueToSearch){
                return valueToSearch === valueToFind;
            };
        };
        //
        // iterate through the data and filter out non-matching items
        tableData.each(function(item){
            item.display = false;
            //
            // the keys of the filter_node hash are the names of the fields
            // we are going to filter
            filterNodes.keys().each(function(menuName){
                //
                // menuName can contain multiple field names separated by '::'
                var fields = menuName.split('::');
                var menuValue = $F(filterNodes.get(menuName));
                for (var i=0, len=fields.length; i<len; i++) {
                    var field = fields[i];
                    //
                    // if the data fails the test and if the menu option value
                    // is a non-empty string, do not display the item
                    if (menuValue.length < 1 || filterFunctions(field)(menuValue, item[field])) {
                        item.display = true;
                        break;
                    } else {
                        item.display = false;
                    }
                }
                if (!item.display) {
                    throw $break;
                }
            });
        });
        // Sort data. The menu option value is the name of a product field.
        if (sortNode) {
            var sortCriteria = $F(sortNode);
            if (tableData[0].hasOwnProperty(sortCriteria)) {
                tableData = tableData.sortBy(function(p){
                    return p[sortCriteria];
                });
            }
        }
        this.build(tableData);
    };
    
    return that;
};


/**
	* This method returns either the formatted price of a product or the range
	* of prices for the product.
	* @return {String} formatted string with pre- & post-tax prices
    * @param {Object} sku JSON-formatted SKU data. Must include formattedTaxedPrice and formattedPrice properties.
    * @methodOf bb.productView
*/
bb.productView.formatPriceRange = function(prod) {
    var price_string = '';
    if (generic.productData.validateSkusArray(prod.skus)) {
        var prod_skus_length = prod.skus.length;
        var uniquePricesCount = prod.skus.pluck('PRICE').uniq().length;
        if (uniquePricesCount > 1)  {
            var sortedSkus = prod.skus.sortBy(function(s){return s.PRICE;});
            price_string = sortedSkus[0].formattedPrice;
            price_string += " - " + sortedSkus[prod_skus_length-1].formattedTaxedPrice;
        } else {
            price_string = prod.skus[0].formattedTaxedPrice;
        }
        return price_string;
    } else {
        return '';
    }
};

bb.productView.setCallout = function(calloutNode,prod) {
	if (prod.PROD_RGN_SUBHEADING) {
		calloutNode.update(prod.PROD_RGN_SUBHEADING);
	} else {
		calloutNode.update("&nbsp;");
	}          
}

bb.productView.TosMessage = {
    domNode : null,
    skuData : null,
    isQuickshop : null,
    init : function(args) {
        this.domNode = args.domNode;
        this.addButtonNode = args.addButtonNode;
        this.skuData = args.skuData;
        this.isQuickshop = args.isQuickshop;
        if (Object.isElement(this.domNode)) {
            if (this.skuData) {
                this.toggleDisplay(this.skuData);
            }
            var self = this;
            document.observe("select:sku", function(evt) {
                self.toggleDisplay(evt.memo);
            });
        }
    },

    toggleDisplay : function(skuData) {
        if (Object.isElement(this.domNode)) {
            if (bb.productView.isTos(skuData)) {
                //Only show the button on a single product page.
                if (!this.isQuickshop) {
                    this.domNode.update(bb.productView.tempOutOfStockBtn);
                    this.initCSBISLink( $('btn-tos'), {
                        url: '/templates/popups/bis_notification.tmpl?SKU_BASE_ID=' + skuData.SKU_BASE_ID,
                        elementId: 'bis_notification'                 
                    });
                }else{
                    this.domNode.update(bb.productView.tempOutOfStock);
                }
            }
            else if (bb.productView.isSoldOut(skuData)) {
                this.domNode.update(bb.productView.soldOut);
            }
            else if (bb.productView.isComingSoon(skuData)) {
                //Only show the button on a single product page.
                if (!this.isQuickshop) {
                    this.domNode.update(bb.productView.comingSoonBtn);
                    this.initCSBISLink( $('btn-cs'), {
                        url: '/templates/popups/cs_notification.tmpl?CAT_BASE_ID=' + CAT_BASE_ID + '&PROD_BASE_ID=' + PROD_BASE_ID + '&SKU_BASE_ID=' + skuData.SKU_BASE_ID,
                        elementId: 'cs_notification'                 
                    });
                }else{
                    this.domNode.update(bb.productView.comingSoon);
                }
            }
            else {
                this.domNode.update('');
            }

            if (this.domNode.innerHTML) {
                this.domNode.style.display = "block";
                if ( this.addButtonNode ) {
                    this.addButtonNode.hide();
                } else {
                    $$('.btn-add-to-bag')[0].style.display = "none";
                }
            } else {
                this.domNode.style.display = "none";
                if ( this.addButtonNode ) {
                    this.addButtonNode.show();
                } else {
                    $$('.btn-add-to-bag')[0].style.display = "block";
                }
            }
        }
    },

    /**
    	* This method is used to initiate the Coming Soon and Back In Stock 
      * popups.
      * @requires param{node} node to attach event to.
    	* @requires param{args} url and elementId passed.
     	* @methodOf bb.productView.TosMessage
    */
    initCSBISLink : function(node, args) {

        if (!Object.isElement(node)) { return; }

        var self = this;
        node.observe("click", function(evt){
            evt.preventDefault();
            self.cSBISPopover(args);
        });

    },
    
    /**
    	* This method is used to display the back in stock and coming soon popovers for the product pages.
    	* generic.templatefactory is first called to grab the popup template and
    	* then on callback, generic.overlay.launch is used to set up the overlay 
    	* with the html that is returned.
    	* @requires param{args} url and elementId passed.
     	* @methodOf bb.productView.TosMessage
    */
    cSBISPopover : function(args) {
    
        generic.templatefactory.get({path: args.url, forceReload: true}).evaluateCallback({
            callback: function(html) {
    
                var wrapperNode = new Element("div", {"class":"csbis-wrapper popup"});
                $(document.body).insert(wrapperNode);
                wrapperNode.insert(html);
    
                bb.overlay.launchPopover({content: wrapperNode});
    
                // wire up close link
                var closeButtonNode = wrapperNode.select("a.close-link")[0];
                closeButtonNode.observe("click", function(closeClickEvent) {
                    closeClickEvent.preventDefault();
                    wrapperNode.remove();
                    bb.overlay.hide();
                });
                
                if ( $(args.elementId) ) {            
                    $(args.elementId).observe('submit', function (evt) {
                        evt.preventDefault();
                        var elm = evt.element();
                        value = elm.EMAIL_ADDRESS.value;
                        r = /\w{1,}[@][\w\-]{1,}([.]([\w\-]{1,})){1,3}$/.test(value);
                        if (r) {
                
                            $$(".csbis-wrapper .add-progress")[0].style.display = "block";
                            $$(".csbis-wrapper .add-button")[0].style.display = "none";            
                
                            var params = elm.serialize(true);
                        
                            var callback = function(html) {
                                var wrapperNode = $$('.csbis-wrapper')[0];
                                wrapperNode.update(html);
    
                                // wire up close link
                                var closeButtonNode = wrapperNode.select("a.close-link")[0];
                                closeButtonNode.observe("click", function(closeClickEvent) {
                                    closeClickEvent.preventDefault();
                                    wrapperNode.remove();
                                    bb.overlay.hide();
                                });
                            }
    
                            var id = generic.jsonrpc.fetch({
                                "method" : 'generic',
                                "params" : [params],
                                "onSuccess": function(jsonRpcResponse){  
                                     generic.templatefactory.get({path: elm.action, forceReload: true}).evaluateCallback({
                                        callback: function(html){
                                            callback(html)
                                        }
                                    });
                                },
                                "onFailure": function(jsonRpcResponse){
                                    generic.templatefactory.get({path: '/templates/popups/notification_error.tmpl', forceReload: true}).evaluateCallback({
                                        callback: function(html){
                                            callback(html)
                                        }
                                    });
                                }
                            });
    
                        } else {  
                         
                            generic.showErrors([{
                                text: bb.productView.email_format
                            }], $$(".csbis-wrapper ul.error_messages")[0]);
                        }
                    });
                } 
            }
        });
    }
};

//# INVENTORY STATUS CODES and shoppability
//# 1 = Active (shoppable)
//# 2 = Temporarily Out Of Stock (shoppable)
//# 3 = Coming Soon (shoppable or not, depending on brand)
//# 4 = Do Not Display (not displayed, except on dev)
//# 5 = Inactive (not shoppable, remove from cart)
//# 6 = Promotional (not shoppable, but not removed from cart)
//# 7 = Sold Out (not shoppable, remove from cart)
//
//# DISPLAY STATUS CODES
//# 0 = not displayable, corresponds to INVENTORY STATUS 5
//# 1 = displayable, corresponds to INVENTORY STATUS 1, 2, 3, 6, 7
//# 2 = displayable on dev only, corresponds to INVENTORY STATUS 4

/*
* tests a sku obj to see if it is out of stock.
* checks the INVENTORY_STATUS field.
*/
bb.productView.isTos = function(sku) {
        return (sku && sku.INVENTORY_STATUS === 2);
};
/*
* tests a sku obj to see if it is coming soon.
* checks the INVENTORY_STATUS field.
*/
bb.productView.isComingSoon = function(sku) {
        return (sku && sku.INVENTORY_STATUS === 3);
};
/*
* tests a sku obj to see if it is Sold Out.
* checks the INVENTORY_STATUS field.
*/
bb.productView.isSoldOut = function(sku) {
    return (sku && sku.INVENTORY_STATUS === 7);
};
/*
* tests a sku obj to see if it is Displayable.
*/
bb.productView.isDoNotDisplay = function(sku) {
    return (sku && (sku.INVENTORY_STATUS === 4 || sku.INVENTORY_STATUS === 5));
};
/*
* tests a product obj to see if any of its SKUs are shoppable.
*/
bb.productView.isProductShoppable = function(productData) {
    var shoppable = true;
    if (productData && productData.skus && productData.skus.length > 0) {
        // shoppable = true;
    } else {
        shoppable = false;
    }
    return shoppable;
};
/*
* tests a sku obj to see if it is Shoppable.
*/
bb.productView.isSkuShoppable = function(skuData) {
    var shoppable = true;
    if (skuData && skuData.isShoppable === 1) {
        shoppable = true;
    }
    else {
        shoppable = false;
    }
    return shoppable;
};

bb.productView.launchQuickshopForVideo = function(productId,ww_cat) {
    var productDataParams = {};

    productDataParams.pageDataKey = 'catalog.spp';
    productDataParams.productId = productId;
    productDataParams.categoryId = ww_cat;

    bb.productView.page_data_configuration = generic.rb("page_data_configuration");
    if (bb.productView.page_data_configuration.get("catalog.spp.productFields") != "catalog.spp.productFields") {
        productDataParams.categoryFields = bb.productView.page_data_configuration.get("catalog.spp.categoryFields");
        productDataParams.productFields = bb.productView.page_data_configuration.get("catalog.spp.productFields");
        productDataParams.skuFields = bb.productView.page_data_configuration.get("catalog.spp.skuFields");
    }

    productDataParams.callback = function(sppData) {
        // pass to quickshop view
        launchQuickshop({productData: sppData});

    };

    // 2. Obtain the data
    generic.productData.getProductData(productDataParams);
};