#ifndef FIXPOINT_ALGORITHM_HPP
#define FIXPOINT_ALGORITHM_HPP

#include "IdSet.hpp"
#include "IdMap.hpp"
#include "VariableAssignment.hpp"
#include "EquationSystem.hpp"

template<typename Domain>
struct FixpointAlgorithm {
  virtual ~FixpointAlgorithm() { }
  virtual VariableAssignment<Domain>* maxFixpoint(const EquationSystem<Domain>&) const = 0;
};

template<typename Domain>
struct NaiveFixpointAlgorithm : public FixpointAlgorithm<Domain> {
  virtual VariableAssignment<Domain>* maxFixpoint(const EquationSystem<Domain>& system) const {
    VariableAssignment<Domain>* rho = NULL;
    VariableAssignment<Domain>* result = system.assignment(infinity<Domain>());
    do {
      if (rho) delete rho;
      rho = result;
      result = system.eval(*rho);
    } while (!system.equalAssignments(*rho, *result));
    if (rho) delete rho;
    return result;
  }
};

template<typename Domain>
struct SmartFixpointAlgorithm : public FixpointAlgorithm<Domain> {
  struct DynamicVariableAssignment : public VariableAssignment<Domain> {
    DynamicVariableAssignment(const EquationSystem<Domain>& system)
      : _system(system),
        _evaluating(NULL),
        _values(system.variableCount(), -infinity<Domain>()),
        _stable(system.variableCount()),
        _haveValue(system.variableCount()),
        _influence(system.variableCount(), IdSet<Variable<Domain> >(system.variableCount())),
        _id(0) { }

    const Domain& operator[](const Variable<Domain>& var) const {
      _id++;
      solve(var);
      for (unsigned int i = 0; i < _id; ++i) {
        std::cout << "  ";
      }
      std::cout << "operator[] " << var.name() << " => " << _values[var] << std::endl;
      _id--;
      if (_evaluating) {
        _influence[var].insert(*_evaluating);
      }
      return _values[var];
    }

    private:
    void solve(const Variable<Domain>& x) const {
      if (!_stable.contains(x)) {
        _stable.insert(x);
        for (unsigned int i = 0; i < _id; ++i) {
          std::cout << "  ";
        }
        std::cout << "solve(" << x.name() << ") " << &x << " " << _evaluating << std::endl;
        std::cout << _stable << std::endl;

        const Variable<Domain>* oldEval = _evaluating;
        _evaluating = &x;
        Domain val = _system[x]->eval(*this);
        _evaluating = oldEval;

        if (val != _values[x]) {
          IdSet<Variable<Domain> > oldInfluence = _influence[x];
          _influence[x].clear();
          _values[x] = val;

          _stable.filter(oldInfluence);

          for (typename IdSet<Variable<Domain> >::iterator it = oldInfluence.begin();
               it != oldInfluence.end();
               ++it) {
            solve(_system.variable(*it));
          }
        }
      }
    }

    const EquationSystem<Domain>& _system;
    mutable const Variable<Domain>* _evaluating;
    mutable IdMap<Variable<Domain>,Domain> _values;
    mutable IdSet<Variable<Domain> > _stable;
    mutable IdSet<Variable<Domain> > _haveValue;
    mutable IdMap<Variable<Domain>,IdSet<Variable<Domain> > > _influence;
    mutable unsigned int _id;
  };

  virtual VariableAssignment<Domain>* maxFixpoint(const EquationSystem<Domain>& system) const {
    return new DynamicVariableAssignment(system);
  }
};

#endif