/**
   * Compare the {@linkplain Entity} objects returning the desired ordering.
   *
   * @param e1 The first {@linkplain Entity} to be used in the comparison.
   * @param e2 The second {@linkplain Entity} to be used in the comparison.
   * @return -1 if e1 is less than e2; 0 if e1 and e2 are equal 1 if e2 is greater than e1
   */
  @Override
  public int compare(E e1, E e2) {
    Fitness f1 = e1.getFitness();
    Fitness f2 = e2.getFitness();

    return f1.compareTo(f2);
  }
  /**
   * After every {@link #interval} iteration, pick {@link #numberOfSentries a number of} random
   * entities from the given {@link Algorithm algorithm's} topology and compare their previous
   * fitness values with their current fitness values. An environment change is detected when the
   * difference between the previous and current fitness values are >= the specified {@link
   * #epsilon} value.
   *
   * @param algorithm used to get hold of topology of entities and number of iterations
   * @return true if a change has been detected, false otherwise
   */
  @Override
  public <A extends HasTopology & Algorithm & HasNeighbourhood> boolean detect(A algorithm) {
    if ((AbstractAlgorithm.get().getIterations() % interval == 0)
        && (AbstractAlgorithm.get().getIterations() != 0)) {
      List all = Java.List_ArrayList().f(algorithm.getTopology());

      for (int i = 0; i < numberOfSentries.getParameter(); i++) {
        // select random sentry entity
        int random = Rand.nextInt(all.size());
        StandardParticle sentry = (StandardParticle) all.get(random);

        // check for change
        // double previousFitness = sentry.getFitness().getValue();

        boolean detectedChange = false;

        if (sentry.getFitness().getClass().getName().matches("MinimisationFitness")) {
          Fitness previousFitness = sentry.getFitness();
          sentry.calculateFitness();
          Fitness currentFitness = sentry.getFitness();

          if (Math.abs(previousFitness.getValue() - currentFitness.getValue()) >= epsilon) {
            detectedChange = true;
          }
        } else if (sentry.getFitness().getClass().getName().matches("StandardMOFitness")) {
          MOFitness previousFitness = (MOFitness) sentry.getFitness();
          sentry.calculateFitness();
          MOFitness currentFitness = (MOFitness) sentry.getFitness();

          for (int k = 0; k < previousFitness.getDimension(); k++)
            if (Math.abs(
                    previousFitness.getFitness(k).getValue()
                        - currentFitness.getFitness(k).getValue())
                >= epsilon) {
              detectedChange = true;
              break;
            }
        }
        if (detectedChange) {
          System.out.println("Detected a change");
          return true;
        }

        // remove the selected element from the all list preventing it from being selected again
        all.remove(random);
      }
    }
    return false;
  }
  @Override
  public Vector get(Particle particle) {
    Vector newPos = (Vector) delegate.get(particle);

    Particle tmp = particle.getClone();
    tmp.setPosition(newPos);
    Fitness newFitness = particle.getBehaviour().getFitnessCalculator().getFitness(tmp);

    final UniformDistribution uniform = new UniformDistribution();
    Vector newPBest =
        newPos.plus(
            Vector.newBuilder()
                .repeat(newPos.size(), Real.valueOf(1.0))
                .build()
                .multiply(
                    new P1<Number>() {
                      @Override
                      public Number _1() {
                        return uniform.getRandomNumber(
                            -granularity.getParameter(), granularity.getParameter());
                      }
                    }));
    tmp.setPosition(newPos);
    Fitness newPBestFitness = particle.getBehaviour().getFitnessCalculator().getFitness(tmp);

    if (newPBestFitness.compareTo(newFitness) < 0) {
      Vector tmpVector = Vector.copyOf(newPos);
      newPos = newPBest;
      newPBest = tmpVector;

      newPBestFitness = newFitness;
    }

    double dot =
        ((Vector) particle.getNeighbourhoodBest().getBestPosition())
            .subtract(newPos)
            .dot(newPBest.subtract(newPos));

    if (dot < 0) {
      return (Vector) particle.getPosition();
    }

    particle.put(Property.BEST_POSITION, newPBest);
    particle.put(Property.BEST_FITNESS, newPBestFitness);

    return newPos;
  }