// wForms Custom Functions
//Network Technology Solutions
//8-15-2007

//Custom function to allow date in any format supported by the local browser as well as YYYY-MM-DD format
wFORMS.behaviors['validation'].isDate = function(s) { 
	var cYEAR = 0, cMONTH = 1, cDAY = 2; 
	var aDate; 
	aDate = s.split("\-"); 
    var testDate = new Date(aDate[cYEAR], aDate[cMONTH] - 1, aDate[cDAY]); 
	
	if ((aDate[cYEAR] != testDate.getFullYear() ) || (aDate[cMONTH] != 1 + testDate.getMonth()) ||(aDate[cDAY] != testDate.getDate()))
		var testDate = new Date(s);
		
	return wFORMS.behaviors['validation'].isEmpty(s) || !isNaN(testDate); 
} 
//End custom date function

wFORMS.behaviors['validation'].custom_validation = function(element,classname) { 
      var wBehavior = wFORMS.behaviors['validation'];         // shortcut 

      var nbErrors = 0; 

      if(wBehavior.isEmpty(element.value)) return 0;         // if it's not require already, don't check blank fields 

      if (classname.indexOf('|') != -1) {                  // looking for 'validate-something|this|that' in classname 
         var options = classname.split('|'); 
         classname = options[0]; 
         for (z=1; z<options.length; z++){               // check for field names in options and get values 
            obj = document.getElementsByName(options[z]); 
            value = false; 
            for (i=0; i<obj.length; i++) { 
               v = wBehavior.getFieldValue(obj[i]);
               if (v) value = (typeof(v) == 'string') ? v : v[0]; 
            } 
            if (value) options[z] = value; 
         } 
      } 
             
      switch(classname) { 
         case "validate-minlen": 
         case "validate-minlength": 
            if (!options[1]) return; 
            if (element.value.length < eval(options[1])) { 
               wBehavior.showError(element, "Minimum length of "+options[1]+"."); 
               nbErrors++; 
            } 
            break; 
         case "validate-maxlen": 
         case "validate-maxlength": 
            if (!options[1]) return; 
            if (element.value.length > eval(options[1])) { 
               wBehavior.showError(element, "Maximum length of "+options[1]+"."); 
               nbErrors++; 
            } 
            break; 
         case "validate-within": 
            if (!options[1]) return; 
            if (!options[2]) return; 
            if (!(element.value >= options[1] && element.value <= options[2])) { 
               wBehavior.showError(element, "Must be within "+options[1]+" and "+options[2]+"."); 
               nbErrors++; 
            } 
            break; 
         case "validate-lt": 
         case "validate-less": 
            if (!options[1]) return; 
            if (!element.value < options[1]) { 
               wBehavior.showError(element, "Must be less than "+options[1]+"."); 
               nbErrors++; 
            } 
            break; 
         case "validate-gt": 
         case "validate-greater": 
            if (!options[1]) return; 
            if (!element.value > options[1]) { 
               wBehavior.showError(element, "Must be greater than "+options[1]+"."); 
               nbErrors++; 
            } 
            break; 
         case "validate-eq": 
         case "validate-equal": 
            if (!options[1]) return; 
            if (element.value != options[1]) { 
               wBehavior.showError(element, "Values don't match."); 
               nbErrors++; 
            } 
            break; 
         case "validate-ne": 
         case "validate-neq": 
         case "validate-notequal": 
            if (!options[1]) return; 
            if (element.value == options[1]) { 
               wBehavior.showError(element, "Values can not be the same."); 
               nbErrors++; 
            } 
            break; 
         case "validate-number": 
         case "validate-numeric": 
            if(!wBehavior.isInteger(element.value)) { 
               wBehavior.showError(element, wBehavior.errMsg_integer); 
               nbErrors++; 
            }                
            break; 
         case "validate-mod10": 
            if (!isMod10()) { 
               wBehavior.showError(element, "This is not a valid number."); 
               nbErrors++; 
            } 
            break; 
         case "validate-creditcard": 
            if (!isMod10()) { 
               wBehavior.showError(element, "This is not a valid credit card."); 
               nbErrors++; 
               return; 
            } 
            switch (options[1]) { 
               case 'V'      : var ccReg = /^4\d{12}(\d{3})?$/; break;         // Visa 
               case 'M'      : var ccReg = /^5[1-5]\d{14}$/; break;            // Mastercard 
               case 'D'      :                                        // Discover 
               case 'S'      : var ccReg = /^6011\d{12}$/; break;            // Discover (why S?) 
               case 'A'      : var ccReg = /^3[4|7]\d{13}$/; break;            // American Express 
            //   case 'DINERS'   : var ccReg = /^3[0|6|8]\d{12}$/; break; 
            //   case 'ENROUTE'   : var ccReg = /^2[014|149]\d{11}$/; break; 
            //   case 'JCB'      : var ccReg = /^3[088|096|112|158|337|528]\d{12}$/; break; 
            //   case 'SWITCH'   : var ccReg = /^(49030[2-9]|49033[5-9]|49110[1-2]|4911(7[4-9]|8[1-2])|4936[0-9]{2}|564182|6333[0-4][0-9]|6759[0-9]{2})\d{10}(\d{2,3})?$/; break; 
            //   case 'DELTA'   : var ccReg = /^4(1373[3-7]|462[0-9]{2}|5397[8|9]|54313|5443[2-5]|54742|567(2[5-9]|3[0-9]|4[0-5])|658[3-7][0-9]|659(0[1-9]|[1-4][0-9]|50)|844[09|10]|909[6-7][0-9]|9218[1|2]|98824)\d{10}$/; break; 
            //   case 'SOLO'      : var ccReg = /^(6334[5-9][0-9]|6767[0-9]{2})\d{10}(\d{2,3})?$/; break; 
            // Add additonal card types here 
               default         : var ccReg = /^0\d{22}$/; // field definition should make this impossible 
            } 
            if (!ccReg.test(element.value)) { 
               wBehavior.showError(element, "Invalid credit card type/number."); 
               nbErrors++; 
            } 
            break; 
         case "validate-zipcode":
         case "validate-zipusa": 
            if (!isValidZipCode(element.value)) { 
               wBehavior.showError(element, "This is not a valid zip code."); 
               nbErrors++; 
            } 
            break; 
         case "validate-phonenumber": 
         case "validate-phone": 
            regex   = new RegExp(/^\(?(\d{3})\)?[\s-\.]?(\d{3})[\s-\.]?(\d{4})$/); 
            if (!regex.test(element.value)) { 
               wBehavior.showError(element, "This is not a valid phone number."); 
               nbErrors++; 
            } else { 
               matched = regex.exec(element.value); 
               element.value = '(' + matched[1] + ") " + matched[2] + "-" + matched[3]; 
            } 
            break;       
         case "validate-name": 
            regex   = new RegExp(/^[a-zA-Z\s.\-]+$/); 
            if (!regex.test(element.value)) { 
               wBehavior.showError(element, "This name appears to be invalid."); 
               nbErrors++; 
            } 
            break;       
         case "validate-street": 
         case "validate-address": 
         case "validate-city": 
            regex   = new RegExp(/^[a-zA-Z0-9\s.#\(\)\-]+$/); 
            if (!regex.test(element.value)) { 
               wBehavior.showError(element, "This "+classname.substr(9)+" appears to be invalid."); 
               nbErrors++; 
            } 
            break;       
         case "validate-nopobox": 
            regex   = new RegExp(/P\.* *O\.* *B*O*X*/i); 
            if (regex.test(element.value)) { 
               wBehavior.showError(element, "P.O. box not allowed."); 
               nbErrors++; 
            } 
            break; 
            
         case "validate-url": 
            regex   = new RegExp(/^(http:\/\/)|(https:\/\/)|(ftp:\/\/)|(\/)/); 
            if (!regex.test(element.value)) { 
               wBehavior.showError(element, "This does not appear to be a valid URL."); 
               nbErrors++; 
            } 
            break;  
		  
          //Year 1800-2099
          case "validate-YYYY": 
            regex   = new RegExp(/^(19|20)[\d]{2,2}$/); 
            if (!regex.test(element.value)) { 
               wBehavior.showError(element, "This does not appear to be a valid year."); 
               nbErrors++; 
            } 
            break;
            
          //Time 00:00 xx  
//          case "validate-time": 
//            regex   = new RegExp(/^((0?[1-9]|1[012])(:[0-5]\d){0,2}(?i:\x20[AP]M))$/); 
//            if (!regex.test(element.value)) { 
//               wBehavior.showError(element, "This does not appear to be a valid time."); 
//               nbErrors++; 
//            } 
//            break;            

      } //switch 
      return nbErrors; 

      // validation functions 
      
      function isValidZipCode(value) {
   		var re = /^\d{5}([\-]\d{4})?$/;
   		return (re.test(value));
      }
      isMod10 = function() { 
         element.value = element.value.split("-").join(""); 
         // Add even digits in even length strings or odd digits in odd length strings. 
         var checksum = 0; 
         for (var i=(2-(element.value.length % 2)); i<=element.value.length; i+=2) { 
               checksum += parseInt(element.value.charAt(i-1)); 
         } 
         // Analyze odd digits in even length strings or even digits in odd length strings. 
         for (var i=(element.value.length % 2) + 1; i<element.value.length; i+=2) { 
            var digit = parseInt(element.value.charAt(i-1)) * 2; 
            if (digit < 10) { checksum += digit; } else { checksum += (digit-9); } 
         } 
         return ((checksum % 10) == 0); 
      } 
             
   }