// -----------------------------------------------------------
// Une expression régulière pour savoir si la valeur est vide
// ou ne contient que des espaces.

var isEmptyRE = new RegExp("^\\ *$","g");


// -----------------------------------------------------------
// Vérifie qu'un champ du formulaire n'est pas vide ou ne contient
// pas que des espaces. Si ce n'est pas le cas, un message est 
// affiché pour signaler le problème et on renvoie faux.

function isEmpty(aTextField)
{
  fieldName  = aTextField.name;
  fieldValue = aTextField.value;

  if (isEmptyRE.test (fieldValue))
  {
    aTextField.focus();
    alert ("Le champ " + fieldName + " est vide !");
    return true;
  }
  else
  {
    return false;
  } 
}


// --------------
// -- GROUPE 1 --
// --------------

// Affiche un message d'erreur et renvoie faux si la valeur
// n'est pas acceptable pour un caractéristique du groupe 1.
// Sinon renvoie vrai.
function checkGroup1Value(aTextField)
{
  name  = aTextField.name;
  value = aTextField.value;

  if (isEmpty(aTextField))
  {
    // Message d'erreur déjà affiché
    return false;
  }
  else if ( (value < 5) || (value > 13) )
  {
    alert ("La valeur '" + value + "' du champ " + name +
           " n'est pas valide.\n" +
           "Elle doit être comprise entre 5 et 13.");
    aTextField.focus();
    return false;
  }
  else
  {
    return true;
  }
}

// Convertit un champ du groupe 1 en points.
// Renvoie -1 si la valeur n'est pas acceptable.
// Voir aussi checkGroup1Value()
function convertGroup1Value(aTextField)
{
  name  = aTextField.name;
  value = aTextField.value;

  switch (value)
  {
  case "13":  return 20;
  case "12":  return 16;
  case "11":  return 13;
  case "10":  return 10;
  case  "9":  return  7;
  case  "8":  return  5;
  case  "7":  return  3;
  case  "6":  return  1;
  case  "5":  return  0;
  default:  return -1;
  }
}

function computeGroup1Total(group1Fields, group1MaxTotal)
{
  var total1 = 0;

  for (var i = 0; i < group1Fields.length; i++)
  {
    total1 += convertGroup1Value(group1Fields[i]);
  }
  document.RegForm.total1.value = total1;

  if (total1 > group1MaxTotal)
  {
    alert ("Le total du groupe 1 est trop élevé.\n" +
           "La limite pour ce groupe est de " + group1MaxTotal + ".");
    group1Fields[0].focus();
    return false;
  }
  else
  {
    return true;
  }    
}

function checkGroup1()
{
  // Ajouter ici des nouveaux champs du groupe 1
  group1Fields = new Array(5);
  group1Fields [0] = document.RegForm.habilete;
  group1Fields [1] = document.RegForm.dexterite;
  group1Fields [2] = document.RegForm.forcephysique;
  group1Fields [3] = document.RegForm.constitution;
  group1Fields [4] = document.RegForm.rapidite;
 
  // Modifier ici le total maximum du groupe 1
  var group1MaxTotal = 50;

  for (var i = 0; i < group1Fields.length; i++)
  {
    if ( checkGroup1Value (group1Fields[i]) == false )
    {
      return false;
    }   
  }

  return computeGroup1Total(group1Fields, group1MaxTotal);
}


// --------------
// -- GROUPE 2 --
// --------------

// Affiche un message d'erreur et renvoie faux si la valeur
// n'est pas acceptable pour un caractéristique du groupe 1.
// Sinon renvoie vrai.
function checkGroup2Value(aTextField)
{
  // On utilise la même fonction que pour le groupe 1.
  return checkGroup1Value(aTextField);
}

// Convertit un champ du groupe 2 en points.
// Renvoie -1 si la valeur n'est pas acceptable.
// Voir aussi checkGroup1Value()
function convertGroup2Value(aTextField)
{
  // On utilise la même fonction que pour le groupe 1.
  return convertGroup1Value (aTextField);
}

function computeGroup2Total(group2Fields, group2MaxTotal)
{
  var total2 = 0;

  for (var i = 0; i < group2Fields.length; i++)
  {
    total2 += convertGroup2Value(group2Fields[i]);
  }
  document.RegForm.total2.value = total2;

  if (total2 > group2MaxTotal)
  {
    alert ("Le total du groupe 2 est trop élevé.\n" +
           "La limite pour ce groupe est de " + group2MaxTotal + ".");
    group2Fields[0].focus();
    return false;
  }
  else
  {
    return true;
  }    
}

function checkGroup2()
{
  // Ajouter ici des nouveaux champs du groupe 2
  group2Fields = new Array(6);
  group2Fields [0] = document.RegForm.maitrisearme;
  group2Fields [1] = document.RegForm.maitrisetir;
  group2Fields [2] = document.RegForm.maitrisemainnue;
  group2Fields [3] = document.RegForm.esquive;
  group2Fields [4] = document.RegForm.observation;
  group2Fields [5] = document.RegForm.discretion;
 
  // Modifier ici le total maximum du groupe 2
  var group2MaxTotal = 60;

  for (var i = 0; i < group2Fields.length; i++)
  {
    if ( checkGroup2Value (group2Fields[i]) == false )
    {
      return false;
    }   
  }

  return computeGroup2Total(group2Fields, group2MaxTotal);
}

// --------------
// -- GROUPE 3 --
// --------------

// Affiche un message d'erreur et renvoie faux si la valeur
// n'est pas acceptable pour un caractéristique du groupe 3.
// Sinon renvoie vrai.
function checkGroup3Value(aTextField)
{
  name  = aTextField.name;
  value = aTextField.value;

  if (isEmpty(aTextField))
  {
    // Message d'erreur déjà affiché
    return false;
  }
  else if ( (value < 0) || (value > 8) )
  {
    alert ("La valeur '" + value + "' du champ " + name +
           " n'est pas valide.\n" +
           "Elle doit être comprise entre 0 et 8.");
    aTextField.focus();
    return false;
  }
  else
  {
    return true;
  }
}

// Convertit un champ du groupe 3 en points.
// Renvoie -1 si la valeur n'est pas acceptable.
// Voir aussi checkGroup3Value()
function convertGroup3Value(aTextField)
{
  name  = aTextField.name;
  value = aTextField.value;

  switch (value)
  {
  case "8":  return 20;
  case "7":  return 16;
  case "6":  return 13;
  case "5":  return 10;
  case "4":  return  7;
  case "3":  return  5;
  case "2":  return  3;
  case "1":  return  1;
  case "0":  return  0;
  default:   return -1;
  }
}

function computeGroup3Total(group3Fields, group3MaxTotal)
{
  var total3 = 0;

  for (var i = 0; i < group3Fields.length; i++)
  {
    total3 += convertGroup3Value(group3Fields[i]);
  }
  document.RegForm.total3.value = total3;

  if (total3 > group3MaxTotal)
  {
    alert ("Le total du groupe 3 est trop élevé.\n" +
           "La limite pour ce groupe est de " + group3MaxTotal + ".");
    group3Fields[0].focus();
    return false;
  }
  else
  {
    return true;
  }    
}

function checkGroup3()
{
  // Ajouter ici des nouveaux champs du groupe 3
  group3Fields = new Array(5);
  group3Fields [ 0] = document.RegForm.epee;
  group3Fields [ 1] = document.RegForm.hache;
  group3Fields [ 2] = document.RegForm.hallebarde;
  group3Fields [ 3] = document.RegForm.lance;
  group3Fields [ 4] = document.RegForm.masse;
  group3Fields [ 5] = document.RegForm.baton;
  group3Fields [ 6] = document.RegForm.dague;
  group3Fields [ 7] = document.RegForm.bouclier;
  group3Fields [ 8] = document.RegForm.arc;
  group3Fields [ 9] = document.RegForm.arbalete;
  group3Fields [10] = document.RegForm.fronde;
 
  // Modifier ici le total maximum du groupe 3
  var group3MaxTotal = 110;

  for (var i = 0; i < group3Fields.length; i++)
  {
    if ( checkGroup3Value (group3Fields[i]) == false )
    {
      return false;
    }   
  }

  return computeGroup3Total(group3Fields, group3MaxTotal);
}



// -----------------------------------------------------------
// Recalcule entièrement les valeurs de vérifications des
// caractéristiques, et renvoie vrai si tout est OK, faux sinon.
function checkCaracteristics()
{
  if ( (checkGroup1() == false) ||
       (checkGroup2() == false) ||
       (checkGroup3() == false) )
  {
    return false;
  }
  else
  {
    return true;
  }
}

// -----------------------------------------------------------
// Valide le contenu du formulaire d'inscription. Renvoie faux
// si le formulaire n'est pas valide, sinon vrai.
// Appelée par RegForm.onSubmit.

function validateRegForm()
{
  // Vérification des champs vides
  if ( (isEmpty (document.RegForm.nomreel))     ||
       (isEmpty (document.RegForm.mailreel))   ||
       (isEmpty (document.RegForm.description)) ||
       (isEmpty (document.RegForm.login))       ||
       (isEmpty (document.RegForm.password))
     )
  {
    return false;
  }

  // Vérification des valeurs des caractéristiques
  if (checkCaracteristics() == false)
  {
    return false;
  }

  return true;
}