var brx = brx || {};
brx.productView = brx.productView || {}

brx.productView.addButton = function (args) { 
    var skuBaseId = args.skuBaseId;
    var progressNode = args.progressNode;
    var addButtonNode = args.addButtonNode;
    var skuData = args.skuData;
    var skuBaseId;

    if (args.skuData && args.skuData.SKU_BASE_ID) {
        skuBaseId = args.skuData.SKU_BASE_ID;
    } else if (args.skuBaseId) {
        skuBaseId = args.skuBaseId;
    } else {
        return null;
    }

    //preserve current cat in cart
    var cat_base_id;
    if (args.skuData && typeof args.skuData.PARENT_CAT_ID != "undefined"){
        cat_base_id = args.skuData.PARENT_CAT_ID;
        cat_base_id = cat_base_id.match("[0-9]+")[0];
    }

    var itemType = args.itemType || 'cart';
    var alt_params = '';
    addButtonNode.bind("click", function(clickEvt) {
        clickEvt.preventDefault();
        var item_params = {};
	
        if (progressNode) {
            progressNode[0].style.display = "block";
            addButtonNode[0].style.display = "none";
        }
        var revertButton = function() {
            if (progressNode) {
                progressNode[0].style.display = "none";
                addButtonNode[0].style.display = "block";
            }            
        };
        // Send individual parameters based on type
        if (itemType == 'favorites') {
            item_params = {
                skus: [skuBaseId],
                itemType: 'favorites',
                action: 'add',
                CAT_BASE_ID: cat_base_id
            }                   
        } else if (itemType == 'replenishment') {
            if($('#replenishment-container').length>0 || $('.replenishment_container').length>0){
                if($('#replenishment-container').is(':hidden') || $('.replenishment_container').is(':hidden')){
                    item_params = {
                        skus: [skuBaseId],
                        itemType: 'cart',
                        INCREMENT: 1,
                        CAT_BASE_ID: cat_base_id
                    }
                }else if($('#replenishment-container').is(':visible') || $('.replenishment_container').is(':visible')){
                    item_params = {
                        skus: [skuBaseId],
                        action: 'add',
                        add_to_cart: 1,
                        itemType: 'replenishment',
                        INCREMENT: 1,
                        CAT_BASE_ID: cat_base_id
                    } 
                }
            }else{
                item_params = {
                    skus: [skuBaseId],
                    itemType: 'cart',
                    INCREMENT: 1,
                    CAT_BASE_ID: cat_base_id
                }
            }
        } else {
            item_params = {
                skus: [skuBaseId],
                itemType: 'cart',
                INCREMENT: 1,
                CAT_BASE_ID: cat_base_id
            }
        }
        // Adding additional params when definied in .setItemType
        var params = item_params;
        if (alt_params) {
            params = $.extend(alt_params, params);
        }

        generic.checkout.cart.updateCart({
            params: params,
            onSuccess: function(r) {
                var resultData = r.getData();
                revertButton(progressNode);
                site.utilityNav.displayCartData(resultData.trans_data);
                addButtonNode.trigger("cartButton.success", [resultData]);
            },
            onFailure: function(ss) {
                revertButton(progressNode);
                var errorObjectsArray = ss.getMessages();
                addButtonNode.trigger("cartButton.updateLimited", [errorObjectsArray]); // item limit msg 
            }
        });
    });

    // post-callback custom-event handling
    addButtonNode.bind('cartButton.success',function(e,resultDataArr){ 
        $(document).trigger('cart.updated', [resultDataArr]); 
        generic.overlay.hide(); // explicit hide for msg
    }).bind('cartButton.updateLimited',function(e, errorDataArr){
        var error = errorDataArr[0];
        var obj = { errorText: error.text };
        
        generic.template.get({
            path:"/templates/add-to-cart-error-overlay.tmpl",
            object: obj,
            callback: function(html) {
                generic.overlay.launch({
                    content: html, 
                    lockPosition: true, 
                    cssStyle: {
                        width: "340px"
                    }
                }); 
            }
        });
    });

    return {
        getItemType: function() {
            return itemType;
        },
        setItemType: function(args) {
            // you can just change the item type or also add additional params
            if (!args.itemType) {
                return null;
            }
            itemType = args.itemType;
            alt_params = args.altParams;
        },
        setSkuBaseFromJsonProperty: function (newSkuBaseJson) {

            skuBaseId = newSkuBaseJson.skuBaseId;

        },
        setSkuBaseId: function (newSkuBaseId) {

            skuBaseId = newSkuBaseId;

        },
        setSkuData: function (data) {
            skuData = data;
            this.setSkuBaseId(data.SKU_BASE_ID);
        },
        setShoppable: function() {
            if (!skuData) {
                return null;
            }
            if (brx.productData.isShoppable(skuData)) {
                addButtonNode.removeClass("hidden");                
            } else {
                addButtonNode.addClass("hidden");                               
            }
        }
    };
};


brx.productData = {
    isActive: function(skuData) {
        return skuData.INVENTORY_STATUS && skuData.INVENTORY_STATUS == 1;
    },
    isTempOutOfStock: function(skuData) {
        return skuData.INVENTORY_STATUS && skuData.INVENTORY_STATUS == 2;
    },
    isComingSoon: function(skuData) {
        return skuData.INVENTORY_STATUS && skuData.INVENTORY_STATUS == 3;
    },
    isDisplayedOnDev: function(skuData) {
        return skuData.INVENTORY_STATUS && skuData.INVENTORY_STATUS == 4;
    },
    isInactive: function(skuData) {
        return skuData.INVENTORY_STATUS && skuData.INVENTORY_STATUS == 5;
    },
    isSoldOut: function(skuData) {
        return skuData.INVENTORY_STATUS && skuData.INVENTORY_STATUS == 7;
    },
    isShoppable: function(skuData) {
        return brx.productData.isActive(skuData) || brx.productData.isTempOutOfStock(skuData);
    }
};

brx.productView.cartOverlay = {
 
    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;
        }
    },
    hide: function() {
        var cartOverlayNode = $("div.cart-overlay");
        if (cartOverlayNode.length > 0) {
            generic.overlay.hide();
        }
    },
    scrollContainer: function() {
        //containerBody = $(document.body);
       $("html,body").animate({ scrollTop: $("#viewcart").scrollTop() + 'px' }, "slow", "swing");
    },
    launch: function(r) { 
        var cartItem; 
	 
        if (typeof r.getItem !== "function") { 
            return;
        } 
        cartItem = r.getItem(); 
        cartItem.totalCartItems = generic.checkout.cart.getTotalItems();  // this will return 0 until response to cart JSON-RPC is modified to include user transaction data
        var rbLanguageHash = generic.rb('language');
        if (cartItem.totalCartItems == 1) {
            cartItem.totalCartItemsMessage = rbLanguageHash.get("in_your_cart");
        }
        else {
            cartItem.totalCartItemsMessage = rbLanguageHash.get("in_your_cart_plural");
        }
        var holdSubtotal = generic.checkout.cart.getSubtotal(); 
        cartItem.totalCartAmount = parseFloat(holdSubtotal).toFixed(2);
        var cartMethod = r.getMethod(); 
        cartItem.cartMessage = this.getMessage(cartMethod); 
 
        var anchorNode = $("div.utility-nav a#viewcart") ? $("div.utility-nav a#viewcart") : $("content"); 
        var leftOffset = (-(320 - anchorNode.width())); 
		this.scrollContainer();

	    var cssCartOverlayNode = $('.unav_cart','#unav').find(".submenu_grid");

        generic.template.get({
		path:"/templates/cart-overlay.tmpl",
            object: cartItem,
            callback: function(html) {

                $('.unav_cart_container').html(html);

                var pixels = parseInt( cssCartOverlayNode.css('left') ) + 'em';
                cssCartOverlayNode.css('left',0);

                var timeout = function() { 
               
			        cssCartOverlayNode.css('left',pixels);

		        }

                setTimeout(timeout,5000);

                $('.utility_item.unav_cart, a.unav_cart').bind('mouseover',function(){
                        cssCartOverlayNode.css('left',0);
                }).bind('mouseout',function(){
                        cssCartOverlayNode.css('left',pixels);
                });

            }
        });
    }
};

brx.productView.populateCartTotal = function(cartItemCount) {
    if(typeof cartItemCount.getCount != "undefined"){
        var cartItemCount = cartItemCount.getCount();
        var cartTotalNode = $("#utilnav_cartcount");

        if(cartItemCount){	
                cartTotalNode.html(cartItemCount);
        }
    }
};
$(document).bind("cart.updated", function(event, cartResultObjParam) {
    /* Display once active */
    $('.no-initial-display').css("display","block");

    brx.productView.cartOverlay.launch(cartResultObjParam); 
    brx.productView.populateCartTotal(cartResultObjParam);
});


brx.productView.favoritesMessageDisplay = {
    getMessage: function(jsonRpcResponse) {
        if (!jsonRpcResponse) {
            return null;
        }
        var textObj = {};
        var rbLanguageHash = generic.rb('language');
        var cartResults = jsonRpcResponse.getCartResults();
        var cartItem = cartResults.getItem();

        var msgHash = {
            name: cartItem.product.PROD_RGN_NAME + ' ',
            text: rbLanguageHash.get('success.add_sku.collection')
        };
        var shadename = cartItem.product.sku.SHADENAME;
        if (shadename) {
            msgHash.name += shadename + " ";
        };                    
        textObj.text = msgHash.name + ' ' + msgHash.text;
        
        return textObj;
    },
    launch: function(jsonRpcResponse) {
        var textObj = this.getMessage(jsonRpcResponse);        
        generic.template.get({
		path: "/templates/favorites-results.tmpl",
            object: textObj,
            callback: function(html) {

                generic.overlay.launch({
                    content: html,
                    includeBackground: false,
                    lockPosition: true,
                    cssStyle: {
                        width: "340px"
                    }
                });
                // Add click event to favorites close button
                var closeNode = $('#favorites-message').find("a.close-btn");
                closeNode.bind("click", function(e) {
                    e.preventDefault();
                    generic.overlay.hide();
                });
            }
        });
    }
};


$(document).bind("favorites.updated", function(event, jsonRpcResponse) {
    brx.productView.favoritesMessageDisplay.launch(jsonRpcResponse);
});


brx.productView.filterTable = function (args) {
    var initFilterChangeEvent = function(selectNode){
        var self = this;
        selectNode.bind('change', function (evt) {
            // evt.target.fire("table:filter", evt.target);
            that = $.grep(that, function(n){
			  return (n == evt.target);
			});

        });
    };
    var filterNodes = new generic.Hash();
    var sortNode = null;
    var tableData;
    var that = {};
    /**
     * This method builds the HTML select menu node.
     * @methodOf brx.filter
     * @param {Node} args.filterMenuContainerNode the node where the filter menus will be inserted
     */
    that.createMenus = function(args) {
        var self = this;
        var options = $.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 = [];
            $.each(options.menuMetaData.filters, function(){
                var slct = initFilterMenu({
                    field: this.field,
                    label: this.label
                });
                if (slct) {
                    menus.push({label: "" + this.label + brx.rb.language.filterBy + ':', 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( brx.rb.language.all );
            slct.append(opt);
            $.each(buildArgs.menuOptions, function(idx) {
                opt = new Element("option", {
                    value : this
                })
                opt.append(this);
                slct.append(opt);
            });
            return slct;
        };
        var getMenuOptions = function(fields){
            var menuOptions = [];
            for (var i = 0, len = fields.length; i<len; i++) {
                var fieldName = fields[i];
                $.each(options.tableData, function(){
                    var menuVal = this[fieldName];
                    if (menuVal) {
                        menuOptions.push(menuVal);
                    }
                });
                menuOptions = $.unique(menuOptions)
                if (menuOptions.length < 2) {
                    return null;
                }
                return menuOptions;
            }
        };

        var filterMenuObjects = getMenuElements();

        if (filterMenuObjects.length > 0) {
            $.each(filterMenuObjects, function(){
                var lbl = new Element('label', {'class':'filterby'});
                lbl.append(this.label);
                options.filterMenuContainerNode.append(lbl);
                var slct = record.node;
                options.filterMenuContainerNode.append(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 = $.extend({
            menuWidth: 100,
            selectNodeID: "sort-menu"
        }, args || {});
        var slct = new Element("select", {
            'class': "width_" + options.menuWidth,
            id: options.selectNodeID,
            name: options.selectNodeID });
        $.each(options.sortMenuArray, function(){
            slct.insert(new Element("option", {
                value: this.field,
                selected: "selected" }).append(this.label));
        });
        options.containerNode.append(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
            $.each(filterNodes.keys(), 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;
};



brx.productView.kitAdjustments = (function(){

    // use as utilities
    return {

        adjustShadenames : function (args) {

            // apply kit adjustments for shadename
            if( (args.productData.skus.length==1) )  {

                var singleSku = args.productData.skus[0];
                var previouslyPiped = new String( singleSku.SHADE_DESCRIPTION ).split('|');

                if( previouslyPiped.length > 1 ) { // empty split still has 1

                    // replace label node to bypass non-kit shade_desc visual changes
                    //args.shadesContainerNode.find('.shadename').remove();
                    $('.shadename').remove()
                    var spanTag = $('<span />').addClass('shadename-kit').html( previouslyPiped[0] );
                    //args.shadesContainerNode.find('.shade-name-container').append( spanTag );
                    $('.shade-name-container').append(spanTag);
                    $('.swatch-unit', args.shadesContainerNode ).each(function(){

                        $(this).mouseenter(function(){

                            var index = this.id.split('-')[1];
                            spanTag.html( previouslyPiped[index] );

                        });

                    });
                }

            } // end kit data check

        }, // end method name

        getSwatchKitConfigs : function (args) {

            var swatchConfigs, templateVars = {};

            // Established Swatch Type
            switch(args.count) {
                case 2:
                swatchConfigs = { swatchWidth: 160, swatchHeight: 30, swatchUnitHeight: 29, swatchInternalRowCount: 1, cellsPerRow: 1 };
                templateVars = { 'SWATCH_CONTAINER_WIDTH':159, 'SWATCH_CONTAINER_HEIGHT':29 }; // duo
                break;

                case 3:
                swatchConfigs = { swatchWidth: 160, swatchHeight: 35, swatchUnitHeight: 34, swatchInternalRowCount: 1, cellsPerRow: 1 };
                templateVars = { 'SWATCH_CONTAINER_WIDTH':160, 'SWATCH_CONTAINER_HEIGHT':34 }; // trio
                break;

                case 4:
                swatchConfigs = { swatchWidth: 160, swatchHeight: 30, swatchUnitHeight: 29, swatchInternalRowCount: 1, cellsPerRow: 1 };
                templateVars = { 'SWATCH_CONTAINER_WIDTH':159, 'SWATCH_CONTAINER_HEIGHT':29 }; // quad
                break;

                case 5:
                swatchConfigs = { swatchWidth: 160, swatchHeight: 30, swatchUnitHeight: 29, swatchInternalRowCount: 1, cellsPerRow: 1 };
                templateVars = { 'SWATCH_CONTAINER_WIDTH':159, 'SWATCH_CONTAINER_HEIGHT':29 }; // quin
                break;

                case 6:
                swatchConfigs = { swatchWidth: 160, swatchHeight: 25, swatchUnitHeight: 24, swatchInternalRowCount: 2, cellsPerRow: 1 };
                templateVars = { 'SWATCH_CONTAINER_WIDTH':160, 'SWATCH_CONTAINER_HEIGHT':49 }; // sext
                break;

                case 7:
                case 8:
                case 9:
                //case 10:
                case 11:
                //case 12:
                //case 13:
                //case 14:
                case 15:
                case 16:
                case 17:
                case 18:
                case 19:
                //case 20:
                swatchConfigs = { swatchWidth: 160, swatchHeight: 30, swatchUnitHeight: 29, swatchInternalRowCount: 2, cellsPerRow: 1 };
                templateVars = { 'SWATCH_CONTAINER_WIDTH':159, 'SWATCH_CONTAINER_HEIGHT':58 }; 
                break;

                case 10:
                swatchConfigs = { swatchWidth: 160, swatchHeight: 30, swatchUnitHeight: 29, swatchInternalRowCount: 2, cellsPerRow: 1 };
                templateVars = { 'SWATCH_CONTAINER_WIDTH':159, 'SWATCH_CONTAINER_HEIGHT':59 }; // ten
                break;

                case 12:
                swatchConfigs = { swatchWidth: 160, swatchHeight: 30, swatchUnitHeight: 29, swatchInternalRowCount: 2, cellsPerRow: 1 };
                templateVars = { 'SWATCH_CONTAINER_WIDTH':166, 'SWATCH_CONTAINER_HEIGHT':58 }; // twelve
                break;

                case 13:
                swatchConfigs = { swatchWidth: 160, swatchHeight: 30, swatchUnitHeight: 29, swatchInternalRowCount: 2, cellsPerRow: 1 };
                templateVars = { 'SWATCH_CONTAINER_WIDTH':180, 'SWATCH_CONTAINER_HEIGHT':58 }; // twelve
                break;

                case 14:
                swatchConfigs = { swatchWidth: 160, swatchHeight: 30, swatchUnitHeight: 29, swatchInternalRowCount: 2, cellsPerRow: 1 };
                templateVars = { 'SWATCH_CONTAINER_WIDTH':166, 'SWATCH_CONTAINER_HEIGHT':58 }; // twelve
                break;

                case 20:
                swatchConfigs = { swatchWidth: 160, swatchHeight: 30, swatchUnitHeight: 29, swatchInternalRowCount: 2, cellsPerRow: 1 };
                templateVars = { 'SWATCH_CONTAINER_WIDTH':159, 'SWATCH_CONTAINER_HEIGHT':58 }; // twelve
                break;

                case 23:
                case 24:
                swatchConfigs = { swatchWidth: 160, swatchHeight: 30, swatchUnitHeight: 29, swatchInternalRowCount: 2, cellsPerRow: 1 };
                templateVars = { 'SWATCH_CONTAINER_WIDTH':159, 'SWATCH_CONTAINER_HEIGHT':58 }; // twelve
                break;

                default:
                swatchConfigs = { swatchWidth: 40, swatchHeight: 40, swatchUnitHeight: 39, swatchInternalRowCount: 1, cellsPerRow: 4 };
                templateVars = { 'SWATCH_CONTAINER_WIDTH':39, 'SWATCH_CONTAINER_HEIGHT':39 }; // single
                break;
            }

            return { swatchConfigs : swatchConfigs, templateVars : templateVars }

        }

    };

})();