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

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

/* 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 Expression {
public:
  Expression(Expression *left, Expression *right, token_type type);
  virtual ~Expression() = default;
  std::string getRepr();
  const Expression *getLeft();
  const Expression *getRight();
  virtual float eval(int arg) = 0;
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) override;
protected:
  void setRepr() override;
};

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

class Variable : public Expression {
private:
  char name;
public:
  explicit Variable(char name);
  ~Variable();
  float eval(int arg) override;
protected:
  void setRepr() override;
};

class AddExpression : public Expression {
public:
  AddExpression(Expression *left, Expression *right);
  ~AddExpression();
  float eval(int arg) override;
};

class SubExpression : public Expression {
public:
  SubExpression(Expression *left, Expression *right);
  ~SubExpression();
  float eval(int arg) override;
};

class NegationExpression : public Expression {
public:
  explicit NegationExpression(Expression *right);
  ~NegationExpression();
  float eval(int arg) override;
protected:
  void setRepr() override;
};

class DivisionExpression : public Expression {
public:
  DivisionExpression(Expression *left, Expression *right);
  ~DivisionExpression();
  float eval(int arg) override;
};

class MultiplicationExpression : public Expression {
public:
  MultiplicationExpression(Expression *left, Expression *right);
  ~MultiplicationExpression();
  float eval(int arg) override;
};

class PowerExpression : public Expression {
public:
  PowerExpression(Expression *left, Expression *right);
  ~PowerExpression();
  float eval(int arg) override;
};

#endif /* EXPRESSIONS_H */