ko.validation.rules['integer'] = {
    validator: function (val, validate) {
        return val === null || val === "" || (validate && /^-?\d*$/.test(val.toString()));
    },
    message: 'Must be empty or an integer value'
};

ko.validation.rules['behaviourHandler'] = {
	validator: function (val, validate) {
		try {
			var validatorObject;
			if (validate.expression) {
			    validatorObject = eval(validate.expression);
			} else if (validate.relativeFunction) {
			    validatorObject = validate.parentObservable[validate.relativeFunction]();
			}
			return validatorObject.isValid(val, validate);
		}
		catch(err) {
			return true;
		}

	},
	message: 'Cannot validate the field'
}

ko.extenders.amount = function(target, option) {

    var result = ko.pureComputed({
        read: function() { return target() },
        write: function (val) {
            if(val !== null && val !== "") {
                var current = val;

                var str = val.toString().split(".").join("");
                str = str.replace(",", ".");
                str = accounting.formatMoney(parseFloat(str), "", 2, ".", ",");

// target.isValid(false);
                target(str);
            }
            target(null);
        }
    });
    // return the new computed observable
    return result;
};

ko.validation.rules['numeric'] = {
	    validator: function (val, validate) {
	        if(val !== null && val !== "") {
	            var current = val;

	            if(val==null)
	                return false;

	            var str = val.toString().split(".").join("");
	            str = str.replace(",", ".");
	            str = accounting.formatMoney(parseFloat(str), "", validate.params, ".", ",");

	            // Normalizzazione accounting e input
	            str = str.toString().split(".").join("");
	            val = val.toString().split(".").join("");

	            if(val == str) {
	                return true;
	            }
	            return false;
	        }
	        return true;
	    },
	    message: 'Must be empty or an account value'
};

ko.validation.rules['daAValidator1'] = {
        validator: function (val, validate) {

            if( val == null && validate != null ){
                return false;
            }

            return true;
        },
        message: 'Enter the number from'
};

ko.validation.rules['daAValidator2'] = {
        validator: function (val, validate) {

            if( val != null &&  validate != null && parseFloat(val) > parseFloat(validate)){
                return false;
            }

            return true;
        },
        message: 'Since the number must be less than the number A'
};

ko.validation.rules['timestamp'] = {
    validator: function(val, validate) {
        if(validate == 'DD/MM/YYYY') {
            return val === null || moment(val, validate, true).isValid();
        } else {
            return val === null || moment(val, validate).isValid();
        }
    }
}

ko.validation.rules['dateInPast'] = {
        validator: function(val, params) {
            if ((val !== null) && moment(val, params.format).isValid()) {
                var now = moment(moment().format(params.format), params.format);
                if (params.allowSame) {
                    return !moment(val, params.format).isAfter(now);
                } else {
                    return moment(val, params.format).isBefore(now);
                }
            }
            return true;
        }
    }

ko.validation.rules['dateInFuture'] = {
        validator: function(val, params) {
            if ((val !== null) && moment(val, params.format).isValid()) {
                var now = moment(moment().format(params.format), params.format);
                if (params.allowSame) {
                    return !moment(val, params.format).isBefore(now);
                } else {
                    return moment(val, params.format).isAfter(now);
                }
            }
            return true;
        }
    }

ko.validation.rules['dataInAnno'] = {
        validator: function(target, options) {
            var newValue = target;
                if(newValue!=null){
                      var anno = parseInt(newValue.substring(newValue.length - 4, newValue.length));
                      if(options === anno){
                          return true;
                      }else{
                          return false;
                      }
                }
            return true;
        },
        message: 'Year not valid'
    };

ko.validation.rules['importoMinoreDi'] = {
        validator: function(target, options) {
            if(target!=null) {
                var targetInt = parseFloat(target.toString().split(".").join("").replace(",", "."));
                var paramInt = parseFloat(options.toString().split(".").join("").replace(",", "."));

                if(targetInt < paramInt) {
                    return false;
                }
                return true;
            }
            return true;
        },
        message: 'Importo minore di valore'
     };

ko.validation.rules['importoMin'] = {
        validator: function(target, options) {
            if(target!=null) {
                var targetInt = parseFloat(target.toString().split(".").join("").replace(",", "."));
                var paramInt = parseFloat(options.toString().split(".").join("").replace(",", "."));

                return targetInt >= paramInt;
            }
            return true;
        },
        message: 'Importo minore di valore'
     };

ko.validation.rules['importoMax'] = {
        validator: function(target, options) {
            if(target!=null) {
                var targetInt = parseFloat(target.toString().split(".").join("").replace(",", "."));
                var paramInt = parseFloat(options.toString().split(".").join("").replace(",", "."));

                return targetInt <= paramInt;
            }
            return true;
        },
        message: 'Importo maggiore di valore'
 };

ko.validation.rules["precisioneImporto"] = {
        validator: function(target, options) {
            if(target!=null) {
                var targetInt = target.toString().split(".").join("").replace(",", ".");

                var max = "";
                for(var i = 0; i < options; i++) {
                    max += "9";
                }

                max = parseInt(max);

                if(Math.abs(parseInt(targetInt.split(".")[0])) > max) {
                    return false;
                }

                return true;

            }
            return true;
        },
        message: 'precisione importo errata'
    }

ko.validation.rules['importoMaggioreDi'] = {
        validator: function(target, options) {
            if(target!=null) {
                var targetInt = parseFloat(target.toString().split(".").join("").replace(",", "."));
                var paramInt = parseFloat(options.toString().split(".").join("").replace(",", "."));

                if(targetInt > paramInt) {
                    return false;
                }
                return true;
            }
            return true;
        },
        message: 'Importo maggiore di valore'
 };

/**
 * options è un observable array contenente importi (non funzioni ko, stringhe rappresentati importi)
 */
ko.validation.rules['importoMaggioreDiObsArray'] = {
        validator: function(target, options) {
            if(target!=null) {
                var paramInt = 0;
                for(var i = 0; i < options.length; i++) {
                    paramInt += accounting.unformat(options[i], ",");
                }
                var targetInt = parseFloat(target.toString().split(".").join("").replace(",", "."));

                if(targetInt > paramInt) {
                    return false;
                }
                return true;
            }
            return true;
        },
        message: 'Importo maggiore di valore'
 };

ko.validation.rules['minObservableArrayLength'] = {
    validator: function (obj, params) {
        return obj.length >= params.minLength;
    },
    message: "Array does not meet minimum length requirements"
};

ko.validation.rules['maxObservableArrayLength'] = {
        validator: function (obj, params) {
            return obj.length <= params.maxLength;
        },
        message: "Array does not meet maximum length requirements"
    };

ko.validation.rules['mutexInputField'] = {
    validator: function (obj, params) {
        var param1 = obj;
        var param2 = params;
        // XOR OPERATOR
        return (param1!=null || param2!=null) && !(param1!=null && param2!=null);
    },
    message: "Solo uno dei due campi può essere valorizzato"
};

ko.validation.rules['size'] = {
	    validator: function (obj, params) {
	        return obj!=null && obj.length >= parseInt(params.min) && obj.length <= parseInt(params.max)
	    },
	    message: "La lunghezza non va bene"
	};
ko.validation.registerExtenders();