/*
    Warning - Contrôle JavaScript utilisable uniquement sur les pages ASP.NET référencant 
    un contrôle serveur ScriptManager avec un référence au service RechercheVehicule.asmx
    Warning - Utilise la bibliothèque Commun.js
*/

// Variables initialisées à l'init du groupe pour savoir si on revient sur le groupe ou un refresh
var MARQUE;
var APPELLATION_COMMERCIALE;
var BOITE_VITESSE;
var CARBURANT;
var CARROSSERIE;
var PUISSANCE;
var ANNEE_COMMERCIALISTATION;
var CODE_AUTO;

var TESS_LOT2_ACTIF;
var DATE_MISE_EN_CIRCULATION;
var ID_ACT_INTERNE;
var NOM_PARCOURS;
var NUMERO_SESSION;
var ID_VISITEUR;

/*************************** VARIABLES D'AIDE POUR L'AFFICHAGE *************************/
var pageRechargee = false;
var afficherChampAnneeCommercialisation = false;
var afficherZeroVehicule = true;
// si on vient de sélectionner marques étendue dans la liste
var codeListeMarquesEtendueSelectionne = false;
// si on vient de sélectionner modeles étendue dans la liste
var codeListeModelesEtendusSelectionne = false;
var timeout = 0;

/********************* VARIABLES CONTENANT LES VALEURS DE LA RECHERCHE ***********/
var marque;
var appellationCommerciale;
var carburant;
var boiteVitesse;
var carrosserie;
var puissance;
var anneeMiseCirculation;
var codeAuto;
var estTessActive = true;
var codeListeMarquesEtendue;
var codeListeModelesEtendue;
var idSession;

var listeEtendueMarque = false;
var listeEtendueModele = false;

var listeCarburantBoite = new Array();
var nbVehiculesTrouves;
var anneeDebut = "";
var anneeFin = "";

/********************************* CONSTANTES *******************************/
var LimiteNombreVehiculesTESS1;
var LimiteNombreVehiculesTESS2;
var LimiteNombreVehiculesTESS3;

var CODE_LISTE_MARQUES_ETENDUE;
var CODE_LISTE_MODELES_ETENDUE;
var AFFICHAGE_AUTRES_MARQUES;
var AFFICHAGE_AUTRES_MODELES;

var VALEUR_PAR_DEFAUT = "NSP";
var VALEUR_NSP = "ValeurTemporaire";

/******************************* VARIABLES DES CRITERES DE RECHERCHE ************/
var selectMarque;
var selectAppellationCommerciale;
var selectCarburant;
var selectBoiteVitesse;
var selectTypeCarrosserie;
var selectPuissanceFiscale;
var champAnneeCommercialisation;

/***************************************************************************************************/
/*************************** METHODES EN CAS DE TIMEOUT DE L'APPEL AJAX ****************************/
/***************************************************************************************************/
// un timeout est survenu, on ne retentera pas de réappeler le web service
function TimeOutSurvenu() {
    timeout = 1;
    alert("un time out est survenu");
}

// on remet la valeur timeout à 0 car on n'a pas eu de time out
function ReinitialiserTimeOut() {
    if (timeout == 1) {
        alert("le time out a été repris");
        timeout = 0;
    }
    
}

/***************************************************************************************************/
/********************** METHODE POUR RECUPERER LES VALEURS DES DONNEES AUTOMATES *******************/
/***************************************************************************************************/
// Récupère les informations du véhicule choisi par l'utilisateur
function RecupererInformationsVehicule(
    marqueChoisie, 
    appellationCommercialeChoisie, 
    carburantChoisi, 
    boiteVitesseChoisie, 
    carrosserieChoisie, 
    puissanceChoisie, 
    anneeMiseCirculationChoisie, 
    codeAutoChoisi, 
    codeListeMarquesEtendueChoisie,
    codeListeModelesEtendueChoisie, 
    recupererInformationsVehiculeChoisie,
    idSessionCourante,
    tessLot2ActifChoisi,
    dateMiseEnCirculationChoisie,
    idActInterneChoisi,
    nomParcours,
    numeroSession,
    idVisiteur)
{
    marque = marqueChoisie;
    appellationCommerciale = appellationCommercialeChoisie;
    carburant = carburantChoisi;
    boiteVitesse = boiteVitesseChoisie;
    carrosserie = carrosserieChoisie;
    puissance = puissanceChoisie;
    anneeMiseCirculation = anneeMiseCirculationChoisie;
    codeAuto = codeAutoChoisi;
    codeListeMarquesEtendue = codeListeMarquesEtendueChoisie;
    if (codeListeMarquesEtendue != "")
    {
        listeEtendueMarque = true;
        ajouteTexte(" ( Liste étendue ) ", "spanListeEtendue");
    }
    codeListeModelesEtendue = codeListeModelesEtendueChoisie;
    if (codeListeModelesEtendue != "")
    {
        listeEtendueModele = true;
    }
    idSession = idSessionCourante;
    
    MARQUE = marqueChoisie;
    APPELLATION_COMMERCIALE = appellationCommercialeChoisie;
    CARBURANT = carburantChoisi;
    BOITE_VITESSE = boiteVitesseChoisie;
    CARROSSERIE = carrosserieChoisie;
    PUISSANCE = puissanceChoisie;
    ANNEE_COMMERCIALISTATION = anneeMiseCirculationChoisie;
    CODE_AUTO = codeAutoChoisi;
    
    TESS_LOT2_ACTIF = tessLot2ActifChoisi;
    DATE_MISE_EN_CIRCULATION = dateMiseEnCirculationChoisie.substring(dateMiseEnCirculationChoisie.length - 4, dateMiseEnCirculationChoisie.length);

    ID_ACT_INTERNE = idActInterneChoisi;
    NOM_PARCOURS = nomParcours;
    NUMERO_SESSION = numeroSession;
    ID_VISITEUR = idVisiteur;
    
    testerChargementPage();
}

// on teste si la page est chargée par un refresh ou un retour sur le groupe
// pour cela, il faut que le code auto ne soit pas vide et que les anciens critères de recherche
// soient les mêmes que ceux courants
function testerChargementPage()
{
    if (CODE_AUTO != "")
    {
        pageRechargee = (
            (marque == MARQUE) && (appellationCommerciale == APPELLATION_COMMERCIALE) &&
            (carburant == CARBURANT) && (boiteVitesse == BOITE_VITESSE) &&
            (puissance == PUISSANCE) && (anneeMiseCirculation == ANNEE_COMMERCIALISTATION) &&
            (codeAuto == CODE_AUTO)
            );
        return pageRechargee;
    }
    else
    {
        return false;
    }
}
/***************************************************************************************************/
/**************************** METHODES POUR RECUPERER LES LIMITES DE VEHICULES *********************/
/***************************************************************************************************/

// récupère les limites de véhicules pour afficher directement le tableau de véhicule
function initialiserParametresRechercheVehicule()
{
    if (LimiteNombreVehiculesTESS1 == null || LimiteNombreVehiculesTESS1 == "" ||
        LimiteNombreVehiculesTESS2 == null || LimiteNombreVehiculesTESS2 == "" || 
        LimiteNombreVehiculesTESS3 == null || LimiteNombreVehiculesTESS3 == "")
    {
        DA.WEB.PS.MoteurRendu.Auto.Web.RechercheVehicule.RecupererParametres(OnRecupererValeursParametres, OnFailedRecupererValeursParametres);
	}
}

function OnRecupererValeursParametres(results)
{
    if (results != null)
    {
        if (results["LimiteNombreVehiculesTESS1"] != null)
        {
            LimiteNombreVehiculesTESS1 = results["LimiteNombreVehiculesTESS1"];
        }
        if (results["LimiteNombreVehiculesTESS2"] != null)
        {
            LimiteNombreVehiculesTESS2 = results["LimiteNombreVehiculesTESS2"];
        }
        if (results["LimiteNombreVehiculesTESS3"] != null)
        {
            LimiteNombreVehiculesTESS3 = results["LimiteNombreVehiculesTESS3"];
        }
        if (results["CodeListeMarquesEtendue"] != null)
        {
            CODE_LISTE_MARQUES_ETENDUE = results["CodeListeMarquesEtendue"];
        }
        if (results["CodeListeModelesEtendue"] != null)
        {
            CODE_LISTE_MODELES_ETENDUE = results["CodeListeModelesEtendue"];
        }
        if (results["AffichageAutresMarques"] != null)
        {
            AFFICHAGE_AUTRES_MARQUES = results["AffichageAutresMarques"];
        }
        if (results["AffichageAutresModeles"] != null)
        {
            AFFICHAGE_AUTRES_MODELES = results["AffichageAutresModeles"];
        }
    }
    ReinitialiserTimeOut();
}

// en cas d'echec, on retente une fois de rappeler le web service
function OnFailedRecupererValeursParametres(erreur) {
    if (erreur.get_timedOut() && timeout == 0) {
        TimeOutSurvenu();
        initialiserParametresRechercheVehicule();
    } else {
        ReinitialiserTimeOut();
    }
}

// détermine si on affiche directement le tableau de véhicules
function afficherListeVehicules(nbVehicules)
{
    if (nbVehicules <= 0)
    {
        return false;
    }
    if( (nbVehicules <= LimiteNombreVehiculesTESS1 && carburant == "") || 
    	(nbVehicules <= LimiteNombreVehiculesTESS2 && (boiteVitesse != "" || carrosserie != "" || puissance != "") ) 
        ||
        anneeMiseCirculation != "")
    {
        return true;
    }
    
    if( nbVehicules > LimiteNombreVehiculesTESS1 )
	{
		//valider quand meme si la limite LimVehicules3 n'est pas atteinte
		if(nbVehicules <= LimiteNombreVehiculesTESS3 && puissance != "" && puissance != VALEUR_PAR_DEFAUT)
		{
	        // si on est en rechargement et que la valeur de la puissance est NSP, alors on ne doit pas générer le tableau	
		    if (puissance == VALEUR_NSP && pageRechargee)
		    {
		        return false;
		    }
		    else
		    {
			    return true;
			}
		}
	}
	viderTableauVehicules();
	return false;
}

/****************************************************************************************************/
/********************************** METHODES AJAX POUR RECHERCHER LE VEHICULE ***********************/
/****************************************************************************************************/

/***************************************METHODES AJAX POUR LES MARQUES ******************************/
// méthode appelée lorsque l'utilisateur change de valeur dans la liste des marques
// calcule soit les modèles associés, soit récupère toutes les marques
function MarqueModifiee(tessActive, selection)
{
    afficherChampAnneeCommercialisation = false;
    // on réinitialise les modèles sans la liste étendue des modèles
    codeListeModelesEtendue = "";
    codeListeModelesEtendusSelectionne = false;
    // si on ne selectionne pas autre marque
    if (selection != CODE_LISTE_MARQUES_ETENDUE)
    {
        // on précise qu'on ne vient pas de sélectionner code liste marques etendues
        codeListeMarquesEtendueSelectionne = false;
    //  si on revient de la page suivant et qu 'on avait sélectionné modèles étendues, on garde
        RecupererListeAppellationsCommerciales();
    }
    else
    {
        // on précise que l'on vient de sélectionner code liste marques etendues
        // pour vider dans la méthode call back les questions suivantes 
        // et remettre la liste sur la valeur par défaut
        codeListeMarquesEtendueSelectionne = true;
        attente();
        ajouteTexte(" ( Liste étendue ) ", "spanListeEtendue");
        listeEtendueMarque = true;
        
        DA.WEB.PS.MoteurRendu.Auto.Web.RechercheVehicule.RecupererListeMarques(listeEtendueMarque, tessActive, idSession, OnRecupererListeMarquesComplete, OnFailed);
    }
}

// Méthode appelée lors de l'initialisation du groupe pour récupérer les marques
function RecupererListeMarques(tessActive)
{
    if (tessActive != undefined){
        try{
            estTessActive = tessActive;
        }
        catch (Exception){
            estTessActive = true;
        }
    }
    selectMarque = document.forms["form1"].elements.reponseMarqueVoiture;
    selectAppellationCommerciale = document.forms["form1"].elements.reponseAppellationCommercialeVoiture;
    selectCarburant = document.forms["form1"].elements.reponseCarburant;
    selectBoiteVitesse = document.forms["form1"].elements.reponseBoiteVitesse;
    selectTypeCarrosserie = document.forms["form1"].elements.reponseTypeCarrosserie;
    selectPuissanceFiscale = document.forms["form1"].elements.reponsePuissanceFiscale;
    champAnneeCommercialisation = recupereInputReponse("AnneeCommercialisation");
    
    // Valeur par défaut, on masque et on vide toutes les autres questions
    cacheQuestion("AppellationCommercialeVoiture");
    cacheQuestion("Carburant");
    cacheQuestion("BoiteVitesse");
    cacheQuestion("TypeCarrosserie");
    cacheQuestion("PuissanceFiscale");
    cacheQuestion("AnneeCommercialisation");
    cacheQuestion("ChoixModeleVoiture");
    viderListe(selectAppellationCommerciale);
    viderListe(selectCarburant);
    viderListe(selectBoiteVitesse);
    viderListe(selectTypeCarrosserie);
    viderListe(selectPuissanceFiscale);
    viderChamp(champAnneeCommercialisation);
    viderTableauVehicules();
    attente();
    DA.WEB.PS.MoteurRendu.Auto.Web.RechercheVehicule.RecupererListeMarques(listeEtendueMarque, estTessActive, idSession, OnRecupererListeMarquesComplete, OnFailedRecupererListeMarquesComplete);
}
function OnRecupererListeMarquesComplete(results) 
{
    viderListe(selectMarque);
    ajouterOptions(selectMarque, results.ListeResultats);
    nbVehiculesTrouves = results.NombreVehiculesRetournes;
    if (marque != null && marque != CODE_LISTE_MARQUES_ETENDUE) 
    {
        // on remet par défaut la liste à "Sélectionner" si on a choisi marque étendue
        if (!listeEtendueMarque)
        {
            ajouterOptionVide(selectMarque);
            ajouterOption(selectMarque, CODE_LISTE_MARQUES_ETENDUE, AFFICHAGE_AUTRES_MARQUES);
        }
    }
    // si on vient de sélectionner marques étendues, on vide les questions suivantes
    // et on remet la liste à sa valeur par défaut
    if (codeListeMarquesEtendueSelectionne)
    {
        marque = "";
        appellationCommerciale = "";
        carburant = "";
        boiteVitesse = "";
        carrosserie = "";
        anneeMiseCirculation = "";
        viderListe(selectAppellationCommerciale);
        viderListe(selectCarburant);
        viderListe(selectBoiteVitesse);
        viderListe(selectTypeCarrosserie);
        viderListe(selectPuissanceFiscale);
        viderChamp(champAnneeCommercialisation);
        viderTableauVehicules();
        // on ne pourra plus sélectionner cette valeur
        codeListeMarquesEtendueSelectionne = false;
        afficherQuestionsNecessaires(true);
    }
    
    if (estDefini(marque)){
        positionnerChoix(selectMarque, marque);
        RecupererListeAppellationsCommerciales();
    }
    else
    {
        finAttente();
    }
    cacherProgression();
    ReinitialiserTimeOut();
}

// On retente de récupérer une fois la liste des marques en cas de time out
function OnFailedRecupererListeMarquesComplete(erreur) {
    if (erreur.get_timedOut() && timeout == 0) {
        TimeOutSurvenu();
        DA.WEB.PS.MoteurRendu.Auto.Web.RechercheVehicule.RecupererListeMarques(listeEtendueMarque, estTessActive, idSession, OnRecupererListeMarquesComplete, OnFailedRecupererListeMarquesComplete);
    }
    else {
        ReinitialiserTimeOut();
    }
}

/***************************************METHODES AJAX POUR LES MODELES ******************************/
// Méthode appelée lorsque l'utilisateur change la valeur du modèle
// récupère la liste des carburants ou récupère tous les modèles de la marque
function ModeleModifie(selection)
{
    afficherChampAnneeCommercialisation = false;
    // si on n'a pas sélectionné "autre modele", on recherche les carburants
    if (selection != CODE_LISTE_MODELES_ETENDUE)
    {
        // on précise qu'on ne vient pas de sélectionner code liste modeles etendues
        codeListeModelesEtendusSelectionne = false;
        RecupererListeCarburants();
    }
    else
    {
        // on précise que l'on vient de sélectionner code liste modeles etendues
        // pour vider dans la méthode call back les questions suivantes 
        // et remettre la liste sur la valeur par défaut
        codeListeModelesEtendusSelectionne = true;
        // on recharge la liste des appellations commerciales étendue
        listeEtendueModele = true;
        viderListe(selectAppellationCommerciale);
        viderListe(selectCarburant);
        viderListe(selectBoiteVitesse);
        viderListe(selectTypeCarrosserie);
        viderListe(selectPuissanceFiscale);
        viderChamp(champAnneeCommercialisation);
        viderTableauVehicules();
                 
        recupererListeAppellationsCommerciales(listeEtendueModele);
    }
}
function RecupererListeAppellationsCommerciales()
{
    afficherProgression();
    
    viderListe(selectAppellationCommerciale);
    viderListe(selectCarburant);
    viderListe(selectBoiteVitesse);
    viderListe(selectTypeCarrosserie);
    viderListe(selectPuissanceFiscale);
    viderChamp(champAnneeCommercialisation);
    viderTableauVehicules();
    
    var marqueSelectionnee = recupererOptionSelectionnee(selectMarque);
    if (marque != null && marque != marqueSelectionnee){
        // On a choisi après un retour en arrière une autre marque de véhicule
        // Il faut donc vider tous les champs pré-remplis et positionner la nouvelle marque
        marque = marqueSelectionnee;
        appellationCommerciale = '';
        carburant = '';
        boiteVitesse = '';
        carrosserie = '';
        puissance = '';
        anneeMiseCirculation = '';
    }
    attente();
    // on teste si la marque est une marque particulière
    DA.WEB.PS.MoteurRendu.Auto.Web.RechercheVehicule.EstMarqueParticuliere(marque, OnEstMarqueParticuliereComplete, OnFailed);
}

function OnEstMarqueParticuliereComplete(results)
{
    if (!results || codeListeModelesEtendue == CODE_LISTE_MODELES_ETENDUE)
    {
        listeEtendueModele = true;
    }
    else
    {
        //  si on revient de la page suivant et qu 'on avait sélectionné modèles étendues, on garde
    // on ne réaffiche pas la liste des modèles étendus si on a changé de marque
        listeEtendueModele = false;
    }
    recupererListeAppellationsCommerciales(listeEtendueModele);
}
// récupère la liste des modèles d'une marque
// en paramètre si on affiche tous les modèles ou non
function recupererListeAppellationsCommerciales(listeEtendue)
{
    attente();
    if (!listeEtendue)
    {
        // liste des modèles de base
        DA.WEB.PS.MoteurRendu.Auto.Web.RechercheVehicule.RecupererListeModelesRecents(marque, OnRecupererListeModelesComplete, OnFailed);
    }
    else
    {
        // liste de tous les modèles (liste étendue)
        DA.WEB.PS.MoteurRendu.Auto.Web.RechercheVehicule.RecupererListeAppellationsCommerciales(marque, idSession, OnRecupererListeModelesComplete, OnFailed);
    }
}

function OnRecupererListeModelesComplete(results)
{
    nbVehiculesTrouves = results.NombreVehiculesRetournes;
    ajouterOptions(selectAppellationCommerciale, results.ListeResultats);
   
    if (!listeEtendueModele)
    {
        ajouterOption(selectAppellationCommerciale, CODE_LISTE_MODELES_ETENDUE, AFFICHAGE_AUTRES_MODELES);
    }
    // si on vient de sélectionner liste modèles étendues, on vide les questions suivantes
    // on réinitialise la question à sa valeur par défaut
    if (codeListeModelesEtendusSelectionne)
    {
        positionnerChoix(selectAppellationCommerciale, VALEUR_PAR_DEFAUT);
        appellationCommerciale = "";
        carburant = "";
        boiteVitesse = "";
        carrosserie = "";
        anneeMiseCirculation = "";
        viderListe(selectCarburant);
        viderListe(selectBoiteVitesse);
        viderListe(selectTypeCarrosserie);
        viderListe(selectPuissanceFiscale);
        viderChamp(champAnneeCommercialisation);
        viderTableauVehicules();
        // on ne pourra plus sélectionner cette valeur
        codeListeModelesEtendusSelectionne = false;
        afficherQuestionsNecessaires(true);
    }
    if (estDefini(appellationCommerciale)){
        if (positionnerChoix(selectAppellationCommerciale, appellationCommerciale)) {
            RecupererListeCarburants();
        }
        else {
            finAttente();
        }
    }
    else
    {
        afficherQuestionsNecessaires(true);
    }
    cacherProgression();
}

/***************************************METHODES AJAX POUR LES CARBURANTS ******************************/
function RecupererListeCarburants()
{
    afficherProgression();
    
    viderListe(selectCarburant);
    viderListe(selectBoiteVitesse);
    viderListe(selectTypeCarrosserie);
    viderListe(selectPuissanceFiscale);
    viderChamp(champAnneeCommercialisation);
    viderTableauVehicules();
    afficherChampAnneeCommercialisation = false;
    
    if (!pageRechargee)
    {
        carburant = "";
        // FLOK: Inutile...
        //anneeMiseCirculation = "";
    }
    else
    {
        carburant = CARBURANT;
    }
    boiteVitesse = "";
    carrosserie = "";
    puissance = "";
    anneeMiseCirculation = "";
        
    
    appellationCommerciale = recupererOptionSelectionnee(selectAppellationCommerciale);

    attente();
    DA.WEB.PS.MoteurRendu.Auto.Web.RechercheVehicule.RecupererListeCarburantsBoites(marque, appellationCommerciale, OnRecupererRecupererListeCarburantsComplete, OnFailed);
}

function OnRecupererRecupererListeCarburantsComplete(results)
{
    nbVehiculesTrouves = results.NombreVehiculesRetournes;
   
    if (afficherListeVehicules(nbVehiculesTrouves))
    {
        creerLignesVehicules();
    }
	else
	{
        ajouterOptionParDefaut(selectCarburant);
        
        // vide les variables
        boiteVitesse = '';
        carrosserie = '';
        puissance = '';
        anneeMiseCirculation = '';
        
        listeCarburantBoite = new Array();
        
        for (var i=0; i<results.ListeResultats.length; i++){
            // on sauvegarde les couples carburant boite
            var carburantBoite = new Object();
            carburantBoite.Carburant = results.ListeResultats[i].Carburant;
            carburantBoite.Boite = results.ListeResultats[i].Boite;
            
            switch (results.ListeResultats[i].Carburant){
                case "ESSENCE":{
                    ajouterOption(selectCarburant, "ESSENCE", "Essence");
                    carburantEssence=true;
                    carburantBoite.Code = "ESSENCE";
                    break;
                }
                case "GASOIL":
                case "DIESEL":
                    {
                        ajouterOption(selectCarburant, "DIESEL", "Diesel");
                        carburantDiesel = true;
                        carburantBoite.Code = "DIESEL";
                        if (carburant == "GASOIL") {
                            carburant = "DIESEL";
                        }
                        break;
                    }
                case "ELECTRIQUE":
                case "GNV":
                case "GPL":
                case "E8":
                case "AUTRE":
                    {
                        ajouterOption(selectCarburant, "AUTRE", "Autre carburant");
                        if (carburant == "ELECTRIQUE" || carburant == "GNV" || carburant == "GPL" || carburant == "E8") {
                            carburant = "AUTRE";
                        }
                        carburantAutre = true;
                        carburantBoite.Code = "AUTRE";
                        break;
                    }
            }
            
            listeCarburantBoite.push(carburantBoite);
        }
        
        // si qu'un seul carburant existe, on préinitialise la variable carburant
        if (results.ListeResultats.length == 1 || selectCarburant.length == 2)
        {
            carburant = selectCarburant.options[1].value;
        }
        if (estDefini(carburant)){
            if (positionnerChoix(selectCarburant, carburant))
            {
                RecupererListeBoites();
            }
        }
        else
        {   
            afficherQuestionsNecessaires(true);
        }
        cacherProgression();
    }
}

/***************************************METHODES POUR LES BOITES ******************************/
function RecupererListeBoites()
{
    afficherProgression();
    
    viderListe(selectBoiteVitesse);
    viderListe(selectTypeCarrosserie);
    viderListe(selectPuissanceFiscale);
    viderChamp(champAnneeCommercialisation);
    viderTableauVehicules();
    
    if (!pageRechargee)
    {
        boiteVitesse = "";
        anneeMiseCirculation = "";
    }
    else
    {
        boiteVitesse = BOITE_VITESSE;
    }
    carrosserie = "";
    puissance = "";
    anneeMiseCirculation = "";
    
        
    carburant = recupererOptionSelectionnee(selectCarburant);
    
    // si on a sélectionné vide, on ne continue pas
    if (carburant == VALEUR_PAR_DEFAUT)
    {   
        carburant = "";
        afficherQuestionsNecessaires(true);
    }
    else
    {
        ajouterOptionParDefaut(selectBoiteVitesse);
        
        var boiteM = false;
        var boiteA = false;
        var boiteX = false;
        
        for (var i = 0; i < listeCarburantBoite.length; i++)
        {
            if (listeCarburantBoite[i].Code == carburant)
            {
                switch (listeCarburantBoite[i].Boite){
                    case "M":{
                        boiteM = true;
                        break;
                    }
                    case "A":{
                        boiteA = true;
                        break;
                    }
                    case "X":{
                        boiteX = true;
                        break;
                    }
                }
            }
        }
        
        if (boiteM)
        {
            ajouterOption(selectBoiteVitesse, "M", "Manuelle");
        }
        if (boiteA)
        {
            ajouterOption(selectBoiteVitesse, "A", "Automatique");
        }
        if (boiteX)
        {
            ajouterOption(selectBoiteVitesse, "X", "Electrique");
        }
                
        // si qu'une seule boite de vitesse existe, on préinitialise la variable boiteVitesse
        if (listeCarburantBoite.length == 1 || selectBoiteVitesse.length == 2)
        {
            boiteVitesse = selectBoiteVitesse.options[1].value;
        }
        
        if (estDefini(boiteVitesse)){
            if (positionnerChoix(selectBoiteVitesse, boiteVitesse))
            {
                RecupererListeCarrosseries();
            }
        }
        else
        {   
            afficherQuestionsNecessaires(true);
        }
        cacherProgression();
    }
}

/***************************************METHODES AJAX POUR LES CARROSSERIES ******************************/
function RecupererListeCarrosseries()
{
    afficherProgression();
   
    viderListe(selectTypeCarrosserie);
    viderListe(selectPuissanceFiscale);
    viderChamp(champAnneeCommercialisation);
    viderTableauVehicules();
    afficherChampAnneeCommercialisation = false;
    
    if (!pageRechargee)
    {
        carrosserie = "";
        anneeMiseCirculation = "";
    }
    else
    {
        carrosserie = CARROSSERIE;
    }
    puissance = "";
    anneeMiseCirculation = "";
    
    boiteVitesse = recupererOptionSelectionnee(selectBoiteVitesse);
   
    attente();
    DA.WEB.PS.MoteurRendu.Auto.Web.RechercheVehicule.RecupererListeCarrosseries(marque, appellationCommerciale, carburant, boiteVitesse, OnRecupererListeCarrosseriesComplete, OnFailed);

}        
function OnRecupererListeCarrosseriesComplete(results) 
{
    nbVehiculesTrouves = results.NombreVehiculesRetournes;
    if (afficherListeVehicules(nbVehiculesTrouves))
    {
        creerLignesVehicules();
    }
    else
    {
        ajouterOptionParDefaut(selectTypeCarrosserie);
       
        for (var i=0; i<results.ListeResultats.length; i++){
            switch (results.ListeResultats[i]){
                case "BE3":
			    case "BE4":
			    case "BE5":
			    case "BER":
			    case "LIM": 
			        {
			            ajouterOption(selectTypeCarrosserie, "BER", "Berline");
			            if (carrosserie == "BE3" || carrosserie == "BE4" || carrosserie == "BE5" || carrosserie == "LIM") {
			                carrosserie = "BER";
			            }
			            break;
			        }
                case "BK3":
			    case "BK4":
			    case "BK5":
			    case "BRK":
			    case "FLE":
			    case "MSP":
			    case "LSP":
			        {
			            ajouterOption(selectTypeCarrosserie, "FLE", "Break, Monospace & Ludospace");
			            if (carrosserie == "BK3" || carrosserie == "BK4" || carrosserie == "BKR" || carrosserie == "MSP" || carrosserie == "LSP") {
			                carrosserie = "FLE";
			            }
			            break;
			        }
                case "CAB":{
                    ajouterOption(selectTypeCarrosserie, "CAB", "Cabriolet");
                    break;
                }
                case "CPE":{
                    ajouterOption(selectTypeCarrosserie, "CPE", "Coupé");
                    break;
                }
                case "MSP":{
                    ajouterOption(selectTypeCarrosserie, "MSP", "Monospace");
                    break;
                }
                case "TTS":{
                    ajouterOption(selectTypeCarrosserie, "TTS", "Tous terrains");
                    break;
                }
                case "DIV":
                default:{
                    ajouterOption(selectTypeCarrosserie, "DIV", "Véhicule utilitaire");
                    break;
                }
            }
        }
        
        // si qu'un seul type de carrosserie existe, on préinitialise la variable carrosserie
        if (results.ListeResultats.length == 1 || selectTypeCarrosserie.length == 2)
        {
            carrosserie = selectTypeCarrosserie.options[1].value;
        }
        if (estDefini(carrosserie)){
            if (positionnerChoix(selectTypeCarrosserie, carrosserie))
            {
                RecupererListePuissances();   
            }
        }
        else
        {   
            afficherQuestionsNecessaires(true);
        }
        cacherProgression();
    }
} 

/***************************************METHODES AJAX POUR LES PUISSANCES ******************************/
function RecupererListePuissances()
{
    afficherProgression();
    
    viderListe(selectPuissanceFiscale);
    viderChamp(champAnneeCommercialisation);
    viderTableauVehicules();
    afficherChampAnneeCommercialisation = false;
    
    if (!pageRechargee)
    {
        puissance = "";
        anneeMiseCirculation = "";
    }
    else
    {
        if (PUISSANCE != "")
        {
            puissance = PUISSANCE;
        }
        else
        {
            puissance = VALEUR_NSP;
        }
    }
    anneeMiseCirculation = "";
    
    carrosserie = recupererOptionSelectionnee(selectTypeCarrosserie);
    attente();
    DA.WEB.PS.MoteurRendu.Auto.Web.RechercheVehicule.RecupererListePuissances(marque, appellationCommerciale, carburant, boiteVitesse, carrosserie, OnRecupererListePuissancesComplete, OnFailed);
}        
function OnRecupererListePuissancesComplete(results)
{  
    nbVehiculesTrouves = results.NombreVehiculesRetournes;
    if (afficherListeVehicules(nbVehiculesTrouves))
    {
        // si on recharge la page et que la puissance précédente était NSP, alors on repositionne
        // à la main la liste
        if (pageRechargee) {
            if (PUISSANCE == "")
                positionnerChoix (selectPuissanceFiscale, puissance)
            else
                initialiserSelectPuissanceFiscale (results);
        }
        creerLignesVehicules();
    }
    else {
        initialiserSelectPuissanceFiscale(results);
    }
}

function initialiserSelectPuissanceFiscale (results) {
    ajouterOptionParDefaut(selectPuissanceFiscale);
    ajouterOptions(selectPuissanceFiscale, results.ListeResultats, " CV");

    // si le nombre de véhicule est inférieur à 45, alors on ajoute l'option "Ne sait pas"
    if ((nbVehiculesTrouves < LimiteNombreVehiculesTESS3) && (nbVehiculesTrouves > 0)) {
        ajouterOptionNSP(selectPuissanceFiscale);
    }
    // si qu'une seule puissance existe, on préinitialise la variable puissance
    if (results.ListeResultats.length == 1) {
        puissance = results.ListeResultats[0];
    }
    // On repositionne la puissance si elle était à NSP ou non sélectionnée au retour de la page a propos voiture
    if (estDefini(puissance) || pageRechargee) {
        if (positionnerChoix(selectPuissanceFiscale, puissance)) {
            RecupererPeriodeCommercialisation();
        }
    }
    else {
        afficherQuestionsNecessaires(true);
    }
    cacherProgression();
}

/************************* METHODES AJAX POUR LES PERIODES DE COMMERCIALISATION ***********************/
function RecupererPeriodeCommercialisation()
{
    afficherProgression();
    
    //viderChamp(champAnneeCommercialisation);
    remplirChamp(champAnneeCommercialisation, CONST_TEXTE_AAAA_DEFAUT);
    viderTableauVehicules();
    
    if (!pageRechargee)
    {
        anneeMiseCirculation = CONST_TEXTE_AAAA_DEFAUT;
    }
    else
    {
        anneeMiseCirculation = ANNEE_COMMERCIALISTATION;
    }
    
    puissance = recupererOptionSelectionnee(selectPuissanceFiscale);
    var puiss = puissance;
    if (puissance == VALEUR_NSP)
    {
        // on ne recherche pas les véhicules de puissance 0 CV !
        puiss = "";
    }
    attente();
    DA.WEB.PS.MoteurRendu.Auto.Web.RechercheVehicule.RecupererPeriodeCommercialisation(marque, appellationCommerciale, carburant, boiteVitesse, carrosserie, puiss, OnRecupererPeriodeCommercialisationComplete, OnFailed);
}        
function OnRecupererPeriodeCommercialisationComplete(results) 
{
    // on n'affiche l'année de commercialisation que si le nombre de véhicules retournés est supérieur à LimiteNombreVehiculesTESS2 : 20
    if (results.ListeResultats != null && results.ListeResultats.length > 0 && results.NombreVehiculesRetournes > LimiteNombreVehiculesTESS2) {
        anneeDebut = results.ListeResultats[0].DateDebut.getFullYear();
        anneeFin = results.ListeResultats[0].DateFin.getFullYear();
        var anneeCourante = new Date().getFullYear();

        if (anneeFin > anneeCourante) {
            anneeFin = anneeCourante;
        }

        // si le nombre de véhicule est inférieur à 45, alors on ajoute au texte "facultatif"
        var texteAnneeCommercialisation = document.getElementById("txtPeriodeCommercialisation");
        var texteFacultatif = document.getElementById("txtFacultatif");

        if (texteAnneeCommercialisation != null) {
            cacheDiv("txtPeriodeCommercialisation");

            var paramNouveauTexteAnneeComm = document.createTextNode("\u00a0[" + anneeDebut + " à " + anneeFin + "]");
            var paramAncienTexteAnneeComm = texteAnneeCommercialisation.firstChild;
            texteAnneeCommercialisation.replaceChild(paramNouveauTexteAnneeComm, paramAncienTexteAnneeComm);
            montreDiv("txtPeriodeCommercialisation");

            if (texteFacultatif != null) {
                cacheDiv("txtFacultatif");

                nbVehiculesTrouves = results.NombreVehiculesRetournes;
                if (nbVehiculesTrouves < LimiteNombreVehiculesTESS3) {
                    var paramNouveauTexteFacultatif = document.createTextNode("\u00a0(facultatif)");
                    var paramAncienTexteFacultatif = texteFacultatif.firstChild;
                    texteFacultatif.replaceChild(paramNouveauTexteFacultatif, paramAncienTexteFacultatif);
                    montreDiv("txtFacultatif");
                }
            }
        }

        // si on est tess 2 activé alors on préalimente cette valeur par la date de mise en circulation initialisée au groupe précédent
        if (TESS_LOT2_ACTIF == 'true' && DATE_MISE_EN_CIRCULATION != "") {
            anneeMiseCirculation = DATE_MISE_EN_CIRCULATION;
        }

        // On recherche les véhicules si la date de mise en circulation est valide.
        if (!pageRechargee && estDefini(anneeMiseCirculation)) {
            if (anneeMiseCirculation >= anneeDebut && anneeMiseCirculation <= anneeFin) {
                remplirChamp(champAnneeCommercialisation, anneeMiseCirculation);
                creerLignesVehicules();
            }
            else {
                remplirChamp(champAnneeCommercialisation, CONST_TEXTE_AAAA_DEFAUT);
            }
        }
        else {
            if (CODE_AUTO != '') {
                remplirChamp(champAnneeCommercialisation, ANNEE_COMMERCIALISTATION);
                creerLignesVehicules();
            }
        }
        afficherChampAnneeCommercialisation = (puissance != VALEUR_PAR_DEFAUT);
        afficherQuestionsNecessaires(true);
    }
    else
    {
        // sinon, on affiche directement le tableau
        if (results.ListeResultats != null && results.ListeResultats.length > 0 && results.NombreVehiculesRetournes <= LimiteNombreVehiculesTESS2) {
        // on cache la question année de mise ne circulation si elle était affichée
            afficherChampAnneeCommercialisation = false;
            creerLignesVehicules();
        }
        else {
            afficherChampAnneeCommercialisation = false;
            afficherQuestionsNecessaires(true);
        }
    }

    /*if (!pageRechargee) {
        cacheQuestion("ChoixModeleVoiture");
    }
    else {
        creerLignesVehicules();
    }*/
    cacherProgression();
} 

/***************************************************************************************************/
/***************************** AFFICHAGE DES QUESTIONS NECESSAIRES *********************************/
/***************************************************************************************************/

// affiche ou masque les questions d'un coup après le calcul de la recherche vehicule
function afficherQuestionsNecessaires(traiterTableau)
{    
    afficherQuestionNecessaire("AppellationCommercialeVoiture", selectAppellationCommerciale);
    afficherQuestionNecessaire("Carburant", selectCarburant);
    // pour la boite de vitesse, on ne l'affiche pas si il n'y a que 2 éléments dans la liste dont
    // celui par défaut et la boite électrique
    if (selectBoiteVitesse.length == 0 || (selectBoiteVitesse.length == 2 && selectBoiteVitesse[1].value == "X"))
    {
        cacheQuestion("BoiteVitesse");
    }
    else
    {
        afficheQuestionComplete("BoiteVitesse");
    }
    afficherQuestionNecessaire("TypeCarrosserie", selectTypeCarrosserie);
    afficherQuestionNecessaire("PuissanceFiscale", selectPuissanceFiscale);
    
    var tableau = document.getElementById("tableau");
    // on cache le champ année de commercialisation si  :
    // le champ est vide
    // on n'a pas rechargé la page
    // que la variable afficherChampAnneeCommercialisation est false
    if (champAnneeCommercialisation.value == "" && !pageRechargee && !afficherChampAnneeCommercialisation)
    {
        cacheQuestion("AnneeCommercialisation");
    }
    else
    {
        if (afficherChampAnneeCommercialisation) {
            afficheQuestionComplete("AnneeCommercialisation");
        }
        else {
            cacheQuestion("AnneeCommercialisation");
        }
    }
    if (traiterTableau)
    {
        cacheQuestion("ChoixModeleVoiture");
    }
    if (pageRechargee)
    {
        afficheQuestionComplete("ChoixModeleVoiture");
    }
    
    // si aucun véhicule n'a été trouvé et que la liste des marques n'est pas à sa valeur par défaut
    // alors on affiche la div comme quoi aucun véhicule n'a été trouvé
    var marqueCourante = recupererOptionSelectionnee(selectMarque);
    if (nbVehiculesTrouves == 0 && marqueCourante != VALEUR_PAR_DEFAUT && marque != "0" &&
        appellationCommerciale != VALEUR_PAR_DEFAUT && appellationCommerciale != "0")
    {
        montreDiv("aideErreurZeroVehicule");
        FluxStatErreurRecherche(nbVehiculesTrouves);
    }
    finAttente();
    alternerStyleBlocs(CONST_STYLE_QUESTIONS_BACKGROUND_BLEUCLAIR,CONST_STYLE_QUESTIONS_BACKGROUND_BLEUFONCE,true);
}

// affiche ou cache une question selon que la selection de celle-ci
function afficherQuestionNecessaire(idQuestion, select)
{
    if (select == null || select == VALEUR_PAR_DEFAUT || select.length <= 1)
    {
        cacheQuestion(idQuestion);
        return false;
    }
    else
    {
        afficheQuestionComplete(idQuestion);
        return true;
    }
}

/***************************************************************************************************/
/****************************** GENERATION DU TABLEAU DE VEHICULES *********************************/
/***************************************************************************************************/


/* Constantes et variables globales. */
var CONST_STYLE_ON_MOUSE_OVER = "fondModeleVehiculeBleuMouseOver";
var CONST_STYLE_ON_CLICK = "fondModeleVehiculeBleuTresFonce";

var idLigneModeleChoisi = null;
var classParDefautModeleChoisi = null;


// récupère la liste de tous les véhicules avec les critères de recherche spécifiés
function creerLignesVehicules()
{  
    var champAnneeMiseCirculation = recupereInputReponse("AnneeCommercialisation");
    anneeMiseCirculation = champAnneeMiseCirculation.value;
    // si on a spécifié NSP à la puissance fiscale, on appelle le web service avec ""
    var puiss = puissance;
    if (puissance == VALEUR_NSP || puissance == VALEUR_PAR_DEFAUT)
    {
        // on ne recherche pas les véhicules de puissance 0 CV !
        puiss = "";
    }
    var anneeRecherche = anneeMiseCirculation;
    if (anneeMiseCirculation == CONST_TEXTE_AAAA_DEFAUT) {
        anneeRecherche = "";
    }
    DA.WEB.PS.MoteurRendu.Auto.Web.RechercheVehicule.RecupererListeVersions(marque, appellationCommerciale, carburant, boiteVitesse, carrosserie, puiss, anneeRecherche, OnCreerLignesVehiculesComplete, OnFailed);
}

// méthode qui vide le tableau de véhicules
function viderTableauVehicules()
{
    var tableau = document.getElementById("tableau");
    // tableau.firstChild.childNodes[0] --> entete
    // tableau.firstChild.childNodes[1] --> entete
    // tableau.firstChild.childNodes[n], n > 1 --> lignes de véhicules
    if (tableau.firstChild.childNodes.length >= 3)
    {
        var texte = tableau.firstChild.firstChild;
        var entete = tableau.firstChild.childNodes[1];
        tableau.removeChild(tableau.firstChild);
        var tbody = document.createElement("tbody");
        tbody.appendChild(texte);
        tbody.appendChild(entete);
        tableau.appendChild(tbody);
    }
    // on remet la couleur par défaut du texte dans l'entête
    document.getElementById('erreurModeleSelectionne').style.color = '#787789';
}

function OnCreerLignesVehiculesComplete (resultat)
{
    cacheDiv("aideErreurZeroVehicule");

    nbVehiculesTrouves = resultat.NombreVehiculesRetournes;

    // afficherListeVehicules ne prend pas en compte l'annee au format AAAA
    if (anneeMiseCirculation == CONST_TEXTE_AAAA_DEFAUT) {
        anneeMiseCirculation = "";
    }
    // si trop de véhicules sont retournés, on affiche une alert qui dit qu'il faut d'autres critères
    // et si on n'est pas en rechargement de la page
    if (!afficherListeVehicules (nbVehiculesTrouves) && !pageRechargee)
    {
        viderTableauVehicules();
        afficherQuestionsNecessaires(true);
        // si on a la valeur puissance fiscale sélectionnée, on ré-affiche la question sur l'année de commercialisation
        puissance = recupererOptionSelectionnee (selectPuissanceFiscale);
        if (puissance != VALEUR_PAR_DEFAUT) {
            afficheQuestionComplete ("AnneeCommercialisation");
        }
        if ((nbVehiculesTrouves <= 0) && !(marque == VALEUR_PAR_DEFAUT || marque == "")) {
            montreDiv("aideErreurZeroVehicule");
        }
        else {
            montreDiv("aideErreurTropVehicule");
        }
        FluxStatErreurRecherche(nbVehiculesTrouves);
    }
    else
    {
        cacheDiv("aideErreurTropVehicule");
        var tableau = document.getElementById ("tableau");
      
        /* on supprime si nécessaire les lignes correspondants à l'ancienne recherche
           on conserve l'entete contenant le recap de la recherche */    
        viderTableauVehicules();
        
        // on ajoute les lignes correspondants aux véhicules de la recherche
        var isBleuFonce = false;
        for (var i=0; i < resultat.ListeResultats.length; i++) 
        {
            var classParDefaut = (!isBleuFonce) ? CONST_STYLE_QUESTIONS_BACKGROUND_BLEUCLAIR : CONST_STYLE_QUESTIONS_BACKGROUND_BLEUFONCE;
            isBleuFonce = !isBleuFonce;

            var tr = genererTdLigne (i, resultat.ListeResultats[i], classParDefaut);
            tableau.firstChild.appendChild (tr);
        }

        afficheQuestionComplete ("ChoixModeleVoiture");
        afficherQuestionsNecessaires (false);
    }
    
    // on sélection le code auto si on est dans le cas d'un rechargement
    preselectionnerModeleAuto();
}

// Permet de sélectionner le code auto.
function preselectionnerModeleAuto() {
    if (pageRechargee && CODE_AUTO != '') {
        var listeVehicules = recupereInputReponse("ChoixModeleVoiture");
        if (listeVehicules != null) {
            for (i = 0; i < listeVehicules.length; i++) {
                if (listeVehicules[i].value == CODE_AUTO) {
                    idLigneModeleChoisi = listeVehicules[i].value;
                    classParDefautModeleChoisi = document.getElementById(idLigneModeleChoisi).className;
                    document.getElementById(idLigneModeleChoisi).className = CONST_STYLE_ON_CLICK;

                    listeVehicules[i].checked = true;
                    break;
                }
            }
        }
    }
}

// fonction utilisée pour générer le tableau de la recherche véhicule pour l'Ajax
function genererTdLigne(numero, vehicule, classParDefaut)
{
    var tr = document.createElement ("tr");
    preserverAttributsEtEvenements (tr, vehicule.CodeAuto, classParDefaut);

    var tdSelection = genererTdSelection (numero, vehicule.CodeAuto);
    var tdModele = genererTdModele (numero, vehicule.Version);
    var tdPuissance = genererTdPuissance (numero, vehicule.Puissance);
    var tdCarrosserie = genererTdCarrosserie (numero, vehicule.CodeAuto, vehicule.Carrosserie);
    var tdAnneeFabrication = genererTdAnneeFab (numero, vehicule.CodeAuto, vehicule.AnneeFabrication, vehicule.FinAnneeFabrication);
    var tdTypeMine = genererTdTypeMine (numero, vehicule.TypeMine);

    tr.appendChild (tdSelection);
    tr.appendChild (tdModele);
    tr.appendChild (tdPuissance);
    tr.appendChild (tdCarrosserie);
    tr.appendChild (tdAnneeFabrication);
    tr.appendChild (tdTypeMine);

    return tr;
}

function preserverAttributsEtEvenements (tr, codeAuto, classParDefaut) 
{
    tr.setAttribute ("id", codeAuto);
    tr.className = classParDefaut;

    tr.onmouseover = function () {
        tr.className = CONST_STYLE_ON_MOUSE_OVER + " cursorPointer";
    }
    tr.onmouseout = function () {
        tr.className = (idLigneModeleChoisi != null && tr.id == idLigneModeleChoisi) ? CONST_STYLE_ON_CLICK : classParDefaut;
    }
    tr.onclick = function () {
        if (idLigneModeleChoisi != null && idLigneModeleChoisi != "") {
            var trModeleChoisi = document.getElementById (idLigneModeleChoisi);
            if (trModeleChoisi != null) {
                trModeleChoisi.className = classParDefautModeleChoisi;
            }
        }
        idLigneModeleChoisi = tr.id;
        classParDefautModeleChoisi = classParDefaut;

        tr.className = CONST_STYLE_ON_CLICK;
        inscrireValeur ('ChoixModeleVoiture', codeAuto);

        //validerRechercheVehicule (window.event);
    }
}

function genererTdModele(numero, version)
{
    var texte = document.createTextNode (version);
    var td = document.createElement ("td");
    td.setAttribute ("id", "colonneMODELE_" + numero);
    td.appendChild (texte);
    return td;
}

function genererTdPuissance(numero, puissance)
{
    puissance += "CV";
    var texte = document.createTextNode (puissance);
    var td = document.createElement("td");
    td.setAttribute("id", "colonneP_FISCALE_" + numero);
    td.setAttribute("align", "center");
    td.appendChild(texte);
    return td;
}

function genererTdCarrosserie(numero, codeAuto, carrosserie)
{
    var td = document.createElement("td");
    td.setAttribute("id", "colonneCARROSSERIE_" + numero);
    td.setAttribute("align", "center");
    td.appendChild(document.createTextNode(nombresPortesAjax(carrosserie)));
    return td;
}

function genererTdAnneeFab(numero, codeAuto, debut, fin)
{
    var texte = valideCoherenceBornesDateAjax ("De "+  debut + " a " + fin);
    var noeudTexte = document.createTextNode (texte)
    var td = document.createElement ("td");
    td.setAttribute ("id", "colonneANNEE_FAB_" + numero);
    td.setAttribute ("align", "center");
    td.appendChild (noeudTexte);
    return td;
}

function genererTdTypeMine(numero, typeMine)
{
    var texte = document.createTextNode (typeMine);
    var td = document.createElement ("td");
    td.setAttribute ("id", "colonneTYP_MINES_" + numero);
    td.setAttribute ("align", "center");
    td.appendChild (texte);
    return td;
}

function sortTableFacadeEntete(id, nomColonne, rev, nbLigneEntete)
{
	//attention: si on modifie l'id des colonnes, il faut modifier egalementt la fonction comparerValeurs
	var idCol;
	if (nomColonne =="modele")  idcol=1;
	if (nomColonne =="puissance")  idcol=2;
	if (nomColonne =="portes")  idcol=3;
	if (nomColonne =="annee")  idcol=4;
	if (nomColonne =="type")  idcol=5;
	
	sortTableDAAuto (id,idcol,rev,nbLigneEntete);

    preselectionnerModeleAuto();
}

// id  est l'id de l'element TABLE, TBODY, THEAD ou TFOOT à trier.
// col est l'indice de la colonne à trier, 0 = premiere colonne, 1 = 2e colonne, etc.
// rev est utilisé pour trier ou non le tableau dans l'ordre décroissant
// lignesIgnorees est le nombre de lignes exclues du tri (les premières lignes)
// N.B : Cette fonction a été spécifiée à partir de la fonction sortTable() définie dans le fichier "commun.js" (partagé avec ExtranetBNPP).
function sortTableDAAuto (id, col, rev, lignesIgnorees) {
	if (document.ELEMENT_NODE == null) { 
		document.ELEMENT_NODE = 1;
		document.TEXT_NODE = 3;
	}
	
	var tblEl = document.getElementById(id);
  
	if (tblEl.reverseSort == null) {
		tblEl.reverseSort = new Array();
		tblEl.lastColumn = 1;
	}

	if (tblEl.reverseSort[col] == null)
		tblEl.reverseSort[col] = rev;

	if (col == tblEl.lastColumn)
		tblEl.reverseSort[col] = !tblEl.reverseSort[col];

	tblEl.lastColumn = col;

	var oldDsply = tblEl.style.display;
	tblEl.style.display = "none";

	var i, j;
	var minVal, minIdx;
	var testVal;
	var cmp;

    /***
     *  Commentaire de FLOK - 09/09/2008
     *  BUG: 
     *      La fonction de tri : "sortTable (...)" vire tous les attributs y compris les gestionnaires d'événements du tableau de résultat.
     *      -   TR =>   id/className/onClick/onMouseOver/onMouseOut ; 
     *      -   TD =>   height/width (1ère cellule de la row)/align ; 
     *  Solutions : 
     *      1. soit chercher comment préserver les attributs des "TR" et "TD" ; 
     *      2. soit refaire une boucle pour ajouter ces paramètres.
     */

    // [Début] boucle modèles
	for (i = lignesIgnorees; i < tblEl.rows.length - 1; i++) {
		minIdx = i;
		minVal = getTextValue(tblEl.rows[i].cells[col]);

		for (j = i + 1; j < tblEl.rows.length; j++) {
			testVal = getTextValue(tblEl.rows[j].cells[col]);
			cmp = comparerValeurs(minVal, testVal, col);
			if (tblEl.reverseSort[col])
				cmp = -cmp;
			if (cmp == 0 && col != 1)
				cmp = comparerValeurs(getTextValue(tblEl.rows[minIdx].cells[1]),
									getTextValue(tblEl.rows[j].cells[1]), col);
			if (cmp > 0) {
				minIdx = j;
				minVal = testVal;
			}
		}

		if (minIdx > i) {
		    // [FLOK:09/09/2008]
		    // Attention : L'appel à la fonction "insertRow()" ne préserve aucun des attributs y compris les gestionnaires d'événements de la row en cours de traitement.
			var tmpRowIn = tblEl.insertRow (i);
			for(z = 0;z < tblEl.rows[minIdx+1].cells.length; z++){
				var noeudCopie = document.getElementById (tblEl.rows[minIdx+1].cells[z].id).cloneNode(true);
				tmpRowIn.appendChild (noeudCopie);
			}

            // On préserve les attributs et les événements de la ligne du tableau avant suppression.
            var codeAuto = tblEl.rows [minIdx+1].id;
            preserverAttributsEtEvenements (tmpRowIn, codeAuto, "");

            // On supprime la ligne courante du tableau.
			tblEl.deleteRow (minIdx+1);
		}
	} // [Fin] boucle modèles.

    alternerCssModelesAuto();

    preselectionnerModeleAuto();

	tblEl.style.display = oldDsply;

	return false;
}

/***
 *  Permet d'alterner les styles CSS des modèles Auto.
 */
function alternerCssModelesAuto() {
    var tableau = document.getElementById ('tableau').childNodes[0];    // tbody
    var nbNoeuds = tableau.childNodes.length;   // tbody.childNodes.length 
    var isCouleurPrecedenteBleuFonce = false;
    var isPremierModeleAuto = true;

    if (nbNoeuds <= 1) 
        return;

    for (var numNoeud=2; numNoeud < nbNoeuds; numNoeud++) {
        var noeudCourant = tableau.childNodes [numNoeud];
        var newClassName = "";

        if (isPremierModeleAuto) {
            newClassName =  " " + CONST_STYLE_QUESTIONS_BACKGROUND_BLEUCLAIR;
            isCouleurPrecedenteBleuFonce = false;
            isPremierModeleAuto = false;
        }
        else {
            if (isCouleurPrecedenteBleuFonce) {
                newClassName = " " + CONST_STYLE_QUESTIONS_BACKGROUND_BLEUCLAIR;
            }
            else {
                newClassName = " " + CONST_STYLE_QUESTIONS_BACKGROUND_BLEUFONCE;
            }
            isCouleurPrecedenteBleuFonce = !isCouleurPrecedenteBleuFonce;
        }

        // On applique la nouvelle valeur de l'attribut "class".
        noeudCourant.className = newClassName;
    }
}


/***************************************************************************************************/
/************************************** VALIDATION DE LA PAGE **************************************/
/***************************************************************************************************/
function validerRechercheVehicule(event)
{
    var listeVehicules = recupereInputReponse("ChoixModeleVoiture");
    
    var vehiculeSelectionne = false;
	
	var champAnneeMiseCirculation = recupereInputReponse("AnneeCommercialisation");
    if (anneeDebut != "" && anneeFin != "" && champAnneeMiseCirculation.value != "")
    {
        if ((anneeDebut > champAnneeMiseCirculation.value) || (anneeFin < champAnneeMiseCirculation.value))
        {
            viderTableauVehicules()
            cacheQuestion("ChoixModeleVoiture");
            return;
        }
    }
    
    // si on a changé la valeur du champ année de commercialisation,
    // on recalcule le tableau
    if (anneeMiseCirculation != champAnneeMiseCirculation.value && anneeMiseCirculation != "")
    {
        creerLignesVehicules();
        return;
    }
    else {
        // FLOK: Ne sert à rien.
        anneeMiseCirculation = champAnneeMiseCirculation.value;
    }
    
    if (listeVehicules != null)
    {
        for (i = 0; i < listeVehicules.length; i++)
        {
	        if (listeVehicules[i].checked) {
		        vehiculeSelectionne = true;
		        break;
		    }
        }
        if (vehiculeSelectionne) {
            // Certains critères ne sont pas forcément nécessaires après un choix de véhicule
            // Cependant, si après un rechargement, on sélectionne un véhicule nécessitant moins de critères que précédemment
            // on se doit de vider les anciens champs correspondants aux critères dorénavant vides !
            if (selectCarburant.length == 0) {
                ajouterOptionParDefaut(selectCarburant);
                positionnerChoixParDefaut(selectCarburant);
            }
            if (selectBoiteVitesse.length == 0) {
                ajouterOptionParDefaut(selectBoiteVitesse);
                positionnerChoixParDefaut(selectBoiteVitesse);
            }
            if (selectTypeCarrosserie.length == 0) {
                ajouterOptionParDefaut(selectTypeCarrosserie);
                positionnerChoixParDefaut(selectTypeCarrosserie);
            }
            if (selectPuissanceFiscale.length == 0) {
                ajouterOptionParDefaut(selectPuissanceFiscale);
                positionnerChoixParDefaut(selectPuissanceFiscale);
            }
            remplirChamp(champAnneeCommercialisation, anneeMiseCirculation);
            valider(event);
        }
        else
        {
            // affichage d'une erreur dans le tableau
            document.getElementById('erreurModeleSelectionne').style.color = 'red';
            // on taggue un flux 998
            FluxStatErreurPasDeChoix();
        }
//        else
//        {
//            creerLignesVehicules();
//        }
    }
    else
    {
        // on affiche une erreur dans les questions
     //   valider(event);
     //   montreAide('Erreur');
        creerLignesVehicules();
    }
}

/***************************************************************************************************/
/********************************** TFLUXSTAT en cas d'erreurs *************************************/
/***************************************************************************************************/
// aucun véhicule ou trop de véhicules sont trouvés
function FluxStatErreurRecherche(nbVehicules) {
    TFluxStat2("997", recupererNumeroPropositionInput() + ' | ' + nbVehicules + ' | ' + NOM_PARCOURS);
}

// aucun véhicule n'a été sélectionné (click sur le bouton suivant)
function FluxStatErreurPasDeChoix() {
    TFluxStat2("998", recupererNumeroPropositionInput() + ' | ' + NOM_PARCOURS);
}

function TFluxStat2(flux, fluxComment) {
    TFluxstat2("100", "2", flux, fluxComment, ID_ACT_INTERNE, NUMERO_SESSION, ID_VISITEUR);
}

function ValiderAnneeCommercialisation(champAnneeCommercialisation)
{
    pageRechargee = false;
    var val=champAnneeCommercialisation.value;
    champAnneeCommercialisation.value = AAAA(champAnneeCommercialisation.value);
    if(val!='' && val!=CONST_TEXTE_AAAA_DEFAUT)
    {
         if ((!isAnneeHorsBorne (champAnneeCommercialisation.value)) && (isInteger(champAnneeCommercialisation.value))) 
         {
             flasheQuestion ('AnneeCommercialisation', '');
             creerLignesVehicules();
         }
         else 
         {
            champAnneeCommercialisation.value=CONST_TEXTE_AAAA_DEFAUT;
            flasheQuestion ('AnneeCommercialisation', '#ff0000');
            cacheDiv ('ChoixModeleVoiture');
            return;
         }
     }
     else
     {
        creerLignesVehicules();
        champAnneeCommercialisation.value=CONST_TEXTE_AAAA_DEFAUT;
        flasheQuestion ('AnneeCommercialisation', '#ff0000');
     }
}

if (typeof(Sys) !== "undefined") Sys.Application.notifyScriptLoaded();