// itanda - input validation functions
// Version 1.0
// Copyright (c) JHC Technology Limited, 2006


var objLastErrorField = null;
var strLastErrorFieldBGColor = "";
var reWhitespace = /^\s+$/ ;
var strErrorColor = " #D0EDD0";

String.prototype.trim = function() {
  return ((ar=/^\s*([\s\S]*\S+)\s*$/.exec(this)) ? ar[1] : ""); 
}

function trim (str) {
  if (str == null) {
    return ("");
  }
  else {
    return (str.trim());
  }
} 

function setErrorColor(strColor) {
  strErrorColor = strColor;
}

function setFieldById(strField, strValue) {
  setField(document.getElementById(strField.replace("[]", "")), strValue);
}

function setField(objField, strValue) {
  if (objField.type == "select-one") {
    for (i = 0; i < objField.options.length; i++) {
      if (objField.options[i].value == strValue) {
        objField.selectedIndex = i;
        break;
      }
    }
  }
  else if (objField.type == "select-multiple") {
    var strValueList = "," + strValue + ",";
    for (i = 0; i < objField.options.length; i++) {
      if (strValueList.indexOf(objField.options[i].value) != -1 && 
          objField.options[i].value != "") {
        objField.options[i].selected = true;
      }
    }
  }
  else if ((objField.type == "radio") || (objField[0] && objField[0].type == "radio")) {
    if (objField.length > 0) {
      for (i = 0; i < objField.length ; i++) {
        if (objField[i].value == strValue) {
          objField[i].checked = true;
          break;
        }
      }
    }
    else {
      if (objField.value == strValue) {
        objField.checked = true;
      }
    }
  }
  else if (objField.type = "checkbox") {
    if (typeof strValue == 'boolean') {
      objField.checked = strValue;
    }
    else if (strValue = "") {
      objField.checked = false;
    }
    else {
      objField.checked = true;
    }      
  }
  else {
    objField.value = strValue;
  }
}

function setFocus(objField) {
  if ((objField.type != "radio") && (!objField == null)) {
    objField.focus();
  }
  if ((objField.type == "text") || (objField.type == "textarea") || (objField.type == "password")) {
    objField.select();
  }
}
 
function isEmpty(str) {   
  return ((str == null) || (str.length == 0));
}
	
function isWhitespace(str) {
  return (isEmpty(str) || reWhitespace.test(str));
}

function isValidEmail(str) {
  var emailStr = trim(str);
  var checkTLD = 1;  // 1 for check against list below
  var knownDomsPat=/^(com|net|org|edu|int|mil|gov|arpa|biz|aero|name|coop|info|pro|museum)$/;
  var emailPat=/^(.+)@(.+)$/;
  var specialChars="\\(\\)><@,;:\\\\\\\"\\.\\[\\]";
  var validChars="\[^\\s" + specialChars + "\]";
  var quotedUser="(\"[^\"]*\")";
  var ipDomainPat=/^\[(\d{1,3})\.(\d{1,3})\.(\d{1,3})\.(\d{1,3})\]$/;
  var atom=validChars + '+';
  var word="(" + atom + "|" + quotedUser + ")";
  var userPat=new RegExp("^" + word + "(\\." + word + ")*$");
  var domainPat=new RegExp("^" + atom + "(\\." + atom +")*$");
  var matchArray=emailStr.match(emailPat);
  if (matchArray == null) {
    //alert("Email address seems incorrect (check @ and .'s)");
    return false;
  }
  var user=matchArray[1];
  var domain=matchArray[2];
  for (i=0; i<user.length; i++) {
    if (user.charCodeAt(i)>127) {
      //alert("Ths username contains invalid characters.");
      return false;
    }
  }
  for (i=0; i<domain.length; i++) {
    if (domain.charCodeAt(i)>127) {
      //alert("Ths domain name contains invalid characters.");
      return false;
    }
  }
  if (user.match(userPat) == null) {
    //alert("The username doesn't seem to be valid.");
    return false;
  }
  var IPArray=domain.match(ipDomainPat);
  if (IPArray != null) {
    for (var i=1; i<=4; i++) {
      if (IPArray[i] > 255) {
        //alert("Destination IP address is invalid!");
        return false;
      }
    }
    return true;
  }
  var atomPat=new RegExp("^" + atom + "$");
  var domArr=domain.split(".");
  var len=domArr.length;
  for (i=0;i<len;i++) {
    if (domArr[i].search(atomPat)==-1) {
      //alert("The domain name does not seem to be valid.");
      return false;
    }
  }
  if (checkTLD && domArr[domArr.length-1].length!=2 && 
      domArr[domArr.length-1].search(knownDomsPat)==-1) {
    // alert("The address must end in a well-known domain or two letter " + "country.");
    return false;
  }
  if (len < 2) {
    //lert("This address is missing a hostname!");
  return false;
  }
  return true;
}

function isDigit(strChar) {
  return ((strChar >= "0") && (strChar <= "9"));
}

function isInteger(str) {
  if (isWhitespace(str)) {
    return false;
  }
  for (i = 0; i < str.length; i++) {   
    var strChar = str.charAt(i);
    if (!isDigit(strChar)) {
      return false;
    }
  }
  return true;
}

function isNumeric(str) {
  if (isWhitespace(str)) {
    return false;
  }
  var strValidChars = "0123456789.,";
  for (i = 0; i < str.length; i++) {   
    var strChar = str.charAt(i);
    if (strValidChars.indexOf(strChar) == -1) {
      return false;
    }
  }
  return true;   
}

function stripChars (str, strRemove) {   
  var strReturn = "";
  for (var i = 0; i < str.length; i++) {   
    var strChar = str.charAt(i);
    if (strRemove.indexOf(strChar) == -1) {
      strReturn += strChar;
    }
  }
  return strReturn;
}

function maxLength(str, iMax) {
  if (str.length <= iMax) {
    return true;
  }
  else {
    return false;
  }
}

function minLength(str, iMin) {
  if (str.length >= iMin) {
    return true;
  }
  else {
    return false;
  }
}

function getSelectedRadioValue(arrRadioButton) {
  var strReturn = "";
  if (arrRadioButton.length > 0) {
    for (i = 0; i < arrRadioButton.length; i++) {
      if (arrRadioButton[i].checked) {
        strReturn = arrRadioButton[i].value;
        break;
      }
    }
  }
  else {
    if (arrRadioButton.checked) {
      strReturn = arrRadioButton.value;
    }
  }
  return strReturn;
}


function getSelectedRadioIndex(arrRadioButton) {
  var strReturn = "";
  if (arrRadioButton.length > 0) {
    for (i = 0; i < arrRadioButton.length; i++) {
      if (arrRadioButton[i].checked) {
        strReturn = i;
        break;
      }
    }
  }
  else {
    if (arrRadioButton.checked) {
      strReturn = 0;
    }
  }
  return strReturn;
}

function checkRadio(arrRadioButton) {
  var bSelected = false;
  if (arrRadioButton.length > 0) {
    for (i = 0; i < arrRadioButton.length ; i++) {
      if (arrRadioButton[i].checked) {
        bSelected = true;
        break;
      }
    }
  }
  else {
    bSelected = arrRadioButton.checked;
  }
  return bSelected;
}

function checkCheckbox(arrCheckbox) {
  var bSelected = false;
  if (arrCheckbox.length > 0) {
    for (i = 0; i < arrCheckbox.length ; i++) {
      if (arrCheckbox[i].checked) {
        bSelected = true;
        break;
      }
    }
  }
  else {
    bSelected = arrCheckbox.checked;
  }
  return bSelected;
}

function checkList(objList, intIndex) {
  return (objList.selectedIndex == intIndex);
}

function checkField(objField, strRules, arrRule) {
  //var bOptional = arrRule[3];
  strRules = trim(strRules);
  if (strRules == "") {
    return "";
  }
  strRules = strRules.toLowerCase();
  bOptional = true;
  if (("," + strRules + ",").indexOf(",required") != -1) {
    bOptional = false;
  }
  if (bOptional) {
    if (isWhitespace(objField.value)) {
      return "";
    }
  }
  if (objField.disabled == true) {
    return "";
  }
  var strField = objField.value;
  if (objField.type == "select-multiple" && isWhitespace(strField)) {
    var iOpt;
    for (iOpt = 0; iOpt < objField.options.length; iOpt++) {
      if (objField.options[iOpt].selected) {
        if (!isWhitespace(objField.options[iOpt].value)) {
          strField = objField.options[iOpt].value;
          break;
        }  
      }
    }
  }
  var aRules = strRules.split(",");
  for (iRule = 0; iRule < aRules.length; iRule++) {
    strRule = aRules[iRule];
    switch(strRule) {

      case "required": {
        if (isWhitespace(strField)) {
          return "required";
         }
         break; 
      } // END case required
 
      case "empty": {
        if (!isWhitespace(strField)) {
          return "not empty";
        }
        break;
      } // END case empty


      case "email": {
        if (!isValidEmail(strField)) {
          return "invalid email address";
        }
        break;
      } // END case enail;

      case "telephone": {
        if (!isValidTelephone(strField)) {
          return "invalid telephone number";
        }
        break;
      } // END case telephone;

      case "integer": {
        if (!isInteger(strField)) {
          return "not a number";
        }
        break;
      } // END case integer

      case "numeric": {
        if (!isNumeric(strField)) {
          return "not a number";
        }
        break;
      } // END case numeric

      case "select": {
        return !checkList(objField, 0);
        break;
      } // END case select
    
      case "radio": {
        return checkRadio(objField);
        break;
      } // END case radio
    
      case "checkbox": {
        return checkCheckbox(objField);
        break;
      } // END case radio
    
      case "date": {
        if (!isValidDate(strField, objField)) {
          return "invalid date";
        } 
        break;
      } // END case date

      case "time": {
        if (!isValidTime(strField)) {
          return "invalid time";
        }
        break;
      } // END case time

      case "maxlength": {
        return maxLength(strField, arrRule[4]);
        break;
      } // END case maxlength

      case "minlength": {
        return minLength(strField, arrRule[4]);
        break;
      } // END case minlength

      case "regexp": { // regular expression in the format /regexp/[optional modifier]
        var reRule = arrRule[4];
        return reRule.test(strField);
        break;
      } // END case regexp

      default: {
        return "invalid rule " + strRule;
        break;
      } // END default
    }
  }
  return "";
}

function isValidField(objField, strRules, arrRule) {
  var strReturn;
  strReturn = checkField(objField, strRules, arrRule);
  if (strReturn == "") {
    return true;
  }
  return false;
}

function isValidFieldByName(strField, strRules, arrRule) {
  return isValidField(getObject(strField), strRules, arrRule);
}


function validateField(objField, strRules) {
  var strReturn;
  strReturn = checkField(objField, strRules, arrRule);
  // Need to handle good and bad class names etc and find error message field

}

function isValidTelephone(str) {
  var nMinLength = "10";
  var nMaxLength = "14";
  var iPos;
  var str = trim(str).toLowerCase();
  if (str == "") {
    return true;
  } 
  iPos = str.indexOf("x");
  if (iPos != -1) {
    str = str.substr(0, iPos);
  }
  var strIgnore = " ()-";
  var strNew = "";
  for (i = 0; i < str.length; i++) {
	  if (strIgnore.indexOf(str.charAt(i)) == -1) {
	     strNew += str.charAt(i);
	  }
  } 
  str = strNew;
  if (str.charAt(0) == "+") {
    str = str.substr(1);
  }
  if (!isInteger(str)) {
    return false;
  }
  if (str.length < nMinLength || str.length > nMaxLength) {
    return false;
  }
  return true;
}

function isValidTime(str) {
  // Not yet implemented
  return true;
}

function isValidDate(str, objField) {
  var checkstr = "0123456789";
  var Datevalue = "";
  var DateTemp = "";
  var separator = "/";
  var day;
  var month;
  var year;
  var leap = 0;
  var err = 0;
  var i;
  err = 0;
  var iPos;
  DateValue = trim(str);
  if (trim(str) == "") {
    if (arguments.length > 1) {
      DateValue = objField.value;
    }
  }
  if (DateValue == "") {
    return true;
  } 
  // Add zeros as required to day and month 
  var strSeparatorIn = separator;
  if (DateValue.indexOf(strSeparatorIn) == -1) {
    strSeparatorIn = "-";
  }
  if (DateValue.indexOf(strSeparatorIn) == -1) {
    strSeparatorIn = ".";
  } 
  iPos = DateValue.indexOf(strSeparatorIn);
  if (iPos == 1) {
    DateValue = "0" + DateValue;
  }
  iPos = DateValue.substring(3).indexOf(strSeparatorIn);     
  if (iPos == 1) {
    DateValue = DateValue.substring(0, 3) + "0" +  DateValue.substring(3);
  }
  // Delete all chars except 0..9 
  for (i = 0; i < DateValue.length; i++) {
	  if (checkstr.indexOf(DateValue.substr(i,1)) >= 0) {
	     DateTemp = DateTemp + DateValue.substr(i,1);
	  }
  }
  if (DateTemp == "") {
    return false;
  } 
  DateValue = DateTemp;
  // Always change date to 8 digit string 
  if (DateValue.length == 4) {
    DateValue = DateValue + (new Date()).getFullYear();
  }
  if (DateValue.length == 6) {
    var nYear = DateValue.substr(4,2);
    if (nYear > 40) {
      nYear = "19" + nYear;
    }
    else {
      nYear = "20" + nYear;   
    }  
    DateValue = DateValue.substr(0,4) + nYear;
  }
  if (DateValue.length != 8) {
     err = 19;
  }
  // year is wrong if year = 0000 
  year = DateValue.substr(4,4);
  if (year == 0) {
      err = 20;
  }
  // Validation of month 
  month = DateValue.substr(2,2);
  if ((month < 1) || (month > 12)) {
     err = 21;
  }
  // Validation of day 
  day = DateValue.substr(0,2);
  if (day < 1) {
    err = 22;
  }
  // Validation leap-year / february / day 
  if ((year % 4 == 0) || (year % 100 == 0) || (year % 400 == 0)) {
    leap = 1;
  }
  if ((month == 2) && (leap == 1) && (day > 29)) {
    err = 23;
  }
  if ((month == 2) && (leap != 1) && (day > 28)) {
    err = 24;
  }
  // Validation of other months 
  if ((day > 31) && ((month == "01") || (month == "03") || (month == "05") || (month == "07") || (month == "08") || (month == "10") || (month == "12"))) {
    err = 25;
  }
  if ((day > 30) && ((month == "04") || (month == "06") || (month == "09") || (month == "11"))) {
    err = 26;
  }
  // if 00 is entered, no error, deleting the entry 
  if ((day == 0) && (month == 0) && (year == 00)) {
    err = 0; 
    day = ""; 
    month = ""; 
    year = ""; 
    separator = "";
  }
  if (err == 0) {
    if (arguments.length > 1) {
      objField.value = day + separator + month + separator + year;
    }
    return true;
  }
  return false;
}


function getObject(n, d) { //v4.01
  var p,i,x;  
  if (!d) {
    d=document;
  } 
  if ((p=n.indexOf("?")) > 0 && parent.frames.length) {
    d = parent.frames[n.substring(p+1)].document; 
    n = n.substring(0,p);
  } 
  if (!(x=d[n]) && d.all) {
    x = d.all[n]; 
  }
  for (i=0;!x&&i<d.forms.length;i++) {
    x=d.forms[i][n];
  }
  for (i=0;!x&&d.layers&&i<d.layers.length;i++) {
    x= getObject(n, d.layers[i].document);
  }
  if (!x && d.getElementById) {
    x = d.getElementById(n); 
  }
  return x;
}

function handleError(objField, strMsg) {
  if ((objField.type == "text") || (objField.type == "textarea") || (objField.type == "password")) {
    if (objLastErrorField != null) {
      objLastErrorField.style.backgroundColor = strLastErrorFieldBGColor;
    }
    objLastErrorField = objField;
    strLastErrorFieldBGColor = objField.style.backgroundColor;
    objField.style.backgroundColor =  strErrorColor;
  }
  setFocus(objField);
  alert(strMsg);
}

function clearError(objField) {
  if ((objField.type == "text") || (objField.type == "textarea") || (objField.type == "password")) {
    objField.style.backgroundColor = "#FFFFFF";
  }
}


var MODE_ALERT = "1";
var MODE_ERROR_FIELD = "2";

var errorStateClass = "error";
var errorFieldSuffix = "_msg";
var validationMode = MODE_ERROR_FIELD;

var aFieldValidationAttributes;

function validateField(objField) {
  var aAttributes;
  var strValidation;
  var strOriginalClassName;
  var bValid = true;
  if (!aFieldValidationAttributes) {
    strValidation = objField.validation;
  }
  else {
    aAttributes = getValidtationAttributes(objField.name);
    strValidation = aAttributes[1];
    strOriginalClassName = aAttributes[2];
  }
  var strMessage = trim(checkField(objField, strValidation))
  if (validationMode == MODE_ALERT) {
    if (strMessage != "") {
      alert(strMessage);
    }
    bValid = false;
  }  
  else if (validationMode == MODE_ERROR_FIELD) {
    var strErrorField = objField.name + this.errorFieldSuffix;
    strErrorField = strErrorField.replace("[]", "");
    var objErrorField = getObject(strErrorField);
    if (!objErrorField) {
      alert("Invalid error field name " + strErrorField);
      return;
    }  
    if (strMessage != "") {
      if (!aFieldValidationAttributes.length) {
        objField.originalClassName = objField.className;
      } 
      objField.className = errorStateClass;
      objErrorField.innerHTML = "- " + strMessage;
      bValid = false;
    }
    else {
      if (objField.className == errorStateClass) {
        if (aFieldValidationAttributes.length) {
          objField.className = strOriginalClassName; 
        }
        else {    
          objField.className = objField.originalClassName;
        }
      }
      objErrorField.innerHTML = "";
    }
  }
  else {
    alert("Invalid validation mode (" + mode + ")");
  }
  return bValid;
}

function attachFieldValidation(strForm, aRules) {
	var objForm = getObject(strForm);
  if (arguments.length > 1) {
    aFieldValidationAttributes = new Array(aRules.length);
    for (i = 0; i < aRules.length; i++) {
      var strField = aRules[i][0];
      var strRule = aRules[i][1];
      var objField = getObject(strField);
      objField.onblur = function() { validateField(this); }
      aFieldValidationAttributes[i] = [strField, strRule, objField.className, ""];
    }      
  }
  else {
    for (i = 0; i < objForm.length; i++) {
      if (objForm[i].validation) {
        objForm[i].onblur = function() { validateField(this); }
      }
    }
  }
}

function getValidtationAttributes(strField) {
  if (!aFieldValidationAttributes.length) {
    return "";
  }
  for (i = 0; i < aFieldValidationAttributes.length; i++) {
    var strFieldName = aFieldValidationAttributes[i][0];
    if (strFieldName == strField) {
      return aFieldValidationAttributes[i];
    }
  }
  alert("No validation attributes found for field: " + strField);
  return "";
}

function validateForm(aRules) {
  var bValid = true; 
  for (var iRule = 0; iRule < aRules.length; iRule++) {
    var strField = aRules[iRule][0];
    if (!validateField(getObject(strField))) {
      bValid = false;
    }
  }
  return bValid;
}