/* PIA - Lenguajes Modernos de Programación
 * FACULTAD DE CIENCIAS FÍSICO MATEMÁTICAS
 * Luis Sebastián Martínez Vega - LCC */

#ifndef EXPRESSIONS_H
#define EXPRESSIONS_H
#include <string>
#include "lexer.hpp"

/* Debido a que en eval() llamamos a la respectiva
   función trigonométrica, hay un conflicto entre
   nombres de las funciones definidas en cmath y
   los nombres definidos aquí. Por esa razón decidí
   renombrarlos con el prefijo i_ que significa
   "identifier". Esto puede ser solucionado con un
   namespace, pero es mucho pedo, así lo dejo.*/
enum trig_functions {
  i_sin,
  i_cos,
  i_tan,
  i_csc,
  i_sec,
  i_ctg
};

class Differentiator; // Forward declaration
class Simplifier;

class Expression {
public:
  Expression(Expression *left, Expression *right, token_type type);
  virtual ~Expression() = default;
  std::string getRepr();
  virtual Expression *diff(const Differentiator *d) = 0;
  template <class E>
  Expression *simplify(E *expr, const Simplifier *s);
  Expression *getLeft();
  Expression *getRight();
  virtual float eval(int arg=0) = 0;
  virtual Expression *copy() = 0; // Regresa una copia de la expresión actual.
protected:
  Expression *left;
  Expression *right;
  token_type type;
  virtual void setRepr();
  void delTree();
  std::string repr{};
};

class Literal : public Expression {
private:
  int value;
public:
  explicit Literal(int value);
  ~Literal();
  int getValue();
  float eval(int arg=0) override;
  Expression *diff(const Differentiator *d) override;
  Expression *copy() override;
protected:
  void setRepr() override;
};

class Function : public Expression {
private:
  trig_functions function_name;
  Expression *arg;
public:
  Function(Expression *arg, trig_functions name);
  ~Function();
  Expression *getArg();
  float eval(int arg=0) override;
  Expression *diff(const Differentiator *d) override;
  trig_functions getFunctionName() const;
  Expression *copy() override;
protected:
  void delTree();
  void setRepr() override;
};

class Variable : public Expression {
private:
  char name;
public:
  explicit Variable(char name);
  ~Variable();
  float eval(int arg=0) override;
  Expression *diff(const Differentiator *d) override;
  Expression *copy() override;
protected:
  void setRepr() override;
};

class AddExpression : public Expression {
public:
  AddExpression(Expression *left, Expression *right);
  ~AddExpression();
  float eval(int arg=0) override;
  Expression *diff(const Differentiator *d) override;
  Expression *copy() override;
};

class SubExpression : public Expression {
public:
  SubExpression(Expression *left, Expression *right);
  ~SubExpression();
  float eval(int arg=0) override;
  Expression *copy() override;
  Expression *diff(const Differentiator *d) override;
};

class NegationExpression : public Expression {
public:
  explicit NegationExpression(Expression *right);
  ~NegationExpression();
  float eval(int arg=0) override;
  Expression *copy() override;
  Expression *diff(const Differentiator *d) override;
protected:
  void setRepr() override;
};

class DivisionExpression : public Expression {
public:
  DivisionExpression(Expression *left, Expression *right);
  ~DivisionExpression();
  float eval(int arg=0) override;
  Expression *copy() override;
  Expression *diff(const Differentiator *d) override;
};

class MultiplicationExpression : public Expression {
public:
  MultiplicationExpression(Expression *left, Expression *right);
  ~MultiplicationExpression();
  float eval(int arg=0) override;
  Expression *copy() override;
  Expression *diff(const Differentiator *d) override;
};

class PowerExpression : public Expression {
public:
  PowerExpression(Expression *left, Expression *right);
  ~PowerExpression();
  float eval(int arg=0) override;
  Expression *copy() override;
  Expression *diff(const Differentiator *d) override;
};

#endif /* EXPRESSIONS_H */