//Tableau des messages d'erreur
var TabMessage = new Array()
TabMessage[0] = "Le champ doit obligatoirement être renseigné";
TabMessage[1] = "Le champ doit être saisi comme un entier";
TabMessage[2] = "Le champ doit être saisi au format numérique";
TabMessage[3] = "La date saisie n'est pas valide";
TabMessage[4] = "L'heure saisie n'est pas valide";
TabMessage[5] = "L'adresse email saisie n'est pas valide.";

//Séparateur utilisé pour séparer la définition des formats des différents champs
var SeparateurByHidden=';';

/*'------------------------------------------------------------------------
' VerifieForm(TheForm)
' Vérifie un formulaire en fonction du template de chaque champ defini dans le champ caché FORMATS
' Nom des champs de formulaire traités et leur format : NOM_DU_CHAMP1=*TEMPLATE*;NOM_DU_CHAMP2=*TEMPLATE*;...
' Separateur = ;
' *TEMPLATE* =        NOTNULL pour un champ non NULL
' *TEMPLATE* =        NUM pour un champ numérique
' *TEMPLATE* =        INT pour un entier
' *TEMPLATE* =        EMAIL pour un email
' *TEMPLATE* =        JJMMAAAA pour une date
' *TEMPLATE* =        HHMMSS pour une heure
' Le template peut cumulé à la fois une expression et '!' pour un champ qui ne peut être nul
' par exemple :
'        "MON_CHAMP=NOTNULLJJMMAAAA" (un champ date non null)
'        "MON_CHAMP=JJMMAAAA" (un champ date pouvant être null)
'------------------------------------------------------------------------*/
function VerifieForm(TheForm)
{
        var i;
        var Pos;
				var elem;
				var nom_format;
        var Template = "";
        var Ok = true;
        var NumField=-1;
				
				var format = TheForm.FORMATS.value;
				
				if (format.length == 0)
				{ return true;
				}
				else
				{
  				var control = format.split(SeparateurByHidden);
  
          //Parcours de tous les éléments du formulaire
          i = 0
  				 				
          while (i<control.length && Ok)
          {
                  //Récupération de l'élément à contrôler
  								nom_format = control[i].split("=");
  								elem = eval("TheForm.elements['"+nom_format[0]+"']");
  								
                  //Récupération du format du champ
  								Template = nom_format[1];
                  Template = Template.toUpperCase()
  
                  //Teste l'élément en fonction du template
  
                  //Le champ ne doit pas être NULL
                  if (Ok && Template.indexOf('NOTNULL')!=-1)
                  {
                   	 		 if (elem.length == null)
                         {
                                 if (elem.value == null || elem.value == "")
                                 {
                                          Message = TabMessage[0];
                                          Ok = false;
                                  }
                         }
                         else
                         {
  														if (elem.selectedIndex == null || elem.selectedIndex=="undefined")
  														{
  														  for(j=0;j<elem.length;j++)
  															{
  															  if (elem[j].checked) break;
  															}
  															if (j>=elem.length)
  															{
                                      Message = TabMessage[0];
                                      Ok = false;															
  															}
  														}
  														else 
  														{
                                if (elem.selectedIndex == 0)
                                {
                                        Message = TabMessage[0];
                                        Ok = false;
                                }
  														}
                          }
                  }
  								
                  //Le champ ne doit pas être VIDE
                  if (Ok && Template.indexOf('NOTEMPTY')!=-1)
                  {
                   	 		 if (elem.length == null)
                         {
                                 if (elem.value == null || elem.value == "")
                                 {
                                          Message = TabMessage[0];
                                          Ok = false;
                                  }
                         }
                         else
                         {
                                  if (elem.options.length == 0)
                                  {
                                          Message = TabMessage[0];
                                          Ok = false;
                                  }
                          }
                  }									
  
                  if (elem.value != null && elem.value != "")
                  {
                          //Le champ doit être au format numérique entier
                          if (Ok && Template.indexOf('INT')!=-1)
                          {
                                  if (! chkInt(elem.value))
                                  {
                                          Message = TabMessage[1];
                                          Ok = false;
                                  }
                          }
                          else
                          {
                           				//Le champ doit être au format numérique
                                  if (Ok && Template.indexOf('NUM')!=-1)
                                  {
                                          if (! chkFlt(elem.value))
                                          {
                                                  Message = TabMessage[2];
                                                  Ok = false;
                                          }
                                  }
                          }
  
                          //Le champ doit être au format Date français JJ/MM/AAAA
                          if (Ok && Template.indexOf('JJMMAAAA')!=-1)
                          {
                                  if (! chkDate(elem.value))
                                  {
                                          Message = TabMessage[3];
                                          Ok = false;
                                  }
                          }
  
                          //Le champ doit être au format Heure HH:MM:SS
                          if (Ok && Template.indexOf('HHMMSS')!=-1)
                          {
                                  if (! chkTime(elem.value))
                                  {
                                          Message = TabMessage[4];
                                          Ok = false;
                                  }
                          }
  
                          //Le champ doit être au format Email
                          if (Ok && Template.indexOf('EMAIL')!=-1)
                          {
  												 		 	  TabEmail = elem.value.split(";");
  																for (j=0;j<TabEmail.length;j++)
  																{
                                    if (! ChkEmail(TabEmail[j]))
                                    {
                                           Message = TabMessage[5];
                                           Ok = false;
  																				 break;
                                    }
  																}
                           }
                  }
                  i++;
          }
  
          if (!Ok)
          {
                  alert(Message)
  								if (elem.length != null)
  								{
                   	 if (elem.selectedIndex != null && elem.selectedIndex!="undefined") elem.focus();
  									 else elem[0].focus();
  								}
  								else elem.focus();
          }
  
  				return Ok;
	 }
}


//Séparateur utilisé dans le nom du champ de formulaire
var Separateur='__';

/*'------------------------------------------------------------------------
' VerifieForm2(TheForm)
' Vérifie un formulaire en fonction du template de chaque champ joint au nom du champ
' Nom des champs de formulaire traités : NOM_DU_CHAMP__*TEMPLATE*
' __ = Separateur
' *TEMPLATE* =        NOTNULL pour un champ non NULL
' *TEMPLATE* =        NUM pour un champ numérique
' *TEMPLATE* =        INT pour un entier
' *TEMPLATE* =        EMAIL pour un email
' *TEMPLATE* =        JJMMAAAA pour une date
' *TEMPLATE* =        HHMMSS pour une heure
' Le template peut cumulé à la fois une expression et '!' pour un champ qui ne peut être nul
' par exemple :
'        NAME="MON_CHAMP__NOTNULLJJMMAAAA" (un champ date non null)
'        NAME="MON_CHAMP__JJMMAAAA" (un champ date pouvant être null)
'------------------------------------------------------------------------*/
function VerifieForm2(TheForm)
{
        var i;
        var Pos;
        var Template = "";
        var Ok = true;
        var NumField=-1;

        //Parcours de tous les éléments du formulaire
        i = 0
        while (i<TheForm.elements.length && Ok)
        {
                //Si l'élément correspond à un champ à évaluer
                Pos = TheForm.elements[i].name.indexOf(Separateur)

                if (Pos != -1)
                {
                        //Récupération du format du champ
                        Template = TheForm.elements[i].name.substr(Pos)
                        Template = Template.toUpperCase()

                        //Teste l'élément en fonction du template

                        //Le champ ne doit pas être NULL
                        if (Ok && Template.indexOf('NOTNULL')!=-1)
                        {
                                if (TheForm.elements[i].length == null)
                                {
                                        if (TheForm.elements[i].value == null || TheForm.elements[i].value == "")
                                        {
                                                Message = TabMessage[0];
                                                Ok = false;
                                                NumField = i;
                                        }
                                }
                                else
                                {
                                        if (TheForm.elements[i].selectedIndex == 0)
                                        {
                                                Message = TabMessage[0];
                                                Ok = false;
                                                NumField = i;
                                        }
                                }
                        }

                        //Le champ ne doit pas être VIDE
                        if (Ok && Template.indexOf('NOTEMPTY')!=-1)
                        {
                                if (TheForm.elements[i].length == null)
                                {
                                        if (TheForm.elements[i].value == null || TheForm.elements[i].value == "")
                                        {
                                                Message = TabMessage[0];
                                                Ok = false;
                                                NumField = i;
                                        }
                                }
                                else
                                {
                                        if (TheForm.elements[i].options.length == 0)
                                        {
                                                Message = TabMessage[0];
                                                Ok = false;
                                                NumField = i;
                                        }
                                }
                        }												

                        if (TheForm.elements[i].value != null && TheForm.elements[i].value != "")
                        {
                                //Le champ doit être au format numérique entier
                                if (Ok && Template.indexOf('INT')!=-1)
                                {

                                        if (! chkInt(TheForm.elements[i].value))
                                        {
                                                Message = TabMessage[1];
                                                Ok = false;
                                                NumField = i;
                                        }
                                }
                                else
                                {
                                        //Le champ doit être au format numérique
                                        if (Ok && Template.indexOf('NUM')!=-1)
                                        {
                                                if (! chkFlt(TheForm.elements[i].value))
                                                {
                                                        Message = TabMessage[2];
                                                        Ok = false;
                                                        NumField = i;
                                                }
                                        }
                                }

                                //Le champ doit être au format Date français JJ/MM/AAAA
                                if (Ok && Template.indexOf('JJMMAAAA')!=-1)
                                {
                                        if (! chkDate(TheForm.elements[i].value))
                                        {
                                                Message = TabMessage[3];
                                                Ok = false;
                                                NumField = i;
                                        }
                                }

                                //Le champ doit être au format Heure HH:MM:SS
                                if (Ok && Template.indexOf('HHMMSS')!=-1)
                                {
                                        if (! chkTime(TheForm.elements[i].value))
                                        {
                                                Message = TabMessage[4];
                                                Ok = false;
                                                NumField = i;
                                        }
                                }

                                //Le champ doit être au format Email
                                if (Ok && Template.indexOf('EMAIL')!=-1)
                                {
																 	 		 	TabEmail = TheForm.elements[i].value.split(";");
																				for (j=0;j<TabEmail.length;j++)
																				{
                                          if (! ChkEmail(TabEmail[j]))
                                          {
                                                Message = TabMessage[5];
                                                Ok = false;
                                                NumField = i;
																								break;
                                          }
																				}
                                }
                        }
                }
                i++;
        }

        if (!Ok)
        {
                alert(Message)
                TheForm.elements[NumField].focus()
        }

				return Ok;
}


/*-----------------------------------------------------------------------------------
chkInt(In)
Vérifie si In et un entier
Renvoie true ou false
-----------------------------------------------------------------------------------*/
function chkInt(In)
{ var i;

    // check for all numbers; au moins 1 chiffre

     for ( i=0; i <In.length; i++)
     {
          ch = In.substring(i, i+1);

          if (ch >= "0" && ch <= "9")
          {
                         oneInt = true
          }
                  else
                  {
                                return (false);
                  }
     }
        return(true)
}

/*-----------------------------------------------------------------------------------
chkFlt(In)
Vérifie si In et un entier
Renvoie true ou false
-----------------------------------------------------------------------------------*/
function chkFlt(In)
{ var i;

    // check for all numbers; au moins 1 chiffre

     for ( i=0; i <In.length; i++)
     {
          ch = In.substring(i, i+1);

          if ((ch >= "0" && ch <= "9") || ch==",")
          {
                         oneInt = true
          }
                  else
                  {
                                return (false);
                  }
     }
        return(true)
}


/*-----------------------------------------------------------------------------------
numDaysIn(mth,yr)
Renvoie le nombre de jour du mois mth dans l'anné yr
-----------------------------------------------------------------------------------*/
function numDaysIn(mth,yr) // jan == 1
{
        if (mth==4 || mth==6 || mth==9 || mth==11) return 30;
        else if ((mth==2) && leapYear(yr)) return 29;
        else if (mth==2) return 28;
        else return 31;
}  // end numDaysIn

/*-----------------------------------------------------------------------------------
leapYear(yr)
Vérifie si yr est une année bissextile
Renvoie true ou false
-----------------------------------------------------------------------------------*/
function leapYear(yr)
{
        if (((yr % 4 == 0) && yr % 100 != 0) || yr % 400 == 0)
        {
                return true;
        }
                else
        {
                return false;
        }
}  //  end leapYear



/*-----------------------------------------------------------------------------------
chkDate(day, mth, yr)
Vérifie si day/mth/yr est une date valide
Renvoie true ou false
-----------------------------------------------------------------------------------*/
function chkDate(LaDate)
{
        if ( LaDate.length != 10)
        {
                return(false)
        }

        var day = LaDate.substring(0, 2);
        var mth = LaDate.substring(3, 5);
        var yr = LaDate.substring(6, 10);

        if ( LaDate.substring(2,3) != '/' || LaDate.substring(5,6) != '/')
        {
                return(false)
        }

        if ( mth>12 || mth==0)
        {
                return(false)
        }
        if (day>numDaysIn(mth, yr))
        {
                return(false)
        }
        if ( !(chkInt(day)) )
        {
                return(false)
        }

        if ( !(chkInt(mth)) )
        {
                return(false)
        }
        if ( !(chkInt(yr)) )
        {
                return(false)
        }
        if ( yr<1900 || yr > 3000)
        {
                return(false)
        }

        return(true)
}

/*-----------------------------------------------------------------------------------
chkTime(heure)
Vérifie si heure est une heure valide
Renvoie true ou false
-----------------------------------------------------------------------------------*/
function chkTime(heure)
{
        if ( heure.length != 8)
        {
                return(false)
        }

        var h = heure.substring(0, 2);
        var m = heure.substring(3, 5);
        var s = heure.substring(6, 8);

        if ( heure.substring(2,3) != ':' || heure.substring(5,6) != ':')
        {
                return(false)
        }

        if ( !(chkInt(h)) )
        {
                return(false)
        }

        if ( !(chkInt(m)) )
        {
                return(false)
        }
        if ( !(chkInt(s)) )
        {
                return(false)
        }
        if ( m>60 || s>60)
        {
                return(false)
        }

        return(true)
}

/*'------------------------------------------------------------------------
' ChkEmail (emailStr)
' Vérifie la validité d'une adresse email
'------------------------------------------------------------------------*/
function ChkEmail (emailStr) {
        var emailPat=/^(.+)@(.+)$/
        var specialChars="\\(\\)<>@,;:\\\\\\\"\\.\\[\\]"
        var validChars="\[^\\s" + specialChars + "\]"
        var quotedUser="(\"[^\"]*\")"
        var ipDomainPat=/^\[(\d{1,3})\.(\d{1,3})\.(\d{1,3})\.(\d{1,3})\]$/
        var atom=validChars + '+'
        var word="(" + atom + "|" + quotedUser + ")"
        var userPat=new RegExp("^" + word + "(\\." + word + ")*$")
        var domainPat=new RegExp("^" + atom + "(\\." + atom +")*$")

        var matchArray=emailStr.match(emailPat)
        if (matchArray==null) {
                return false
        }
        var user=matchArray[1]
        var domain=matchArray[2]

        if (user.match(userPat)==null) {
            return false
        }

        var IPArray=domain.match(ipDomainPat)
        if (IPArray!=null) {
                  for (var i=1;i<=4;i++) {
                    if (IPArray[i]>255) {
                                return false
                    }
            }
            return true
        }

        var domainArray=domain.match(domainPat)
        if (domainArray==null) {
            return false
        }

        var atomPat=new RegExp(atom,"g")
        var domArr=domain.match(atomPat)
        var len=domArr.length
        if (domArr[domArr.length-1].length<2 ||
            domArr[domArr.length-1].length>3) {
           return false
        }

        if (len<2) {
           return false
        }

        return true;
}

//Cette fonction prends un champ de formulaire avec la valeur par défaut qu'il est censé avoir à l'origine
//Si ce champs n'a plus cette valeur par défaut alors la fonction renvoie true
function IsFilledInput(Field,MyForm,DefaultValue)
{
    var i;

    //Vérification de la longueur : Pour le cas des boutons radio length > 0
    if ( document.forms[MyForm].elements[Field].type != null )
    {
        //en fonction du type d'input
        switch( (document.forms[MyForm].elements[Field].type) )
        {
            case 'hidden' :
            case 'text'   :
                    if ( !(document.forms[MyForm].elements[Field].value =='undefined' || document.forms[MyForm].elements[Field].value == '' ||document.forms[MyForm].elements[Field].value == DefaultValue) )
                        return true;
                    break;
            case 'checkbox':
                    if (document.forms[MyForm].elements[Field].checked)
                             return true;
                    break;
            case 'select-one' :
                    for(i=0;i<document.forms[MyForm].elements[Field].length;i++)
                    {
                        if (document.forms[MyForm].elements[Field][i].selected && document.forms[MyForm].elements[Field][i].value!=DefaultValue)
                            return true;
                    }
                    break;
        }
    }
    else
    {
        //en fonction du type d'input
        switch( document.forms[MyForm].elements[Field][0].type )
        {
            case 'radio' :
                    //Parcours de l'ensemble des boutons pour déterminer quel bouton est coché
                     for(i=0;i<document.forms[MyForm].elements[Field].length;i++)
                    {
                        if (document.forms[MyForm].elements[Field][i].checked && document.forms[MyForm].elements[Field][i].value!=DefaultValue)
                            return true;
                    }
                    break;
        }
    }

}