#ifndef LEMON_SIMANN_H

#define LEMON_SIMANN_H

namespace lemon {

  const double INFTY = 1e24;

  class SimAnnBase {

  public:

    class Controller;

  private:

    Controller *controller;

  protected:

    double curr_cost;

    double prev_cost;

    double best_cost;

    virtual void mutate() = 0;

    virtual void revert() = 0;

    virtual void saveAsBest() = 0;

  public:

    SimAnnBase() {

      curr_cost = prev_cost = best_cost = INFTY;

    }

    void setController(Controller &_controller) { controller = &_controller; }

    double getBestCost() { return best_cost; }

    void run() {

      while (controller->next()) {

        mutate();

        if (controller->accept(prev_cost - curr_cost)) {

          controller->acceptEvent();

          if (curr_cost < best_cost) {

            saveAsBest();

            controller->improveEvent();

          }

        }

        else {

          revert();

          controller->rejectEvent();

        }

      }

    }

    class Controller {

    public:

      virtual void acceptEvent() {}

      virtual void improveEvent() {}

      virtual void rejectEvent() {}

      virtual bool next() = 0;

      virtual bool accept(double cost_diff) = 0;

    };

  };

  template <typename E>

  class SimAnn : public SimAnnBase {

  private:

    E *curr_ent;

    E *prev_ent;

    E *best_ent;

  public:

    SimAnn() : SimAnnBase() {}

    void setEntity(E &Ent) {

      curr_ent = new E(Ent);

      prev_ent = new E(Ent);

      best_ent = new E(Ent);

    }

    E getBestEntity() { return *best_ent; }

    void mutate() {

      *prev_ent = *curr_ent;

      prev_cost = curr_cost;

      curr_cost = curr_ent->mutate();

    }

    void revert() {

      E *tmp = curr_ent;

      curr_ent = prev_ent;

      prev_ent = tmp;

      curr_cost = prev_cost;

    }

    void saveAsBest() {

      *best_ent = *curr_ent;

      best_cost = curr_cost;

    }

  };

  class EntitySkeleton {

  public:

    // returns the new cost

    double mutate() { return 0.0; }

  };

  template <typename E>

  class SimAnn2 : public SimAnnBase {

  private:

    E *curr_ent;

    E *best_ent;

  public:

    SimAnn2() : SimAnnBase() {}

    void setEntity(E &Ent) {

      curr_ent = new E(Ent);

      best_ent = new E(Ent);

    }

    E getBestEntity() { return *best_ent; }

    void mutate() {

      curr_ent->mutate();

    }

    void revert() {

      curr_ent->revert();

    }

    void saveAsBest() {

      *best_ent = *curr_ent;

      best_cost = curr_cost;

    }

  };

  class EntitySkeleton2 {

  public:

    // returns the new cost

    double mutate() { return 0.0; }

    // restores the entity to its previous state i.e. reverts the effects of

    // the last mutate()

    void revert() {}

  };

}

#endif