jsPackage("epoint.ow.forms")

epoint.ow.forms.ValidatorJs = {
	
	formatMessage : function (fieldValue, message, messageArgsArray) {
		var formatedMessage = message.replace('{1}', fieldValue);

		for (var i = 0; i < messageArgsArray.length; i++) {
			formatedMessage = formatedMessage.replace('{' + (i+2) + '}', messageArgsArray[i]);
		}
		return formatedMessage;
	},
	
	validatorResult : function(/*String*/ messageKey, /*array of String*/ messageParametersArray) {
		return {
			key : messageKey,
			messageParameters : messageParametersArray
		};
	},
	
	runValidator : function(/*String*/ validatorId, form, field, /*array*/ parameterArray) {
		var validator = this.validators[validatorId];
		if (validatorId != null) {
			return validator.apply(this, [form, field].concat(parameterArray));
		} else {
			return null;
		}
	},
	
	validators : {
		"pl.epoint.ow.forms.validators.IntegerValidator" : function (form, field, minValue, maxValue) {
				var fieldValue = epoint.ow.Utils.trim(field.value);
				
				var re = new RegExp('^(-?)(\\d*)$');
				if (!re.test(fieldValue)) {
					return this.validatorResult('IntegerValidator', []);
				}
				var value = parseInt(fieldValue, 10);
				
				if (isNaN(value)) {
					return this.validatorResult('IntegerValidator', []);
				}
				if (minValue != null && value < minValue) {
					return this.validatorResult('IntegerValidator.MIN', [minValue]);
				}
				if (maxValue != null && value > maxValue) {
					return this.validatorResult('IntegerValidator.MAX', [maxValue]);
				}
				
				return null;
			},
			
		"pl.epoint.ow.forms.validators.ConstantValueValidator" : function (form, field, constantValue) {
				var fieldValue = epoint.ow.Utils.trim(field.value);
				if (fieldValue != constantValue) {
					return this.validatorResult('ConstantValueValidator', [constantValue]);
				}
				
				return null;
			},
		
		"pl.epoint.ow.forms.validators.DecimalValidator" : function (form, field, minValue, maxValue, scale, precision, separator) {
				var fieldValue = epoint.ow.Utils.trimZeros(field.value);
				
				if (separator != ".") {
					fieldValue = epoint.ow.Utils.replaceString(fieldValue, separator, ".");
				}
				if (fieldValue.match(new RegExp('^(-?)(\\d*)(\\.?)(\\d*)$')) == null) {
					return this.validatorResult('DecimalValidator', [(precision - scale), scale]); 
				}
				
				var intPart = RegExp.$2;
				var dot = RegExp.$3;
				var fraq = RegExp.$4;
				var value = parseFloat(fieldValue); 
				
				if (intPart.length > (precision - scale)) {
					return this.validatorResult('DecimalValidator.PRECISION', [(precision - scale), scale]);
				}
				if (dot != "" && fraq.length > scale) {
					return this.validatorResult('DecimalValidator.SCALE', [(precision - scale), scale]);
				}
				
				if ((maxValue != null) && (value > maxValue)) {
					return this.validatorResult('DecimalValidator.MAX', [(precision - scale), scale, maxValue]);
				}
				if ((minValue != null) && (value < minValue)) {
					return this.validatorResult('DecimalValidator.MIN', [(precision - scale), scale, minValue]);
				}
				
				return null;
			},
			
			"pl.epoint.ow.forms.validators.AtMostOneValueValidator" : function (form, field) {
				var fieldValue = epoint.ow.Utils.getFieldValue(form, field.name);
				if (fieldValue instanceof Array && fieldValue.length > 1) {
					return this.validatorResult('AtMostOneValueValidator', []);
				}
				
				return null;
			},
			
			"pl.epoint.ow.forms.validators.SingleValuePatternValidator" : function (form, field, pattern, separator) {
				var valueArray;
				if (separator != null) {
					valueArray = field.value.split(separator);
				} else {
					valueArray = new Array();
					valueArray[0] = field.value;
				}
					
				var re = new RegExp(pattern);
				
				for(var i = 0; i < valueArray.length; i++) {
					var value = epoint.ow.Utils.trim(valueArray[i]);
					
					if (!re.test(value)) {
						return this.validatorResult('SingleValuePatternValidator', [pattern, value]);
					}
				}
				
				return null;
			},
			
			"pl.epoint.ow.forms.validators.EmailValidator" : function (form, field, pattern, separator) {
				var result = this.runValidator("pl.epoint.ow.forms.validators.SingleValuePatternValidator", form, field, [pattern, separator]);
				if (result != null) {
					result.key = "EmailValidator";
				}
				return result;
			}
	},
	
	formValidatorConfigs : {},
	
	addValidator : function(validatorId, validatorFn) {
		this.validators[validatorId] = validatorFn;
	},
	
	addValidatorConfig : function(formName, config) {
		this.formValidatorConfigs[formName] = config;
	},
	
	getFieldValidators : function(formName, fieldName) {
		var formConfig = this.formValidatorConfigs[formName];
		if (formConfig == null) {
			return new Array();
		}
		var fieldConfig = formConfig[fieldName];
		if (fieldConfig == null) {
			return new Array();
		}
		return fieldConfig;
	},

	validateForm : function(formName) {
		var form = document.forms[formName];
		
		for (var i = 0; i < form.elements.length; i++) {
			var field = form.elements[i];
			
			if (field.disabled) {
				continue;
			}
			
			var fieldValidatorConfigList = this.getFieldValidators(formName, field.name);
			for(var j = 0; j < fieldValidatorConfigList.length; j++) {
				var validatorId = fieldValidatorConfigList[j][0];
				var runIfNoValue = fieldValidatorConfigList[j][1];
				var messageKeys = fieldValidatorConfigList[j][2];
				var parameters = fieldValidatorConfigList[j][3];
				var fieldValue = epoint.ow.Utils.getFieldValue(form, field.name);
				
				if ((fieldValue instanceof Array && fieldValue.length == 0) || fieldValue == "") {
					if (runIfNoValue == false) {
						continue;
					}
				}
				
				var result = this.runValidator(validatorId, form, field, parameters);
				if (result != null) {
					var msg = messageKeys[result.key];
					if (msg == null) {
						msg = result.key;
					} else {
						msg = this.formatMessage(fieldValue, msg, result.messageParameters);
					}
					
					alert(msg);
					field.focus();
					return false;
				}
			}
			
		}
		
		return true;
	},
	
	submitForm : function (formName, action, jsValidation) {
		if (jsValidation == null || jsValidation == true) {
			if (this.validateForm(formName) == false) {
				return false;
			}
		}
		
		var form = document.forms[formName];
		if (action != null && action != "") {
			form.action = action;
		}
		form.submit();
	}
}