Shaping Recycling Logistics

Set<Long> existingWpIds = new HashSet<>();

if(JOB_TYPE_DELIVERY.equalsIgnoreCase(jobType)) {
  existingWpIds.addAll(crmService.getDeliveryRepository().findAllWpIdsByProgram(program));
} else if(JOB_TYPE_COLLECTION.equalsIgnoreCase(jobType) || JOB_TYPE_BIN.equalsIgnoreCase(jobType)
                                                        || JOB_TYPE_PALLET.equalsIgnoreCase(jobType)) {
  existingWpIds.addAll(crmService.getCollectionRepository().findAllWpIdsByProgram(program));
}
/* ... Later in the processing loop ... */
if(existingWpIds.contains(wpId)) {
  problems.add("Duplicate entry found for wpId: " + wpId);
  hasProblem = true;
}

@Service
public class PackDistributionService {
  /* Defines a "cost" for each pack size, influencing the optimisation. */
  /* Lower cost implies higher preference in the distribution. */
  private int getPackCost(int boxQuantity) {
      if(boxQuantity == 3) return 2;  /* Base unit, efficient. */
      if(boxQuantity == 6) return 3;  /* More efficient than two 3-packs (2*2=4), encouraging its use. */
      if(boxQuantity == 5) return 3;  /* Less preferred for certain combinations. */
      if(boxQuantity == 2) return 6;  /* Less efficient. */
      if(boxQuantity == 1) return 10; /* Least efficient. */
      if(boxQuantity == 4) return 7;  /* More efficient than two 2-packs. */
      return Integer.MAX_VALUE;       /* Should not happen for valid pack sizes. */
  }

  /**
   ,* Distributes a total number of boxes into an optimal combination of pack sizes,
   ,* prioritising based on a defined scoring system.
   ,*
   ,* @param totalBoxes The total number of boxes to distribute.
   ,* @param availablePackSizes A list of all available PackSize entities.
   ,* @return A Map where keys are PackSize entities and values are the quantity of that pack size.
   ,*/
  public Map<PackSize, Integer> distributePacks(int totalBoxes, List<PackSize> availablePackSizes) {
    /* Sort pack sizes by box quantity in ascending order for DP. */
    availablePackSizes.sort((ps1, ps2) -> Integer.compare(ps1.getBoxQuantity(), ps2.getBoxQuantity()));
    /* dp[i] stores a SimpleEntry: key = min_total_cost, value = min_num_packs. */
    SimpleEntry<Integer, Integer>[] dp = new SimpleEntry[totalBoxes + 1];
    /* parent[i] stores the PackSize used to reach 'i' boxes from a previous state. */
    PackSize[] parent = new PackSize[totalBoxes + 1];

    /* Initialise dp array. */
    for(int i = 1; i <= totalBoxes; i++) {
      dp[i] = new SimpleEntry<>(Integer.MAX_VALUE, Integer.MAX_VALUE); /* Max cost, Max packs. */
    }

    dp[0] = new SimpleEntry<>(0, 0); /* 0 cost, 0 packs for 0 boxes. */

    for(int i = 1; i <= totalBoxes; i++) {
      for(PackSize packSize : availablePackSizes) {
        int currentPackBoxQty = packSize.getBoxQuantity();
        int currentPackCost = getPackCost(currentPackBoxQty);
        if(currentPackBoxQty <= i) {
          SimpleEntry<Integer, Integer> prevDp = dp[i - currentPackBoxQty];
          if(prevDp.getKey() != Integer.MAX_VALUE) { /* Check if previous state is reachable. */
            int newTotalCost = prevDp.getKey() + currentPackCost;
            int newNumPacks = prevDp.getValue() + 1;
            /* Prioritise lower total cost, then fewer packs. */
            if(newTotalCost < dp[i].getKey() || (newTotalCost == dp[i].getKey() && newNumPacks < dp[i].getValue())) {
              dp[i] = new SimpleEntry<>(newTotalCost, newNumPacks);
              parent[i] = packSize;
            }
          }
        }
      }
    }

    Map<PackSize, Integer> result = new HashMap<>();
    int currentBoxes = totalBoxes;
    /* Check if a solution was found. */
    if(dp[totalBoxes].getKey() == Integer.MAX_VALUE) {
        LOGGER.warning("No exact distribution found for " + totalBoxes + " boxes with available pack sizes.");
        return result;
    }

    while(currentBoxes > 0 && parent[currentBoxes] != null) {
      PackSize usedPack = parent[currentBoxes];
      result.put(usedPack, result.getOrDefault(usedPack, 0) + 1);
      currentBoxes -= usedPack.getBoxQuantity();
    }

    if(currentBoxes != 0) {
      LOGGER.warning("Could not perfectly reconstruct distribution for " + totalBoxes + " boxes. Remaining: " + currentBoxes);
      if (currentBoxes > 0 && !availablePackSizes.isEmpty()) {
        PackSize smallestPack = availablePackSizes.stream()
                                    .min((ps1, ps2) -> Integer.compare(ps1.getBoxQuantity(),
                                                                          ps2.getBoxQuantity()))
                                    .orElse(null);

        if(smallestPack != null) {
          result.put(smallestPack, result.getOrDefault(smallestPack, 0) +
                     (currentBoxes + smallestPack.getBoxQuantity() - 1) /
                     smallestPack.getBoxQuantity());
        }
      }
    }
    return result;
  }
}