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){
    var isDisplayAccrochePrix = true ;
    
    //Initialisation des donnees pour la page GDBC
    var divObj = getElement("conteneur", 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>" ;
                }
                
                //Modification du background    
                var divFond = document.getElementById("globalconteneur") ;
                if(divFond){
                    divFond.style.backgroundImage = "url(/FR/images/static/globalconteneur-comparer.jpg)" ;
                }
                
                var resizeFunc = setTimeout("resizeRow()", 1000) ;
                
                //on affiche les produits
                var divContentProductsObj = getElement("contentProducts", true, "") ;
                if(divContentProductsObj){
                    displayBloc(divContentProductsObj) ;
                }
                
                //on va changer la classe du dernier produit a comparer que pour IE6
                if(navigator.appVersion.indexOf("6.0") > -1){
                    if(modelList.get(modelList.length() - 1) != ""){
                        var lastProduct = modelList.get(modelList.length() - 1) ;
                        var eltLastProduct = getElement("ligneproduit-"+lastProduct) ;
                        
                        eltLastProduct.className = "row-prod-last" ; 
                    }
                }

                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 resizer les lignes de BU
*/
function resizeRow(){
    //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" ;
                    }
                }
            }
        }
    }
    
    //on va recalculer la hauteur de chaque ligne de declinaison
    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" ;
                    }
                }
            }
        }
    }
    
    
    //On va determiner la hauteur de chaque ligne de declinaisons et concu pour
    var maxRowConcuPour = 0 ;
    var maxRowDecl = 0 ;
                
    for(var k=0 ; k<modelList.length() ; k++){
        var ligneObj = getElement("ligneproduit-"+modelList.get(k), true, "") ;
        if(ligneObj){
            var eltRow = ligneObj.getElementsByTagName("DIV") ;
            if(eltRow){
                //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("row4") > -1){
                        var heightRow = elt.offsetHeight ;
                        if(heightRow > maxRowDecl){
                            maxRowDecl = heightRow ;
                        }
                    }
                    else if(elt && elt.className && elt.className.indexOf("row3") > -1){
                        var heightRow = elt.offsetHeight ;

                        if(heightRow > maxRowConcuPour){
                            maxRowConcuPour = heightRow ;
                        }
                    }
                }
            }
        }
    }
    
    for(var k=0 ; k<modelList.length() ; k++){
        var ligneObj = getElement("ligneproduit-"+modelList.get(k), true, "") ;
        if(ligneObj){
            var eltRow = ligneObj.getElementsByTagName("DIV") ;
            if(eltRow){
                //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("row4") > -1){
                        elt.style.height = maxRowDecl+"px" ;
                    }
                    else if(elt && elt.className && elt.className.indexOf("row3") > -1){
                        elt.style.height = maxRowConcuPour+"px" ;
                    }                                
                }
                
                //on va fixer la hauteur de la colonne titre
                var eltTitleDecl = getElement("decl", true, "") ;
                if(eltTitleDecl){
                    eltTitleDecl.style.height = maxRowDecl+"px" ;
                }
                var eltTitleConcuPour = getElement("concupour", true, "") ;
                if(eltTitleConcuPour){
                    eltTitleConcuPour.style.height = maxRowConcuPour+"px" ;
                }
            }
        }
    }    
}

/* #######################################################################
* 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 ;
}