//=====================================================================================================================
// SubmitForm js Include File
// CopyRight(c) 2002,2003 - A/S Web B.V.
// version:  1
// revision: 2
// date:     11-03-03
// -------------------------------------------------------------------------------------------------------------------
// IncludeFile voor het automatisch nalopen van verplicht in te vullen form velden
// Om dit bestand te kunnen gebruiken is tevens het include-bestand 'functions.js' nodig
// -------------------------------------------------------------------------------------------------------------------
// de volgende functions kunnen in de bestanden, waarin dit bestand is geincluded,
// worden opgenomen:
//
// function registerType(typeName, validChars, emptyValue, validMinimumLength, validMaximumLength, specificFieldCheck); *)
// function registerField(fieldId, parentForm, inputFields, inputType, emptyText, invalidText, isRequired, validMinimumLength, validMaximumLength); **)
// function submitForm(form) ***)
// function setFieldRequired(fieldId, required) 
// function enableField(fieldId)
// function disableField(fieldId)
// function registerPasswordFields(field1, field2) ****)
//
//
//    *) - in principe is deze function bijna nooit nodig, omdat de meeste standaard inputfield-types bij de
//         initialisatie van dit script automatisch worden gegenereerd;
//       - validChars is een string van alle karakters, die in een veld van het gedefinieerde type aanwezig mogen zijn;
//       - de volgende types zijn standaard in dit bestand geregistreerd: "tekst","int","float_nl","float_gb","pccijfers","pcletters",
//        "leeftijd","telefoonnr","wachtwoord","dd","mm" en "yyyy";
//       
//   **) - inputType moet een geregistreerd type zijn. Indien dit type niet aanwezig is, moet het d.m.v. 'registerType'
//         worden toegevoegd;
//       - indien 'validMaximumLength' wordt weggelaten, wordt deze automatisch gelijk aan 'validMinimumLength'. Als 
//         deze waardes aan elkaar gelijk zijn, wordt een exacte lengte verwacht, mits de ingevoerde waardes ongelijk
//         aan nul zijn;
//       - emptyText en invalidText zijn de teksten die tussen de berichten van de alertBoxes worden geplakt (bijv. 
//         "uw naam" en "ongeldige naam";
//       - inputFields moet een array zijn (bijv. [document.form1.naamveld]). De reden hiervan is, dat zo e mogelijkheid
//         bestaat twee velden te combineren voor 1 check (bijv. een kengetal en een telefoonnummer, die samen een tien-
//         cijferig telefoonnummer moeten vormen;
//
//  ***) - function voor het posten van het form, waarna alle velden worden nagelopen;
//       - parameter 'form' moet het formobject zijn (dus bijvoorbeeld:
//           <input type="button" onClick="javascript:submitForm(this.form);" value="verzenden">
//
// ****) - deze function zorgt ervoor dat er naast de standaard checks op inhoud van de geregistreerde velden, de twee
//         velden, die via deze function worden geregistreerd worden gecontroleerd op een identieke inhoud. omdat de 
//         twee geregistreerde velden exact overeen moeten komen voor de password-controle, moet er een speciale check
//         plaatsvinden
//
//=====================================================================================================================
var FIELD_FIRST    = 0;
var FIELD_LAST     = 1;
var doReplaceText  = false;
var fieldToReplace = FIELD_LAST;
var inputTypes     = new Array();
var inputFields    = new Array();
var fieldIds       = new Array();
var paswordField1  = null;
var paswordField2  = null;

registerType("tekst","abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ.-/&+@ \r\n","",[],0);
registerType("tekst_uitgebreid","abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ.,-/&+@ 1234567890!?\r\n","",[],0);
registerType("int","0123456789","",[],0);
registerType("float_nl","0123456789,","",[],0);
registerType("float_gb","0123456789.","",[],0);
registerType("geslacht","mv","",[],1,1);
registerType("huisnr","0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ","",[],0);
registerType("pccijfers","0123456789","",[],4,4);
registerType("pcletters","abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ","",[],2,2);
registerType("leeftijd","0123456789","0",[],0);
registerType("telefoonnr","0123456789 -","0",[],10,11);
registerType("telefoonnr_internationaal","0123456789 -+","0",[],null, null);
registerType("wachtwoord","0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ.- ","",[],0);
registerType("dd","0123456789","",[],2,2);
registerType("mm","0123456789","",[],2,2);
registerType("yyyy","0123456789","",[],4,4);
registerType("email","0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ.-_@","",[".","@"],6,0);
registerType("serial","0123456789- ","",[],0);
registerType("url","0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ.- :/","",["."],null,null,urlCheck);
registerType("gironr","0123456789pP","",[],7,8,giroCheck);
registerType("banknr","0123456789","",[],9,null,bankCheck);
registerType("adres","0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ .-","",[],null,null,adresCheck);
registerType("postcode","0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ ","",[],6,7,postcodeCheck);
registerType("datum_kort", "0123456789-", "", ["-"], 6,10,datumCheck);
registerType("tijd", "0123456789:", "", [":"], 4,5,tijdCheck);
registerType("radio", "", "", "", 0, 0, radioCheck);

//==========================================================================================================
// Input Type definities
//==========================================================================================================

// function voor het toevoegen van een inputType object aan de inputTypes array
function registerType(typeName, validChars, emptyValue, requiredChars, validMinimumLength, validMaximumLength, specificFieldCheck){
	inputTypes[typeName] = new typeObject(validChars, emptyValue, requiredChars, validMinimumLength, validMaximumLength, specificFieldCheck);
}

// typeObject constructor
//
// - validChars zijn alle karakters die in het inputveld aanwezig mogen zijn
//   indien andere karakters aanwezig zijn, zal bij een check de veldwaarde als ongeldig 
//   worden aangemerkt;
// - emptyValue kan gebruikt worden voor het geval er wel iets is ingevuld, de gebruikte
//   karakters ook geldig zijn, maar een bepaalde ingevulde waarde niet geldig is. bij een
//   empty string komt de invulwaarde sowieso niet door de check heen (verplicht veld);
// - validLengths kunnen gebruikt worden als een specifiek aantal karakters ingevuld moet worden,
//   zoals bij telefoonnummers en postcodes. Indien '0' wordt opgegeven, wordt hierop niet
//   gechecked;
// - specificFieldCheck is een pointer die kan verwijzen naar een function die een check doet
//   op de inputstring die afwijkt van de standaard-check die op alle inputstrings worden uitgevoerd.
//   de standaardcheck wordt altijd uitgevoerd. de specifieke function wordt alleen uitgevoerd,
//   indien deze gedefinieerd is. voor de definitie van de functions is onder het blok input type
//   definities een blok gereserveerd
//
function typeObject(validChars, emptyValue, requiredChars, validMinimumLength, validMaximumLength, specificFieldCheck){
	this.validChars         = validChars;
	this.emptyValue         = emptyValue;
	this.requiredChars      = requiredChars;
	this.validMinimumLength = validMinimumLength;
	this.validMaximumLength = (validMaximumLength != null) ? validMaximumLength : 0;
	
	if (specificFieldCheck != null){
		this.specificFieldCheck = specificFieldCheck;
	}
	else{
		this.specificFieldCheck = null;
	}
}

//==========================================================================================================
// specificFieldCheck-Functions
//
// in dit blok van het script mogen
// specifieke input-type functions
// worden aangemaakt
//==========================================================================================================
function giroCheck(inputString){
	var result = true;
	if (inputString.length == 7){
		if ((inputString.indexOf("p") != -1) || (inputString.indexOf("P") != -1)){
			result = false;
		}
	}
	else{
		var teken = inputString.charAt(0);
		if ((teken!='p') && (teken!='P')){
			result = false;
		}
		if ((inputString.lastIndexOf("p") > 0) || (inputString.lastIndexOf("P") > 0)){
			result = false;
		}
	}
	return(result);
}

function bankCheck(inputString){
	var result    = true;
	var totaal    = 0;
	var countDown = inputString.length+1;
	for (var i=0; i<inputString.length; i++){
		var teken = parseInt(inputString.charAt(i));
		countDown--;
		totaal += teken * countDown;
	}
	if (totaal%11){
		result = false;
	}
	return(result);
}

function adresCheck(inputString){
	var result = true;
	var delen  = inputString.split(" ");
	
	if (delen.length < 2){
		if (!confirm(languageMessage(CONFIRM_ADDRESS_COMPLETE))){
			result = false;
		}
	}
	else{
		if (isNaN(parseInt(delen[delen.length-1]))){
			if (!confirm(languageMessage(CONFIRM_ADDRESS_CORRECT))){
				result = false;
			}
		}
	}
	return(result);
}

function postcodeCheck(inputString){
	var result = true;
	
	if (isNaN(parseInt(inputString.substr(0,4)))){
		result = false;
	}
	else if ((inputString.length == 7) && (inputString.substr(4,1) != " ")){
		result = false;
	}
	else{	
		if (!isNaN(parseInt(inputString.substr(inputString.length-2,1)))){
			result = false;
		}
		else if (!isNaN(parseInt(inputString.substr(inputString.length-1,1)))){
			result = false;
		}
	}
	return(result);
}

function datumCheck(inputString){
	var dateParts = inputString.split("-");
	var result = true;
	var daysPerMonth = [31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31];
	
	if (dateParts.length != 3){
		result = false;
	}
	else if ((dateParts[0].length < 1) || (dateParts[0].length > 2)){
		result = false;
	}
	else if ((dateParts[1].length < 1) || (dateParts[1].length > 2)){
		result = false;
	}
	else if ((dateParts[2].length < 2) || (dateParts[2].length > 4)){
		result = false;
	}
	else if ((parseInt(dateParts[1]) < 0) || (parseInt(dateParts[1]) > 12)){
		result = false;
	}
	else if ((dateParts[2].length == 4) && ((dateParts[2] < 1900) || (dateParts[2] > 3000))){
		result = false;
	}
	else{
		schrikkel = ((parseInt(dateParts[2])%4) != 0);
		if (schrikkel){
			daysPerMonth[1] = 28;
		}
		month = parseInt(dateParts[1]) - 1;
		if ((parseInt(dateParts[0]) < 0) || (parseInt(dateParts[0]) > daysPerMonth[month])){
			result = false;
		}	
	}
	return(result);
}

function tijdCheck(inputString){
	var result = true;
	var timeParts = inputString.split(":");

	if (timeParts.length != 2){
		result = false;
	}
	else if ((parseInt(timeParts[0]) > 23) || (parseInt(timeParts[1]) > 59)){
		result = false;
	}
	else if (inputString.indexOf(":") != (inputString.length - 3)){
		result = false;
	}
	
	return(result);
}

function urlCheck(inputString){
	var result = true;
	if ((inputString.indexOf("http://") != 0) && (inputString.indexOf("www.") != 0)){
		result = false;
	}
	return(result);
}

function radioCheck(inputString){
	alert(inputString);
}

//==========================================================================================================
// Input velden checks
//==========================================================================================================

// function om te controleren of, indien verplichte karakters bij het type horen, deze ook aanwezig zijn
function hasRequiredChars(SString, RRequiredChars){
	if (RRequiredChars.length){
		for (var i=0; i<RRequiredChars.length; i++){
			if(SString.indexOf(RRequiredChars[i])==-1) {
				return false;
			}
		}
	}
	return true;
}

// function voor het registreren van velden die als verplicht zijn aangemerkt
// deze function kan worden aangeroepen vanuit de html-file vanwaaruit dit jscript
// is geincluded (? maf, die engelsche text in nederlandsche tekst)
function registerField(fieldId, parentForm, myInputFields, inputType, emptyText, invalidText, isRequired, validMinimumLength, validMaximumLength){
	var lMinimumLength        = validMinimumLength ? validMinimumLength : 0;
	var lMaximumLength        = validMaximumLength ? validMaximumLength : 0;
	fieldIds[fieldIds.length] = fieldId;
	inputFields[fieldId]      = new inputFieldObject(parentForm, myInputFields, inputType, emptyText, invalidText, isRequired, lMinimumLength, lMaximumLength);
	//inputFields[inputFields.length] = new inputFieldObject(myInputFields, inputType, emptyText, invalidText, isRequired, lMinimumLength, lMaximumLength);
}

function setFieldRequired(fieldId, required){
	inputFields[fieldId].isRequired = required;
}

function enableField(fieldId){
	fields = inputFields[fieldId].fields;
	for (var i=0; i<fields.length; i++){
		fields[i].disabled = false;
	}
}

function disableField(fieldId){
	fields = inputFields[fieldId].fields;
	for (var i=0; i<fields.length; i++){
		fields[i].disabled = true;
	}
}

function registerPasswordFields(field1, field2){
	if (field1 == field2){
		alert(languageMessage(ERROR_PASSWORD_FIELDS));
	}
	else{
		paswordField1 = field1;
		paswordField2 = field2;
	}
}

// inputfieldobject, er kunnen meerdere velden worden gecombineerd, indien gewenst
function inputFieldObject(parentForm, myInputFields, inputType, emptyText, invalidText, isRequired, validMinimumLength, validMaximumLength){
	this.parentForm         = parentForm;
	this.fields             = myInputFields;
	this.inputType          = inputType;
	this.emptyText          = emptyText;
	this.invalidText        = invalidText;
	this.isRequired         = isRequired;
	this.validMinimumLength = validMinimumLength;
	this.validMaximumLength = validMaximumLength;
}

// function die gecalled wordt door checkFields, waarbij een veld wordt ingevuld
// en vervolgens geselecteerd. werkt voor ie en ns
function selectInputField(field, value){
	if (doReplaceText){
		field.value = value;
	}
	else{
		alert(value);
	}
	field.select();
	field.focus();
}

// function die dient om de value van 1 of de gecombineerde values van meerdere velden
// te checken en de velden te selecteren, indien nodig
function checkField(field){
	var type  = inputTypes[field.inputType];
	var inputString = "";
	var checkLength = true;
	for (var i=0; i<field.fields.length && field.fields.length; i++){
		inputString += field.fields[i].value;
		switch (field.inputType) {
			case "radio":
			case "checkbox":
				break;
			default:
			
				if (!field.fields[i].disabled){
					if ((Trim(inputString) == languageMessage(WARNING_U_MUST) + field.emptyText + languageMessage(WARNING_FILL_IN)) || (Trim(inputString) == languageMessage(WARNING_INCORRECT_VALUE)) || (Trim(inputString) == field.invalidText)){
						selectInputField(field.fields[i], Trim(inputString));
						return(false);
					}
					else if (Trim(inputString) == ""){
						if (field.isRequired){
							selectInputField(field.fields[i], languageMessage(WARNING_U_MUST) + field.emptyText + languageMessage(WARNING_FILL_IN));
							return(false);
						}
					}
					// jw toegevoegd om untyped velden toe te voegen als verplicht veld!!!
					else if (!field.inputType.length){
						return(true);
					}
					else if (Trim(inputString) == type.emptyValue){
						selectInputField(field.fields[i], languageMessage(WARNING_INCORRECT_VALUE));
						return(false);
					}
					else if (!IsValid(inputString, type.validChars)) {
						selectInputField(field.fields[i], field.invalidText);
						return false;
					}
					else if (!hasRequiredChars(inputString, type.requiredChars)) {
						selectInputField(field.fields[i], field.invalidText);
						return false;
					}
					else if (type.specificFieldCheck){
						if (!type.specificFieldCheck(inputString)){
							selectInputField(field.fields[i], field.invalidText);
							return false;
						}
					}
				}
				else{
					checkLength = false;
				}
				
				break;
				
		} // end of switch
	}
	
	if (checkLength){
		if (field.isRequired || inputString.length){
			var validMinimumLength = (field.validMinimumLength) ? field.validMinimumLength : type.validMinimumLength;
			var validMaximumLength = (field.validMaximumLength) ? field.validMaximumLength : type.validMaximumLength;
			if ((validMinimumLength == validMaximumLength) && (validMaximumLength)) {
				if (inputString.length!=validMaximumLength){
					selectInputField(field.fields[fieldToReplace*(field.fields.length-1)], languageMessage(WARNING_ILLEGAL_CHARCOUNT) + field.emptyText + languageMessage(WARNING_CHARCOUNT) + validMaximumLength + languageMessage(WARNING_CHARCOUNT_FINAL));
					return false;
				}
			}
			else{
				if (inputString.length<validMinimumLength){
					selectInputField(field.fields[fieldToReplace*(field.fields.length-1)], languageMessage(WARNING_ILLEGAL_CHARCOUNT) + field.emptyText + languageMessage(WARNING_CHARCOUNT_MIN) + validMinimumLength + languageMessage(WARNING_CHARCOUNT_FINAL));
					return false;
				}
				else if ((inputString.length>validMaximumLength) && (validMaximumLength)){
					selectInputField(field.fields[fieldToReplace*(field.fields.length-1)], languageMessage(WARNING_ILLEGAL_CHARCOUNT) + field.emptyText + languageMessage(WARNING_CHARCOUNT_MAX) + validMaximumLength + languageMessage(WARNING_CHARCOUNT_FINAL));
					return false;
				}
			}
		}
	}
	
	return(true);
}

function submitForm(form){
	var doSubmit = true;
	for (var i=0; i<fieldIds.length; i++){
		if (inputFields[fieldIds[i]].parentForm  == form){
			if (!checkField(inputFields[fieldIds[i]])){
				doSubmit = false;
				break;
			}
		}
	}
	if (doSubmit){
		if (paswordField1 && paswordField2){
			if (paswordField1.value != paswordField2.value){
				doSubmit = false;
				alert(languageMessage(ERROR_PASSWORD_VERIFICATION));
			}
		}
	}

	if (doSubmit){
		form.submit();
	}
	return(doSubmit);
}