#include <poincare/symbol.h>
  
  #include <poincare/context.h>
  #include <poincare/division.h>
  #include <poincare/multiplication.h>
  #include <poincare/parenthesis.h>
  #include <poincare/power.h>
  
  #include <poincare/layout_engine.h>
  #include "layout/char_layout.h"
  #include "layout/horizontal_layout.h"
  #include "layout/vertical_offset_layout.h"
  
  #include <ion.h>
  #include <cmath>
  
  extern "C" {
  #include <assert.h>
  }
  
  namespace Poincare {
  
  const char * Symbol::textForSpecialSymbols(char name) {
    switch (name) {
      case SpecialSymbols::Ans:
        return "ans";
      case SpecialSymbols::un:
        return "u(n)";
      case SpecialSymbols::un1:
        return "u(n+1)";
      case SpecialSymbols::vn:
        return "v(n)";
      case SpecialSymbols::vn1:
        return "v(n+1)";
      case SpecialSymbols::M0:
        return "M0";
      case SpecialSymbols::M1:
        return "M1";
      case SpecialSymbols::M2:
        return "M2";
      case SpecialSymbols::M3:
        return "M3";
      case SpecialSymbols::M4:
        return "M4";
      case SpecialSymbols::M5:
        return "M5";
      case SpecialSymbols::M6:
        return "M6";
      case SpecialSymbols::M7:
        return "M7";
      case SpecialSymbols::M8:
        return "M8";
      case SpecialSymbols::M9:
        return "M9";
      case SpecialSymbols::V1:
        return "V1";
      case SpecialSymbols::N1:
        return "N1";
      case SpecialSymbols::V2:
        return "V2";
      case SpecialSymbols::N2:
        return "N2";
      case SpecialSymbols::V3:
        return "V3";
      case SpecialSymbols::N3:
        return "N3";
      case SpecialSymbols::X1:
        return "X1";
      case SpecialSymbols::Y1:
        return "Y1";
      case SpecialSymbols::X2:
        return "X2";
      case SpecialSymbols::Y2:
        return "Y2";
      case SpecialSymbols::X3:
        return "X3";
      case SpecialSymbols::Y3:
        return "Y3";
      default:
        assert(false);
        return nullptr;
    }
  }
  
  int Symbol::getVariables(isVariableTest isVariable, char * variables) const {
   size_t variablesLength = strlen(variables);
   if (isVariable(m_name)) {
     char * currentChar = variables;
     while (*currentChar != 0) {
       if (*currentChar == m_name) {
         return variablesLength;
       }
       currentChar++;
     }
     if (variablesLength < k_maxNumberOfVariables) {
       variables[variablesLength] = m_name;
       variables[variablesLength+1] = 0;
       return variablesLength+1;
     }
     return -1;
   }
   return variablesLength;
  }
  
  Symbol::SpecialSymbols Symbol::matrixSymbol(char index) {
    switch (index - '0') {
      case 0:
        return SpecialSymbols::M0;
      case 1:
        return SpecialSymbols::M1;
      case 2:
        return SpecialSymbols::M2;
      case 3:
        return SpecialSymbols::M3;
      case 4:
        return SpecialSymbols::M4;
      case 5:
        return SpecialSymbols::M5;
      case 6:
        return SpecialSymbols::M6;
      case 7:
        return SpecialSymbols::M7;
      case 8:
        return SpecialSymbols::M8;
      case 9:
        return SpecialSymbols::M9;
      default:
        assert(false);
        return SpecialSymbols::M0;
    }
  }
  
  Symbol::Symbol(char name) :
    m_name(name)
  {
  }
  
  Symbol::Symbol(Symbol&& other) :
    m_name(other.m_name)
  {
  }
  
  Symbol::Symbol(const Symbol& other) :
    m_name(other.m_name)
  {
  }
  
  Expression * Symbol::clone() const {
    return new Symbol(m_name);
  }
  
  int Symbol::polynomialDegree(char symbol) const {
    if (m_name == symbol) {
      return 1;
    }
    return 0;
  }
  
  int Symbol::privateGetPolynomialCoefficients(char symbolName, Expression * coefficients[]) const {
    if (m_name == symbolName) {
      coefficients[0] = new Rational(0);
      coefficients[1] = new Rational(1);
      return 1;
    }
    coefficients[0] = clone();
    return 0;
  }
  
  Expression * Symbol::replaceSymbolWithExpression(char symbol, Expression * expression) {
    if (m_name == symbol) {
      Expression * value = expression->clone();
      if (parent() && value->needParenthesisWithParent(parent())) {
        value = new Parenthesis(value, false);
      }
      return replaceWith(value, true);
    }
    return this;
  }
  
  Expression::Sign Symbol::sign() const {
    /* TODO: Maybe, we will want to know that from a context given in parameter:
    if (context.expressionForSymbol(this) != nullptr) {
      return context.expressionForSymbol(this)->sign(context);
    }*/
    if (m_name == Ion::Charset::SmallPi) {
      return Sign::Positive;
    }
    if (m_name == Ion::Charset::Exponential) {
      return Sign::Positive;
    }
    return Sign::Unknown;
  }
  
  bool Symbol::isApproximate(Context & context) const {
    // TODO: so far, all symbols A to Z, M0->M9 hold an approximate values. But they should be able to hold exact values later.
    if (isScalarSymbol() || isMatrixSymbol()) {
      return true;
    }
    return false;
  }
  
  float Symbol::characteristicXRange(Context & context, AngleUnit angleUnit) const {
    if (m_name == 'x') {
      return NAN;
    }
    return 0.0;
  }
  
  bool Symbol::hasAnExactRepresentation(Context & context) const {
    // TODO: so far, no symbols can be exact but A, ..Z should be able to hold exact values later.
    return false;
  }
  
  Expression * Symbol::shallowReduce(Context& context, AngleUnit angleUnit) {
    // Do not replace symbols in expression of type: 3->A
    if (parent()->type() == Type::Store && parent()->operand(1) == this) {
      return this;
    }
    const Expression * e = context.expressionForSymbol(this);
    if (e != nullptr && hasAnExactRepresentation(context)) { // TODO: later A...Z should be replaced.
      /* The stored expression had been beautified which forces to call deepReduce. */
      return replaceWith(e->clone(), true)->deepReduce(context, angleUnit);
    }
    return this;
  }
  
  template<typename T>
  Evaluation<T> * Symbol::templatedApproximate(Context& context, AngleUnit angleUnit) const {
    if (m_name == Ion::Charset::IComplex) {
      return new Complex<T>(0.0, 1.0);
    }
    if (context.expressionForSymbol(this) != nullptr) {
      return context.expressionForSymbol(this)->privateApproximate(T(), context, angleUnit);
    }
    return new Complex<T>(Complex<T>::Undefined());
  }
  
  Expression::Type Symbol::type() const {
    return Expression::Type::Symbol;
  }
  
  char Symbol::name() const {
    return m_name;
  }
  
  ExpressionLayout * Symbol::createLayout(PrintFloat::Mode floatDisplayMode, int numberOfSignificantDigits) const {
    if (m_name == SpecialSymbols::Ans) {
      return LayoutEngine::createStringLayout("ans", 3);
    }
    if (m_name == SpecialSymbols::un) {
      return new HorizontalLayout(
          new CharLayout('u'),
          new VerticalOffsetLayout(
            new CharLayout('n'),
            VerticalOffsetLayout::Type::Subscript,
            false),
          false);
    }
    if (m_name == SpecialSymbols::un1) {
      return new HorizontalLayout(
        new CharLayout('u'),
        new VerticalOffsetLayout(
          LayoutEngine::createStringLayout("n+1", 3),
          VerticalOffsetLayout::Type::Subscript,
          false),
        false);
    }
    if (m_name == SpecialSymbols::vn) {
      return new HorizontalLayout(
          new CharLayout('v'),
          new VerticalOffsetLayout(
            new CharLayout('n'),
            VerticalOffsetLayout::Type::Subscript,
            false),
          false);
    }
    if (m_name == SpecialSymbols::vn1) {
      return new HorizontalLayout(
        new CharLayout('v'),
        new VerticalOffsetLayout(
          LayoutEngine::createStringLayout("n+1", 3),
          VerticalOffsetLayout::Type::Subscript,
          false),
        false);
    }
    if (isMatrixSymbol() || isSeriesSymbol(m_name) || isRegressionSymbol(m_name)) {
      return LayoutEngine::createStringLayout(textForSpecialSymbols(m_name), 2);
    }
    return LayoutEngine::createStringLayout(&m_name, 1);
  }
  
  int Symbol::writeTextInBuffer(char * buffer, int bufferSize, PrintFloat::Mode floatDisplayMode, int numberOfSignificantDigits) const {
    if (bufferSize == 0) {
      return -1;
    }
    if (bufferSize == 1) {
      buffer[bufferSize-1] = 0;
      return 0;
    }
    /* Special cases for all special symbols */
    if (m_name >0 && m_name < 32) {
      return strlcpy(buffer, textForSpecialSymbols(m_name), bufferSize);
    }
    buffer[0] = m_name;
    buffer[1] = 0;
    return 1;
  }
  
  bool Symbol::isMatrixSymbol() const {
    if (m_name >= (char)SpecialSymbols::M0 && m_name <= (char)SpecialSymbols::M9) {
      return true;
    }
    return false;
  }
  
  bool Symbol::isScalarSymbol() const {
    if (m_name >= 'A' && m_name <= 'Z') {
      return true;
    }
    return false;
  }
  
  bool Symbol::isVariableSymbol(char c)  {
    if (c >= 'a' && c <= 'z') {
      return true;
    }
    return false;
  }
  
  bool Symbol::isSeriesSymbol(char c) {
    if (c >= (char)SpecialSymbols::V1 && c <= (char)SpecialSymbols::N3) {
      return true;
    }
    return false;
  }
  
  bool Symbol::isRegressionSymbol(char c) {
    if (c >= (char)SpecialSymbols::X1 && c <= (char)SpecialSymbols::Y3) {
      return true;
    }
    return false;
  }
  
  int Symbol::simplificationOrderSameType(const Expression * e, bool canBeInterrupted) const {
    assert(e->type() == Expression::Type::Symbol);
    if ((uint8_t)m_name == ((uint8_t)static_cast<const Symbol *>(e)->name())) {
      return 0;
    }
    if ((uint8_t)m_name > ((uint8_t)static_cast<const Symbol *>(e)->name())) {
      return 1;
    }
    return -1;
  }
  
  }