/*
 * validazione dei campi di registrazione
 */
function regValidation()
{
	
	var u_username = new LiveValidation('u_username',{ validMessage: "ok!" });
	u_username.add(Validate.Presence, { failureMessage: "\nInserisci l'username!" });
	u_username.add( Validate.Length, { minimum: 4, maximum: 16,tooShortMessage: "\nDeve contenere almeno 4 caratteri!",tooLongMessage : "Deve contenere massimo 16 caratteri!" } );
	u_username.add( Validate.Format, { pattern: /^[a-zA-Z0-9._-]{4,16}$/i, failureMessage: "\nL'username può contenere solo lettere, numeri, punti (.), trattini (-) e caratteri di sottolineatura (_)"  } );

	var u_password1 = new LiveValidation('u_password1',{ validMessage: "ok!" });
	u_password1.add(Validate.Presence, { failureMessage: "\nInserisci la password!" });
	u_password1.add( Validate.Length, { minimum: 6, maximum: 12,tooShortMessage: "\nDeve contenere almeno 6 caratteri!",tooLongMessage : "Deve contenere massimo 12 caratteri!" } );
	u_password1.add( Validate.Format, { pattern: /^[^"\/\\<>|@§]{1,16}$/i, failureMessage: "\nI seguenti caratteri non sono validi: \" < > \ / | @ §"  } );
	u_password1.add( Validate.Custom,  { against: function(value,args){ 
													username = document.getElementById(args.match).value;
													return (value != username);
												}, args: {match: 'u_username'}, failureMessage: "\nLa password deve essere diversa dall'username!"  } );
	//Validate.Custom( 55, { against: function(value,args){ return !(value % args.divisibleBy) }, args: {divisibleBy: 5} } );
	
	var u_password2 = new LiveValidation('u_password2',{ validMessage: "ok!" });
	u_password2.add(Validate.Presence, { failureMessage: "\nInserisci la password di conferma!" });
	u_password2.add( Validate.Confirmation, { match: 'u_password1', failureMessage: "\nLe due password non coincidono!" } );
	
	
	var u_email = new LiveValidation('u_email',{ validMessage: "ok!" });
	u_email.add( Validate.Presence, { failureMessage: "\nInserisci l'email!" });
	u_email.add( Validate.Email, {failureMessage: "\nInserire una mail valida!"} );
	u_email.add( Validate.Format, { pattern: /^[^'"\/\\,]{1,45}$/i, failureMessage: "\nContiene caratteri non validi!"  } );
	
	var u_name = new LiveValidation('u_name',{ validMessage: "ok!" });
	u_name.add( Validate.Presence, { failureMessage: "\nInserisci il nome!" });
	u_name.add( Validate.Format, { pattern: /^[^"\/\\<>|]{1,45}$/i, failureMessage: "\nI seguenti caratteri non sono validi: \" < > \ / | "  } );
	
	var u_surname = new LiveValidation('u_surname',{ validMessage: "ok!" });
	u_surname.add( Validate.Presence, { failureMessage: "\nInserisci il cognome!" });
	u_surname.add( Validate.Format, { pattern: /^[^"\/\\<>|]{1,45}$/i, failureMessage: "\nI seguenti caratteri non sono validi: \" < > \ / | "  } );
	
	var u_teamName = new LiveValidation('u_teamName',{ validMessage: "ok!" });
	u_teamName.add( Validate.Presence, { failureMessage: "\nInserisci il nome della squadra!" });
	u_teamName.add( Validate.Length, { maximum: 16,tooLongMessage : "\nDeve contenere massimo 16 caratteri!" } );
	u_teamName.add( Validate.Format, { pattern: /^[^"\/\\<>|@§]{1,16}$/i, failureMessage: "\nI seguenti caratteri non sono validi: \" < > \ / | @ §"  } );

        var u_actual_nation = new LiveValidation('u_actual_nation',{ validMessage: "ok!" });
	u_actual_nation.add( Validate.Presence, { failureMessage: "\nInserisci la nazione di residenza!" });
        u_actual_nation.add( Validate.Length, { maximum: 16,tooLongMessage : "\nDeve contenere massimo 45 caratteri!" } );
	u_actual_nation.add( Validate.Format, { pattern: /^[^"\/\\<>|@§]{1,16}$/i, failureMessage: "\nI seguenti caratteri non sono validi: \" < > \ / | @ §"  } );

	var allValidationObj = [ u_username, u_password1,u_password2, u_email, u_name, u_surname,u_teamName,u_actual_nation];
	
	return allValidationObj;
}

/*
 * richiamata al momendo del submit del form di registrazione
 * 
 * restituisce true se tutti i campi sono validi altrimenti false
 * se la validazione è ok esegue la criptografia, assegna la password criptata all' input
 * e elimina le password in chiaro
 * 
 */

function regAreAllValid()
{
	var allValidationObj = regValidation();
	
	
	var areAllValid = LiveValidation.massValidate(allValidationObj);
	
	//controllo le condizioni
	if(!conditionValidation('registration_form','condition') || !conditionValidation('registration_form','contract') || !conditionValidation('registration_form','privacy') || !conditionValidation('registration_form','personal_data_service'))
		areAllValid = false;
	
	//se i campi superano la validazione eseguo il criptaggio della password
	//ed elimino i valori della password in chiaro
	if(areAllValid)
	{
		var pass1 = document.getElementById('u_password1');
		var pass2 = document.getElementById('u_password2');		
		
		//doppia md5 della password, inserisco la hashpass nell'input nascosto
		var hashPass = document.getElementById('u_hash_password');
		hashPass.value = hex_md5(hex_md5(pass1.value));
		
		//alert(hashPass.value);
		
		//azzero il valore del campo della password in chiaro
		//pass1.value = '';
		pass2.value = '';
	}
	
	return areAllValid;
	
}

/*
 * validazione dei radio button sulle condizioni (live validation non supporta la validazione sui radiobutton)
 */
function conditionValidation(nameForm,nameRadio)
{
	if(document.forms[nameForm].elements[nameRadio][0].checked)
	{	
		document.getElementById('u_'+nameRadio).innerHTML = "";
		return true;
	}
	else
	{
		document.getElementById('u_'+nameRadio).innerHTML = "<div class=\"LV_invalid\">Accetta le condizioni per proseguire!</div>";
		return false;
	}
}



/*
 * validazione del campo email del form di recupero password 
 */
function passwordRetrievalValidation()
{
	var pr_email = new LiveValidation('pr_email',{ validMessage: "ok!" });
	var precence = pr_email.add( Validate.Presence, { failureMessage: "\nInserisci l'email" });
	var email = pr_email.add( Validate.Email, {failureMessage: "\nInserire una mail valida!"} );
	var format = pr_email.add( Validate.Format, { pattern: /^[^"\/\\<>|]{1,45}$/i, failureMessage: "\nL'email non deve contenere i seguenti caratteri: \" < > \ / | "  } );

	//var isValid = LiveValidation.massValidate([pr_email]);
	
	return (precence && email && format);
}

/*
 * attiva il submit
 */
function activeSubmit(idBtn)
{
	var submitBtn = document.getElementById(idBtn);
	submitBtn.disabled = false;
}

/*
 * validazione standar per un input di testo generico
 */
function standardTextInputValidation(id,minLength, maxLength)
{
	var stdTextInputVal = new LiveValidation(id,{ validMessage: "ok!" });
	
	if(minLength != null)
		stdTextInputVal.add( Validate.Length, { minimum: minLength,tooShortMessage : "Deve contenere minimo "+minLength+" caratteri!" } );
	
	if(maxLength != null)
		stdTextInputVal.add( Validate.Length, { maximum: maxLength,tooLongMessage : "Deve contenere massimo "+maxLength+" caratteri!" } );
	
	stdTextInputVal.add( Validate.Format, { pattern: /^[^"\/\\<>|]{1,45}$/i, failureMessage: "I seguenti caratteri non sono validi: \" < > \ / | "  } );

	return stdTextInputVal;
}


/*
 * validazione dei campi del profilo
 */
function profileValidation()
{
	var p_name = new LiveValidation('p_name',{ validMessage: "ok!" });
	p_name.add( Validate.Presence, { failureMessage: "Inserisci il nome!" });
	p_name.add( Validate.Format, { pattern: /^[^"\/\\<>|]{1,45}$/i, failureMessage: "I seguenti caratteri non sono validi: \" < > \ / | "  } );

	var p_surname = new LiveValidation('p_surname',{ validMessage: "ok!" });
	p_surname.add( Validate.Presence, { failureMessage: "Inserisci il cognome!" });
	p_surname.add( Validate.Format, { pattern: /^[^"\/\\<>|]{1,45}$/i, failureMessage: "I seguenti caratteri non sono validi: \" < > \ / | "  } );
	
	var p_tax_code = new LiveValidation('p_tax_code',{ validMessage: "ok!" });
	p_tax_code.add( Validate.Format, { pattern: /^[a-zA-Z]{6}[0-9]{2}[a-zA-Z][0-9]{2}[a-zA-Z][0-9]{3}[a-zA-Z]$/i, failureMessage: "Codice fiscale non valido"  } );
	
	var p_region_actual = standardTextInputValidation("p_region_actual", null, 45);
	var p_country_actual = standardTextInputValidation("p_country_actual", null, 45);
	var p_city_actual = standardTextInputValidation("p_city_actual", null, 45);
	var p_address_actual = standardTextInputValidation("p_address_actual", null, 200);
	var p_region_birth = standardTextInputValidation("p_region_birth", null, 45);
	var p_country_birth = standardTextInputValidation("p_country_birth", null, 45);
	var p_city_birth = standardTextInputValidation("p_city_birth", null, 45);
	var p_zipcode_birth = standardTextInputValidation("p_zipcode_birth", null, 10);
	var p_zipcode_actual = standardTextInputValidation("p_zipcode_actual", null, 10);
	
}

/*
 * validazione dei campi di modifica del prfilo nel processo di abbonamento
 */
function membershipProfileValidation()
{
        var u_name = new LiveValidation('u_name',{ validMessage: "ok!" });
	u_name.add( Validate.Presence, { failureMessage: "Inserisci il nome!" });
	u_name.add( Validate.Format, { pattern: /^[^"\/\\<>|]{1,45}$/i, failureMessage: "I seguenti caratteri non sono validi: \" < > \ / | "  } );

	var u_surname = new LiveValidation('u_surname',{ validMessage: "ok!" });
	u_surname.add( Validate.Presence, { failureMessage: "Inserisci il cognome!" });
	u_surname.add( Validate.Format, { pattern: /^[^"\/\\<>|]{1,45}$/i, failureMessage: "I seguenti caratteri non sono validi: \" < > \ / | "  } );

	var u_taxcode = new LiveValidation('u_taxcode',{ validMessage: "ok!" });
        u_taxcode.add( Validate.Presence, { failureMessage: "Inserisci il codice fiscale!" });
	u_taxcode.add( Validate.Format, { pattern: /^[a-zA-Z]{6}[0-9]{2}[a-zA-Z][0-9]{2}[a-zA-Z][0-9]{3}[a-zA-Z]$/i, failureMessage: "Codice fiscale non valido"  } );

        var u_region_actual =new LiveValidation('u_region_actual',{ validMessage: "ok!" });
	u_region_actual.add( Validate.Presence, { failureMessage: "Inserisci la regione di residenza!" });
	u_region_actual.add( Validate.Format, { pattern: /^[^"\/\\<>|]{1,45}$/i, failureMessage: "I seguenti caratteri non sono validi: \" < > \ / | "  } );
        u_region_actual.add( Validate.Length, { maximum: 45,tooLongMessage : "Deve contenere massimo 45 caratteri!" } );

        var u_city_actual =new LiveValidation('u_city_actual',{ validMessage: "ok!" });
	u_city_actual.add( Validate.Presence, { failureMessage: "Inserisci la città di residenza!" });
	u_city_actual.add( Validate.Format, { pattern: /^[^"\/\\<>|]{1,45}$/i, failureMessage: "I seguenti caratteri non sono validi: \" < > \ / | "  } );
        u_city_actual.add( Validate.Length, { maximum: 45,tooLongMessage : "Deve contenere massimo 45 caratteri!" } );

        var u_address_actual =new LiveValidation('u_address_actual',{ validMessage: "ok!" });
	u_address_actual.add( Validate.Presence, { failureMessage: "Inserisci l'indirizzo di residenza!" });
	u_address_actual.add( Validate.Format, { pattern: /^[^"\/\\<>|]{1,200}$/i, failureMessage: "I seguenti caratteri non sono validi: \" < > \ / | "  } );
        u_address_actual.add( Validate.Length, { maximum: 200,tooLongMessage : "Deve contenere massimo 200 caratteri!" } );

        var u_zipcode_actual =new LiveValidation('u_zipcode_actual',{ validMessage: "ok!" });
	u_zipcode_actual.add( Validate.Presence, { failureMessage: "Inserisci il CAP di residenza!" });
	u_zipcode_actual.add( Validate.Format, { pattern: /^[^"\/\\<>|]{1,10}$/i, failureMessage: "I seguenti caratteri non sono validi: \" < > \ / | "  } );
        u_zipcode_actual.add( Validate.Length, { maximum: 10,tooLongMessage : "Deve contenere massimo 10 caratteri!" } );

        var u_country_actual =new LiveValidation('u_country_actual',{ validMessage: "ok!" });
	u_country_actual.add( Validate.Presence, { failureMessage: "Inserisci la nazione di residenza!" });
	u_country_actual.add( Validate.Format, { pattern: /^[^"\/\\<>|]{1,45}$/i, failureMessage: "I seguenti caratteri non sono validi: \" < > \ / | "  } );
        u_country_actual.add( Validate.Length, { maximum: 45,tooLongMessage : "Deve contenere massimo 45 caratteri!" } );
}