#ifndef OPERATOR_HPP
#define OPERATOR_HPP

#include <vector>

template<typename Domain>
struct Operator {
  virtual ~Operator() { }

  virtual Domain eval(const std::vector<Domain>&) const = 0;

  virtual void print(std::ostream&) const = 0;
};

template<typename Domain>
struct Maximum : public Operator<Domain> {
  virtual Domain eval(const std::vector<Domain>& arguments) const {
    Domain result = -infinity<Domain>();
    for (typename std::vector<Domain>::const_iterator it = arguments.begin();
         it != arguments.end();
         ++it) {
      result = (result < *it ? *it : result);
    }
    return result;
  }
  void print(std::ostream& cout) const {
    cout << "max";
  }
};

template<typename Domain>
struct Minimum : public Operator<Domain> {
  virtual Domain eval(const std::vector<Domain>& arguments) const {
    Domain result = infinity<Domain>();
    for (typename std::vector<Domain>::const_iterator it = arguments.begin();
         it != arguments.end();
         ++it) {
      result = (*it < result ? *it : result);
    }
    return result;
  }
  void print(std::ostream& cout) const {
    cout << "min";
  }
};

template<typename Domain>
struct Negation : public Operator<Domain> {
  virtual Domain eval(const std::vector<Domain>& arguments) const {
    if (arguments.size() > 1)
      throw "Too many arguments to a negation.";
    return -arguments[0];
  }
  void print(std::ostream& cout) const {
    cout << "-";
  }
};

template<typename Domain>
struct Addition : public Operator<Domain> {
  virtual Domain eval(const std::vector<Domain>& arguments) const {
    Domain result = 0;
    for (typename std::vector<Domain>::const_iterator it = arguments.begin();
         it != arguments.end();
         ++it) {
      result += *it;
    }
    return result;
  }
  void print(std::ostream& cout) const {
    cout << "add";
  }
};

template<typename Domain>
struct Subtraction : public Operator<Domain> {
  virtual Domain eval(const std::vector<Domain>& arguments) const {
    Domain result = 0;
    for (typename std::vector<Domain>::const_iterator it = arguments.begin();
         it != arguments.end();
         ++it) {
      if (it == arguments.begin())
        result = *it;
      else
        result -= *it;
    }
    return result;
  }
  void print(std::ostream& cout) const {
    cout << "sub";
  }
};

template<typename Domain>
struct Multiplication : public Operator<Domain> {
  virtual Domain eval(const std::vector<Domain>& arguments) const {
    Domain result = 1;
    for (auto it = arguments.begin(),
           end = arguments.end();
         it != end;
         ++it) {
      result *= *it;
    }
    return result;
  }
  void print(std::ostream& cout) const {
    cout << "mult";
  }
};

template<typename Domain>
struct Comma : public Operator<Domain> {
  virtual Domain eval(const std::vector<Domain>& arguments) const {
    if (arguments[0] == -infinity<Domain>()) {
      return -infinity<Domain>();
    }
    return arguments[1];
  }
  void print(std::ostream& cout) const {
    cout << "comma";
  }
};

template<typename Domain>
struct Guard : public Operator<Domain> {
  virtual Domain eval(const std::vector<Domain>& arguments) const {
    Domain result = arguments[2];
    if (arguments[0] < arguments[1]) {
      result = -infinity<Domain>();
    }
    return result;
  }
  void print(std::ostream& cout) const {
    cout << "guard";
  }
};

/*#include "TemplateConstraintMatrix.hpp"

template<typename Domain>
struct MinimumCostFlow : public Operator<Domain> {
  MinimumCostFlow() {
  }
  Domain solve(const Domain& d) const {
  
  }
  virtual Domain eval(const std::vector<Domain>& arguments) const {
    if (arguments.size() != 1)
      throw "Incorrect number of arguments.";
    return solve(arguments[0]);
  }
  void print(std::ostream& cout) const {
    cout << "minCostFlow";
  }
private:
  TemplateConstraintMatrix& constraint; // T
  std::vector<Domain> guard; // c
  std::vector<std::vector<Domain>> multiplication; //A
  unsigned int row;
};*/

template<typename T>
std::ostream& operator<<(std::ostream& cout, const Operator<T>& op) {
  op.print(cout);
  return cout;
}

#endif