var nbProduitChecked = 0 ; //Nb de produit coche pour la comparaison
var mapBuParModele = new Map() ; //La map qui contient les BU pour un modele

/* #######################################################################
* Permet d'analyser les checkbox cocher
* Si le nb de cb coche est superieur a 4, on affiche un message
*/
function checkCompare(cb){
    if(cb.checked){
        nbProduitChecked++ ;
    }
    else{
        nbProduitChecked-- ;
    }
    
    if(nbProduitChecked > 4){
        alert(alertComparer) ;
        cb.checked = "" ;
        nbProduitChecked-- ;        
    }
}


/* #######################################################################
* Permet de cocher ou decocher la checkbox cbId
*/
function checkTheBox(cbId){
    var cb = getElement(cbId, true, "") ;
    if(cb){
        if(cb.checked){
            cb.checked = "" ;
        }
        else{
            cb.checked = "checked" ;
        }
        checkCompare(cb) ;
    }
}


/* #######################################################################
* Permet de cacher un produit
*/
function hideProduct(productId){
    if(document.getElementById(productId)){
        var productDiv = document.getElementById(productId) ;
        productDiv.style.display="none" ;
    }
}


/* #######################################################################
* Permet de reinitialiser tous les produit
*/
function reinitProduct(){
    var contentProductsObj = getElement("contentProducts", true, "") ;
    if(contentProductsObj){
        var childContentProductsObj = contentProductsObj.getElementsByTagName("LI") ;
        for(var i=0 ; i<childContentProductsObj.length ; i++){
            if(childContentProductsObj[i] && childContentProductsObj[i].id.indexOf("ligneproduit-") > -1){
                var modeleId = childContentProductsObj[i].id.split("-")[1] ;
                if(modelList.contains(modeleId) > -1){
                    childContentProductsObj[i].style.display = "block" ;
                }
            }
        }
    }
}


/* #######################################################################
* Permet d'afficher la page comparer les produits
*/
function comparerProduit(titrePage, lienFamille, codeExterneFamille){
    //Initialisation des donnees pour la page GDBC
    var divObj = getElement("page-produits", true, "") ; //container global de la page qui va accueillir le GDBC
     
    //Traitement des produits a comparer
    var isModelListReinit = false ;
    var modelListTemp = new ArrayList() ; //l'ancienne liste de modeles
    
    var produitsAComparer = document.getElementsByName('produit') ;
    
    var func = function loadKoodzaInfo(xmlHttp, httpstatus){
        if(httpstatus == 200){
            oXmlDoc = xmlHttp.responseText ;
            if( oXmlDoc == null) {
                return;
            } 
            else {
                divObj.innerHTML = oXmlDoc ;
                
                //traitement erep
                //le service famille a deja ete appele donc on peut charger directement travailler sur les items
                //serviceId a ete recupere lors de l'appel precedent
                
                //on va verifier si le client ne vient pas d'un autre pays
                var idCentral = _centralNumber ;
                var valueCookieCountry = getCookie("country") ;
                if(valueCookieCountry){
                    var enseigneSiteObj = mapUrlParPays.get(valueCookieCountry) ;
                    if(enseigneSiteObj){
                        idCentral = enseigneSiteObj.getCentrale() ;
                    }
                }
                
                //le service famille a deja ete appele donc on peut charger directement travailler sur les items
                if(mapServiceId){
                    var currentServiceId = mapServiceId.get(_SERVICE_ITEM_FAMILY) ;
                    if(idCentral != "-1"){
                        checkModels(currentServiceId, true) ;
                    }
                }
                
                //affichage uniquement des produits selectionnes par le client
                if(isModelListReinit){ //signifie que le client a choisit des produit a comparer
                    for(var i=0 ; i<modelListTemp.length() ; i++){
                        if(modelList.contains(modelListTemp.get(i)) == -1){
                            hideProduct("ligneproduit-"+modelListTemp.get(i)) ;
                        }
                    }
                }
                
                //on va parcourir les bu pour les modeles et generer les liste et map necessaires a leurs affichages 
                for(var i=0 ; i<modelList.length() ; i++){
                    if(modelList.get(i)){
                        var listeBuModele = mapBuParModele.get(modelList.get(i)) ;
                        
                        if(listeBuModele){
                            for(var j=0 ; j<listeBuModele.length() ; j++){
                                var buModele = listeBuModele.get(j);
                                if(buModele != ""){
                                    var cleBu = buModele.getCleModele() ;
                                    genereBu(cleBu, buModele) ;
                                }
                            }
                        }
                    }
                }

                //on affiche les BU
                var outputStr = recupBu() ;
                var tableBu = getElement("table_bu", true, "") ;
                if(tableBu){
                    tableBu.innerHTML = "<div class='liste_bu'>"+outputStr+"</div>" ;
                }
                
                //on va recalculer la hauteur de chaque ligne de BU
                for(var k=0 ; k<listeBu.length() ; k++){
                    var rowObj = getElement("row"+k, true, "") ;
                    if(rowObj){
                        //on va recalculer la hauteur de chaque ligne de BU
                        var eltRow = rowObj.getElementsByTagName("DIV") ;
                        if(eltRow){
                            var maxRow = 0 ;
                            
                            //on recuperer la hauteur maximale de la ligne
                            for(var p=0 ; p<eltRow.length ; p++){
                                var elt = eltRow[p] ;
                                if(elt && elt.className && elt.className.indexOf("row-prod") > -1){
                                    var heightRow = elt.offsetHeight ;
                                    if(heightRow > maxRow){
                                        maxRow = heightRow ;
                                    }
                                }
                            }
                            //on, va fixer la hauteur a toutes les cellules de cette ligne
                            for(var n=0 ; n<eltRow.length ; n++){
                                var elt = eltRow[n] ;
                                if(elt && elt.className && elt.className.indexOf("row-prod") > -1){
                                    elt.style.height = maxRow+"px" ;
                                }
                            }                            
                        }
                    }
                }                
                
                //Modification du background    
                var divFond = document.getElementById("fond-produits") ;
                if(divFond){
                    if(divFond.style.filter){
                        divFond.style.filter = "progid:DXImageTransform.Microsoft.AlphaImageLoader(src='/FR/images/static/fond-fiche-comparateur.png',sizingMethod='scale')" ;
                    }
                    else{
                        divFond.style.backgroundImage = "url(/FR/images/static/fond-fiche-comparateur.png)" ;
                    }
                }
                
                //Modification du titre de la page
                //1) Image de fond
                var divBgTitrePage = document.getElementById("titre_page") ;
                if(divBgTitrePage){
                    if(divBgTitrePage.style.filter){
                        divBgTitrePage.style.filter = "progid:DXImageTransform.Microsoft.AlphaImageLoader(src='/FR/images/static/"+imgTitrePageComparer+"',sizingMethod='scale')" ;
                    }
                    else{
                        divBgTitrePage.style.backgroundImage = "url(/FR/images/static/"+imgTitrePageComparer+")" ;
                    }
                }                
                //2) Titre
                var divTitrePage = document.getElementById("lib_titre") ;
                if(divTitrePage){
                    divTitrePage.innerHTML = titrePageComparer
                }
                
                //on affiche les produits
                var divContentProductsObj = getElement("contentProducts", true, "") ;
                if(divContentProductsObj){
                    displayBloc(divContentProductsObj) ;
                }
                
                //Redimentionnement de la page
                redimensionnePage("", "page-produits");
                
                var waitingMessage = getElement("waitingMessage", true, "") ;
                if(waitingMessage){
                    hideBloc(waitingMessage) ;
                }  
            }
        }
    }
    
    if(nbProduitChecked < 2 || nbProduitChecked > 4){
        alert(alertComparer) ;
    }
    else{
        //Si des produits sont coches, on va reinitialiser la liste de modeles a checker via eRep.
        //Sinon, on ne fait rien et on garde la liste de modele genere dans la page famille classic
        for(var i=0 ; i<produitsAComparer.length ; i++){
            if(produitsAComparer[i].checked){
                if(!isModelListReinit){
                    modelListTemp = modelList ;
                    modelList = new ArrayList() ; //reinitialisation de la liste des modeles à gerer
                    isModelListReinit = true ;
                }
                modelList.add(produitsAComparer[i].value);
            }
        }
    
        var ajaxProc = new IAjaxProcess("gdbc.html", func) ;
        ajaxProc.run() ;
    }
}


/* #######################################################################
* Permet de generer la map des BU par modele
* Cette map contient la liste des BU pour chaque modele
* @params :
*    - refModele : le code modele
*    - _buGdbc : L'objet BU
*/
function genereBuModele(refModele, _buGdbc){
    //Si la map contient deja une liste de BU pour ce modele, on va la mettre a jour
    if(mapBuParModele.get(refModele) != ""){
        var listeBuModele = mapBuParModele.get(refModele) ;
        listeBuModele.add(_buGdbc) ;
        mapBuParModele.remove(refModele) ;
        mapBuParModele.put(refModele, listeBuModele) ;
    }
    //Sinon, on cree une nouvelle liste de BU pour ce modele    
    else{
        var listeBuModele = new ArrayList() ;
        listeBuModele.add(_buGdbc) ;
        mapBuParModele.put(refModele, listeBuModele) ;
    }    
}


/* #######################################################################
* Permet de generer la map des modele par type de BU
* Cette map contient la liste des modele pour chaque BU
* Cette fonction prend en compte une liste listeBu renseignee dans l'HTML famille
* @params :
*    - _cleBu : le BU
*    - _buGdbc : L'objet BU
*/
function genereBu(_cleBu, _buGdbc){
    //Si la liste des BU ne contient pas ce BU, on va le rajouter dans cette liste et dans la map
    if(listeBu && listeBu.contains(_cleBu) == -1){
        listeBu.add(_cleBu) ;
        var listeBuModele = new ArrayList() ;
        listeBuModele.add(_buGdbc) ;
        mapModeleParBu.put(_cleBu, listeBuModele) ;
    }
    //Sinon on met a jour la liste et la map
    else{
        var listeBuModele = mapModeleParBu.get(_cleBu) ;
        mapModeleParBu.remove(_cleBu) ;
        listeBuModele.add(_buGdbc) ;
        mapModeleParBu.put(_cleBu, listeBuModele) ;
    }
}


/* #######################################################################
* Permet de retourner la STRING de chaque ligne de BU
*/
function recupBu(){
     var outputStr = "" ;
    var isModeleTrouve = false;
    
     //Pour chaque type de BU, on va recuperer la liste des modeles possedant ce BU
    for(var i=0 ; i<listeBu.length() ; i++){
        var cleBu = listeBu.get(i) ; //Le BU
        var listeModeleBu = mapModeleParBu.get(cleBu) ; //La liste des modeles pour ce BU
        
        var classRow = "row" ;
        if(i == listeBu.length()-1){
            classRow = classRow +"-last" ;
        }
        //DEBUT : La ligne du BU
        outputStr = outputStr + "<div class='"+classRow+"' id='row"+i+"'><div class='row-prod-title'>"+cleBu+"</div>" ; //Titre pour ce BU

        //Pour chaque modele de la liste de modele, on va parcourir ses BU.
        //cela permet de recuperer les BU dans l'ordre des modeles de cette liste
        for(var k=0 ; k<modelList.length() ; k++){
            var theCodeModele = modelList.get(k) ; //Le code modele
            var donneeBu = "&nbsp;-&nbsp;" ; //la valeur du BU : texte/image
            
            //ON va parcourir la liste des modeles pour ce BU et si le code modele est egal au code modele recupere precedemment, on va generer la STRING
            for(var j=0 ; j<listeModeleBu.length() ; j++){
                var buModele = listeModeleBu.get(j) ;
                var codeModele = buModele.getCodeModele() ;
                isModeleTrouve = false ;
                
                //Le code modele est trouve
                if(codeModele == theCodeModele){
                    var valeurBu = buModele.getValeurModele() ; //le texte du BU
                    var etoileBu = buModele.getEtoileModele() ; //l'image etoile
                    var imgBu = buModele.getImgModele() ; //l'image du BU
                    
                    //on va former la STRING en fonction du texte/image/Etoile
                    var valeur = "" ;
                    if(valeurBu != ""){
                        valeur = valeur + valeurBu + "</BR>";
                    }
                    if(imgBu != ""){
                        valeur = valeur + "<div id='img_bu"+i+"_"+j+"' style='background:url("+_rootPath+"/images/assets/"+imgBu+") no-repeat'></div></BR>";
                    }
                    if(etoileBu != ""){
                        valeur = valeur + "<img src='"+etoileBu+"'  alt=''/></BR>";
                    }
                    
                    donneeBu = valeur ;
                    isModeleTrouve = true ; //Le modele a ete trouve, on casse la boucle
                    break;
                }
            }
            
            //on va determiner la nomp de la class a appliquer a la div
            var classTd = "row-prod" ;
            if(!isModeleTrouve){
                classTd = "row-prod-empty" ;
            }
            //si on est sur la derniere cellule, on met une classe specifique
            if(k == modelList.length()-1){
                classTd = classTd+"-last" ;
            }
            //chaine de caractere en sortie
            outputStr = outputStr + "<div class='"+classTd+"'>"+donneeBu+"</div>" ;            
        }
        //FIN : On ferme la ligne du BU
        outputStr = outputStr + "</div>"
    }
    
    return outputStr ;
}