/*
--------------------------------------------------------
Collection de fonction de validation de champs de formulaire
--------------------------------------------------------

Les fonctions verifient differents types de champs et de contenu.
Elle s'appellent toutes d'un maniere uniforme.
--------------------------------------------------------
Usage :
        - charger de Javascript dans le HEAD
        - nommer tous les champs explicitement
        - faire les verifications dans le onSubmit du FORM
        - on peut faire toutes les combinaisons logiques
          desirees, avec ou sans message a l'utilisateur
--------------------------------------------------------
Exemples :
onSubmit="return checkTexte(this.nom, 'Donnez votre nom') && checkTexte(this.prenom, 'Donnez votre prenom');"
    Demande un nom ET (&&) un prenom (seul le message de la premiere erreur est affiche)
onSubmit="return checkTexte(this.code_client) || checkTexte(this.login, 'Donnez votre code client ou votre login');"
    Demande un code client OU (||) un login, et n'affiche qu'un seul message dont le texte combine les deux erreurs.
--------------------------------------------------------
Fonctions disponibles :
    checkTexte(champ, message, lmin, lmax)
    checkNum(champ, message, mini, maxi, decimales)
    checkEmail(champ, message)
    checkListe(champ, message)
    checkRadio(champ, message)
    checkDepend(champParent, champType, champEnfant, champType, champEnfant, champType, .... )
Parametres :
    champ : objet champ de formulaire a controler (this.champ)
    message : message (optionnel) a afficher en cas d'erreur (s'il n'est pas la, aucun autre argument ne peut etre donne)
    lmin/lmax : longeur mini/maxi d'une chaine (lmin > 0; lmax >= lmax)
    mini, maxi : valeurs mini/maxi d'un numerique
    decimales : nombre de decimales autorise (0 ou rien pour n'accepter que les entiers)
--------------------------------------------------------
Code en situation :
ATTENTION : le premier appel doit etre sur la meme ligne que le return, sinon, IE5 ne fait que le return...

<script language="JavaScript" src="/js/checkForm.js"></script>
...
<form action="inscription.md" method="post" onSubmit="
        return checkTexte(this.nom, 'Donnez votre nom') &&
        checkTexte(this.prenom, 'Donnez votre prenom') &&
        (checkNum(this.code_client) || checkTexte(this.login, 'Donnez votre code client ou votre login.'));">
    <input type="text" name="nom">
    <input type="text" name="prenom">
</form>
--------------------------------------------------------
*/


// erreurCheck : appele en cas d'erreur (affiche le message eventuel et met le focus sur le champ)
// Cette fonction permet de traiter les erreur d'une autre maniere, le cas echeant (conserve tous les messages en memoire, puis les affiche d'un coup)
function erreurCheck(champ, message) {

    if (message) {                              // Si on ne donne pas de message, on reste silencieux...
        alert(message);
        if (champ.type > "" && champ.type!="hidden") {  // Les boutons radios sont multiples : on ne peut pas leur apporter le focus globalenent
                                                       // de meme pour les hidden
            if(this.onglet){                          // dans le cas ou le champ est dans un onglet on fait ce qui suit
               for( k=1 ; k <= this.onglet.nong; k++){
                this.onglet.changeOnglet('onglet'+k);
                    try{
                    champ.focus();
                    break;
                    }
                    catch(e){
                    continue;
                    }
               }
            }
            else{
            champ.focus();
            }
        }
    }
    return false;
}


// checkTexte : verifie si le champ donne est rempli ou pas
function checkTexte(champ, message, lmin, lmax) {
    var nArgs = checkTexte.arguments.length;
    if ((champ.value > "") && ((nArgs < 3) || (champ.value.length >= lmin)) && ((nArgs < 4) || (champ.value.length <= lmax))) {
        return true;
    } else {
        return erreurCheck(champ, message);
    }
}


// checkNum : verifie si le champ donne est un numerique entier ou reel,
// avec ou sans decimales, compris entre deux bornes
function checkNum(champ, message, mini, maxi, decimales) {
    var nArgs = checkNum.arguments.length;
    var checkStr = champ.value;
    var pos;

    // Remplace les ',' par des '.', de maniere a utiliser parseFloat
    while ((pos = checkStr.indexOf(',')) > -1) {
        checkStr = checkStr.substring(0, pos) + '.' + checkStr.substring(pos + 1);
    }

    // Supprime les 0 de fin apres le point decimal, afin de ne pas perturber la comparaison
    while ((checkStr.length > 1) && (checkStr.indexOf('.') > -1) && (checkStr.charAt(checkStr.length - 1) == '0')) {
        checkStr = checkStr.substring(0, checkStr.length - 1);
    }
    // Supprime le point decimal s'il se retrouve tout seul a la fin
    if ((checkStr.length > 1) && (checkStr.charAt(checkStr.length - 1) == '.')) checkStr = checkStr.substring(0, checkStr.length - 1);

    // Supprime les 0 de tete, afin de ne pas perturber la comparaison
    while ((checkStr.length > 1) && (checkStr.charAt(0) == '0')) {
        checkStr = checkStr.substring(1);
    }
    // Remet un 0 si le caractere suivant est un point decimal
    if (checkStr.charAt(0) == '.') checkStr = '0' + checkStr;

    // Convertis le champ en flottant, puis conversion retour : on pourra comparer les deux
    var checkFloat = parseFloat(checkStr);
    var reCheckStr = String(checkFloat);

    // Mesure le nombre de decimales effectif du nombre convertis en flottant
    pos = reCheckStr.indexOf('.');
    var nbDec = (pos > -1 ? reCheckStr.length - pos - 1 : 0);

    if ((reCheckStr == checkStr) && ((nArgs < 3) || (checkFloat >= mini)) && ((nArgs < 4) || (checkFloat <= maxi)) && ((nArgs < 5) || (nbDec <= decimales))) {
        return true;
    } else {
        return erreurCheck(champ, message);
    }
}


// checkEmail : verifie si le champ donne est une adresse e-mail
function checkEmail(champ, message) {
    var checkStr = champ.value.toLowerCase();
    var checkOK = "0123456789abcdefghijklmnopqrstuvwxyz-_/.@";
    var pos, car, valide = true, posAt = -1, posDot = -1;

    for (pos = 0; pos < checkStr.length; pos++) {
        if (checkStr.charAt(pos) == '@') {
            posAt = pos;
            continue;
        }
        if (checkStr.charAt(pos) == '.') {
            posDot = pos;
            continue;
        }
        if (checkOK.indexOf(checkStr.charAt(pos)) == -1) {
            valide = false;
            break;
        }
    }

    if (valide && (posAt > -1) && (posDot > posAt + 1) && (posDot < checkStr.length - 1)) {
        return true;
    } else {
        return erreurCheck(champ, message);
    }
}


// checkListe : verifie si la liste deroulante a bien une selection non vide
// gestion des listes a selections multiples
function checkListe(champ, message) {
    if (champ.multiple) {
        if (champ.selectedIndex == -1) {
            return erreurCheck(champ, message);
        } else {
            return true;
        }
    } else {
        if (champ.options[champ.selectedIndex].value > "") {
            return true;
        } else {
            return erreurCheck(champ, message);
        }
    }
}


// checkRadio : verifie si le groupe de cases (checkbox ou bouton radio) a bien au moins une coche
function checkRadio(champ, message) {
    var pos, valide = false;
    if (champ.length) {
        for (pos = 0; pos < champ.length; pos++) {
            if (champ[pos].checked) {
                valide = true;
                break;
            }
        }
    } else {
        if (champ.checked) {
            valide = true;
        }
    }

    if (valide) {
        return true;
    } else {
        return erreurCheck(champ, message);
    }
}

function selectAll(champ) {
    if (champ.multiple) {
        for (var pos = 0; pos < champ.options.length; pos++) {
            champ.options[pos].selected = true;
        }
    } else {
        champ.selected = true;
    }
    return true;
}
// checkDate : verifie la validite d'une date
function checkDate(jour,mois,annee,msg){

        if(jour.value && mois.value && annee.value){
            var an2000=new Date("jan 01, 2000 00:00:00");
            var offsetAn2000=(an2000.getYear()==2000)?0:(2000-an2000.getYear());
            var an1999=new Date("jan 01, 1999 00:00:00");
            var offsetAn1999=(an1999.getYear()==1999)?0:(1999-an1999.getYear());
            var jourC=jour[jour.selectedIndex].value;
            var moisC=mois[mois.selectedIndex].value;
            var anneeC=annee[annee.selectedIndex].value;
            var day = new Date(anneeC,moisC-1,jourC);

            annee=(day.getTime()<an2000.getTime())?day.getYear() + offsetAn1999:day.getYear() + offsetAn2000;

            if ( (day.getDate()!=jourC) || ( (day.getMonth() + 1)!=moisC ) || (annee!=anneeC)){
                if(!msg) msg = "La date saisie est invalide";
                return erreurCheck(annee, msg);

            }
            else return true;
        }
        else if (jour.value || mois.value || annee.value){


               return erreurCheck(annee, 'Tous les champs de la date ne sont pas saisis !');
        }
        else return true;

}
// checkPass : verifie la validite d'un password avec sa confirmation dans un formulaire d'inscription
function checkPass(mdp1,message1,mdp2,message2,message3)
{
        if (mdp1.value=='')
        {
                return erreurCheck(mdp1,message1);
        }
        else if (mdp2.value=='')
        {
                return erreurCheck(mdp2,message2);
        }
        else if (mdp1.value!=mdp2.value)
        {
                mdp2.value='';
                return erreurCheck(mdp1,message3);
        }
        else
        {
                return true;
        }
}

// checkDepend : verifie les inputs affilies a un input parent
function checkDepend(champParent,champType)
{
        var xArgs = checkDepend.arguments.length ;
        if (xArgs % 2)
        {
                alert('Le nombre de parametres passes a la fonction checkDepend est incorrect') ;
                return false ;
        }
        if ( champType == 'text' ) test = checkTexte(champParent);
        if ( champType == 'list' ) test = checkListe(champParent);
        if ( champType == 'box' ) test = checkRadio(champParent);
        if (test)
        {
                for (i=2;i<(xArgs-1);i+=2)
                {
                        if ( checkDepend.arguments[i+1] == 'text' )
                        {
                                check = checkTexte(checkDepend.arguments[i]);
                                message = 'Ce champ doit etre rempli';
                        }
                        if ( checkDepend.arguments[i+1] == 'list' )
                        {
                                check = checkListe(checkDepend.arguments[i]);
                                message = 'Vous devez selectionner une option';
                        }
                        if ( checkDepend.arguments[i+1] == 'box' )
                        {
                                check = checkRadio(checkDepend.arguments[i]);
                                message = 'Vous devez cocher une option';
                        }
                        if (!check)
                        {
                                return erreurCheck(checkDepend.arguments[i], message);
                        }
                }
        }
        return true ;
}