import fr.ird.observe.entities.referential.ps.common.ObservedSystem;

 import fr.ird.observe.persistence.avdth.data.logbook.FloatingObjectReader;

 import java.util.LinkedHashSet;

 import java.util.Map;

 import java.util.Set;

     private Trip trip;

     private Route route;

     private Activity activity;

     private boolean canCreateActivity;

     public boolean isCanCreateActivity() {

         return activityPkToId;

     }

     }

     public Set<ObservedSystem> getObservedSystems() {

         return observedSystems;

     }

     }

     public void addDefaultObservedSystemOrSanitizeFloatingObjectOnes(Activity entity) {

                 if ("20".equals(observedSystem.getCode())) {

                     observedSystem20Found = true;

                 }

             }

             }

         }

     }

     public void computeCanCreateActivity() {

             // load observed systems for this activity

             Set<String> observedSystemCodes = activityReader.readObservedSystem(context, tables.activityObservedSystemTableReader, ActivityReader.getActivityPk(activityRow));

             // load activity

             Activity activity = activityWriter.intercept(activityRow, routeId, 0);

             // add default observed system (if none found) and sanitize some observed system coming from DCP

             context.addDefaultObservedSystemOrSanitizeFloatingObjectOnes(activity);

             // write activity observed systems

             activityWriter.writeObservedSystems(activity);

             // while loading Floating objects, we may have change the vessel activity of the activity

             ResultSet activityObservedSystemRow = activityObservedSystemTableReader.next();

             String avdthSystemCode = activityObservedSystemRow.getString(6);

             observedSystemCodes.add(avdthSystemCode);

                 throw new IllegalStateException(String.format("Can't find observedSystem with code: %s from ad-hoc AVDTH to ObServe mapping", avdthSystemCode));

             }

             ObservedSystem observedSystem = dataContext.getObservedSystem(observeSystemCode);

             observedSystems.add(observedSystem);

         }

      * Observed system from {@code ACT_ASSOC} which can create a Floating object.

      */

     public static final Set<String> OBSERVED_SYTEM_CODES_WITH_DCP = Set.of("20", "21", "22", "23", "24", "25", "81");

     private final MutableInt floatingObjectPartCount = new MutableInt();

     private final MutableInt transmittingBuoyCount = new MutableInt();

         VesselActivity vesselActivity = activity.getVesselActivity();

         // Avdth observed system codes associated to the current activity (need them to compute ex nihilo floating object)

         // We need to get the original vessel activity code from AVDTH (to compute some mapping)

         String vesselActivityCode = resultSet.getString(13);

         // Is the floating object can be created by the observed systems?

         // Is the current vessel activity accept to create Floating object?

         boolean vesselActivityAllowFad = vesselActivity.isAllowFad();

             // neither the buoy exist in avdth,

             // neither need to be created by observed system,

             // Do not create the floating object (no log is required here: we are on an activity with no floating object)

             return null;

         }

                 }

                 // do not create the floating object

                 return null;

             }

         if (observedSystem != null) {

             activity.addObservedSystem(observedSystem);

         }

         boolean addBuoyFromObservedSystem = addFloatingObjectMaterials(dataContext,

                                                                        resultSet,

                                                                        vesselActivityCode,

                                                                        objectTypeCode,

                                                                        objectOperation,

                                                                        entity,

                                                                        floatingObjectExistsInAvdth,

             // only add buoy if buoy type known

             entity.addTransmittingBuoy(transmittingBuoy);

         }

         return entity;

     }

                                                ResultSet resultSet,

                                                String vesselActivityCode,

                                                String objectTypeCode,

                                                ObjectOperation objectOperation,

                                                FloatingObject entity,

                                                boolean floatingObjectExistsInAvdth,

             }

         }

             // add ObjectMaterial FOB

             addObjectMaterial(vesselActivityCode, objectMaterialUsed, dataContext.getObjectMaterialFOB(), whenArriving, whenLeaving, entity);

             addDefaultObjectMaterialOnUnknownObjectType = false;

         }

             // add ObjectMaterial 2-1-1 VNLOG

             addObjectMaterial(vesselActivityCode, objectMaterialUsed, dataContext.getObjectMaterialVNLOG(), whenArriving, whenLeaving, entity);

             addDefaultObjectMaterialOnUnknownObjectType = false;

         }

             // add ObjectMaterial 2-1-1 VNLOG + 1-1 DFAD

             addObjectMaterial(vesselActivityCode, objectMaterialUsed, dataContext.getObjectMaterialVNLOG(), whenArriving, whenLeaving, entity);

             addObjectMaterial(vesselActivityCode, objectMaterialUsed, dataContext.getObjectMaterialDFAD(), whenArriving, whenLeaving, entity);

             addDefaultObjectMaterialOnUnknownObjectType = false;

             addBuoyFromObservedSystem = true;

         }

             // add ObjectMaterial 2-2 ALOG

             addObjectMaterial(vesselActivityCode, objectMaterialUsed, dataContext.getObjectMaterialALOG(), whenArriving, whenLeaving, entity);

             addDefaultObjectMaterialOnUnknownObjectType = false;

         }

             // add ObjectMaterial 1-1 DFAD

             addObjectMaterial(vesselActivityCode, objectMaterialUsed, dataContext.getObjectMaterialDFAD(), whenArriving, whenLeaving, entity);

             addDefaultObjectMaterialOnUnknownObjectType = false;

             addBuoyFromObservedSystem = true;

         }

             // add ObjectMaterial 1-2 AFAD

             addObjectMaterial(vesselActivityCode, objectMaterialUsed, dataContext.getObjectMaterialAFAD(), whenArriving, whenLeaving, entity);

             addDefaultObjectMaterialOnUnknownObjectType = false;

         }

             // add ObjectMaterial 2-1-2-1 Carrion

             addObjectMaterial(vesselActivityCode, objectMaterialUsed, dataContext.getObjectMaterialCarrion(), whenArriving, whenLeaving, entity);

             addDefaultObjectMaterialOnUnknownObjectType = false;

         return transmittingBuoy;

     }

     private void addObjectMaterial(String vesselActivityCode, Set<String> objectMaterialUsed, ObjectMaterial objectMaterial, boolean whenArriving, boolean whenLeaving, FloatingObject floatingObject) {

         if (!whenArriving && !whenLeaving) {

             throw new IllegalStateException(String.format("Can't have not whenArriving and not whenLeaving from ACTIVITE.C_OPERA: %s", vesselActivityCode));