brand.product = brand.product || {};

// check for duos, trios quads, etc...
brand.product.getShadeType = function(args) {
    var type = "solo";
    var ismulti = false;
    var sku = args.product.skus[0];
    
    // check properties in page data
    var pdtype = args.product.product_multicolor_type;
    if (!pdtype && sku.sku_multicolor_type) {
        pdtype = sku.sku_multicolor_type;
    }

    // finally, check for multiple hexes
    if (pdtype && (sku.color.length >= args.multicolor_min)) {
        type = pdtype;
        ismulti = true;
    }
      
    return { type: type, ismulti: ismulti };
}


// inventory status display
// SPP: for shaded prods with cards: handles inventory message in card & display 
//      toggling of bag button in card  & spp page
// SPP: for prods w/out cards: handles inventory message in page & display
//      toggling of bag button in page
// MPP cartAdd popover: handles inventory message in popover & display toggling 
//      of bag button in popover
// arguments: 
//      shoppable: page_data sku "shoppable"
//      message: page_data sku "inventory_status_message"
//      messageNode: node in which to insert message string
//      buttonNode: specific bag button node to suppress (optional)  By default
//          brand.product.inventoryStatus hides all nodes w/ class "inventory-status-conditional"
//      containerNode: node to add "visible-inventory-status" css class to (optional)
brand.product.inventoryStatus = function(args) {
    var msgNode = args.messageNode;
    var suppressAddToBag = (args.shoppable === "1" || args.shoppable == 1 ? false : true);
    var btnNodes = [];
    // use specified buttonNode
    var btn = $(args.buttonNode);
    if (btn) {
        btnNodes[0] = btn;
    } else {    
        // get all bag buttons with class="inventory-status-conditional"
        var btnNodes = $$(".inventory-status-conditional");
    }
    
    if (suppressAddToBag) {
        btnNodes.each(function(btn) { 
            btn.hide();
        });
    } else {
        btnNodes.each(function(btn) {
            btn.show();
        });
    }

    var containerNode = args.containerNode; // set css class on container for easier manipulation of inventory display states in css instead of in js
    if (args.message.length > 1) {
        if (msgNode) msgNode.update(args.message);
        if (containerNode) {
            containerNode.addClassName("visible-inventory-status");
        } else if (msgNode) {
            msgNode.style.display = "block";
        }
    } else {
        if (msgNode) msgNode.update("");
        if (containerNode) {
            containerNode.removeClassName("visible-inventory-status");
        } else if (msgNode) {
            msgNode.style.display = "none";
        }
    }

}


// Shoppables on content pages (i.e. news, faves)
brand.product.shoppableContent = {
    cartConfirmProps: {},
    
    init: function(args) {
        //console.log("brand.product.shoppableContent.init");
        var self = this;
        
        var is_shaded = false; 
        var containerId = (args.containerId ? args.containerId : "main_content");
        this.cartConfirmProps = (args.cartConfirmProps ? args.cartConfirmProps : this.cartConfirmProps);
        
        if (args.positionPopup) {
            this.positionPopup = args.positionPopup;
        }
         
        args.products.each(function( product ) {
            var skus = product.skus;
            skus.each(function( sku ) {
    
                var hasLinkNodes = false; 
          
                // check for link nodes as single instances (element  id) or multiple instances (css class)
                var linkNodes = [];
                linkNodes = $(containerId).select("."+sku.path);
                if (linkNodes[0]) {
                    hasLinkNodes = true;
                } else {
                    linkNodes[0] = $(sku.path);
                    if (linkNodes[0]) {
                        hasLinkNodes = true;
                    }
                }
                
                //console.log("brand.product.shoppableContent.init hasLinkNodes = "+hasLinkNodes+" sku = ",sku);
                            
                if (hasLinkNodes) {
                    self.initPopover(product, sku, linkNodes);
                }
            });            
        });         
    },
    
    initPopover: function(product, sku, linkNodes) {
        //console.log("brand.product.shoppableContent.initPopover");
        
        var self = this;
        
        if ((sku.shade_name.length > 0) && (sku.color[0].length > 2)) {
            is_shaded = true;
        } else {
            is_shaded = false;
        }
        
        this.cartConfirmProps.type = "order";
        
        var cartConfirmPlaceholder = $("cart_confirm_placeholder-" + sku.path);
        var cartAddPlaceholder = $("cart_add_placeholder-" + sku.path);
        if (!cartConfirmPlaceholder || !cartAddPlaceholder) return; // placeholder popover nodes not found

        var cartConfirmMsg = new brand.product.cartConfirm({
            id: "cart_confirm-" + sku.path,
            is_shaded: false,
            prodName: product.name,
            nodeToReplace: cartConfirmPlaceholder
        });
        
        cartConfirmMsg.setDisplayProperties(this.cartConfirmProps);
        
        // init quick buy popover
        var cartAddArgs = {
            id: "cart_add-"+sku.path,
            is_shaded: is_shaded,
            prodName: product.name,
            skuFieldId: "prod_sku_cart_add-" + sku.path,
            price: product.price,
            cartConfirm: cartConfirmMsg,
            sku: sku,
            nodeToReplace: cartAddPlaceholder
        }
        
        if (is_shaded) {
            cartAddArgs.smooshId = "smoosh_img_cart_add-" + sku.path // pass smoosh img id to set template to use swatch smoosh instead of product thumb
        } else {
            cartAddArgs.smooshPath = product.thumb;
        }
        
        var cartAddMsg = new brand.product.cartAdd(cartAddArgs);
        
        if ($("prod_sku_cart_add-" + sku.path)) $("prod_sku_cart_add-" + sku.path).value = sku.path; 
        
        var show = function(evt) {
            self.show(evt, cartAddMsg, cartConfirmMsg);
        }
        
        // connect each link node to popover action
        linkNodes.each(function( node ) {
            node.observe("click", show );  
        });
    },
    
    show: function(evt, cartAddMsg, cartConfirmMsg) {
        if (this.positionPopup) { 
            this.positionPopup(evt, cartAddMsg, cartConfirmMsg);
        }
        cartAddMsg.show();            
    }
}


/* brand.product.addButton
 * Adapted from brx.product.addButton
 */
brand.product.addButton = function (args) { 
    var addButtonNode = args.addButtonNode;
    if (!addButtonNode) return;
    var progressNode = args.progressNode;
    var skuData = args.skuData;
    var skus = [];
    var enabled = true;
    var callback = args.callback || function() {};
    var onFailure = args.onFailure || callback;
    var skuField;

    // sku values can be set before click for non-shaded or "add to all buttons"
    if (args.skuData && args.skuData.SKU_BASE_ID) {
        skus = [args.skuData.SKU_BASE_ID];
    } else if (args.skuBaseId) {
        skus = [args.skuBaseId];
    } else if (args.skus) {
        skus = args.skus;
    } else if (args.skuField) {
        skuField = args.skuField;
    } else if (addButtonNode.nodeName === "INPUT") {
        skuField = args.addButtonNode;
    } else {
        return null;
    }
    var itemType = args.itemType || 'cart';
    var action = args.action || 'add';
    
    if (progressNode) {
        var progress = new brand.progress({
            containerNode: addButtonNode,
            progressNode: progressNode
        });
    }

    // for coremetrics: get cat_base_id either from the node id or value
    var cat_base_id;
    var nodeId = addButtonNode.id;
    if (nodeId !== "" && typeof(nodeId) !== "undefined") {
        var matchResult = nodeId.match("CAT[0-9]+");
        if (matchResult){
            cat_base_id = matchResult[0];
            cat_base_id = cat_base_id.match("[0-9]+")[0];
            //console.log("CAT BASE from id ",cat_base_id );
        }
    }
    if (!cat_base_id) {
        var nodeValue = addButtonNode.value;
        if ( typeof nodeValue !== "undefined" && nodeValue !== "" ) {
            var matchResult = nodeValue.match("CAT[0-9]+");
            if (matchResult) {
                cat_base_id = matchResult[0];
                cat_base_id = cat_base_id.match("[0-9]+")[0];
                //console.log("CAT BASE from value",cat_base_id );
            }
        }
    }
        
    addButtonNode.observe("click", function(clickEvt) {
        clickEvt.preventDefault();
        if (!enabled) return;
        var item_params = {};
        
        // set sku value for buttons that don't know sku value until selection (ex: shaded)
        if (skuField) {
            var sku = skuField.value;
            if (sku.indexOf("SKU") > -1) { // get sku base id from full path
                sku = sku.split("SKU")[1];
            }
            skus = [sku];
        }
        if (!skus || !skus[0]) return;

        if (progress) {
            progress.start();
        }
        enabled = false;
        
        // Send individual parameters based on type
        item_params = {
            skus: skus,
            itemType: itemType,
            CAT_BASE_ID: cat_base_id
        }
        // MERGE NOTE: if correct syntax is mac JP, then adding multiple skus looks like it shouldn't use increment or action
        if (itemType !== 'favorites' && skus.length == 1) {
            item_params.INCREMENT = 1;
        }
        if (skus.length == 1) {
            item_params.action = action;
        }
        // MERGE NOTE: not sure if removal calls should be using qty = 0, or "delete" as action.  If the former, then when creating instance of addButton, pass qty instead of action
        //if (action === "delete") {
            //item_params.QTY = 0;
            //item_params.INCREMENT = -1;
        //}
        
        generic.checkout.cart.updateCart({
            params: item_params,
            onSuccess: function(r) {
                var resultData = r.getData();
                callback(r);
                if (progress) progress.clear();
                enabled = true;
                addButtonNode.fire("cartButton:success", resultData);
            },
            onFailure: function(r) {
                onFailure(r);
                if (progress) progress.clear(); 
                enabled = true;
            }
        });
    });
    return {
        getItemType: function() {
            return itemType;
        },
        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.removeClassName("hidden");                
            } else {
                addButtonNode.addClassName("hidden");                               
            }
        },
        setEnabled: function(state) {
            enabled = state;
        }
    };
};

/**
 * brand.product.waitlist
 * basic handling for waitlist popovers/content where present
 * @memberOf brand.product
 */
brand.product.waitlist = {
    
    // note: currently very simple, but placeholder for waitlist instances that have more fancy behavior as some have had in the past
    init: function() {
        //console.log("brand.product.waitlist.init");
        var waitListOverlays = $$("div.overlay-container-waitlist");
        var count = waitListOverlays.length;
        var self = this;
        for (i=0; i<count; i++) {
            self.initOverlay({ overlayContainerNode: waitListOverlays[i] });
        }
    },
    
    initOverlay: function(args) {
        if (!args) return;
        var overlayContainerNode = args.overlayContainerNode;
        if (!overlayContainerNode) return;
        var closeLink = overlayContainerNode.select(".close-link")[0]; // look for a close link
        if (!closeLink) return;
        // attach event handler to close links
        closeLink.observe("click", function(clickEvt) {
            clickEvt.preventDefault();
            overlayContainerNode.hide();
        });
        
        /*
        // close overlay after N milliseconds
        var reset = function() {
            clearTimeout(durationTimer);
            overlayContainerNode.hide();
        }
        var durationTimer = setTimeout(reset, 5000);
        */
    }
};