Ext.namespace('Atolcd', 'Atolcd.Right');

// "correctif" pour afficher la valeur d'une combo, après le load du store
Ext.override(Ext.form.ComboBox, {
    setValue : function(v){
//begin patch
        // Store not loaded yet? Set value when it *is* loaded.
        // Defer the setValue call until after the next load.
        if (this.store.getCount() == 0) {
            this.store.on('load',
                this.setValue.createDelegate(this, [v]), null, {single: true});
            return;
        }
//end patch
        var text = v;
        if(this.valueField){
            var r = this.findRecord(this.valueField, v);
            if(r){
                text = r.data[this.displayField];
            }else if(this.valueNotFoundText !== undefined){
                text = this.valueNotFoundText;
            }
        }
        this.lastSelectionText = text;
        if(this.hiddenField){
            this.hiddenField.value = v;
        }
        Ext.form.ComboBox.superclass.setValue.call(this, text);
        this.value = v;
    }
});

Ext.util.Format.frMoney = function(v){
    v = (Math.round((v-0)*100))/100;
    v = (v == Math.floor(v)) ? v + ".00" : ((v*10 == Math.floor(v*10)) ? v + "0" : v);
    v = String(v);
    var ps = v.split('.');
    var whole = ps[0];
    var sub = ps[1] ? '.'+ ps[1] : '.00';
    var r = /(\d+)(\d{3})/;
    while (r.test(whole)) {
        whole = whole.replace(r, '$1' + ' ' + '$2');
    }
    v = whole + sub;
    if(v.charAt(0) == '-'){
        return '-' + v.substr(1)+' €';
    }
    return  v+" €";
}

Ext.util.Format.frMoneyUnitee = function(v){
    v = Math.round(v);
    v = String(v);
    return  v+" €";
}
Ext.applyIf(Ext.ButtonToggleMgr,{       
         getPressed : function(group){
           var g = groups[group];
           if(g){
               for(var i = 0, len = g.length; i < len; i++){
                   if(g[i].pressed === true){
                       return g[i];
                   }
               }
           }
           return null;
       }});

Atolcd.setValueCombo = function (cbo, value) {
  if (cbo != null && value != null) {
    var indexRecord = cbo.store.find(cbo.valueField, value);
    if (indexRecord < 0)
      indexRecord = 0;
    var record = cbo.store.getAt(indexRecord);
    if (typeof record != 'undefined')
      cbo.onSelect(record,indexRecord);
    return record;
  }
};

// Renderer à utiliser dans les grilles pour les types booléens
Atolcd.rendererBool = function(value, metadata, record, rowIndex, colIndex, store) {
  if (value === true || value === 1 || value === 'true' || value === 't' || value === 'oui') {
    return '<div class="isok">&nbsp;</div>';
  }
  return '';
};

// Renderer à utiliser dans les grilles pour afficher une valeur à 2 chiffres apres la virgule
Atolcd.rendererFloat2 = function(value, metadata, record, rowIndex, colIndex, store) {
  value = parseFloat(value);
  if (!isNaN(value) && value != null) {
    return value.toFixed(2);
  }
  return '';
};


if (!Atolcd.ContextMgr) {

  Atolcd.ContextMgr = function() {
  
    var _cp = new Ext.state.CookieProvider({
      expires: new Date(new Date().getTime()+(1000*60*30)) // 30 minutes
    });
    // Ext.state.Manager.setProvider(_cp);

    var _listComponent = new Ext.util.MixedCollection();

    var _idpage = null;

    return {
      // Fonction appelé une fois qui définit l'identifiant de la page en cour
      setPage: function(idpage) {
        _idpage = idpage;
      },
    
      // Fonction qui permet à un composant de s'enregistrer, et de recevoir en retour
      // un objet de config si il existait dans la page en cour
      register: function(comp){
        if (comp != null && !_listComponent.containsKey(comp.id)) {
          _listComponent.add(comp.id, comp);
          var compContext = _cp.get("page-" + _idpage, comp.id);
          return compContext[comp.id] || {};
        }
      },

      // Fonction qui va appeler la fonction getContext de chaque élément:
      saveContext: function() {
        var tab = {};
        for (var i = 0; i < _listComponent.getCount(); i++) {
          var comp = _listComponent.itemAt(i);
          if (comp != null &&comp.getContext) {
            tab[comp.id] = comp.getContext();
          }
        }
        _cp.set("page-" + _idpage, tab);
      },

      setPageObjectContext: function(idpage, id, newContext, clearOldContext) {
        var contextActuel = (clearOldContext == true ? {} : _cp.get("page-" + idpage, id));
        if (contextActuel && contextActuel != id){
          Ext.apply(contextActuel || {}, newContext || {});
        } else {
          contextActuel = newContext;
        }
        
        _cp.set("page-" + idpage, contextActuel);
        return contextActuel;
      },
      
      getPageObjectContext: function(idpage, id) {
        var ctx = _cp.get("page-" + idpage, id) || {};
        return ctx;
      },

      setPageContext: function(idpage, newContext, clearOldContext) {
        return this.setPageObjectContext(idpage, "CP-" + idpage, newContext, clearOldContext)
      },

      getPageContext: function(idpage) {
        if (typeof idpage == 'undefined' || idpage == null) {
          idpage = _idpage;
        }
        return this.getPageObjectContext( idpage, "CP-" + idpage)
      },
      
      removeContext: function(){
        var cookies = _cp.readCookies();
        for (var cle in cookies)
        {
          if (cle.substring(0,5) == "page-"){
            _cp.clearCookie(cle);
          }
        }

      }

    };
  }();
  
  Ext.EventManager.on(window, 'beforeunload', Atolcd.ContextMgr.saveContext);
  
}


Ext.apply(Atolcd.Right, {
    storeRigth:null,
    islocked: false,
    setOutilsRight:function(toolinit, islocked){
      this.storeRigth = new Ext.data.Store({
        reader: new Ext.data.JsonReader({
          id:'codetypedroit',
          root:'tools'
        },[
          {name:'codetypedroit'},
          {name:'iddroitmodalite', mapping:'tdroitsprofils[0].iddroitmodalite', type:'int'}
        ])
      });
      this.storeRigth.loadData({tools:Ext.util.JSON.decode(toolinit)});
      if (islocked != 'false'){
        this.islocked = true;
      }
    }
    ,getOutilsRight:function(codeTypeDroit){
      if ( this.storeRigth.getById(codeTypeDroit)){
        if (islocked) 
        {
          if (this.storeRigth.getById(codeTypeDroit).get('iddroitmodalite') > 20){
            return 20;
          } else {
            return this.storeRigth.getById(codeTypeDroit).get('iddroitmodalite');
          }
        }
        else 
        {
          return this.storeRigth.getById(codeTypeDroit).get('iddroitmodalite');
        }
      } else {
        return null;
      }
    }
    ,getIsLocked:function(){
      return this.islocked;
    }
});


// "correctif" pour ne pas reselectionner les lignes deja selectionnees
Ext.override(Ext.grid.RowSelectionModel, {
    selectAll : function(){
        if(this.isLocked()){
            return;
        }

        for(var i = 0, len = this.grid.store.getCount(); i < len; i++){
            if (!this.isSelected(i)) 
            {
                this.selectRow(i, true);
            }
        }

            
        
    }
});


//fonction pour le trie numerique js
sortfunction = function (a, b){
   return (a - b);
}

//Fonction retournant un numero de disponible dans une liste.
//Utilise pour récuperer par exemple un numero de parcelle disponible.
//Prends en parametre les numeros existants, et éventuellement un numero à exclure.
Atolcd.getNumDispo = function(listeNumNonDispo, numToExclude){
    //Liste vide
    if(typeof(listeNumNonDispo) == 'undefined' ||  listeNumNonDispo.length == 0){
      if(numToExclude == 1){
        return 2;
      }
      else {
        return 1;
      }
    }
    
    //Trie par ordre numerique
    listeNumNonDispo.sort(sortfunction);

    if(typeof(numNotAllowed) == 'undefined'){
      numNotAllowed = null;
    }
    //Variables pour compairaison de continuité
    var oldNum = 0;
    var curNum = null;
    
    //On cherche une faille dans la continuitée des numero deja pris
    for (var i = 0; i < listeNumNonDispo.length; i++) 
    {
      curNum = listeNumNonDispo[i];
          
      //si première boucle, on compare avec 0
         
          if ((curNum - oldNum) > 1) //La différence entre le nombre d'avant et celui sup à 1, il y a donc faille (on enleve le cas où les nombres sont identiques). 
          {
            //Avant de retourner le numero, on regarde si c'est pas celui non autorisé.
            if ((oldNum + 1) == numToExclude) 
            {
              oldNum = oldNum + 1;
            }
            else 
            {
              return (oldNum + 1);
            }
          }
          else 
          {
            //Nombre continue, on passe au suivant.
            oldNum = curNum;
          }
    }
    
        //On arrive ici, cela signifie que la liste des numero est continue. On retourne le dernier, +1.
    if ((listeNumNonDispo[listeNumNonDispo.length-1] + 1) == numNotAllowed) 
    {
      return (listeNumNonDispo[listeNumNonDispo.length-1] + 2);
    }
    else 
    {
      return (listeNumNonDispo[listeNumNonDispo.length-1] + 1);
    } 
}

//Fonction contains d'un tableau, avec en plus le nbOcc minimum necessaire pour renvoyer vrai. 
//Utilisé par exemple pour savoir si une valeur est en doublont dans un tableau
Atolcd.contains = function(tab, value,nbOcc){
  if(typeof(nbOcc) == 'undefined'){
    nbOcc = 1;
  }
  
  var nbOccValeur = 0;
  for(var i=0; i<tab.length; i++)
  {
    if(tab[i] === value){ //La valeur est dans le tableau
      nbOccValeur += 1;//On incrémente le nombre d'occurence dans ce tableau
      if (nbOccValeur == nbOcc) //On regarde si le nombre d'occurence necesaire demandée est ok
      {
        return true;
      }
    }
  }      
  return false;  
}

//retourne la liste des numero de parcelles pris, avec éventuellement en parametre un ilot a exclure de cette liste. 
//utile dans le cas d'une edition d'ilot par exemple.
Atolcd.getNumParcellesNonDispo = function(scope,callback,idIlotToExclude){
   var listeNumNonDispo = new Array();
 
   //On charges les numero de parcelles non disponibles
    Ext.Ajax.request(
    {
      url: 'request/listeNumParcelleExploit.php',
      method: 'GET',
      success: function(result, request)
      {
       
        var myResponse = eval(result.responseText);
        if (myResponse != null) 
        {
          if (myResponse.length > 0) 
          {
            listeNumNonDispo = myResponse;
                //Vérification du type tableau pour la sortie
              if(typeof(listeNumNonDispo) == 'undefined'){
                 listeNumNonDispo = new Array();
              }
              
              
              
          }else{
            listeNumNonDispo = new Array();
          }
          Ext.callback(callback, scope, [listeNumNonDispo]);
        }
    
      },
      params:{
        idilot: idIlotToExclude
      }
    }); 
}