#include <cstddef>
#include <string>
#include <cmath>
#include "include/lexer.hpp"
#include "include/expressions.hpp"

using std::string, std::to_string;

// Literal o constante.
Literal::Literal(int value) : Expression(NULL, NULL, number) {
  this->value = value;
}

Literal::~Literal() {}

void Literal::setRepr() {
  repr = to_string(value);
}

int Literal::getValue() {
  return value;
}

float Literal::eval(int arg) {
  return getValue();
}

// Función.
Function::Function(Expression *arg, trig_functions name) : Expression(NULL, NULL, function) {
  this->arg = arg;
  function_name = name;
}

Function::~Function() {
  delTree();
}

const Expression *Function::getArg() {
  return arg;
}

trig_functions Function::getFunctionName() {
  return function_name;
}

void Function::delTree() {
  delete arg;
}

float Function::eval(int arg) {
  float function_arg = this->arg->eval(arg);
  
  switch(function_name) {
  case i_sin:
    return std::sin(function_arg);
  case i_cos:
    return std::cos(function_arg);
  case i_tan:
    return std::tan(function_arg);
  case i_csc:
    return std::asin(function_arg);
  case i_sec:
    return std::acos(function_arg);
  default: // Cotangente.
    return std::atan(function_arg);
  }
}

void Function::setRepr() {
  switch(function_name) {
  case i_sin:
    repr += "sin";
    
    break;
  case i_cos:
    repr += "cos";
    
    break;
  case i_tan:
    repr += "tan";
    
    break;
  case i_csc:
    repr += "csc";
    
    break;
  case i_sec:
    repr += "sec";
    
    break;
  case i_ctg:
    repr += "ctg";
    
    break;
  }

  repr += '(';
  repr += arg->getRepr();
  repr += ')';
}

// Variable.
Variable::Variable(char name) : Expression(NULL, NULL, variable) {
  this->name = name;
  setRepr();
}

Variable::~Variable() {}

void Variable::setRepr() {
  repr = string{name};
}

float Variable::eval(int arg) {
  return arg;
}

// Suma.
AddExpression::AddExpression(Expression *left, Expression *right)
  : Expression(left, right, sum) {}

AddExpression::~AddExpression() {
  delTree();
}

float AddExpression::eval(int arg) {
  float right_val = right->eval(arg);
  float left_val = left->eval(arg);

  return right_val + left_val;
}

// Substracción.
SubExpression::SubExpression(Expression *left, Expression *right)
  : Expression(left, right, substraction) {}

SubExpression::~SubExpression() {
  delTree();
}

float SubExpression::eval(int arg) {
  float right_val = right->eval(arg);
  float left_val = left->eval(arg);

  return right_val - left_val;
}

// Negación.
NegationExpression::NegationExpression(Expression *right)
  : Expression(NULL, right, substraction) {}

NegationExpression::~NegationExpression() {
  delTree();
}

void NegationExpression::setRepr() {
  repr = "-(";
  repr += right->getRepr() + ")";
}

float NegationExpression::eval(int arg) {
  float expr_value = right->eval(arg);

  return -1 * expr_value;
}

// División.
DivisionExpression::DivisionExpression(Expression *left, Expression *right)
  : Expression(left, right, division) {}

DivisionExpression::~DivisionExpression() {
  delTree();
}

float DivisionExpression::eval(int arg) {
  float right_val = right->eval(arg);
  float left_val = left->eval(arg);

  return left_val / right_val;
}

// Multiplicación.
MultiplicationExpression::MultiplicationExpression(Expression *left,
                                                   Expression *right)
  : Expression(left, right, multiplication) {}

MultiplicationExpression::~MultiplicationExpression() {
  delTree();
}

float MultiplicationExpression::eval(int arg) {
  float right_val = right->eval(arg);
  float left_val = left->eval(arg);

  return left_val * right_val;
}

// Potencia.
PowerExpression::PowerExpression(Expression *left, Expression *right)
  : Expression(left, right, power) {}

PowerExpression::~PowerExpression() {
  delTree();
}

float PowerExpression::eval(int arg) {
  float right_val = right->eval(arg);
  float left_val = left->eval(arg);

  return std::pow(left_val, right_val);
}