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 org.nuiton.util.*;
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.TimeStep;
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
 *en fonction des VPUE de l'espece cible realisees sur les metiers le mois 
 *precedant, du % d'effort moyen pass
 *et de la distance
 * on a donc 3 coefficients par flottille
 * ATTENTION ce code est valable si un metier n est pratiqu
 */
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 TimeStep param_beginDateTAC = new TimeStep(300);
    public TimeStep param_endDateTAC = new TimeStep(500);
    public double param_tacInkg = 13200000;
	
    public Zone param_zoneMPA = null;
    public TimeStep param_beginDateMPA = new TimeStep(300); 
    public TimeStep param_endDateMPA = new TimeStep(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";

	//String path = "/home1/caparmor/slehuta/";
	//path matrix of coefficients of rum
	/*String param_nomfichier_coeffRUM = "/home1/caparmor/slehuta/Inputs_Anchois/RUMconditionnelMultiSp/CoeffRum.csv";
	// path effort moyen /home1/caparmor/slehuta/Inputs_Anchois/RUMconditionnelMultiSp
	String param_nomfichier_effMoy0 = "/home1/caparmor/slehuta/Inputs_Anchois/RUMconditionnelMultiSp/EffMoy0.csv";
	String param_nomfichier_effMoy1 = "/home1/caparmor/slehuta/Inputs_Anchois/RUMconditionnelMultiSp/EffMoy1.csv";
	String param_nomfichier_effMoy2 = "/home1/caparmor/slehuta/Inputs_Anchois/RUMconditionnelMultiSp/EffMoy2.csv";
	String param_nomfichier_effMoy3 = "/home1/caparmor/slehuta/Inputs_Anchois/RUMconditionnelMultiSp/EffMoy3.csv";
	
	// path matrix of vpue met other
	String param_nomfichier_vpueOthers = "/home1/caparmor/slehuta/Inputs_Anchois/RUMconditionnelMultiSp/VpueOthers.csv";
    //path of distances
	String param_nomfichier_distances0 = "/home1/caparmor/slehuta/Inputs_Anchois/RUMconditionnelMultiSp/Distances0.csv";
	String param_nomfichier_distances1 = "/home1/caparmor/slehuta/Inputs_Anchois/RUMconditionnelMultiSp/Distances1.csv";
	String param_nomfichier_distances2 = "/home1/caparmor/slehuta/Inputs_Anchois/RUMconditionnelMultiSp/Distances2.csv";
    String param_nomfichier_distances3 = "/home1/caparmor/slehuta/Inputs_Anchois/RUMconditionnelMultiSp/Distances3.csv";
*/
	String param_nomfichier_coeffRUM = "Inputs_Anchois/RUMconditionnelMultiSp/CoeffRum.csv";
	// path effort moyen /home1/caparmor/slehuta/Inputs_Anchois/RUMconditionnelMultiSp
	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"); 
    }
 
  

  /**
     * Appel
     * 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 ';'");
    	} 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 TimeStep(0));		
		List<Strategy> allStrategies = siMatrix.getStrategies(new TimeStep(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"));
		
		// System.out.println("strNous : "+strNous);
		
////////////////////////

	
	
	//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);	

		if(context.getSimulationStorage().getParameter().getUseSimulationPlan()){
		double p1= Double.parseDouble(context.getSimulationStorage().getParameter().getTagValue().get("coefvpuepel1")); 
		double p2 = Double.parseDouble(context.getSimulationStorage().getParameter().getTagValue().get("coefvpuepel2"));
		double b1 = Double.parseDouble(context.getSimulationStorage().getParameter().getTagValue().get("coefvpuebol1"));
		double b2 = Double.parseDouble(context.getSimulationStorage().getParameter().getTagValue().get("coefvpuebol2"));
		matrixCoeffRUM.setValue(mesStrategies.get("PelProfil1"),VPUE,p1);
		matrixCoeffRUM.setValue(mesStrategies.get("PelProfil2"),VPUE,p2);
		matrixCoeffRUM.setValue(mesStrategies.get("BolBasques"),VPUE,b1);
		matrixCoeffRUM.setValue(mesStrategies.get("BolBretons"),VPUE,b2);
		double ep1 = Double.parseDouble(context.getSimulationStorage().getParameter().getTagValue().get("coefeffpel1")); 
		double ep2 = Double.parseDouble(context.getSimulationStorage().getParameter().getTagValue().get("coefeffpel2"));
		double eb1 = Double.parseDouble(context.getSimulationStorage().getParameter().getTagValue().get("coefeffbol1"));
		double eb2 = Double.parseDouble(context.getSimulationStorage().getParameter().getTagValue().get("coefeffbol2"));
		matrixCoeffRUM.setValue(mesStrategies.get("PelProfil1"),EFFORT,ep1);
		matrixCoeffRUM.setValue(mesStrategies.get("PelProfil2"),EFFORT,ep2);
		matrixCoeffRUM.setValue(mesStrategies.get("BolBasques"),EFFORT,eb1);
		matrixCoeffRUM.setValue(mesStrategies.get("BolBretons"),EFFORT,eb2);}

		

	//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});
		//System.out.println("matdistance :"+matDistances0 + matDistances1 + matDistances2+matDistances3);
		//// 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
		String fp = context.getSimulationStorage().getParameter().getTagValue().get("fuelPrice");
       	//fuelPrice = StringUtil.toArrayDouble(fp.split(";"));
		//System.out.println("fuel price :" + fuelPrice);
		if(param_fuelPrice == 0){
			double [] fuelP = {0.27,0.25,0.235,0.2405,0.238};
			fuelPrice = fuelP;
		}else{ 
		double [] fuelP = {0,0,0,0,0,0};
		fuelPrice = fuelP;
		}
		
	}// fin de init		
	
	// all matrix var
	protected Map<TimeStep, MatrixND> allMatrixVar = new HashMap<TimeStep, MatrixND>();
		protected MatrixND getMatrixVar(TimeStep 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, TimeStep date, Metier metier) throws Exception {
        boolean result = true ;
        return result;
    }

	
	/**
     * Si la condition est vrai alors cette action est execut
     * de temps de la simulation.
     * @param simulation La simulation pour lequel on utilise cette regle
     */
	
    boolean first = true ;
	public void preAction(SimulationContext context, TimeStep date, Metier metier) throws Exception {
	
		// la preaction 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;
			
			// est ce que la biomasse est > 24000t			
				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 (TimeStep dat = new TimeStep(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();
                            }
                        }

			
			if(SSBmay < 24000000){testTAC = true;
			}else {
		
			
			
			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.getPrimaryCatch() ) {			
				
                        /** Rule E :
						*		| 0 			if SSB y-1 <= 24000t
						* TAC y =	| gamma*(SSB y-1) 	if 24000t < SSB y-1 < 33000t
						*		| gamma*SSB y-1 	if SSB y-1 >= 33000t
						**/
                        if(SSBmay < 24000000) {
							tacInkg = 0 ;
                        }else if(SSBmay >= 33000000){
                            tacInkg = 0.4 * SSBmay  ;
                        }else {
                            tacInkg = 7000000;
                        }
                        // le tac le doit pas depasser le niveau historique
                        if (tacInkg > 33000000){
                            tacInkg = 33000000;
                        }

					double CatchFraTot = 0;
					for (TimeStep dat = new TimeStep(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.4){
						testTAC = true ;
					}
				//}
			}	// fin de test TAC
			}
			//System.out.println("testTac  "+testTAC);
		
		
			// 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.getStep() != 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, elem);
//System.out.println("valueper met : "+ valuePerMet);
				for(Strategy strIndex : strategies){ // boucle sur les str francaises
				Strategy strCourante = (Strategy)context.getDB().findByTopiaId(strIndex.getTopiaId());
				Collection<EffortDescription> strMet = strCourante.getSetOfVessels().getPossibleMetiers() ;
					for(EffortDescription effort : strMet){
					Metier metIndex = effort.getPossibleMetiers();
						if(! metIndex.getName().equals("Autre")){
							Collection <TargetSpecies> target = metIndex.getMetierSeasonInfo(date.getMonth()).getSpeciesTargetSpecies();
							for(TargetSpecies sp : target){
								if(sp.getPrimaryCatch()){
									//System.out.println("Metier : "+metIndex.getName()+" espece cible princ :"+sp.getSpecies().getName());
									Collection <Population> pops = sp.getSpecies().getPopulation();
									double val = 0;
									for(Population pop : pops){
										val += valuePerMet.getValue(strCourante,metIndex,pop);
									}
									getMatrixVar(date.previous()).setValue(strCourante,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.getStep() != 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 
				if (date.getStep() != 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.getStep() > 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.getStep();
									    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);
									}
								}
							}
			
						}
//System.out.println("testMPA :"+testMPA);
						if(testMPA || (testTAC & met.getMetierSeasonInfo(date.getMonth()).getSpeciesTargetSpecies(param_pop.getSpecies()).getPrimaryCatch()) 
									|| context.getMetierMonitor().getForbiddenMetier().contains(met)){
									
							tmp.put(met,0.000000001);
							//System.out.println("tac ou mpa effort nul");
						}else{						
							TimeStep previousDate = date.previous();
							MatrixND matrixVarPreviousMonth = getMatrixVar(previousDate);
							// vpue
							double val = matrixVarPreviousMonth.getValue(str,met,LVALUE);
							double eff_pm = matrixVarPreviousMonth.getValue(str,met,EFFORT);
							//System.out.println("met : "+met.getName()+" lvalue ="+val+"effort ="+eff_pm);
							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
							/*System.out.println(str.getName()+met.getName()+"=pEffMoy:"+pEffMoy);
							System.out.println("CoeffRUMEFFORT:"+matrixCoeffRUM.getValue(str,EFFORT)+";Vpue:"+Vpue);
							System.out.println("CoeffRUMVPUE:"+matrixCoeffRUM.getValue(str,VPUE));
							System.out.println("dat annee" + date.getYear());
							System.out.println("fuelPrice:"+fuelPrice[0]);
							System.out.println("Distances:"+matrixDistances.getValue(str,met,date.getMonth()));
							System.out.println("CoeffRUMDIST:"+matrixCoeffRUM.getValue(str,DIST));*/
					
							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,DIST);
							//System.out.println("sumCum :"+sumCum);					
							tot += Math.exp(sumCum);		
							tmp.put(met,Math.exp(sumCum));
									System.out.println("attrac:"+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("percent met :"+ str.getName()+met.getName() + percent);
						}
						
						//getMatrixVar(date).setValue(str, met, EFFORT, percent); 	
						// attribution de la nouvelle prop pour le mois
					
							smi.setProportionMetier(met,percent);
						//System.out.println("smi set " +  smi.getProportionMetier(met));
						
					}
				}
			}
		}
	}
	
 
    /**
     * Si la condition est vrai alors cette action est execut
     * de temps de la simulation.
     * @param simulation La simulation pour lequel on utilise cette regle
     */
    public void postAction(SimulationContext context, TimeStep date, Metier metier) throws Exception {
    first = true ;   
      
    }

}