/// <reference path="lib/jquery-1.3.2.js" />

// Start CCI.

var CCI = CCI || {};
CCI.Validation =  CCI.Validation || {};

// Start JQuery Validate Options
var xVal = xVal || {};
xVal.JQueryValidateOptions = xVal.JQueryValidateOptions || {};

$.extend(xVal.JQueryValidateOptions, {
        errorClass: "field-validation-error",
        errorElement: "label",
        ignore: ":not(:visible)",       // Ignore the hidden elements

        onfocusout: false,              // Only validate on submit - fixes kindof flakey behavior
        onkeyup: false,
        onclick: false,
        onsubmit: true,

        focusInvalid: false,            // Fixes odd behavior in IE, the scrollTo in show errors is more consistant        
        
        highlight: function(element) {  // Doesn't highlight radio buttons      
            if (!$(element).is("input[type='radio']")) { $(element).addClass("input-validation-error"); } }, 
        unhighlight: function(element) { $(element).removeClass("input-validation-error"); }
    }
);

    xVal.JQueryValidateOptions.errorPlacement = function(error, element) {
        // Adds the option to group by fieldsets
        var $field = element.closest("fieldset");

        if ($field && $field.length > 0) {
            var $errBox = $field.find(".client-validation-errors");

            if (error.html().indexOf("{0}") != -1) {
                var errorIdentifierChains = CCI.Utility.GetValuesFromClass("errorMsg_", element);
                for (var i = 0; i < errorIdentifierChains.length; i++) {
                    var chain = errorIdentifierChains[i].split("_");
                    var prop = window;
                    if (chain && prop) {
                        for (var j = 0; j < chain.length; j++) {
                            if (prop[chain[j].toString()] || prop[chain[j].toString()] === "") {
                                prop = prop[chain[j].toString()];
                            }
                        }
                        if (prop && prop != "") {                            
                            error.text($.format(error.html(), prop));
                            break;
                        }
                    }
                }
            }

            CCI.Validation.CurrentErrors.push(error.text());

            if ($errBox.find("ul").html().indexOf(error.html()) == -1) {
                $errBox.find("ul").append("<li></li>");
                $li = $errBox.find("ul li:last");
                $li.append(error);                
            }

            var multipleErrors = $errBox.find("ul li").length > 1;
            $errBox.find("ul").removeClass(multipleErrors ? "none" : "disc").addClass(multipleErrors ? "disc" : "none");

            var showing = $errBox.is(":visible");
            if (!showing) { $errBox.show(); }
            var newTop = ($field.height() - $errBox.height()) / 2
            $errBox.css("top", newTop);
            if (!showing) { $errBox.fadeIn("slow"); }
        } else {
            // Needs better default behavior
            element.after(error);
        }
    }

    xVal.JQueryValidateOptions.showErrors = function(errorMap, errorList) {
        var $errBoxes = $(this.currentForm).find(".client-validation-errors")
        $errBoxes.find("ul").html("");
        this.toHide = this.toHide.add($errBoxes);

        CCI.Validation.CurrentErrors = [];
        for (var i = 0; this.errorList[i]; i++) {
            var $field = $(this.errorList[i].element).closest("fieldset");
            if ($field && $field.length > 0) {
                var $errBox = $field.find(".client-validation-errors");
                if ($errBox) {
                    this.toShow = this.toShow.add($errBox);
                }
            }
        }

        this.defaultShowErrors(); // Calls errorPlacement

        // All of the errors should be visible at this point
        var $firstError = $(".client-validation-errors:visible:first");
        if ($firstError.length > 0) {
            $.scrollTo($firstError[0], 800, { offset: { top: -10, left: 0} });
        }


        if (CCI.Validation.InvalidHandler
            && typeof CCI.Validation.InvalidHandler == "function"
            && this.errorList.length > 0) {            
            setTimeout(CCI.Validation.InvalidHandler, 0);
        }
    }
    
// End JQuery Validation Options


// Start Custom Validators
CCI.Validation.Require = function(value, element, params) {
    var data = CCI.Validation.GetData(params);
    return data == null || data != "";
}

CCI.Validation.RegexValidate = function(value, element, params) {
    if (params.regex) {
        var data = CCI.Validation.GetData(params);
        return data == null || data.match(params.regex);
    }
    return true;    
}

CCI.Validation.GetData = function(params) {
    var data = "";
    if (params.selectors) {
        for (var i = 0; i < params.selectors.length; i++) {
            $(params.selectors[i]).each(function(i, e) {
                data += $(e).val(); 
            });
        }
    }
    return data;
}

CCI.Validation.ValidateCCExpiration = function() {
    var month = $("#Cart_CheckoutInfo_ExpireMonth option:selected").text();
    var year = $("#Cart_CheckoutInfo_ExpireYear option:selected").text();
    if (month && year) {
        var today = new Date();
        if (month == 12) {
            month = 1;
            year++;
        } else {
            month++;
        }
        var expDate = new Date();
        expDate.setFullYear(year, month, 1);
        return today < expDate;
    }
    return true;
}

CCI.Validation.ValidatePortingAccountPIN = function(value, element, params) {
    var acc = $("#Cart_Lines\\[" + params.id + "\\]_PortingInfo_AccountNumber").val();
    var pin = $("#Cart_Lines\\[" + params.id + "\\]_PortingInfo_PIN").val();
    return acc || pin;
    //return !acc != !pin; //XOR
}

CCI.Validation.ValidateEmailConfirmation = function() {
    var email = $("#Cart_CheckoutInfo_Email").val();
    var emailConfirm = $("#Cart_CheckoutInfo_ConfirmEmail").val();
    return email == "" || emailConfirm == "" || email == emailConfirm;
}

// End Custom Validators