import fr.ird.t3.entities.reference.SpeciesTopiaDao;

 import fr.ird.t3.entities.reference.WeightCategories;

 import fr.ird.t3.entities.reference.WeightCategorySample;

 import fr.ird.t3.services.DecoratorService;

 import fr.ird.t3.services.ioc.InjectDAO;

 import org.apache.commons.logging.Log;

 import org.nuiton.util.TimeLog;

 import java.util.Collection;

 import java.util.HashMap;

 import java.util.HashSet;

 import java.util.Map;

 import static org.nuiton.i18n.I18n.l;

 /**

  *

  * @author Tony Chemit - dev@tchemit.fr

  * @since 1.0

     private LengthWeightConversionTopiaDao lengthWeightConversionDAO;

     @InjectDAO(entityType = SetSpeciesFrequency.class)

     private SetSpeciesFrequencyTopiaDao setSpeciesFrequencyDAO;

     private LengthWeightConversionHelper conversionHelper;

     public ExtrapolateSampleWeightToSetAction() {

         super(Level1Step.EXTRAPOLATE_SAMPLE_WEIGHT_TO_SET);

     }

     public int getNbTreatedSets() {

         return nbTreatedSets;

     }

         this.nbTreatedSets = nbTreatedSets;

     }

     public float getNbTreatedFishesInSamples() {

         return nbTreatedFishesInSamples;

     }

         this.nbTreatedFishesInSamples = nbTreatedFishesInSamples;

     }

     public float getNbCreatedFishesInSetSpeciesFrequency() {

         return nbCreatedFishesInSetSpeciesFrequency;

     }

     @Override

     protected void prepareAction() throws Exception {

         super.prepareAction();

         conversionHelper = lengthWeightConversionDAO.newConversionHelper();

     }

     private void doExecuteTrip(Trip trip, Collection<Sample> samples) {

         incrementsProgression();

         Set<Activity> tripActivities = new HashSet<>();

         // extrapolate for each sample set number to set

         for (Sample sample : samples) {

             long s0 = TimeLog.getTime();

             incrementsProgression();

             float nb = sample.getTotalStandardiseSampleSpeciesFrequencyNumber();

             addInfoMessage(l(locale, "t3.level1.extrapolateSampleWeightToSet.sample.nbFishes", sampleStr, nb));

             nbTreatedFishesInSamples += nb;

             for (SampleSet sampleSet : sample.getSampleSet()) {

                 Activity activity = sampleSet.getActivity();

                 boolean added = tripActivities.add(activity);

                 if (added) {

                     // remove all stuff from activity

     }

     /**

      * <ul>

      * <li>his total weight</<li>

      * <li>his weight of -10Kg category</<li>

      *

      * @param sampleWellStr           sampleSet decorate value

      * @param setWeight               the sampleSet weight computed

      * @param useRfMinus10AndRfPlus10 flag to try to use rf-10 and rf+10

      * @return the computed rf context for the given sample set

      */

         float pondt = setWeight.getTotalWeight();

         Float pondp = setWeight.getPlus10Weight();

         Float pondm = setWeight.getMinus10Weight();

         // compute rftot

         float rftot = pondt / pdecht;

         // compute rfMinus10

         Float rfMinus10 = null;

         if (pdechm != null && pdechm > 0 && pondm != null) {

             rfMinus10 = pondm / pdechm;

         }

         // compute rfPlus10

         Float rfPlus10 = null;

         if (pdechp != null && pdechp > 0 && pondp != null) {

             rfPlus10 = pondp / pdechp;

                 rfMinus10Status = RfUsageStatus.REJECTED_RF_NOT_DEFINED;

             } else {

                 int rfMinus10MinNumber = getConfiguration().getRfMinus10MinNumber();

                 if (Math.abs(rfMinus10) < 0.001f) {

                     addWarningMessage(l(locale, "t3.level1.extrapolateSampleWeightToSet.warning.rfMinus10.too.low",

                             sampleWellStr, rfMinus10, rftot));

                 rfPlus10Status = RfUsageStatus.REJECTED_RF_NOT_DEFINED;

             } else {

                 int rfPlus10MinNumber = getConfiguration().getRfPlus10MinNumber();

                 if (Math.abs(rfPlus10) < 0.001f) {

                     addWarningMessage(l(locale, "t3.level1.extrapolateSampleWeightToSet.warning.rfPlus10.too.low",

                             sampleWellStr, rfPlus10, rftot));

     }

     /**

      *

      * @return the universe of length class limits computed indexed by species

      */

         // for each of those species, found the length class which matches a weight > 10Kg

         Map<Species, Integer> result = new HashMap<>();

         for (Species specie : species) {

             if (conversion != null) {

                 // only add conversion for species if found

                 result.put(specie, lengthClass);

             }

         }

         return result;

     }

     /**

      * This object contains the sample weights (-10,+10 and total) for sample well.

      * <ul>

      */

     protected static class SampleWellSampleWeight {

         Float minus10Weight;

         Float plus10Weight;

         /** Number of fishes for length class > -10Kg. */

         private Float plus10Number;

     }

     /**

      * <ul>

      * <li>{@link #getMinus10Weight()} is legacy {@code pondm}</li>

      * <li>{@link #getPlus10Weight()}} is legacy {@code pondp}</li>

      */

     protected static class SampleWellSetWeight {

         Float totalWeight;

         Float minus10Weight;

         Float plus10Weight;

         protected static SampleWellSetWeight create(Float totalWeight, Float minus10Weight, Float plus10Weight) {

  */

 public class LengthWeightConversionHelper {

     private final Map<String, LengthWeightConversion> lengthWeightConversions;

     private final Map<String, Integer> lengthClassMap;

     private final ConversionContext conversionContext;

     LengthWeightConversionHelper(LengthWeightConversionTopiaDao dao, Ocean ocean, int sex, Date date) {

         this.dao = dao;

         this.conversionContext = new ConversionContext(ocean, sex, date);

     }

     LengthWeightConversionHelper(LengthWeightConversionTopiaDao dao) {

         this.dao = dao;

         this.conversionContext = null;

     }

     private <W extends WeightCategory> W getNextCategory(LengthWeightConversion conversion, int lengthClass, Iterator<W> itr) {

             } else {

                 // get max lengthClass

                 if (nextLengthClass < lengthClass) {

         return result;

     }

         Map<Integer, W> result = new TreeMap<>();

         W currentWeightCategory = null;

         int currentMaxLengthClass = -1;

             if (currentWeightCategory == null) {

                 // get the correct weight category

                 currentWeightCategory = getNextCategory(conversion, lengthClass, itr);

             }

             result.put(lengthClass, currentWeightCategory);

         }

     }

     /**

      * <p/>

      * If not found, then load it from db.

      *

      * @param sex     sex to use

      * @param date    min date to use

      * @return convertor found

      */

     public LengthWeightConversion getConversions(Species species, Ocean ocean, int sex, Date date) {

         if (result == null && !lengthWeightConversions.containsKey(key)) {

             // load it from db

             result = dao.findLengthWeightConversion(species, ocean, 0, date);

     }

     /**

      * <p/>

      * If not found, then load it from db.

      *

      * @param species species to use

      * @return convertor found

      */

     public LengthWeightConversion getConversions(Species species) {

         Objects.requireNonNull(conversionContext,

         LengthWeightConversion result;

         String key = species.getCode() + conversionContext.getKey();

         result = lengthWeightConversions.get(key);

         }

         return result;

     }

         Integer result = lengthClassMap.get(key);

         if (result == null) {

             // load it once for all

             // store it once for all

             lengthClassMap.put(key, result);

             log.info(String.format("Cache lengthClassMap [%d] for %s", lengthClassMap.size(), key));

                     Assert.assertFalse(allCategories.isEmpty());

                     for (WeightCategoryTreatment category : allCategories) {

                     }

                     Range<Integer> open = Range.open(0, 1000);