#ifndef EXPRESSION_H
#define EXPRESSION_H

#include <ostream>
#include <map>
#include <string>
#include <vector>
template<typename T>
struct Expression;
#include "Operator.hpp"

template<typename T>
struct Maximum : public Operator<T> {
  const T eval(const std::vector<Expression<T> >& v, const std::map<std::string, T>& m) const {
    //assert(v.size() == 1);
    T value = -INFINITY;
    for (typename std::vector<Expression<T> >::const_iterator it = v.begin();
         it != v.end();
         ++it) {
      const T result = it->eval(m);
      value = (value < result ? result : value);
    }
    return value;
  }
  virtual std::string output() const {
    return "max";
  }
};

template<typename T>
struct Minimum : public Operator<T> {
  const T eval(const std::vector<Expression<T> >& v, const std::map<std::string, T>& m) const {
    //assert(v.size() == 1);
    T value = INFINITY;
    for (typename std::vector<Expression<T> >::const_iterator it = v.begin();
         it != v.end();
         ++it) {
      const T result = it->eval(m);
      value = (value < result ? value : result);
    }
    return value;
  }
  virtual std::string output() const {
    return "min";
  }
};


template<typename T>
struct Expression {
  Expression(unsigned int id, Operator<T>* o, const std::vector< Expression<T> >& a)
    : _id(id), _operator(o), _arguments(a) { }
  virtual const T eval(std::map<std::string, T> m) const {
    return _operator->eval(_arguments, m);
  }

  virtual Expression<T> maxStrategyEager(const std::map<std::string, T> assignment) const {
    if (dynamic_cast<Maximum<T>*>(_operator) != NULL) {
      T bestVal;
      const Expression<T>* best = NULL;
      for (typename std::vector<Expression<T> >::const_iterator it = _arguments.begin();
           it != _arguments.end();
           ++it) {
        T nextVal = it->eval(assignment);
        if (best == NULL || nextVal > bestVal) {
          best = &(*it);
          bestVal = nextVal;
        }
      }
      return best->maxStrategyEager(assignment);
    }
    std::vector<Expression<T> > newArgs;
    for (typename std::vector<Expression<T> >::const_iterator it = _arguments.begin();
         it != _arguments.end();
         ++it) {
      newArgs.push_back(it->maxStrategyEager(assignment));
    }
    return Expression(_operator, newArgs);
  }

  std::string output() const {
    std::string result = _operator->output() + "(";
    for (typename std::vector<Expression<T> >::const_iterator it = _arguments.begin();
         it != _arguments.end();
         ++it) {
      if (it != _arguments.begin()) {
        result += ", ";
      }
      result += it->output();
    }
    return result + ")";
  }

  virtual ~Expression() {}
  private:
  unsigned int _id;
  Operator<T>* _operator;
  std::vector< Expression<T> > _arguments;

  template<typename E>
  friend std::ostream& operator<<(std::ostream&, const Expression<E>&);
};

template<typename T>
std::ostream& operator<<(std::ostream& cout, const Expression<T>& e) {
  cout << e._operator->output() << "("
    << ")";
  return cout;
}

#endif