//Patrick
//-------------------------------------------------------------------------
// Field checks Library
// R. van Amesfoort (CGEY) Sennol Kaya (ADP)
// 
//-------------------------------------------------------------------------

var FComma = ',';
var FPoint  = '.';
var FMinus	= '-'
var FDecimalSeperator = ','
var Msg_part_1 = 'De invoer datum in rubriek (';
var Msg_part_2 = ') is niet juist. Het formaat moet zijn "31/12/2002"';
var Msg_part_3 = ') is geen geldige datum"';

//-------------------------------------------------------------------------

function replaceChar(aValue,aOldChar,aNewChar) {
var vValue='';
var vChar;
  for (var i = 0; i < aValue.length; i++) {
    vChar = aValue.substring(i,i+1); 
    if (vChar == aOldChar){
      vValue = vValue + aNewChar;
    }
    else {
      vValue = vValue + vChar;
    }
  }
  return vValue;
}

//-------------------------------------------------------------------------

function trimString (str) {
  while (str.charAt(0) == ' ')
    str = str.substring(1);
  while (str.charAt(str.length - 1) == ' ')
    str = str.substring(0, str.length - 1);
  return str;
}

//-------------------------------------------------------------------------

function IsNumber(aInput) {
var vDubbelSeperator = 0;
var j
var vString 

  if ((aInput.value == null) || (aInput.value == "")) {
    return false;
  }

  aString = trimString(aInput.value);
  vString = '';
//look for a piont and replace it with the FDecimalSeperator
 for (j = 0; j < aString.length; j++) {
	if (aString.substring(j,j+1) == FPoint) {
		 vString = vString + FDecimalSeperator;
		 //aString.substring(j,j+1) == FDecimalSeperator;
	}
	else {
		vString = vString + aString.substring(j,j+1);
	}
	
  }
aInput.value = vString;
aString = trimString(aInput.value);

		if (aInput.value.substring(0,1)=='-'){
  		blnNegNul = true;
		  for (var ic=1;ic < aInput.value.lenght;ic++) {
				vString = aInput.value.substring(ic,1);
				if ((vString != '0') && (vString != ',')) {
					blnNegNul = false;
				}
		  }
		  if (blnNegNul == true ) { 
				return false;
			}
		}

  for (j = 0; j < aString.length; j++) {
    if (aString.substring(j,j+1) == FDecimalSeperator){
      ++vDubbelSeperator;
      if (vDubbelSeperator > 1){
        return false;
      }
    }

    if (aString.substring(j,j+1) == "-"){
      if (j > 0){
        return false;
      }
    }

    if ((aString.substring(j,j+1) != "0") &&
        (aString.substring(j,j+1) != "1") &&
        (aString.substring(j,j+1) != "2") &&
        (aString.substring(j,j+1) != "3") &&
        (aString.substring(j,j+1) != "4") &&
        (aString.substring(j,j+1) != "5") &&
        (aString.substring(j,j+1) != "6") &&
        (aString.substring(j,j+1) != "7") &&
        (aString.substring(j,j+1) != "8") &&
        (aString.substring(j,j+1) != "9") &&
        (aString.substring(j,j+1) != "-") &&
        (aString.substring(j,j+1) != FComma)) {
      return false;
    }
  }
  return true;
}

//-------------------------------------------------------------------------

function isPosWholeNumber(aString) {
var vDubbelSeperator = 0;

  if ((aString == null) || (aString == "")) {
    return false;
  }
  for (j = 0; j < aString.length; j++) {
    if (aString.substring(j,j+1) == FDecimalSeperator){
      ++vDubbelSeperator;
      if (vDubbelSeperator > 1){
        return false;
      }
    }

    if (aString.substring(j,j+1) == "-"){
      if (j > 0){
        return false;
      }
    }

    if ((aString.substring(j,j+1) != "0") &&
        (aString.substring(j,j+1) != "1") &&
        (aString.substring(j,j+1) != "2") &&
        (aString.substring(j,j+1) != "3") &&
        (aString.substring(j,j+1) != "4") &&
        (aString.substring(j,j+1) != "5") &&
        (aString.substring(j,j+1) != "6") &&
        (aString.substring(j,j+1) != "7") &&
        (aString.substring(j,j+1) != "8") &&
        (aString.substring(j,j+1) != "9")) {
      return false;
    }
  }
  return true;
}

//-------------------------------------------------------------------------

function  IsNLSocialSecNumber (S){
var I;
var Som; 
var vResult = true;
var vNul = '0';
 
  if (S.length != 9) {
    vResult = false;
  }
  else {
    Som = 0;
    for (I=1; I < 9;++I) {
      Som = Som + (S.charCodeAt(I-1)-vNul.charCodeAt(0)) * (9-I+1);
    }
    vResult = ((Som % 11) == (S.charCodeAt(8)-vNul.charCodeAt(0)));
  }
  return vResult;  
}

//-------------------------------------------------------------------------

function  IsNLBankNumber (S){
var I;
var Som; 
var vNul = '0';

  if (!isPosWholeNumber(S)) {
    return false;
  }
  if (S.length < 9) {
    return true;
  }
  else {
    Som = 0;
    for (I=1; I < S.length+1;++I) {
      Som  = Som + (S.charCodeAt(I-1)-vNul.charCodeAt(0)) * (S.length-I+1);
    }
    vResult = ((Som % 11) == 0);
    return vResult;		
  }
}

//-------------------------------------------------------------------------

function FormatValue(aInput) {
var i = 0;
var t;
var vDecimalenString = '';
var vOrigineelWaarde = aInput.value;
var vMin;
var vMax;
var vBeforeDecimalSeperator;
var vAfterDecimalSeperator;
var vCaractersBefore;
var vCaractersAfter;
var vDecimalInInput; 
var vString;
  vString = aInput.value;

  //look if number is negative
  if ((vString.substring(0,1) == "-") && (vString.substring(1,2) == ","))
  	//Looking if the next character is a FDecimalSeperator
  	//if so, a 0 must be put between - and ,
  	{
	aInput.value = "-0," + vString.substring(2, vString.length);
  	}
  if ((vString.substring(0,1) == "-") && (vString.substring(1,2) == "."))
	//Doing the same for the point as decimalseperator
	{
    aInput.value = "-0," + vString.substring(2, vString.length);
  	}
  
  
  // Trim leading and trailing spaces
  while (aInput.value.charAt(0) == ' ')
    aInput.value = aInput.value.substring(1);
  
  while (aInput.value.charAt(aInput.value.length - 1) == ' ')
    aInput.value = aInput.value.substring(0, aInput.value.length - 1);

  
  // Find decimal seperator
  while ((i < aInput.value.length) && (aInput.value.charAt(i) != FDecimalSeperator)){++i;}
  
  if (i == aInput.value.length) {
    //Set variable for lengthcheck later on in function

    //geen komma gevonden
    if (aInput.Decimals > 0){
      for (t=0;t < aInput.Decimals;t++) {
        vDecimalenString = vDecimalenString + '0'
      }
      aInput.value = aInput.value + FDecimalSeperator + vDecimalenString;
      vDecimalInInput = true;
    }
    else {
        vDecimalInInput = false;
      //waarde is goed doe niets
    }
  }
  
  else {
    //Set variable for lengthcheck later on in function
    vDecimalInInput = true;
    //komma gevonden
    if (aInput.Decimals == 0){
      //mag geen decimalen bevatten
      alert('Deze invoer mag geen decimalen bevatten.');
      return false;
    }
    if (i==0) {
      //,123
      aInput.value = '0' + aInput.value;
      i++;
    }
    
    split = aInput.value.split(FDecimalSeperator);
    if (split[1].length > aInput.Decimals) {
      alert('Maximaal aantal decimalen overschreden.');
      return false;
    }
    else if (split[1].length < aInput.Decimals){
      for (t=0;t < (aInput.Decimals - split[1].length);t++) {
        // rva
        vDecimalenString = vDecimalenString + '0'
      }
      aInput.value = split[0] + FDecimalSeperator + split[1] + vDecimalenString;
    }
  }


  if (aInput.value.length >= eval(aInput.FieldLength)) {
	
	//Count number of caracters before decimalseparator
	vCaractersBefore = 0;
	i = 0;
	while ((i < aInput.value.length) && (aInput.value.charAt(i) != FDecimalSeperator)){
	  if (aInput.value.charAt(i) !=  FMinus) {
        vCaractersBefore = vCaractersBefore + 1;
	  }
	  ++i;
	}   
    //alert("vCaractersBefore" + vCaractersBefore)    
    
    vCaractersAfter = 0;	
    if (vDecimalInInput == true){ 
      //Count number of caracters after decimalseparator
      i = aInput.value.length -1;
	  while ((i > 0) && (aInput.value.charAt(i) != FDecimalSeperator)){
	    vCaractersAfter = vCaractersAfter + 1;
	    --i;
	  }
	  //alert("vCaractersAfter" + vCaractersAfter)
	}  

    //Make sure fieldlength -2(minus and decimalseperator) is >= caractersbefore + caractersafter 
    if (aInput.FieldLength < vCaractersBefore + vCaractersAfter){
      
      
      //If so compose te valid input mask to put in the message by generating the maximum en minimum values
      
      vBeforeDecimalSeperator = '';
	  for (t=0;t < (aInput.FieldLength - aInput.Decimals);t++) {
	    vBeforeDecimalSeperator = vBeforeDecimalSeperator + '9'
 	  }
	  
	  vAfterDecimalSeperator = '';
	  for (t=0;t < (aInput.Decimals);t++) {
	    vAfterDecimalSeperator = vAfterDecimalSeperator + '9'
	  }     
  	  	  
	  //Create strings for messages
	  vMin = '-' + vBeforeDecimalSeperator + FDecimalSeperator + vAfterDecimalSeperator;
	  //alert('vMin='+vMin);
	  vMax = vBeforeDecimalSeperator + FDecimalSeperator + vAfterDecimalSeperator
      //alert('vMax='+vMax);  

	  alert('De waarde moet liggen tussen ' + vMin + ' en ' + vMax);
      return false;    
      //return true;
    }else{
      //Fieldlength -2 >= caractersbefore- and after decimalseperator
      return true;
    }  
  //ValueLength doesn't exceed Fieldlength   
  }else{ 
    return true;
  }
}

//-------------------------------------------------------------------------

function BankNumberCheck(aInput) {
  if (IsNLBankNumber(aInput.value) == false) {
    alert(aInput.value + ' is geen geldig bankrekeningnummer.');
    return false;
  }
  else {
    return true;
  }
}

//-------------------------------------------------------------------------

function SocialSecNumberCheck(aInput) {
  //alert('SocialSecNumberCheck aInput.value=' + aInput.value);
  if (IsNLSocialSecNumber(aInput.value) == false) {
    alert(aInput.value + ' is geen geldig sofinummer.');
    return false;
  }
  else {
    return true;
  }
}

//-------------------------------------------------------------------------
//function NegativeOK(aInput) {
//  var j
//  var vString   
//  vString = aInput.value;
//
//  //look if number is negative
//  if ((vString.substring(0,1) == "-") && (vString.substring(1,2) == ","))
//  	//Looking if the next character is a FDecimalSeperator
//  	//if so, a 0 must be put between - and ,
//  	{
//	aInput.value = "-0," + vString.substring(2, vString.length);
//  	}
//  if ((vString.substring(0,1) == "-") && (vString.substring(1,2) == "."))
//	//Doing the same for the point as decimalseperator
//	{
//    aInput.value = "-0," + vString.substring(2, vString.length);
//  	}
//  return aInput.value;
//}
//-------------------------------------------------------------------------
function NumberCheck(aInput){
var j
var vString

//vString = NegativeOK(aInput);
aString = trimString(aInput.value);
//vString = "";
//look for a piont and replace it with the FDecimalSeperator
// for (j = 0; j < aString.length; j++) {
//	if (aString.substring(j,j+1) == FPoint) {
//		 vString = vString + FDecimalSeperator;
//		 //aString.substring(j,j+1) == FDecimalSeperator;
//	}
//	else {
//		vString = vString + aString.substring(j,j+1);
//	}
//	
//}
//aInput.value = vString;

  if (IsNumber(aInput)) {
    if (CheckDecimals(aInput)) {
    
      if (FormatValue(aInput) == true) {
        return true;
      }
      else {
        return false;
      }    
    
    }
    else {
      alert('De invoer is geen geheel getal.');
      return false;    
    }  
  }  
  else {
    alert('De ingevoerde waarde voldoet niet.');
    return false;
  }
}

//-------------------------------------------------------------------------

function CheckDecimals (aValue){
  
  var HasDecimalSeparator 
  var j
    // init
  aString = trimString(aValue.value);
  
  // check for decimal separator
  for (j = 0; j < aString.length; j++) {
    if (aString.substring(j,j+1) == FDecimalSeperator){
      HasDecimalSeparator = true   
    }
  }  
  aValue.value == aString
  if ((aValue.Decimals > 0)  &&  (HasDecimalSeparator == true)){
    return true
  }else{
    return true
  }
}



function MinMaxCheck(aInput){
var vInputValue

  //check if input has valid numeric value
  if (IsNumber(aInput)) {
    if (CheckDecimals(aInput)) {
      //format input value to valid value
      if (FormatValue(aInput) == true){
      
        //replace Komma with point because eval works with point
        vInputValue = replaceChar(aInput.value,FDecimalSeperator,FPoint);
        if (eval(vInputValue) > eval(aInput.Max)) {
          alert('De waarde moet liggen tussen ' + aInput.Min + ' en ' + aInput.Max + '.');
          return false;
        }else if (eval(vInputValue) < eval(aInput.Min)) {
          alert('De waarde moet liggen tussen ' + aInput.Min + ' en ' + aInput.Max + '.');
          return false;
        }else{
          return true;
        }
      }else{
        return false;
      }
    }else{
      alert('De ingevoerde waarde voldoet niet.');
      return false;
    }
  }else{
    alert('De ingevoerde waarde voldoet niet.');
    return false;
  }
}


//-------------------------------------------------------------------------

function IsNLPostCode (S) {
var I;
var vSubString; 

  if (S.length != 6) {
    return false;
  }
  else {
    vSubString = S.substring(0,4); 
    try {
      I = eval(vSubString);
    }
    catch (exception) {
      return false;
    }  
  }

  if ((I < 1000) || (I == null)) {
    return false
  }

  //delphi code: if not (S[5] in  ['A'..'Z','a'..'z']) then Exit;
  if (!
      (((S.charCodeAt(4) > 64) & (S.charCodeAt(4) < 91)) ||
       ((S.charCodeAt(4) > 96) & (S.charCodeAt(4) < 123)))
     ){return false}

  //delphi code: if not (S[6] in  ['A'..'Z','a'..'z']) then Exit;
  if (!
      (((S.charCodeAt(5) > 64) & (S.charCodeAt(5) < 91)) ||
       ((S.charCodeAt(5) > 96) & (S.charCodeAt(5) < 123)))
     ){return false}


  return true;  
}

//-------------------------------------------------------------------------

function ZipcodeCheck(aInput) {
  //alert('ZipcodeCheck aInput.value=' + aInput.value);
  if (IsNLPostCode(aInput.value) == false) {
    alert(aInput.value + ' is geen geldig postcode.');
    return false;
  }
  else {
    aInput.value = aInput.value.toUpperCase(); 
    return true;
  }
}


//-------------------------------------------------------------------------

function CheckInputField_proc(Input) {
  var dateInput 		= Input.value;
  //var dateInvoerString  = String(dateInput).split(/\//g);
  var dateInvoerString  = String(dateInput).split("/");
// alert('dateInvoerString is: '+dateInvoerString);  
  
  //Check if dateinput constists of 3 "parts"
  if (dateInvoerString.length < 3) {
     return false;
  }
  
  // * Enter "10" as extra parameter to convince PARSEINT ot use 10-based function: ifommited, 08 and 09 are refused (generating -1) as non-valid octal numbers
  // * Javascript dateclass loopt maand van 0 tot 11 dus invoermaand -1
  dateInvoerString[1] = String(parseInt(dateInvoerString[1], 10)-1);

  //Constructor de invoer datum meegeven anders neemt de construcor de huidige datum
  var CurrentDate = new Date(dateInvoerString[2],dateInvoerString[1],dateInvoerString[0]);
	
 
  // * Wanneer met de constructor van Date een ongeldige datum wordt meegegeven dan maakt de JavaClass er 
  //   andere datum van. Wanneer invoerdatum afwijkt van de geconstrueerde datum is het geen geldige datum.
  // alert('CurrentDate.getDate()= ' +  CurrentDate.getDate() + ' vergelijk dateInvoerString[0]' + dateInvoerString[0])
  if (CurrentDate.getDate() != dateInvoerString[0]){
    return false;
  } else {
//alert('CurrentDate.getMonth()= ' +  CurrentDate.getMonth() + ' vergelijk dateInvoerString[1]' + dateInvoerString[1])
    if (CurrentDate.getMonth() != dateInvoerString[1]){ 
      return false;
    } else { 
      if (CurrentDate.getFullYear() != dateInvoerString[2]){

        return false;
	  } else {
	    return true;  
	    }
    }
  }
}


//function CheckDatumInputField(Input) {
//alert('CheckDatumInputField');

//  if (Input.value.length > 0) {
 //   var b = DateCompletion(Input);
//    if (b == true){
//
 //     var c = CheckInputField_proc(Input); 
//      if (c == false){
//        alert(Input.value + ' is geen geldige datum. Het formaat moet zijn 31/12/2002.');
//	    Input.focus();
//	  }  
//	}else{
//	  alert (Input.value + ' is geen geldige datum. Het formaat moet zijn 31/12/2002');
//	  Input.focus();  
//	}  
//  }else if (Input.value.length == 0) {// Input.value.length = 0
//	         alert('Vul de datum in. Het formaat moet zijn 31/12/2002');
// }
 //
//}//function

//-------------------------------------------------------------------------

function invalidDateMessage(Input,error) {
  if (error ==1){
    alert(Msg_part_1 + Input.Description + Msg_part_2);
  } else {
    if (error ==2){
      alert(Msg_part_1 + Input.Description + Msg_part_3);
    } 
  }
}

function DateCompletion(aInputObject) {
  var d = new Date();
  var m = d.getMonth()+1;
  var y = d.getFullYear();   

  var v = aInputObject.value;
  var pos_1 = v.indexOf('/',0);
  var pos_2 = v.indexOf('/',pos_1+1);  
  //No slash in input => false
  if (pos_1 == -1) {
    return false;
  }else{
    //Just one slash and no month input => false
    if (v.length-1 == pos_1) {
      return false;
  	}else {
      
      //Check if there is one slash with more input => add slash + year
      if ((v.length-1 > pos_1) && (pos_2 == -1)) {
        var vInputMonth  = v.substring(pos_1+1,v.length);
         //Check if month input is 2 or less digits
        // and if month input is valid month (1-12)
         if ((vInputMonth.length > 2) || (vInputMonth > 12)){

          return false;
        }else{
          aInputObject.value = aInputObject.value + '/' + y;
          return true;
        }
      }else{
       //Check if there are two slashes => add year
          if ((v.length-1 > pos_1) && (pos_2 == v.length-1)){
	      aInputObject.value = aInputObject.value + y;
          return true;
        }else{
   	      
   	      //Check if there are two slashes and more input
	      if (v.length-1 > pos_2){
           var s = v.substring(pos_2+1,v.length);
            var sInt = parseInt(s);  
             
            if ((s.length == 3) || (s.length > 4)){ 
                return false 
            } else {
              //if lenght are two slashes and more input
               if (pos_1 == 2) {
              var vInputDay  = v.substring(0,pos_1);
             }
             else {
               var vInputDay  = v.substring(0,1);
             }

              var dg = vInputDay;
             
             var vInput = v;
             var datumInput = String(vInput).split("/");
             var mnd = datumInput[1]; 
             if (v.length < 10) {
                if (dg.length == 1) {
                      // dag 1 pos
                       var dgInt = parseInt(dg);
	                  if (dgInt > 0) { 
                       dg = '0' + dg;
                      }
                      }
                    if (mnd.length == 1) {
                      //maand is 1 lang
                      var mndInt = parseInt(mnd);
                      if (mndInt > 0) {
                      mnd = '0' + mnd;
                    }   
               }
                 aInputObject.value = dg + '/' + mnd + '/' +  v.substring(pos_2+1, v.length);
              }
              
              if (sInt < 50){
     		    //if input is under 50 compleet year as 2000
                //aInputObject.value = v.substring(0,pos_2+1) + (2000 + sInt);
    		    aInputObject.value = dg + '/' + mnd + '/' +  + (2000 + sInt);            
     		    return true;     		
     		  }else{
			    //Check if input year > 49 => add year 1900.

			    if ((sInt > 49) && (sInt < 100)){
			     // aInputObject.value = v.substring(0,pos_2+1) + (1900+ sInt);
                  aInputObject.value = dg + '/' + mnd + '/' + (1900+ sInt);
                   return true;
                }  
              }
              return true  
            }      
          }
	    }
	  }	
	}
  }	
} 


function DateFormat(aInputObject, aDateValue, e, dateCheck, dateType) {
  var strCheck   = "8,9,13,47,48,49,50,51,52,53,54,55,56,57"; 
  
  if (strCheck.indexOf(e.keyCode) == -1) {
    e.keyCode = 0;
  }
  else {
    if ((e.keyCode == 13) && (aInputObject.value.length > 0)){
      DateCompletion(aInputObject); 
    }
  }	 
}

//-------------------------------------------------------------------------

function CheckInputField(aInput) {
  var vClientCheck = aInput.ClientCheck;
  var vFieldCheck  = aInput.DataType;
  var vResult;
  //alert('CheckInputField');
  //alert('vClientCheck:' + vClientCheck + ' Verplicht:' + aInput.Verplicht + ' aInput.value:' + aInput.value);
  if (aInput.Mandatory == IS_TRUE){
    if (aInput.value == '') {
      //Input is Mandatory and is empty stop with Checking input
      alert('Rubriek '+ aInput.name+' moet een waarde hebben.');
      if (aInput.type == "text"){			
        aInput.select();
			}
			else {
			  aInput.focus();
			}	
      return false;
    }
    else {
      //Input.value is NOT empty
    }    
  }

  else {
    if (aInput.value == '') {
      //Input is NOT mandatory and is empty so input must be accepted
      return true;
    }
    else {
      //Input is NOT mandatory and is Is
    }
  }

  if (vClientCheck == 'NumberCheck') {
    //alert('numbercheck');
    vResult = NumberCheck(aInput);
  }
  else if (vClientCheck == 'MinMaxCheck') {
    //alert('MinMaxCheck')
    vResult = MinMaxCheck(aInput);
  }
  else if (vClientCheck == 'SocialSecurityCheck') {
    vResult = SocialSecNumberCheck(aInput);
  }
  else if (vClientCheck == 'BankNumberCheck') {
    vResult = BankNumberCheck(aInput);
  }
  else if (vClientCheck == 'DateCheck') {
    //alert('DateFormat');
    vResult = DateFormat(aInput,aInput.value,window.event,true,'3');
  }  
  else if (vClientCheck == 'ZipcodeCheck') {
    vResult = ZipcodeCheck(aInput);
  }  

  else if (vClientCheck == 'NoCheck') {


    if      (vFieldCheck == 'Nummeric') {
      vResult = NumberCheck(aInput);      
    } 
    else if (vFieldCheck == 'Binary-Coded Decimal field') {
      vResult = NumberCheck(aInput); 
    }
    else if (vFieldCheck == 'Date and time field') {
      vResult = DateFormat(aInput,aInput.value,window.event,true,'3');
    }
    
    else {
      vResult = true;
    }
  }  

  if (vResult == false){
    if (aInput.type == "text"){			
      aInput.select();
  	}
		else {
		  aInput.focus();
		}	
  }

  return vResult;
}