/**
 * Prerequis :
 * La variable modelList est un objet de type ArrayList et doit oblgatoirement etre initialise dans la page HTML
 */
var displayPrice = true ;
var nbModelToCheck = 0 ;
var nbModelHidden = 0 ;
var possibleAAfficher = new ArrayList() ;
var isSlideShow = false ;

var isErrorErep = false ;
var disableProductList =  new ArrayList() ;

//liste des modeles valides
var enableModelList = new ArrayList() ; 

//Liste des modeles par prix
var priceModelMap = new Map() ;

//Identifiant du service execute
var serviceId = "" ;

//Map contenant les identifiant de services a partir du service appele
var mapServiceId = new Map() ;


/**
 * Permet de cacher ou non le bloc produit et d'afficher le picto new
 * @param :
 *    - httpStatus : le statut HTTP apres l'appel ajax
 * @desc :
 *    - pour chaque item, on va verfier sa visibilite, si elle est a true alors on affiche le produit, sinon on ne l'affiche pas
*/
var POST_LOAD_ITEM_FAMILY_FUNCTION = function postItemFamilyService(httpStatus){
    if(httpStatus == "200"){
        var contextServiceName = "" ;
        if(isSlideShow){
            contextServiceName = _SERVICE_ITEM_FAMILY_SLIDESHOW ;
        }
        else{
            contextServiceName = _SERVICE_ITEM_FAMILY ;
        }
        
        var currentServiceId = mapServiceId.get(contextServiceName) ;

        var nbItems = getNbItem(currentServiceId) ;
        if(nbItems == -1){
            isErrorErep = true ;
        }
        
        checkModels(currentServiceId, displayPrice) ;

        if(typeof _modeleCourant != "undefined" && typeof _modeleCourant == "string"){
            displayPrevNextProduct(_modeleCourant);
        }
        
        if(typeof nbProduitFamille != "undefined"){
            //desactivation du bloc waitingMessage
            hideBloc(getElement("waitingMessage", true, "")) ;

            //generation du bloc pagination
            writePagination(isErrorErep) ;

            //Affichage des criteres
            if(!isErrorErep){
                displayCriteria() ;
            }
            
            //Affichage des produits
            show("1") ;
            
            //Affichage du bouton comparer
            displayBloc(getElement("comparaison", true, "")) ;
            
            //Affichage du libelle juridique
            displayBloc(getElement("libelleJurPrix", true, "")) ;
        }
    }
    else{
        //erep ne repond plus
        if (typeof nbProduitFamille != "undefined") {
            displayProducts() ;
        }
        hideAllSwitchElement() ;
    }
}


/** #########################################
 * Permet d'afficher les produits precedent et suivant
 * @param :
 *    - _modeleCourant : le modele courant pour lequel il faut recuperer le produit precedent et le produit suivant
*/
function displayPrevNextProduct(_modeleCourant){

    if(_modeleCourant && typeof _modeleCourant == "string"){
    
        var indexModeleCourant = enableModelList.contains(_modeleCourant) ;

        if(indexModeleCourant != -1){
            //on recupere le modele precedant
            var modelePrev = getPrevProduct(indexModeleCourant, indexModeleCourant-1) ;

            //si le modele precedent existe et que l'index du modele courant n'est pas 0, c'est a dire ce n'est pas le premier modele de la liste
            if(modelePrev != "" && indexModeleCourant > 0){
                var produitPrevObj = getElement("vignetteproduit-"+modelePrev , true, "") ; //alors on recupere le bloc html correspondant au modele precedent
                
                if(produitPrevObj){ //si ce bloc html est ok alors on affiche ce bloc
                    var destBlocHtmlPrev = getElement("blocnavigationinterne-prev", true, "") ;
                    if(!destBlocHtmlPrev){
                        destBlocHtmlPrev = parent.document.getElementById("blocnavigationinterne-prev") ;
                    }
                    
                    if(destBlocHtmlPrev){
                        var libProduitNextObj = getElement("libProduitNext"+modelePrev, true, "") ;
                        if(!libProduitNextObj){
                            libProduitNextObj = parent.document.getElementById("libProduitNext"+modelePrev) ;
                        }
                    
                        hideBloc(libProduitNextObj) ;
                        
                        destBlocHtmlPrev.innerHTML = produitPrevObj.innerHTML ;
                    }                
                }
            }
            
            //on recupere le modele precedant
            var modeleNext = getNextProduct(indexModeleCourant, indexModeleCourant+1) ;
            //si le modele suivant existe et que l'index du modele courant n'est le dernier modele de la liste
            if(modeleNext != "" && indexModeleCourant < modelList.length()){
                var produitNextObj = getElement("vignetteproduit-"+modeleNext , true, "") ; //alors on recupere le bloc html correspondant au modele suivant
                if(produitNextObj){ //si ce bloc html est ok alors on affiche ce bloc
                    var destBlocHtmlNext = getElement("blocnavigationinterne-next", true, "") ;
                    if(!destBlocHtmlNext){
                        destBlocHtmlNext = parent.document.getElementById("blocnavigationinterne-next") ;
                    }
                    
                    if(destBlocHtmlNext){
                        var libProduitPrevObj = getElement("libProduitPrev"+modeleNext, true, "") ;
                        if(!libProduitPrevObj){
                            libProduitPrevObj = parent.document.getElementById("libProduitPrev-next"+modeleNext) ;
                        }
                        
                        hideBloc(libProduitPrevObj) ;
                        
                        destBlocHtmlNext.innerHTML = produitNextObj.innerHTML ;
                    }
                }
            }
        }        
    }
}

/** #########################################
 * Permet de recuperer le produit precedent
 * @param :
 *    - _modeleCourant : le modele courant pour lequel il faut recuperer le produit precedent et le produit suivant
 *    - _indexModelePrev : l'index du modele precedent
*/
function getPrevProduct(_indexModeleCourant, _indexModelePrev){
    //recuperation du modele precedent
    var modelePrev = "" ;
    if(_indexModeleCourant > 0){
        modelePrev = enableModelList.get(_indexModelePrev) ;
    }
    return modelePrev ;
}


/** #########################################
 * Permet de recuperer le produit suivant
 * @param :
 *    - _modeleCourant : le modele courant pour lequel il faut recuperer le produit precedent et le produit suivant
 *    - _indexModeleNext : l'index du modele suivant
*/
function getNextProduct(_indexModeleCourant, _indexModeleNext){
    //recuperation du modele suivant
    var modeleNext = "" ;
    if(_indexModeleCourant < enableModelList.length()){
        modeleNext = enableModelList.get(_indexModeleNext) ;
    }
    return modeleNext ;
}



/**
 * Permet de cacher ou non le bloc produit et d'afficher le picto new ou FIN lors du chargement des modeles a partir d'une liste de modele
 * @param :
 *    - httpStatus : le statut HTTP apres l'appel ajax
 * @desc :
 *    - pour chaque item, on va verfier sa visibilite, si elle est a true alors on affiche le produit, sinon on ne l'affiche pas
*/
var POST_LOAD_ITEM_MODELS_FUNCTION = function postItemModelsService(httpStatus){
    if(httpStatus == "200"){
        var currentServiceId = mapServiceId.get(_SERVICE_ITEM_MODELS) ;
        var nbItems = getNbItem(currentServiceId) ;
        if(nbItems == -1){
            isErrorErep = true ;
        }
        checkModels(currentServiceId, displayPrice) ;

        //Dans le cas des ventes complementaire, doit on cacher ou non le bloc
        hideBlockModels("bloc-decouvrirplus") ;

        checkSwitchProductPages(false, modelList) ;        
    }
}

/**
 * Permet de cacher ou non le bloc produit et d'afficher le picto new ou FIN lors du chargement des modeles a partir d'une liste de modele
 * @param :
 *    - httpStatus : le statut HTTP apres l'appel ajax
 * @desc :
 *    - pour chaque item, on va verfier sa visibilite, si elle est a true alors on affiche le produit, sinon on ne l'affiche pas
*/
var POST_LOAD_ITEM_MODEL_FUNCTION = function postItemModelService(httpStatus){
    if(httpStatus == "200"){
        var currentServiceId = mapServiceId.get(_SERVICE_ITEM_MODEL) ;
        var nbItems = getNbItem(currentServiceId) ;
        if(nbItems == -1){
            isErrorErep = true ;
        }
        
        checkModel(currentServiceId, idModel, displayPrice, isFromModel, isFromTg) ;        
        
        var theModelList = new ArrayList() ;
        theModelList.add(idModel) ;
        
        checkSwitchProductPages(true, theModelList) ;
    }
}

/**
 * Permet de verifier les switchs apres la recuperation des prix
*/
function checkSwitchProductPages(_isModelPage, _modelList){
    //appel des interrupteurs
    var _switchArrayAChecker = new Array() ;
    _switchArrayAChecker[0] = SWITCH_ACTIVATION_PRIX ;
    _switchArrayAChecker[1] = SWITCH_ACTIVATION_DEEE ;
    _switchArrayAChecker[2] = SWITCH_ACTIVATION_MDR ;        
    _switchArrayAChecker[3] = SWITCH_ACTIVATION_MDR_SAISIE_PREDICTIVE
    
    if(_isModelPage){
        _switchArrayAChecker[4] = SWITCH_ACTIVATION_OXYLANE_AVIS ;
        _switchArrayAChecker[5] = SWITCH_ACTIVATION_DOC_ASSOCIES ;
        _switchArrayAChecker[6] = SWITCH_ACTIVATION_LIAGE_DKT ;
    }
    
    checkSwitches(_switchArrayAChecker, _client, _siteNumber, _modelList) ;
}

/**
 * Permet de cacher ou non le bloc produit et d'afficher le picto new
 * @param :
 *    - serviceId : Identifiant du service
 *    - isDisplayPrice : true/false doit on gerer l'affichage des prix
*/
function checkModels(serviceId, isDisplayPrice){
    if(modelList && modelList.length() > 0){
        //Nb de modele a verifier
        nbModelToCheck = modelList.length() ;
        
        //Pour chaque modele de la liste global, on va recuperer l'objet Item
        for(var ii=0 ; ii<modelList.length() ; ii++){
            var modelId = modelList.get(ii) ; //identifiant du modele a verifier
            checkModel(serviceId, modelId, isDisplayPrice, false, false) ;
        }
        
        //pour tous les produits a desactiver, on va les cacher
        for(var i=0; i<disableProductList.length(); i++){
            var productToHideObj = disableProductList.get(i) ;
            hideBloc(productToHideObj) ;
        }
        
        //check des switchs
        checkSwitchProductPages(false, modelList) ;

        //on va cacher le message d'attente
        if(getElement("waitingMessage", true, "")){
            hideWaitingMessage();
        }
    }
}

/**
 * Permet de cacher ou non le bloc produit et d'afficher le picto new
 * @param :
 *    - isDisplayPrice : true/false doit on gerer l'affichage des prix
*/
function checkModel(serviceId, idModel, isDisplayPrice, isFromModel, isFromTg){
    if(idModel){        
        var forceDisplayBlock = false ;

        var item = getMyItem(serviceId, idModel) ; //on recupere l'objet Item associe
    
        //on recupere les blocs HTML a afficher ou a cacher
        //5 types :
        //    - vignetteproduit : utilise dans les pages familles
        //    - ligneproduit : utilise dans les pages GDBC
        //    - compare : utilise dans les pages comparateurs
        //    - maSelection : utilise dans la page "Mes produits favoris"
        //    - bloc-vente : utilise dans la page produit
        var blocItemObj = getElement("vignetteproduit-"+idModel, true, "") ;
        forceDisplayBlock = true ;
        if(blocItemObj == null){
            blocItemObj = getElement("ligneproduit-"+idModel, true, "") ;
            forceDisplayBlock = true ;
            if(blocItemObj == null){
                blocItemObj = getElement("compare-"+idModel, true, "") ;
                forceDisplayBlock = true ;
                if(blocItemObj == null){
                    blocItemObj = getElement("maSelection"+idModel, true, "") ;
                    forceDisplayBlock = true ;
                    if(blocItemObj == null){
                        blocItemObj = getElement("bloc-prix"+idModel, true, "") ;
                        forceDisplayBlock = false ;
                        if(blocItemObj == null){
                            blocItemObj = getElement("decouvrirplus"+idModel, true, "") ;
                            forceDisplayBlock = false ;
                        }
                    }
                }
            }
        }
        
        //Si la reponse erep est fausse, on va quand meme afficher les produits
        if(isErrorErep){
            if(isFromModel){
                //redirectProduit(_urlFamille) //_urlFamille doit etre declare dans l'html
                hideBlocId("bloc-prix") ;
            }
            
            if(!forceDisplayBlock){
                nbModelHidden++ ;
                //hideBloc(blocItemObj) ; //Par defaut, le bloc est cache
                disableProductList.add(blocItemObj) ;
            }
            else{
                displayBloc(blocItemObj) ; //Par defaut, le bloc est affiche
            }
        }
        //Item existe donc on va recuperer les prix
        else if(item != null){
            //Traitement que si le bloc HTML existe
            if(blocItemObj){                   
                var isEnable = item.isEnable() ; //l'item est-il valable, faut il l'afficher
                var step = item.getStep() ; //recuperation de son etat : 1/2 ou 3                    
                if(step == "-1" || !item.isStepHomogeneous()){ //Si les tapes du modle ne sont pas homogne, on va forcer l'tape du produit  1
                    step = "1"  ; 
                }
                
                //Si l'item n'est pas valable, alors on cache le bloc HTML correspondant
                if(!isEnable){
                    if(!isFromModel){
                        //hideBloc(blocItemObj) ;
                        disableProductList.add(blocItemObj) ;
                        nbModelHidden++ ;
                    }
                    else{
                        redirectProduit(_urlFamille) //_urlFamille doit etre declare dans l'html
                    }
                }
                //sinon on l'affiche apres avoir verifie son etape de vie pour afficher les pictos NEW ou FIN
                else{
                    //le modele est coherent et peut donc etre affiche, on l'ajoute a la liste
                    //la liste ne doit pas etre renseigne dans le cas d'un appel pour une fiche model
                    if(!isFromTg && !isFromModel){
                        enableModelList.add(idModel);
                    }
                    
                    if(step == "2"){ //etape de vie 2, picto NEW a afficher
                        if(isFromModel) {
                            displayBlocId("message-new") ;
                        }
                        if(getElement("picto-new-"+idModel, true, "")){//cas comparer produit
                            displayBlocId("picto-new-"+idModel) ;
                        }

                        //on va afficher le message de bientot dispo pour la page GDBC et la page famille
                        var eltDiv = getElement("message-"+idModel, true, "") ;
                        if(eltDiv){
                            displayBloc(eltDiv) ;
                        }
                    }
                    else if(step == "3"){ //etape de vie 3, picto FIN a afficher
                        var pictoFin = getElement("picto-fin-"+idModel, true, "") ;
                        if(pictoFin){
                            pictoFin.style.display = "block" ;
                        }           
                    }

                    //on va afficher les prix Decathlon si le modele est en etape de vie different de 2 et que le booleen isDisplayPrice est a true                    
                    if(step != "2"){
                        var messageNew = getElement("message-new", true, "") ;
                        if(messageNew){
                            hideBloc(messageNew) ;
                        }
                        var displayBlocItem = true ;
                        
                        if(isDisplayPrice && item.getMainPrice() != null){
                            //Rcuperation de l'objet Prices qui contient tous les types de prix
                            var oPrice = item.getPrices() ;
                            var oCurrency = oPrice.getCurrency() ; //objet Currency qui va permettre de formater correctement le prix
                            
                            if(oCurrency){
                                //Prix fort
                                var oMainPrice = item.getMainPrice() ; //Prix principal = prix central
                                var valueObj = oMainPrice.getValue() ;
                                var valueCentralePrice = oCurrency.formatValue(oMainPrice.getValue()) ; //on formatte le prix central
                                var isHomogenous = oMainPrice.isPriceHomogeneous() ; //Le prix centrale est il homogene
                                
                                //Prix DEEE
                                var oDeeePrice = item.getWeeePrice() ; //Prix deee
                                var valueDeeePrice = "" ;
                                if(oDeeePrice){
                                    valueDeeePrice = oCurrency.formatValue(oDeeePrice.getValue()) ; //on formatte le prix deee
                                }
                                
                                if(valueCentralePrice != ""){
                                    if(!isFromModel && !isFromTg){
                                        rangeModelByPrice(valueObj, valueCentralePrice, step, idModel) ;
                                    }
                                    
                                    var fonctionGoToProduct = getLinkToDecathFunction(_rootPath, _serverUrl, _urlLiage, idModel, _siteRepositoryEnseigne) ;
                                    
                                    //Prix au kg                                    
                                    var prixKg = getPriceByKg(oMainPrice, oCurrency) ;
                                    
                                    if(prixKg != ""){
                                        var blocPxKgHtml = getElement("infoplus-valeur-prxKg", true, "") ;
                                        if(blocPxKgHtml){
                                            blocPxKgHtml.innerHTML = prixKg ;
                                        }
                                    }
                                    else{
                                        var blocPxKgHtml = getElement("prixKgCell", true, "") ;
                                        if(blocPxKgHtml){
                                            hideBloc(blocPxKgHtml) ;
                                        }
                                        var blocPxKgJurHtml = getElement("prixKgJur", true, "") ;
                                        if(blocPxKgJurHtml){                                
                                            hideBloc(blocPxKgJurHtml) ;
                                        }
                                        var blocPoidsHtml = getElement("poidsCell", true, "") ;
                                        if(blocPoidsHtml){
                                            hideBloc(blocPoidsHtml) ;
                                        }
                                    }
                                    
                                    setPrixDecathlon(idModel, valueCentralePrice, isHomogenous, valueDeeePrice, fonctionGoToProduct) ;
                                    
                                    //on va afficher le bloc prix
                                    var blocPrixObj = getElement("bloc-prix"+idModel, true, "") ;
                                    
                                    if(blocPrixObj){
                                        displayBloc(blocPrixObj) ;
                                    }
                                }
                                else{
                                    displayBlocItem = false ;
                                }
                            }
                            else{
                                displayBlocItem = false ;
                            }
                        }
                        // on va afficher le bloc produit
                        if(displayBlocItem){
                            if(blocItemObj.id != "decouvrirplus"+idModel && blocItemObj.id != "vignetteproduit-"+idModel){
                                displayBloc(blocItemObj) ;
                            }
                            else{
                                possibleAAfficher.add(blocItemObj.id);
                            }
                        }
                    }
                    else{
                        if(blocItemObj.id=="decouvrirplus"+idModel){
                             possibleAAfficher.add(blocItemObj.id);
                        }
                        
                        //on va ranger les produit nouveaute dans la liste des tris
                        rangeModelByPrice("", "", step, idModel) ;
                        
                        //si le client vient d'un autre pays, on va cacher le bloc prix pour les produits en tape de vie 2
                        var valueCookieCountry = getCookie("country") ;
                        if(valueCookieCountry){
                            var divOuAcheterElement = getElement("ouAcheter", true, "") ;
                            if(divOuAcheterElement){
                                hideBloc(divOuAcheterElement) ;
                            }
                        }
                    }
                }
            }
        }
        else{//dans le cas ou l'item est null, on va cacher le bloc produit            
            nbModelHidden++ ;
            //hideBloc(blocItemObj) ; //Par defaut, le bloc est cache
            disableProductList.add(blocItemObj) ; //Au lieu de le cacher directement, on va mettre le bloc a cacher dans une liste qu'on parcourera plus tard pour cacher les bons blocs => pas de risque de desynchro
        }
    }
}


/**
 * Permet de classer les produits par prix
*/
function rangeModelByPrice(_valueObj, _valuePrice, _step, _idModel){
    var listeModelByPrice = "" ;
    var valuePrice = "" ;
    
    //On va mettre a jour l'objet ItemSite
    if(typeof modelObjByIdMap != "undefined"){
        var itemSite = modelObjByIdMap.get(_idModel) ;
        
        //Traitement step != 2
        if(_valuePrice != ""){
            if(itemSite){
                itemSite.setPrixMag(_valuePrice) ;         
            }
            
            //Cast du prix en float : va permettre de trier plus facilement
            valuePrice = parseFloat(_valueObj.integer+"."+_valueObj.decimal) ; //Remplacement du , par .
        }
        else{ //Traitement step == 2
            if(_step == "2"){
                itemSite.setIsNew(true) ;
            }
            valuePrice = "NEW" ;
        }
        
        //Initialisation de la liste des modeles par prix
        var index = -1 ;
        
        //Est ce qu'il a deja ete cree
        if(priceModelMap.get(valuePrice)){
            listeModelByPrice = priceModelMap.get(valuePrice) ;
            index = priceModelMap.remove(valuePrice) ;
        }
        else{ //Sinon on le cree
            listeModelByPrice = new ArrayList() ;
        }
        
        //On rajoute le modele pour cette valeur de prix
        listeModelByPrice.add(_idModel) ;
        
        //On insert cette liste de modele pour cette valeur de prix dans la map
        if(index == -1){
            priceModelMap.put(valuePrice, listeModelByPrice) ;
        }
        else{
            priceModelMap.putIn(index, valuePrice, listeModelByPrice) ;
        }
    }
}


/**
 * Permet de charger tous les items de la famille
 * @param :
 *    - _client : ITOOL
 *    - _familyId : l'identifiant de la famille masterdata
 *    - _idSite : l'identifiant du site
 *    - _idCentral : identifiant de la centrale
 *    - _displayPrice : recuperation ou non des prix
 *    - _isSlideShow : sommes nous dans le slideshow ou non
 * @desc :
 *    - recupere le serveur erep, initialise ce serveur et charge tous les items de la famille
*/
function getFamily(_client, _familyId, _idSite, _idCentral, _displayPrice, _isSlideShow){

    //on va verifier si le client ne vient pas d'un autre pays
    var idCentral = _idCentral ;
    var valueCookieCountry = getCookie("country") ;
    if(valueCookieCountry){
        var enseigneSiteObj = mapUrlParPays.get(valueCookieCountry) ;
        if(enseigneSiteObj){
            idCentral = enseigneSiteObj.getCentrale() ;
        }
    }
    
    if(idCentral != "-1"){
        loadFamily(_client, _familyId, _idSite, _displayPrice, idCentral, POST_LOAD_ITEM_FAMILY_FUNCTION, _isSlideShow) ;
    }
    else{
        if(!_isSlideShow){
            displayProducts() ;
            
            checkSwitchProductPages() ;
        }
    }
}

/**
 * Permet de charger tous les items a partir d'une liste de modeles
 * @param :
 *    - _client : ITOOL
 *    - _idSite : l'identifiant du site
 *    - _idCentral : identifiant de la centrale
 *    - _isDisplayPrice : Doit on afficher les prix
 *    - _isDisplayAss : Doit on afficher les assortiment
 * @desc :
 *    - recupere le serveur erep, initialise ce serveur et charge tous les items de la famille
*/
function getModels(_client, _idSite, _idCentral, _isDisplayPrice, _isDisplayAss){
    //on va verifier si le client ne vient pas d'un autre pays
    var idCentral = _idCentral ;
    var valueCookieCountry = getCookie("country") ;
    if(valueCookieCountry){
        var enseigneSiteObj = mapUrlParPays.get(valueCookieCountry) ;
        if(enseigneSiteObj){
            idCentral = enseigneSiteObj.getCentrale() ;
        }
    }
    
    if(idCentral != "-1"){
        loadModels(_client, _idSite, idCentral, _isDisplayPrice, _isDisplayAss, POST_LOAD_ITEM_MODELS_FUNCTION) ;
    }
    else{
        hideWaitingMessage() ;
    }    
}

/**
 * Permet de charger tous les items a partir d'une liste de modeles
 * @param :
 *    - _client : ITOOL
 *    - _idSite : l'identifiant du site
 *    - _idCentral : identifiant de la centrale
 *    - _idModel : l'identifiant du modele (reference modele)
 *    - _isDisplayPrice : Doit on afficher ou non le prix
 *    - _isFromModel : appel depuis la page modele ou pas
 *    - _isFromTg : appel depuis une TG famille 
 * @desc :
 *    - recupere le serveur erep, initialise ce serveur et charge l'item correspondant au modele
*/
function getModel(_client, _idSite, _idCentral, _idModel, _isDisplayPrice, _isFromModel, _isFromTg){   
    //on va verifier si le client ne vient pas d'un autre pays
    var idCentral = _idCentral ;
    var language = _language ;    
    var valueCookieCountry = getCookie("country") ;
    if(valueCookieCountry){
        var enseigneSiteObj = mapUrlParPays.get(valueCookieCountry) ;
        if(enseigneSiteObj){
            idCentral = enseigneSiteObj.getCentrale() ;
        }
    }
    
    //Renseignement de la variable isFromTg
    var isFromTg = false ;
    if(typeof _isFromTg == "undefined"){
        isFromTg = false ;
    }
    else{
        isFromTg = _isFromTg ;
    }
    
    if(idCentral != "-1"){    
        loadModel(_client, _idSite, idCentral, _idModel, language, _isDisplayPrice, _isFromModel, isFromTg, POST_LOAD_ITEM_MODEL_FUNCTION) ;
    }
    else{
        //on va cacher le bloc ou acheter et les blocs oxylane
        var divOuAcheterElement = getElement("ouAcheter", true, "") ;
        if(divOuAcheterElement){
            hideBloc(divOuAcheterElement) ;
        }
    
        var divOxyClubElement = getElement("oxylaneClub", true, "") ;
        if(divOxyClubElement){
            hideBloc(divOxyClubElement) ;
        }
    }
}


/**
 * Permet de charger tous les items d'une famille et de lancer le traitement post appel Ajax
 * @param :
 *    - _client : ITOOL
 *    - _familyId : l'identifiant de la famille a recuperer
 *    - _idSite : l'identifiant du site
 *    - _displayPrice : recuperation ou non des prix
 *    - _idCentral : l'id de la centrale
 *    - _localfunc : la fontion post ajax a appeler : par ex, POST_LOAD_SWITCH_VENTE_FUNCTION
 *    - _isSlideShow : sommes nous dans le slideshow ou non 
 * @desc :
 *    - recupere le serveur erep, initialise ce serveur et charge tous les items de la famille
*/
function loadFamily(_client, _familyId, _idSite, _isDisplayPrice, _idCentral, _localfunc, _isSlideShow){
    //doit on afficher les informations prix
    displayPrice = _isDisplayPrice ;
    isSlideShow = _isSlideShow ;

    //recupere le serveur eRep
    var contextServicePage = "" ;
    if(_isSlideShow){
        contextServicePage = _SERVICE_ITEM_FAMILY_SLIDESHOW ;
    }
    else{
        contextServicePage = _SERVICE_ITEM_FAMILY ;
    }
    
    _urlErep = getUrlErep(contextServicePage, _client, THIRD_KIND_SITE, _idSite, _familyId, _localfunc) ;
    
    if(_urlErep != "" && typeof _urlErep != "undefined"){
        //Initialisation et execution du service
        var isActivePriceFilter = displayPrice ;
        var isActiveAssFilter = true ;
        serviceId = initExecuteService(_urlErep, _language, _idSite, _idCentral, CONTEXT_MODE_FAMILLE, _familyId, _localfunc, isActivePriceFilter, isActiveAssFilter) ;
        
        mapServiceId.put(contextServicePage, serviceId) ;
    }
}


/**
 * Permet de charger tous les items a partir d'une liste de modeles et de lancer le traitement post appel Ajax
 * @param :
 *    - _client : ITOOL
 *    - _idSite : l'identifiant du site
 *    - _idCentral : l'id de la centrale
 *    - _isDisplayPrice : Doit on afficher les prix
 *    - _isDisplayAss : Doit on afficher les assortiment 
 *    - _localfunc : la fontion post ajax a appeler : par ex, POST_LOAD_SWITCH_VENTE_FUNCTION
 * @desc :
 *    - recupere le serveur erep, initialise ce serveur et charge tous les items de la liste de modeles
*/
function loadModels(_client, _idSite, _idCentral, _isDisplayPrice, _isDisplayAss, _localfunc){
    //recupere le serveur eRep
    displayPrice = _isDisplayPrice ;    
    _urlErep = getUrlErep(_SERVICE_ITEM_MODELS, _client, THIRD_KIND_SITE, _idSite, modelList, _localfunc) ;
    
    if(_urlErep != "" && typeof _urlErep != "undefined"){
        if(modelList){
            if(modelList.length() > 0){
                //Initialisation et execution du service
                var isActivePriceFilter = displayPrice ;
                var isActiveAssFilter = _isDisplayAss ;
                
                serviceId = initExecuteService(_urlErep, _language, _idSite, _idCentral, CONTEXT_MODE_MODELES, modelList, _localfunc, isActivePriceFilter, _isDisplayAss) ;
                
                mapServiceId.put(_SERVICE_ITEM_MODELS, serviceId) ;
            }
        }
        else{
            //Dans le cas des ventes complementaire, on va cacher le bloc si aucun produit n'est dans la VC
            hideBlockModels("bloc-decouvrirplus") ;
        }
    }
    else{
        //erep ne repond plus, on va ckecker les switchs pour les cacher
        hideAllSwitchElement() ;
    }
}


/**
 * Permet de charger tous les items d'une famille et de lancer le traitement post appel Ajax
 * @param :
 *    - _client : ITOOL
 *    - _idSite : l'identifiant du site
 *    - _idCentral : l'identifiant de la centrale
 *    - _idModel : identifiant du modele
 *    - _language : FR|EN|ES|IT ...
 *    - _isDisplayPrice : affichage des prix ou non
 *    - _isFromModel : appel depuis le page modele ou non
  *    - _isFromTg : appel depuis la TG d'une page famille
 *    - _localfunc : la fontion post ajax a appeler : par ex, POST_LOAD_SWITCH_VENTE_FUNCTION
 * @desc :
 *    - recupere le serveur erep, initialise ce serveur et charge tous les items de la famille
*/
function loadModel(_client, _idSite, _idCentral, _idModel, _language, _isDisplayPrice, _isFromModel, _isFromTg, _localfunc){
    //doit on afficher les informations prix
    displayPrice = _isDisplayPrice ;
    isFromModel =_isFromModel ;
    isFromTg = _isFromTg ;
    
    //recupere le serveur eRep      
    _urlErep = getUrlErep(_SERVICE_ITEM_MODEL, _client, THIRD_KIND_SITE, _idSite, _idModel, _localfunc) ;
    idModel = _idModel ;

    if(_urlErep != "" && typeof _urlErep != "undefined"){
        //Initialisation et execution du service
        var isActivePriceFilter = displayPrice ;
        var isActiveAssFilter = true ;
        
        serviceId = initExecuteService(_urlErep, _language, _idSite, _idCentral, CONTEXT_MODE_MODELE, _idModel, _localfunc, isActivePriceFilter, isActiveAssFilter) ;
        
        mapServiceId.put(_SERVICE_ITEM_MODEL, serviceId) ;
    }
    else{
        //erep ne repond plus, on va ckecker les switchs pour les cacher
        hideAllSwitchElement() ;
    }
}


/**
 * Permet de cacher le bloc de vente complementaire si tous les produits de la vente sont desactives
 * @param :
 *    - _idBlockToHide : bloc VC a cacher
*/
function hideBlockModels(_idBlockToHide){
    var blockToHide = getElement(_idBlockToHide, true, "") ;
    if(!blockToHide){
        if(parent){
            blockToHide = parent.document.getElementById(_idBlockToHide) ;
        }
    }
    
    if(blockToHide){
        //Si le nb de bloc cache est egal au nb de modele a afficher dans la VC, alors on va cacher ce bloc
        if(nbModelToCheck == nbModelHidden){
            hideBloc(blockToHide) ;
        }
    }
    completeAffiche();
}

/**
 * Verifie si les VC selectionner alatoirement sont affichable et en selectionne d'autre si elles ne font pas partie des produit affichable
*/
function completeAffiche(){    
    var nbVC=possibleAAfficher.length();
    if(nbVC>2){
        var afficher=selectionAleatoire(nbVC);
        for(var i=0;i<afficher.length;i++){
            var divCourante=getElement(possibleAAfficher.get(afficher[i]),true,"");
            if(divCourante.style.display=="none"){
                divCourante.style.display="block";
                verif=true;
            }else{
                verif=false;
            }
            while(!verif){
                indice=  Math.ceil(Math.random()*nbVC) -1; 
                var j=0;
                verif=true;
                while(j<2 && verif){
                    verif=(afficher[j]!=indice);
                    j++;
                }
                if(verif){
                    var divCouranteModifier=getElement(possibleAAfficher[indice],true,"");
                    if(possibleAAfficher.contains(possibleAAfficher[indice].id)){
                        divCouranteModifier.style.display="block";
                        afficher[i]=indice;
                    }else{
                        verif=false;
                    }
                }
            }
        }       
    }else{
    
        for (var i=0;i<possibleAAfficher.length();i++){
            document.getElementById(possibleAAfficher.get(i)).style.display="block";
        }
    }
}

/**
 * Selectionne 2 positions alatoirement parmit toutes les VC disponible
 * params :
 *    - _nbPdt : nombre de produit disponible
*/
function selectionAleatoire(_nbPdt){
    if(_nbPdt>2){
         var dejaAfficher=[-1,-1];
         for(var l=0; l < 2;l++){
             var verifier=false;
             var indice=  Math.ceil(Math.random()*_nbPdt) -1;
             while(!verifier){
                 var j=0;
                 verifier=true;
                 while(j<l && verifier){
                     verifier=(dejaAfficher[j]!=indice);
                     j++;
                 }
                 if(!verifier)indice=  Math.ceil(Math.random()*_nbPdt) -1; 
             }
             dejaAfficher[l]=indice;
        }
    } else{
         var dejaAfficher=[0,1];
    }
    return dejaAfficher;
}


/**
 * Verif si une VC fait partie des VC selectionner aleatoirement
 * params :
 *    - _tab : tableau des position selectionne
 *    - _pos : position a tester
*/
function verifAffichage(_tab, _pos){
    var estAAfficher=false;
    var i=0;
    while(!estAAfficher && i<_tab.length){
        estAAfficher = (_tab[i] == _pos);
        i++;
    }
    return estAAfficher;
}


/**
 * Permet de recupErer le poids d'un modele et son unite 
 * params :
 *    - _mainPrice : l'objet Price pour le prix centrale
 *    - _currencyObject : l'objet Currency
 * return :
 *    La valeur du prix/kg
*/
function getPriceByKg(_mainPrice, _currencyObject){
    var poidsModeleObj = getElement("poids_modele", true, "") ;
    var uniteModeleObj = getElement("unite_modele", true, "") ;
    
    var valeurPoidsModele = "" ;
    var unitePoidsModele = "" ;
    if(poidsModeleObj && uniteModeleObj){
        valeurPoidsModele = poidsModeleObj.innerHTML ;
        unitePoidsModele = uniteModeleObj.innerHTML ;        
    }
    
    if((unitePoidsModele == "Kg" || unitePoidsModele == "L") && valeurPoidsModele > 0 ){
        var priceValue = _mainPrice.getValue() ;
        var priceByKg = parseFloat(priceValue.getInteger()+"."+priceValue.getDecimal())/valeurPoidsModele ;
        priceByKg=Math.round(priceByKg*100)/100;
        
        // convertion en string pour separer la partie entiere et decimale et construire l objet value                
        priceByKg = priceByKg.toString();
        
        var priceByKg_value = null ; //Objet Value
        if (priceByKg.indexOf('.')!=-1) {
            var priceByKg_value = new JoValue() ;
            priceByKg_value.setInteger(priceByKg.substring(0,priceByKg.indexOf('.'))) ;
            priceByKg_value.setDecimal(priceByKg.substring(priceByKg.indexOf('.')+1)) ;
        }
        else {
            var priceByKg_value = new JoValue();
            priceByKg_value.setInteger(priceByKg) ;
            priceByKg_value.setDecimal(0) ;
        }
        // construction de l objet currency pour utiliser la methode de formatage du prix

        var oCurrency = new JoCurrency();
        oCurrency.setId(_currencyObject.getId());
        oCurrency.setBehind(_currencyObject.isBehind());
        oCurrency.setSymbol(_currencyObject.getSymbol());
        oCurrency.setDecimalNumber(_currencyObject.getDecimalNumber());
        oCurrency.setDecimalDelimiter(_currencyObject.getDecimalDelimiter());
        oCurrency.setThousandDelimiter(_currencyObject.getThousandDelimiter());
        
        if(oCurrency){
            return oCurrency.formatValue(priceByKg_value) +' / ' +unitePoidsModele;
        }
        else{
            return "" ;
        }
    }
    else{
        return "" ;
    }
}


/** #########################################
 * Permet de rediriger l'internaute vers la page famille si le produit n'est plus dispo
 * params :
 *    - _urlPathFamille : l'Url de la page famille a afficher
*/
function redirectProduit(_urlPathFamille){
    if(_urlPathFamille != ""){
        document.location.href = _urlPathFamille + "?nondispo=true" ;        
    }    
}

/** #########################################
 * Permet d'afficher le message d'erreur de non dispo d'un produit
*/
function checkPageStatus(){
    // Doit on afficher le message de non dispo du produit
    var paramsUrl = getParameters() ;
    if (paramsUrl.length > 0 && paramsUrl[0] != "") {
        if((paramsUrl[0][0]).indexOf("?nondispo") > -1){
            if(paramsUrl[0][1] == "true"){
                displayBlocId("advertDispo") ;
            }
        }
    }
}