package rules;

import java.util.HashSet;
import java.util.HashMap;
import java.util.Map;
import java.util.List;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Set;
import java.io.File;
import java.io.Writer;
import java.io.FileWriter;
import java.io.BufferedWriter;
import java.io.FileReader;
import java.util.Collection;
import java.util.Collections;
import java.util.Iterator;
import fr.ifremer.isisfish.IsisFishDAOHelper;
import static org.nuiton.i18n.I18n._;

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;

import org.nuiton.math.matrix.*;
import org.nuiton.topia.*;
import org.nuiton.util.FileUtil;

import scripts.ResultName;
import scripts.RuleUtil;
import scripts.SiMatrix;

import fr.ifremer.isisfish.entities.*;
import fr.ifremer.isisfish.rule.AbstractRule;
import fr.ifremer.isisfish.simulator.MetierMonitor;
import fr.ifremer.isisfish.simulator.PopulationMonitor;
import fr.ifremer.isisfish.simulator.SimulationContext;
import fr.ifremer.isisfish.types.Date;
import fr.ifremer.isisfish.types.Month;
import fr.ifremer.isisfish.simulator.SimulationParameter;
import fr.ifremer.isisfish.datastore.SimulationStorage;
import fr.ifremer.isisfish.datastore.ResultStorage;

/**
 *MPARuleBRUM_conditionnel_MultiSp.java
 *
 * Created: 31/05/10
 * Based on : RUM_conditionnel.java
 *
 * @author sigrid et benjamin
 * @version $Revision: 3.3
 *
 * Last update: $Date: $
 * by : $Author: sigrid $
 */

/**
 * RUM utilise les RUM pour predire a chaque mois la proportion de chaque metier realisé par les pecheurs
 *en fonction des VPUE de l'espece cible realisees sur les metiers le mois 
 *precedant, du % d'effort moyen passé sur le métier entre 2000 et 2004 au mois en cours, 
 *et de la distance à parcourir jusqu'à la zone de pêche * prix du gasoil 
 * on a donc 3 coefficients par flottille
 * ATTENTION ce code est valable si un metier n est pratiqué que dans une et une seule strategie
 */
public class MPARuleBRUM_conditionnel_MultiSp extends AbstractRule {

    /** to use log facility, just put in your code: log.info("..."); */
    static private Log log = LogFactory.getLog(MPARuleBRUM_conditionnel_MultiSp.class);
 	
	public Population param_pop = null;
    public int param_fuelPrice = 0;
    public Month param_beginMonth = Month.JULY;
    public Month param_endMonth = Month.JUNE;
    public Date param_beginDateTAC = new Date(6);
    public Date param_endDateTAC = new Date(500);
    public double param_tacInkg = 13200000;
	
    public Zone param_zoneMPA = null;
    public Date param_beginDateMPA = new Date(0); 
    public Date param_endDateMPA = new Date(500);
    public Month param_beginMonthMPA = Month.APRIL;
    public Month param_endMonthMPA = Month.JULY;
	
	
	
	static final protected String VPUE = "vpue";
	static final protected String EFFORT = "Effort";
	static final protected String DIST = "distance";
	static final protected String LVALUE = "LandingsValue";
		
	//path matrix of coefficients of rum
	public String param_nomfichier_coeffRUM = "Inputs_Anchois/RUMConditionnelMultiSp/CoeffRum.csv";
    // path effort moyen 
	String param_nomfichier_effMoy0 = "Inputs_Anchois/RUMConditionnelMultiSp/EffMoy0.csv";
	String param_nomfichier_effMoy1 = "Inputs_Anchois/RUMConditionnelMultiSp/EffMoy1.csv";
	String param_nomfichier_effMoy2 = "Inputs_Anchois/RUMConditionnelMultiSp/EffMoy2.csv";
	String param_nomfichier_effMoy3 = "Inputs_Anchois/RUMConditionnelMultiSp/EffMoy3.csv";
	// path matrix of vpue met other
	String param_nomfichier_vpueOthers = "Inputs_Anchois/RUMConditionnelMultiSp/VpueOthers.csv";
    //path of distances
	String param_nomfichier_distances0 = "Inputs_Anchois/RUMConditionnelMultiSp/Distances0.csv";
	String param_nomfichier_distances1 = "Inputs_Anchois/RUMConditionnelMultiSp/Distances1.csv";
	String param_nomfichier_distances2 = "Inputs_Anchois/RUMConditionnelMultiSp/Distances2.csv";
    String param_nomfichier_distances3 = "Inputs_Anchois/RUMConditionnelMultiSp/Distances3.csv";

	
	protected File CoeffRum; 
	protected File EffMoy0;
	protected File EffMoy1;
	protected File EffMoy2;
	protected File EffMoy3;
	protected File VpueOthers;
     protected File Distances0;
	protected File Distances1;
	protected File Distances2;
	protected File Distances3;
	
	protected MatrixND matrixCoeffRUM;
	protected MatrixND matrixPercEffMoy;
	protected MatrixND matrixVpueOthers;	
	protected MatrixND matrixDistances;    
	protected MatrixND matrixVar;  

	protected List<Metier> metiers;
	// interdit de faire des set sur les strategies de la map, il faut recuperer les strategies de la date courante
	protected Map<String , Strategy> mesStrategies;
	protected Double [] fuelPrice;
	
    protected String [] necessaryResult = {
            ResultName.MATRIX_BIOMASS,
            ResultName.MATRIX_GROSS_VALUE_OF_LANDINGS_PER_SPECIES_PER_STRATEGY_MET,
			ResultName.MATRIX_CATCH_WEIGHT_PER_STRATEGY_MET_PER_ZONE_POP,
			ResultName.MATRIX_EFFORT_PER_STRATEGY_MET,
			ResultName.MATRIX_EFFORT_NOMINAL_PER_STRATEGY_MET,
    };
    
    /**
     * @return the necessaryResult
     */
    public String[] getNecessaryResult() {
        return this.necessaryResult;
    }
    
    /**
     * Permet d'afficher a l'utilisateur une aide sur la regle.
     * @return L'aide ou la description de la regle
     */
    public String getDescription() {
        return _("calcul le temps passe sur chaque metier possible a l aide des RUM / "+
		"attend une matrice de coefficient du RUM / "+
		"une matrice de coeff pour le calcul des valeurs des especes non décrites / ");
    }
 
  

  /**
     * Appelé au démarrage de la simulation, cette méthode permet d'initialiser
     * des valeurs
     * @param simulation La simulation pour lequel on utilise cette regle
     */
    public void init(SimulationContext context) throws Exception  {

    // load coefficients of rum file 
		if (param_nomfichier_coeffRUM==null || "".equals(param_nomfichier_coeffRUM)){
    		CoeffRum = FileUtil.getFile(".*.csv", "fichier coeff rum ';'");
    	} else {
    		CoeffRum = new File(param_nomfichier_coeffRUM);
    	}

	/*// effort moy files
		EffMoy0 = new File(param_nomfichier_effMoy0);
		EffMoy1 = new File(param_nomfichier_effMoy1);
		EffMoy2 = new File(param_nomfichier_effMoy2);
		EffMoy3 = new File(param_nomfichier_effMoy3);*/
		
    // load vpue others file
		if (param_nomfichier_vpueOthers==null || "".equals(param_nomfichier_vpueOthers)){
			VpueOthers = FileUtil.getFile(".*.csv", "fichier 0 csv séparateur ';'");
    	} else {
    		VpueOthers = new File(param_nomfichier_vpueOthers);
    	}
                
	//Load file of distances
		Distances0 = new File(param_nomfichier_distances0);
		Distances1 = new File(param_nomfichier_distances1);
		Distances2 = new File(param_nomfichier_distances2);
		Distances3 = new File(param_nomfichier_distances3);

	
	// reccuperation des metiers et strategies
		SiMatrix siMatrix = SiMatrix.getSiMatrix(context);
		metiers = siMatrix.getMetiers(new Date(0));		
		List<Strategy> allStrategies = siMatrix.getStrategies(new Date(0));	
		List <Month> months = Month.getMonths(Month.JANUARY,Month.DECEMBER);
		
		String[] metiersNomsNous = new String[]{"Espagnols","Autre", "PelProfil1Gironde", "PelProfil1Landes", 
		"PelProfil1Nord", "PelProfil1Rochebonne","PelProfil2Gironde", "PelProfil2Landes", "PelProfil2Nord",
		"PelProfil2Rochebonne","BolincheProfil1gir", "BolincheProfil1lan","BolincheProfil2nord", 
		"GermonPel1","GermonPel2","SardinePel1","SardinePel2","SardineBol1","SardineBol2",
		"BarPel1_GdG","BarPel2_GdG","BarPel1_Manche","BarPel2_Manche"};
		List<Metier> metiersNous = new ArrayList<Metier>();
		for(String metiersNomCurrent : metiersNomsNous){
			for (Metier met : metiers){
				System.out.println("met.getname : " + met.getName() + "; metiercourant :" + metiersNomCurrent + "; liste:" + metiersNous);				
				if(met.getName().equals(metiersNomCurrent)){
					metiersNous.add(met);
				}
			}
		}
			
		// creation de mes strategies qui ne contient pas les espagnols et ordre
		mesStrategies = new HashMap<String, Strategy>();
		for(Strategy str : allStrategies) {
			mesStrategies.put(str.getName(), str);
		}
		mesStrategies.remove("Espagnols");
		List <Strategy> mStr = new ArrayList(mesStrategies.values());
		List <Strategy> strNous = new ArrayList<Strategy>();
		strNous.add(mesStrategies.get("PelProfil1"));
		strNous.add(mesStrategies.get("PelProfil2"));
		strNous.add(mesStrategies.get("BolBasques"));
		strNous.add(mesStrategies.get("BolBretons"));
		
		 
		
////////////////////////
	//creation et import des matrices des coeff des rum
		matrixCoeffRUM = MatrixFactory.getInstance().create(
				"matrixCoeffRUM",
				new List[]{strNous,Arrays.asList(new String[]{EFFORT, VPUE, DIST})},
                new String[]{"Strategies","Coeff"});						
		matrixCoeffRUM.importCSV(new FileReader(CoeffRum),new int []{0,0});
		System.out.println("coeff RUM: " + matrixCoeffRUM);	
	
	/*// creation de la matrice des % effort par mois met moyen
		MatrixND matrixEffMoy0 = MatrixFactory.getInstance().create(
			"matrixEffMoy0",
			new List[]{metiersNous,months},
			new String[]{"Metiers","Month"});
		matrixEffMoy0.importCSV(new FileReader(EffMoy0),new int []{0,0});
		MatrixND matrixEffMoy1 = MatrixFactory.getInstance().create(
			"matrixEffMoy1",
			new List[]{metiersNous,months},
			new String[]{"Metiers","Month"});
		matrixEffMoy1.importCSV(new FileReader(EffMoy1),new int []{0,0});
		MatrixND matrixEffMoy2 = MatrixFactory.getInstance().create(
			"matrixEffMoy2",
			new List[]{metiersNous,months},
			new String[]{"Metiers","Month"});
		matrixEffMoy2.importCSV(new FileReader(EffMoy2),new int []{0,0});
		MatrixND matrixEffMoy3 = MatrixFactory.getInstance().create(
			"matrixEffMoy3",
			new List[]{metiersNous,months},
			new String[]{"Metiers","Month"});
		matrixEffMoy3.importCSV(new FileReader(EffMoy3),new int []{0,0});
		
		matrixPercEffMoy = MatrixFactory.getInstance().create(
			"matrixEffMoy",
			new List[]{mStr,metiers,months},
			new String[]{"Strategies","Metiers","Month"});
		MatrixND matImportEffMoy = MatrixFactory.getInstance().create(new int[]{metiersNous.size(),12});
		for(Strategy str : mesStrategies.values()){
			for(Metier met : metiers){
				for(Month mois : months){
					if ("BolBasques".equals(str.getName())) {
					matImportEffMoy = matrixEffMoy2;
					}else if ("BolBretons".equals(str.getName())) {
					matImportEffMoy = matrixEffMoy3;
					}else if ("PelProfil1".equals(str.getName())) {
					matImportEffMoy = matrixEffMoy0;
					}else if ("PelProfil2".equals(str.getName())) {
					matImportEffMoy = matrixEffMoy1;}
					matrixPercEffMoy.setValue(str, met, mois, matImportEffMoy.getValue(met,mois));
				}// fin de for months
			}// fin de for met
		}//	fin de for strategy*/
	
	//creation et import des matrices des vpue du metier other
		matrixVpueOthers = MatrixFactory.getInstance().create(
				"matVpueOthers",
				new List[]{strNous,months},
                new String[]{"Strategies","mois"});
		matrixVpueOthers.importCSV(new FileReader(VpueOthers),new int []{0,0});
	
	//// creation et import des matrices des distances parcourues
		//// import des distances parcourues
		MatrixND matDistances0 = MatrixFactory.getInstance().create(
				"matDistances0",
				new List[]{metiersNous,months},
                new String[]{"Metiers","Month"});
          MatrixND matDistances1 = MatrixFactory.getInstance().create(
				"matDistances1",
				new List[]{metiersNous,months},
                new String[]{"Metiers","Month"});
          MatrixND matDistances2 = MatrixFactory.getInstance().create(
				"matDistances2",
				new List[]{metiersNous,months},
                new String[]{"Metiers","Month"});
          MatrixND matDistances3 = MatrixFactory.getInstance().create(
				"matDistances3",
				new List[]{metiersNous,months},
                new String[]{"Metiers","Month"});
		matDistances0.importCSV(new FileReader(Distances0),new int []{0,0});
		matDistances1.importCSV(new FileReader(Distances1),new int []{0,0});
		matDistances2.importCSV(new FileReader(Distances2),new int []{0,0});
		matDistances3.importCSV(new FileReader(Distances3),new int []{0,0});
		
		//// creation de la matrice
		matrixDistances = MatrixFactory.getInstance().create(
				"matrixDistances",
				new List[]{strNous,metiersNous,months},
                new String[]{"Strategies","Metiers","Month"});

		MatrixND matImportDist = MatrixFactory.getInstance().create(new int[]{14,12});
		for(Strategy str : mesStrategies.values()){
			for(Metier met : metiers){
				for(Month mois : months){
					if ("BolBasques".equals(str.getName())) {
					matImportDist = matDistances2;
					}else if ("BolBretons".equals(str.getName())) {
					matImportDist = matDistances3;
					}else if ("PelProfil1".equals(str.getName())) {
					matImportDist = matDistances0;
					}else if ("PelProfil2".equals(str.getName())) {
					matImportDist = matDistances1;}

					matrixDistances.setValue(str, met, mois, matImportDist.getValue(met,mois));
				}// fin de for months
			}// fin de for met
		}//	fin de for strategy
		
		//// creation de la sequence de prix du gasoil
		if(param_fuelPrice == 0){
			double [] fuelPrice = {0,0,0,0,0,0};
		}else{ double [] fuelPrice = {0,0,0,0,0,0};
		}
		
	}// fin de init		
	
	// all matrix var
	protected Map<Date, MatrixND> allMatrixVar = new HashMap<Date, MatrixND>();
		protected MatrixND getMatrixVar(Date askedDate) {
		MatrixND result = allMatrixVar.get(askedDate);
		// si on demande on matrice qui n existe pas encore : on la cree
		if (result == null) {
			MatrixND matrixVar = createMatrixVar();
			allMatrixVar.put(askedDate, matrixVar);
			result = matrixVar;
		}
		return result;
	}
	
	protected MatrixND createMatrixVar (){
		// Creation d'une nouvelle matrix qui n'existe pas encore ...
		MatrixND matrixVar = MatrixFactory.getInstance().create(
			"matrixVar",
			new List[]{new ArrayList(mesStrategies.values()), metiers, Arrays.asList(new String[]{EFFORT, LVALUE})},
            new String[]{"Strategies","Metiers","Variables"});
		return matrixVar ;
	}	
	
	

	
	/**
     * La condition qui doit etre vrai pour faire les actions
     * @param simulation La simulation pour lequel on utilise cette regle
     * @return vrai si on souhaite que les actions soit faites
     */
	 
    public boolean condition(SimulationContext context, Date date, Metier metier) throws Exception {
        boolean result = true ;
        return result;
    }

	
	/**
     * Si la condition est vrai alors cette action est executée avant le pas
     * de temps de la simulation.
     * @param simulation La simulation pour lequel on utilise cette regle
     */
	
    boolean first = true ;
	public void preAction(SimulationContext context, Date date, Metier metier) throws Exception {
	
		// la préaction n est realisee qu une seule fois pour tous les metiers		
		if (first == true){
			first = false ;
			SiMatrix siMatrix = SiMatrix.getSiMatrix(context);
			ResultStorage Result = context.getSimulationStorage().getResultStorage();
			MatrixND currentMatrixVar = getMatrixVar(date);
			List<Strategy> strategies = (List<Strategy>)currentMatrixVar.getSemantic(0);
			List<Metier> metiers = (List<Metier>)currentMatrixVar.getSemantic(1);
		
			TopiaContext tx = context.getDB();
			String id = param_zoneMPA.getTopiaId();
            param_zoneMPA = ((Zone)tx.findByTopiaId(id));
		

// est-ce que le TAC est atteint?
			boolean testTAC = false;
			if(date.before(param_beginDateTAC)) {
				testTAC= false;
			} else if(date.after(param_endDateTAC)) {
				testTAC= false;
			} else {
				Species sp = param_pop.getSpecies();
				TargetSpecies ts = metier.getMetierSeasonInfo(date.getMonth()).getSpeciesTargetSpecies(sp);
				if (ts != null) {
					int ny = date.getYear() ;
                    boolean firstSemester = date.getMonth().before(param_beginMonth);
					ResultStorage matResult = context.getSimulationStorage().getResultStorage();
                       //year in which to consider biomass in may ?
                        int year = 0;
                        if(firstSemester & ny > 0) year = ny - 1;
                        else year = ny ;

                        // computing proportionnal TAC  value :
                        // Biomass in may
            			double SSBmay = 0;
            			double tacInkg = 0;
            			for (Date dat = new Date(0); dat.before(date); dat = dat.next()) {
                            if (dat.getYear() == year & dat.getMonth().equals(Month.JUNE)){
								MatrixND matB = matResult.getMatrix(dat, param_pop, ResultName.MATRIX_BIOMASS);
								SSBmay  = matB.sumAll();
                            }
                        }

                        /** Rule B :
						*		| 0 			if SSB y-1 <= 21000t
						* TAC y =	| gamma*(SSB y-1 - Blim)/(Bpa-Blim)*SSBy-1	if 21000t < SSB y-1 < 33000t
						*		| gamma*SSB y-1 	if SSB y-1 >= 33000t
						**/
                        if(SSBmay < 21000000) {
							tacInkg = 0 ;
                        }else if(SSBmay >= 33000000){
                            tacInkg = 0.4 * SSBmay  ;
                        }else {
                            tacInkg = 0.4 * SSBmay * (SSBmay-21000000)/12000000;
                        }
                        // le tac le doit pas depasser le niveau historique
                        if (tacInkg > 33000000){
                            tacInkg = 33000000;
                        }

					double CatchFraTot = 0;
					for (Date dat = new Date(0); dat.before(date); dat = dat.next()) {
	                    if( (dat.getYear() == year & dat.getMonth().after(param_endMonth)) ||
								(firstSemester & dat.getYear() == ny) ){
							MatrixND mat = matResult.getMatrix(dat, param_pop, 
								ResultName.MATRIX_CATCH_WEIGHT_PER_STRATEGY_MET_PER_ZONE_POP);
							for(Strategy str : strategies){			
								if(!"Espagnols".equals(str.getName())){
									MatrixND Fra1 = mat.copy().getSubMatrix(0,str);
									Fra1 = Fra1.sumOverDim(0); // sum strategy
									Fra1 = Fra1.sumOverDim(1); // sum metiers
									Fra1 = Fra1.sumOverDim(2); // sum groups
									Fra1 = Fra1.sumOverDim(3); // sum zones
									Fra1 = Fra1.reduce();	 
									double CatchFra1 = Fra1.getValue(0);
									CatchFraTot += CatchFra1 ;
								}
							}	
						}
					}
										
					if (CatchFraTot >= tacInkg*0.5){
						testTAC = true ;
					}
				}
			}	// fin de test TAC
			
			
		
		
			// 1)  reccupere valeurs effort et debarquement du mois precedant -> vpue
				//a) reccupere les landings values en esp principale des metiers le mois precedent 
			if (date.getDate() != 0) {
				MatrixND valueMat = Result.getMatrix(date.previous(), ResultName.MATRIX_GROSS_VALUE_OF_LANDINGS_PER_SPECIES_PER_STRATEGY_MET);
				List<Strategy> str = (List<Strategy>)valueMat.getSemantic(0);
				//pour reccuperer les index des strategies francaises
				int comptSt = 0;
				int comptTab = 0;
				int[] elem = new int[mesStrategies.size()]; 
				for(Strategy st : str){
					if (mesStrategies.values().contains(st)){
						elem[comptTab] = comptSt;
						comptTab +=1;
					}
					comptSt += 1;	
				}
				
				MatrixND valuePerMet = valueMat.getSubMatrix(0, new ArrayList(mesStrategies.values()).toArray());

				for(Strategy strIndex : strategies){
					for(Metier metIndex : metiers){
						if(! metIndex.getName().equals("Autre")){
							Collection <TargetSpecies> target = metIndex.getMetierSeasonInfo(date.getMonth()).getSpeciesTargetSpecies();
							for(TargetSpecies sp : target){
								if(sp.getPrimaryCatch()){
									Collection <Population> pops = sp.getSpecies().getPopulation();
									double val = 0;
									for(Population pop : pops){
										val += valuePerMet.getValue(strIndex,metIndex,pop);
									}
									getMatrixVar(date.previous()).setValue(strIndex,metIndex,LVALUE,val);
								}
							}
						}
					}
				}
				System.out.print("MatrixVar "+ getMatrixVar(date.previous()));	
			}
			
			
				// b) reccupere de l effort nominal par strategy met  du mois precedant
			MatrixND EffortNominalPerStrMet_pm = 	null;
			if (date.getDate() != 0){
				EffortNominalPerStrMet_pm = Result.getMatrix(
				date.previous(),
				ResultName.MATRIX_EFFORT_NOMINAL_PER_STRATEGY_MET);
				System.out.println("EffortNominalPerStrMet_pm  "+EffortNominalPerStrMet_pm);
			}
					// Boucle sur les strategies	
			for(Strategy strIndex : strategies){
			
				// interdit de faire des set sur les strategies de la semantique de la matrice, il faut recuperer les strategies de la date courante
				Strategy str = (Strategy)context.getDB().findByTopiaId(strIndex.getTopiaId());		
				StrategyMonthInfo smi = str.getStrategyMonthInfo(date.getMonth());
				Collection<EffortDescription> strMet = str.getSetOfVessels().getPossibleMetiers() ;
				
				
				//2) eff du mois précédant 
				if (date.getDate() != 0){				
					for (EffortDescription effort : strMet){ 
						//double effortTotStr =  EffortNominalPerStrMet_pm.getSubMatrix(0,str,1).sumOverDim(1).reduce().getValue(0);
						Metier met = effort.getPossibleMetiers() ;
						double eff = EffortNominalPerStrMet_pm.getValue(str,met);
						getMatrixVar(date.previous()).setValue(str,met,EFFORT,eff);
					}
				}
			
				// 3) calcul des pourcentages d effort 
				if (date.getDate() > 0){ 
				// calcul avec les RUM des pourcentages d effort du pas de temps 		
					//  map temporaire de stoquage des valeurs de sum cum calculees pour les met de la strategie.
					Map<Metier, Double> tmp = new HashMap<Metier, Double>();
					double tot = 0;
				
					// boucle sur les met de la str
					for (EffortDescription effort : strMet){ 					
						Metier met = effort.getPossibleMetiers() ;    			
						System.out.println("Boucle metier 3, metier possible: "+met.getName());
						boolean testMPA = false;
											
						if(met.getMetierSeasonInfo(date.getMonth()).getSpeciesTargetSpecies(param_pop.getSpecies()).getPrimaryCatch() & !testTAC){
							// test MPA : 
							
							if(date.before(param_beginDateMPA)) {
								testMPA = false;
							} else if(date.after(param_endDateMPA)) {
								testMPA = false;
							} else if (date.getMonth().before(param_beginMonthMPA)) {
								testMPA = false;
							} else if (date.getMonth().after(param_endMonthMPA)) {
								testMPA = false;
							} else if (!met.getMetierSeasonInfo(date.getMonth()).getSpeciesTargetSpecies(param_pop.getSpecies()).getPrimaryCatch()){
								testMPA = false;
							}else { 
								List<Cell> cellMetiers = met.getMetierSeasonInfo(date.getMonth()).getCells();
								//System.out.println("cellMetiers "+cellMetiers);
								List<Cell> cells = param_zoneMPA.getCell();
								//System.out.println("cells "+cells);
								if(Collections.disjoint(cellMetiers, cells)){
									testMPA = false ;// result = false : la MPA ne concerne pas le mtier -> RUM
								}else{
											// MPA partielle -> RUM ou totale -> E=0 ???
											MetierSeasonInfo infoMetier = met.getMetierSeasonInfo(date.getMonth());
											int tailleZoneMetierInitiale = cellMetiers.size();
											cellMetiers.removeAll(cells);
											int tailleZoneMetierNew = cellMetiers.size();
							//System.out.println("taille de la zone restante "+tailleZoneMetierNew);
							
									if (cellMetiers.size() == 0) { // MPA totale
										testMPA =true;
									}else{ // MPA partielle
										testMPA = false;
										//System.out.println("intersection non nulle");
										ZoneDAO dao = IsisFishDAOHelper.getZoneDAO(context.getDB());            
										// Create new empty zone for cantonnement
									    String name = "ZoneCantonnement-" + metier.getName()+ "-" + date.getDate();
									    Zone zoneCantonnement = dao.findByName(name);
									    int cpt=0;
									    while (zoneCantonnement != null) {
									        cpt++;
									        zoneCantonnement = dao.findByName(name + "-" + cpt);
									    }
									    zoneCantonnement = dao.create();
									    if (cpt > 0) {
									        name += "-" + cpt;
									    }
									    zoneCantonnement.setName(name);
									            
									    // Remove prohibited zone and add not prohibited cell to zoneCantonnement
									    Collection<Zone> zoneMetiers = infoMetier.getZone();
									    for (Iterator<Zone> i=zoneMetiers.iterator(); i.hasNext();) {
									        Zone zone = i.next();
									        // copy list cell to not modify original zone
									        List<Cell> tmpCells = new ArrayList<Cell>(zone.getCell());
									        int originalSize = tmpCells.size();
									        tmpCells.removeAll(param_zoneMPA.getCell());
									        int tmpSize = tmpCells.size();
									        //System.out.println("taille new zoen"+tmpCells.size());
									        zoneCantonnement.addAllCell(tmpCells);
											//System.out.println("taille de zone cantonnement"+zoneCantonnement.getCell().size());
									        i.remove();
									    }
										//System.out.println("taille de zone cantonnement final"+zoneCantonnement.getCell().size());
										ArrayList<Zone> newZone = new ArrayList<Zone>();
										newZone.add(zoneCantonnement);
										infoMetier.setZone(newZone);
									}
								}
							}
			
						}

						if(testMPA || (testTAC & met.getMetierSeasonInfo(date.getMonth()).getSpeciesTargetSpecies(param_pop.getSpecies()).getPrimaryCatch())){
							tmp.put(met,0.0);
						}else{						
							Date previousDate = date.previous();
							MatrixND matrixVarPreviousMonth = getMatrixVar(previousDate);
							// vpue
							double val = matrixVarPreviousMonth.getValue(str,met,LVALUE);
							double eff_pm = matrixVarPreviousMonth.getValue(str,met,EFFORT);
							double Vpue = 0;
							if(eff_pm != 0 & !(met.getName().equals("Autre"))){	
								Vpue = val / eff_pm;
								System.out.println("vpue o :"+Vpue);
						    }else if(met.getName().equals("Autre")){
								Vpue = matrixVpueOthers.getValue(str,previousDate.getMonth());
							}
							// % eff moy
							//double pEffMoy = matrixPercEffMoy.getValue(str,met,date.getMonth());
							double pEffMoy = smi.getProportionMetier(met);
							// calcul
							double sumCum = pEffMoy * matrixCoeffRUM.getValue(str,EFFORT)*100
									+ Vpue * matrixCoeffRUM.getValue(str,VPUE)
									+ fuelPrice[date.getYear()] * matrixDistances.getValue(str,met,date.getMonth()) * matrixCoeffRUM.getValue(str,met,DIST);
							System.out.println("sumCum :"+sumCum);					
							tot += Math.exp(sumCum);		
							tmp.put(met,Math.exp(sumCum));
						}
					}
			
					for (EffortDescription effort : strMet){ 
						Metier met = effort.getPossibleMetiers() ;
						System.out.println("Boucle metier 4, metier possible: "+met.getName());
						double percent = 0;						
						if(tot != 0){	
							percent = tmp.get(met)/tot;
							if(percent == 0) percent = 0.000000001;
						}
						System.out.println("tmp.get(met):"+tmp.get(met)+" tot : "+tot);
						//getMatrixVar(date).setValue(str, met, EFFORT, percent); 	
						// attribution de la nouvelle prop pour le mois
						if (!context.getMetierMonitor().getForbiddenMetier().contains(met)) {
							smi.setProportionMetier(met,percent);
						System.out.println("smi set " +  smi.getProportionMetier(met));
						}
					}
				}
			}
		}
	}
	
 
    /**
     * Si la condition est vrai alors cette action est executée apres le pas
     * de temps de la simulation.
     * @param simulation La simulation pour lequel on utilise cette regle
     */
    public void postAction(SimulationContext context, Date date, Metier metier) throws Exception {
    first = true ;   
      
    }

}