var checkObjects     = new Array();
var errors           = "";
var errorCount       = 0;
var returnVal        = false;
var language         = new Array();

language["header"]         = "____________________________________\n\nThe following error(s) have occured:\n____________________________________\n"
language["start"]          = "  ->";
language["field"]          = " The ";
language["require"]        = " field is required";
language["requireand"]     = " field is required and";
language["minlength"]      = " must consist of at least ";
language["maxlength"]      = " must not contain more than ";
language["minmaxlength"]   = " and no more than ";
language["minvalue"]       = " must be at least ";
language["maxvalue"]       = " value cannot be more than ";
language["minmaxvalue"]    = " but no more than ";
language["chars"]          = " characters";
language["num"]            = " must contain a number";
language["int"]            = " must contain a whole number";
language["float"]          = " must contain a number";
language["email"]          = " must contain a valid e-mail address";
language["errors"]         = " Number of errors: ";
language["row"]            = " Row: ";

// -----------------------------------------------------------------------------
// define - Call this function in the beginning of the page. I.E. onLoad.
//
//    n = name of the input field (Required)
//    type = string, num, email (Required)
//    HTMLname
//    minlength = the value must have at least [min] characters (Optional)
//    maxlength = the value must have maximum [max] characters (Optional)
//    d = (Optional)
//
// -----------------------------------------------------------------------------

function sysValidateInit()
{
   checkObjects     = new Array();
   errors           = "";
   errorCount       = 0;
   returnVal        = false;
}


function sysInit(form, HTMLname, type)
{
   eval("V_"+form+" = new sysInitResult(form, HTMLname, type);");
   checkObjects[checkObjects.length] = eval("V_"+form);

   return checkObjects[checkObjects.length-1];
}

function sysInitResult(form, HTMLname, type)
{

   this.form         = form;
   this.HTMLname     = HTMLname;
   this.type         = type;

   this.formname     = "record";
   this.isrequired   = false;
   this.minlength    = 0;
   this.maxlength    = 0;
   this.thedefault   = "";
   this.minvalue     = 0;
   this.maxvalue     = 999999999;
   this.format       = "";
}

function sysValidate( )
{
   if (checkObjects.length > 0)
   {
      errors = "";
      errorCount = 0;
      var tmpError = "";
      var row = 0;
      var savedRow = 0;

      for (o = 0; o < checkObjects.length; o++)
      {
         //
         // If the name begins with '_' then this is a list value
         //
         if ((checkObjects[o].form.substring(0,1)) == "_") continue;

         var validateObject        = new Object();

         validateObject.form        = eval("document." + checkObjects[o].formname + "." + checkObjects[o].form + ";");
         var type                   = eval("document." + checkObjects[o].formname + "." + checkObjects[o].form + ".type;");
         if (type == "text" || type == "textarea" || type == "password")
         {
            validateObject.val      = eval("document." + checkObjects[o].formname + "." + checkObjects[o].form + ".value;");
            validateObject.len      = eval("document." + checkObjects[o].formname + "." + checkObjects[o].form + ".value.length;");
         }
         else if (type == "hidden")
         {
            continue;
         }
         else
         {
            validateObject.val      = "";
            validateObject.len      = 0;
         }

         validateObject.formname    = checkObjects[o].formname;
         validateObject.isrequired  = checkObjects[o].isrequired;
         validateObject.HTMLname    = checkObjects[o].HTMLname;
         validateObject.minlength   = checkObjects[o].minlength;
         validateObject.maxlength   = checkObjects[o].maxlength;
         validateObject.type        = checkObjects[o].type;
         validateObject.thedefault  = checkObjects[o].thedefault;
         validateObject.minvalue    = checkObjects[o].minvalue;
         validateObject.maxvalue    = checkObjects[o].maxvalue;
         validateObject.format      = checkObjects[o].format;

            //
            // Almost the same as sysValidateList() (mostly WITHOUT the row stuff)
            //

            tmpError = doValidateObject(validateObject);
            if (tmpError)
            {
               if(tmpError == "SETTODEFAULT")
               {
                  eval("document." + checkObjects[o].formname + "." + checkObjects[o].form + ".value='" + validateObject.thedefault + "';");
               }
               else
               {
                  errors += tmpError;
               }
            }
            else
            {
               if(validateObject.format == "yorn" || validateObject.format == "upper")
               {
                  eval("document." + checkObjects[o].formname + "." + checkObjects[o].form + ".value='" + validateObject.val.toUpperCase() + "';");
               }
               if(validateObject.format == "lower")
               {
                  eval("document." + checkObjects[o].formname + "." + checkObjects[o].form + ".value='" + validateObject.val.toLowerCase() + "';");
               }
            }

            //
            // Almost the same as sysValidateList() (mostly WITHOUT the row stuff)
            //
      }
   }

   if (errors)
   {
      var msg = language["header"].concat("\n" + errors + "\n");
      // var msg = language["header"].concat("\n" + errors + "\n"+ language["errors"] + errorCount);

      alert(msg);
      errors = "";
      returnVal = false;
   }
   else
   {
      returnVal = true;
   }
}


function sysValidateList(changeArray)
{
   if (checkObjects.length > 0)
   {
      errors = "";
      errorCount = 0;
      var tmpError = "";
      var row = 0;
      var savedRow = 0;

      for (lca=0;lca<changeArray.length;lca++)
      {
			if (changeArray[lca] == "") continue;
         for (o = 0; o < checkObjects.length; o++)
         {
            //
            // If the name does not begin with '_' then this is not a list value
            //
            if ((checkObjects[o].form.substring(0,1)) != "_") continue;

            var validateObject         = new Object();
            validateObject.form        = eval("document." + checkObjects[o].formname + ".x_" + changeArray[lca] + checkObjects[o].form + ";");
            var type                   = eval("document." + checkObjects[o].formname + ".x_" + changeArray[lca] + checkObjects[o].form + ".type;");
            if (type == "text" || type == "textarea" || type == "password")
            {
               validateObject.val      = eval("document." + checkObjects[o].formname + ".x_" + changeArray[lca] + checkObjects[o].form + ".value;");
               validateObject.len      = eval("document." + checkObjects[o].formname + ".x_" + changeArray[lca] + checkObjects[o].form + ".value.length;");
            }
            else if (type == "hidden")
            {
				continue;
            }
            else
            {
               validateObject.val      = "";
               validateObject.len      = 0;
            }

            validateObject.formname    = checkObjects[o].formname;
            validateObject.isrequired  = checkObjects[o].isrequired;
            validateObject.HTMLname    = checkObjects[o].HTMLname;
            validateObject.minlength   = checkObjects[o].minlength;
            validateObject.maxlength   = checkObjects[o].maxlength;
            validateObject.type        = checkObjects[o].type;
            validateObject.thedefault  = checkObjects[o].thedefault;
            validateObject.minvalue    = checkObjects[o].minvalue;
            validateObject.maxvalue    = checkObjects[o].maxvalue;
            validateObject.format      = checkObjects[o].format;

            // Duplicate code as sysValidate() but WITH the row stuff
            tmpError = doValidateObject(validateObject);
            if (tmpError)
            {
               if(tmpError == "SETTODEFAULT")
               {
                  eval("document." + checkObjects[o].formname + ".x_" + changeArray[lca] + checkObjects[o].form + ".value='" + validateObject.thedefault + "';");
               }
               else
               {
                  row = eval("document." + checkObjects[o].formname + ".x_" + changeArray[lca] + "_row.value;");
                  if (row != savedRow)
                  {
                     tmpError = language["row"] + row + "\n" + tmpError;
                     savedRow = row;
                  }
                  else
                  {
                     // tmpError = tmpError
                  }
                  errors += tmpError;
               }
            }
            else
            {
               if(validateObject.format == "yorn" || validateObject.format == "upper")
               {
                  eval("document." + checkObjects[o].formname + ".x_" + changeArray[lca] + checkObjects[o].form + ".value='" + validateObject.val.toUpperCase() + "';");
               }
               if(validateObject.format == "lower")
               {
                  eval("document." + checkObjects[o].formname + ".x_" + changeArray[lca] + checkObjects[o].form + ".value='" + validateObject.val.toLowerCase() + "';");
               }
            }
         }
      }
   }

   if (errors)
   {
      var msg = language["header"].concat("\n" + errors + "\n");
      // var msg = language["header"].concat("\n" + errors + "\n"+ language["errors"] + errorCount);

      alert(msg);
      errors = "";
      returnVal = false;
   }
   else
   {
      returnVal = true;
   }
}

function doValidateObject(validateObject)
{

   var error = "";

   if (validateObject.type == "string")
   {

      if (validateObject.minlength && validateObject.maxlength && (validateObject.len < validateObject.minlength || validateObject.len > validateObject.maxlength))
      {
         error = language['start'] + language['field'] + validateObject.HTMLname + ((validateObject.isrequired)?language['requireand']:"") + language['minlength'] + validateObject.minlength + language['minmaxlength'] + validateObject.maxlength+language['chars'] + "\n";
         errorCount++;
      }

      else if (validateObject.minlength && !validateObject.maxlength && (validateObject.len < validateObject.minlength))
      {
         error = language['start'] + language['field'] + validateObject.HTMLname + ((validateObject.isrequired)?language['requireand']:"") + language['minlength'] + validateObject.minlength + language['chars'] + "\n";
         errorCount++;
      }

      else if (validateObject.maxlength && !validateObject.minlength &&(validateObject.len > validateObject.maxlength))
      {
         error = language['start'] + language['field'] + validateObject.HTMLname + ((validateObject.isrequired)?language['requireand']:"") + language['maxlength'] + validateObject.maxlength + language['chars'] + "\n";
         errorCount++;
      }

      else if (validateObject.isrequired && !validateObject.minlength && !validateObject.maxlength && validateObject.len <= 0)
      {
         error = language['start'] + language['field'] + validateObject.HTMLname + language['require'] + "\n";
         errorCount++;
      }

      else if(validateObject.format)
      {
         if(validateObject.format == "yorn")
         {
            if (validateObject.val && validateObject.val.toUpperCase() != "Y" && validateObject.val.toUpperCase() != "N")
            {
               error = language['start'] + language['field'] + validateObject.HTMLname + " must be Y or N " + "\n";
               errorCount++;
            }
         }
      }
   }

   else if (validateObject.type == "int" || validateObject.type == "float")
   {

      if (validateObject.type == "int")
      {
         if( validateObject.isrequired && validateObject.len <= 0 || validateObject.len > 0 && isNaN(validateObject.val) || validateObject.val.indexOf(".") > -1 )
         {
            error = language['start'] + language['field'] + validateObject.HTMLname + ((validateObject.isrequired)?language['requireand']:"") + language['int'] + "\n";
            errorCount++;
         }
         else if (parseInt(validateObject.val) < validateObject.minvalue)
         {
            error = language['start'] + language['field'] + validateObject.HTMLname + ((validateObject.isrequired)?language['requireand']:"") + language['minvalue'] + validateObject.minvalue + language['minmaxvalue'] + validateObject.maxvalue + "\n";
            errorCount++;
         }
         else if (parseInt(validateObject.val) > validateObject.maxvalue)
         {
            error = language['start'] + language['field'] + validateObject.HTMLname + ((validateObject.isrequired)?language['requireand']:"") + language['minvalue'] + validateObject.minvalue + language['minmaxvalue'] + validateObject.maxvalue + "\n";
            errorCount++;
         }
      }

      if (validateObject.type == "float")
      {

         if ((validateObject.type == "float") && (validateObject.isrequired && validateObject.len <= 0) || (validateObject.len > 0 && isNaN(validateObject.val)))
         {
            error = language['start'] + language['field'] + validateObject.HTMLname + ((validateObject.isrequired)?language['requireand']:"") + language['float'] + "\n";
            errorCount++;
         }
         else if (parseFloat(validateObject.val) < validateObject.minvalue)
         {
            error = language['start'] + language['field'] + validateObject.HTMLname + ((validateObject.isrequired)?language['requireand']:"") + language['minvalue'] + validateObject.minvalue + language['minmaxvalue'] + validateObject.maxvalue + "\n";
            errorCount++;
         }
         else if (parseFloat(validateObject.val) > validateObject.maxvalue)
         {
            error = language['start'] + language['field'] + validateObject.HTMLname + ((validateObject.isrequired)?language['requireand']:"") + language['minvalue'] + validateObject.minvalue + language['minmaxvalue'] + validateObject.maxvalue + "\n";
            errorCount++;
         }
      }

      else if (validateObject.minlength && validateObject.maxlength && (validateObject.len < validateObject.minlength || validateObject.len > validateObject.maxlength))
      {
         error = language['start'] + language['field'] + validateObject.HTMLname + ((validateObject.isrequired)?language['requireand']:"") + language['minlength'] + validateObject.minlength + language['minmaxlength'] + validateObject.maxlength+language['chars'] + "\n";
         errorCount++;
      }

      else if (validateObject.minlength && !validateObject.maxlength && (validateObject.len < validateObject.minlength))
      {
         error = language['start'] + language['field'] + validateObject.HTMLname + ((validateObject.isrequired)?language['requireand']:"") + language['minlength'] + validateObject.minlength + language['chars'] + "\n";
         errorCount++;
      }

      else if (validateObject.maxlength && !validateObject.minlength &&(validateObject.len > validateObject.maxlength))
      {
         error = language['start'] + language['field'] + validateObject.HTMLname + ((validateObject.isrequired)?language['requireand']:"") + language['maxlength'] + validateObject.maxlength + language['chars'] + "\n";
         errorCount++;
      }

      else if (validateObject.isrequired && !validateObject.minlength && !validateObject.maxlength && validateObject.len <= 0)
      {
         error = language['start'] + language['field'] + validateObject.HTMLname + language['require'] + "\n";
         errorCount++;
      }

   }

   else if(validateObject.type == "email")
   {

      // Checking existense of "@" and ".". Length of must >= 5 and the "." must not directly precede or follow the "@"
      if ((validateObject.val.indexOf("@") == -1) || (validateObject.val.charAt(0) == ".") || (validateObject.val.charAt(0) == "@") || (validateObject.len < 6) || (validateObject.val.indexOf(".") == -1) || (validateObject.val.charAt(validateObject.val.indexOf("@")+1) == ".") || (validateObject.val.charAt(validateObject.val.indexOf("@")-1) == "."))
      {
         error = language['start'] + language['field'] + validateObject.HTMLname + language['email'] + "\n";
      }

   }

   //if (validateObject.format && validateObject.len <= 0 && error=="" )
   //{
   //   if(validateObject.format == "yorn"
   //   error = "SETTODEFAULT";
   //}

   if (validateObject.thedefault && validateObject.len <= 0 && error=="" )
   {
      error = "SETTODEFAULT";
   }

   return error;
}


function setPatternToShortDate(dateString, pattern)
{
   if ((dateString == null) || (dateString == ""))
   {
      return "";
   }
   if ((pattern == null) || (pattern == ""))
   {
      return "";
   }
   // Static & Final
   var alertMessage = "Invalid Date";
   var seperatorString = " /-.";    // Possible SHORT date delimeters
   var SEPERATORS = seperatorString.split("");
   var n = SEPERATORS.length;
   var dateCharString = "M~12,MM~12,d~31,dd~31,y,yy,yyyy";
   var DATE_CHARS = dateCharString.split(",");
   var d = DATE_CHARS.length;
   // Get the pattern delimeter
   for (var i = 0; i < n; i++)
   {
      if (pattern.match(SEPERATORS[i]))
      {
         var currentSeparator = SEPERATORS[i];
         break;
      }
   }

   // Tokenize the pattern for later use
   var patternArray = pattern.split(currentSeparator);

   // Get the dateString delimeter
   for (var i = 0; i < n; i++)
   {
      if (dateString.match(SEPERATORS[i]))
      {
         var dateStringSeparator = SEPERATORS[i];
         break;
      }
   }
   // Tokenize the dateString for later use
   var dateStringArray = dateString.split(dateStringSeparator);

   // Make sure dateString can be parsed to a Date();
   if ((dateStringSeparator != ".") && (dateStringSeparator != " "))
   {
      if (! __validateDateType(dateString))
      {
      alert(alertMessage);
      return "";     // Bad String
      }
   }
   // Make some assumptions with the dateString passed by the user based on the pattern passed
   var myNewString = "";
   var returnString = "";
   for (var i = 0; i < patternArray.length; i++)
   {
      myNewString += patternArray[i] + "~"+dateStringArray[i]+"|";
   }
   var myNewStringArray = myNewString.split("|");
   for (var i = 0; i < myNewStringArray.length; i++)
   {
      var myDateToken = myNewStringArray[i].split("~");
      var newDateReturn = "";
      for (var j = 0; j < d; j++)
      {
         dateCharToken = DATE_CHARS[j].split("~");
         if (myDateToken[0] == dateCharToken[0])
         {
            if ((myDateToken[0] == "d") || (myDateToken[0] == "dd") || (myDateToken[0] == "M") || (myDateToken[0] == "MM"))
            {
               // check for overflow
               if (parseInt(myDateToken[1],10) > parseInt(dateCharToken[1],10))
               {
                  alert(alertMessage);
                  return "";
               }
               if ((myDateToken[0] == "d") || (myDateToken[0] == "dd"))
               {
                  var chkDay = myDateToken[1];
               }
               else
               {
                  var chkMonth = myDateToken[1];
               }
               // format according to pattern - day and month
               var tk = "";
               if (((myDateToken[0].length == 2) && (parseInt(myDateToken[1],10)) < 10) && (myDateToken[1].length != 2))
               {
                  var tk = "0"+myDateToken[1];
               }
               else
               {
                  if (((myDateToken[0].length == 1) && (parseInt(myDateToken[1],10)) < 10) && (myDateToken[1].length > 1))
                  {
                     var tk = myDateToken[1].split("")[1];
                  }
                  else
                  {
                     if (myDateToken[1].length <3)
                     {
                        var tk = myDateToken[1];
                     }
                  }
               }
               if (parseInt(tk,10) == 0)
               {
                  alert(alertMessage);
                  return "";
               }
               if (tk.length > 2)
               {
                  return  "";
               }
            }
            else
            {
               // format according to pattern - year
               var chkYear = myDateToken[1];
               if ((myDateToken[0] == "y") || (myDateToken[0] == "yy")|| (myDateToken[0] == "yyyy"))
               {
                  var curYr =  __validateYear(myDateToken[1],myDateToken[0]);
                  if (curYr != "")
                  {
                     var tk = curYr;
                  }
                  else
                  {
                     alert(alertMessage);
                     return "";
                  }
               }
            }
            returnString = returnString +tk+currentSeparator;
         }
      }
   }
   returnStrVal = returnString.substring(0,returnString.length-1);
   // tokeneize and do a final check before returning the new dateString
   returnStrValArray = returnStrVal.split(currentSeparator);
   for (var j = 0; j < returnStrValArray.length; j++)
   {
      if (isNaN(parseInt(returnStrValArray[j],10)))
      {
         returnStrVal = "";
         break;
      }
   }
   if (! __checkLastDayOfMonth(chkDay,chkMonth,chkYear))
   {
      alert(alertMessage);
      return dateString;
   }
   return returnStrVal;
}

function __validateYear(yrValue,yrPattern)
{
   var BIG_YEAR = "yyyy";
   var MEDIUM_YEAR = "yy";
   var SMALL_YEAR  = "y";

   var myValue = yrValue;
   // handle SMALL_YEAR;
   if (yrPattern == SMALL_YEAR)
   {
      if ((myValue.length == 4))
      {
         myValue = myValue.substring(2,4);
      }
      if ((myValue.length == 2) && (parseInt(myValue,10) < 10))
      {
         var retString = myValue.split("")[1];
         return retString;
      }
      else
      {
         if ((myValue.length == 1) || ((myValue.length == 2) && (parseInt(myValue,10) > 9)))
         {
            var retString = myValue;
            return retString;
         }
      }
   }
   // handle MEDIUM_YEAR;
   if (yrPattern == MEDIUM_YEAR)
   {
      if ((myValue.length == 4))
      {
         myValue = myValue.substring(2,4);
      }
      if ((myValue.length < 2) && (parseInt(myValue,10) < 10))
      {
         var retString = "0"+myValue;
         return retString;
      }
      else
      {
         if ((myValue.length == 2))
         {
            var retString = myValue;
            return retString;
         }
      }
   }
   // handle BIG_YEAR;
   if (yrPattern == BIG_YEAR)
   {
      if ((myValue.length == 2) || (myValue.length == 1))
      {
         var myCentury = __getCentury(myValue);
         var retString = (myCentury + parseInt(myValue,10));
         return retString.toString();
      }
      else
      {
         if ((myValue.length == 4))
         {
            var retString = myValue;
            return retString;
         }
      }
   }
   return "";
}

function __getCentury(yr)
{
   var OFFSET_YEAR = 30;
   var myDate = new Date();
   var cutOffStr = (myDate.getFullYear() +  OFFSET_YEAR).toString();
   var cutOff = parseInt(cutOffStr.substring(2,4),10);
   if (parseInt(yr,10) > cutOff)
   {
      var century = 1900;        // Safe to assume that we won't be dealing with dates  below the year 1900 !!
   }
   else
   {
      var century = 2000;        // Safe to assume that we won't be dealing with dates  above the year 2099  !!
   }
   return century;
}

function __validateDateType(newValue)
{
   if( !isNaN( Date.parse(newValue) ) )
   {
      return true;
   }
   else
   {
      return false;
   }
}

function __checkLastDayOfMonth(dy,mo,yr)
{
   var dayMonthString = "01~31,02~28,03~31,04~30,05~31,06~30,07~31,08~31,09~30,10~31,11~30,12~31";
   var dayMonthArray = dayMonthString.split(",");
   for (var j = 0; j < 12; j++)
   {
      dmToken = dayMonthArray[j].split("~");
      if (parseInt(dmToken[0],10) == parseInt(mo,10))
      {
         if (parseInt(mo,10) != 2)
         {
            if (((parseInt(dy,10) == 30) || (parseInt(dy,10) == 31)) && (parseInt(dy,10) > dmToken[1]))
            {
               return false;
            }
         }
         else
         {  // handle leap year if the month is Feb
            if (parseInt(dy,10) > 29)
            {
               return false;
            }
            var mod = parseInt(yr,10)/4;    // Mod 4
            if (! isNaN(parseInt(mod.toString().split(".")[1],10) ))
            {  // not divisible by 4
               if (parseInt(dy,10) > 28)
               {      // not a leap year
                  return false;
               }
            }
            else
            {
               var mod = parseInt(yr,10)/40;    // Mod 400   (divide by 40 - last 2 digits of yr)
               if (isNaN(parseInt(mod.toString().split(".")[1],10) ))
               {  // divisible by 40
                  if (parseInt(dy,10) > 29)
                  {  // leap year
                     return false;
                  }
               }
               else
               {
                  var mod = parseInt(yr,10)/10;    // Mod 100   (divide by 10 - last 2 digits of yr)
                  if (isNaN(parseInt(mod.toString().split(".")[1],10) ))
                  {  // divisible by 10
                     if (parseInt(dy,10) > 28)
                     {  // not a leap year
                        return false;
                     }
                  }
               }
            }
         }
      }
   }
   return true;
}


/*
function formKeyPress(evt, pElement)
{
   pForm = pElement.form;

   if (window.Event)
   {
      var whichCode = evt.which;
   }
   else
   {
      if (evt.type == "keypress")
         var whichCode = evt.keyCode;
      else
         var whichCode = evt.button;
   }

   if (whichCode == 13)
   {
      if (top.doValidate() == true)
         if (doAction(pElement.form, pElement.name))
            pForm.submit();
      return false;
   }
   return true;
}

function buttonOnClick(pForm, sName)
{
   if (doValidate() == true)
      if (doAction(pForm, sName))
         pForm.submit();
}
*/