#include <poincare/logarithm.h>
#include "layout/horizontal_layout.h"
#include "layout/vertical_offset_layout.h"
#include <poincare/addition.h>
#include <poincare/approximation_engine.h>
#include <poincare/arithmetic.h>
#include <poincare/division.h>
#include <poincare/multiplication.h>
#include <poincare/naperian_logarithm.h>
#include <poincare/power.h>
#include <poincare/rational.h>
#include <poincare/simplification_engine.h>
#include <poincare/symbol.h>
#include <poincare/undefined.h>
#include <cmath>
#include <ion.h>
extern "C" {
#include <assert.h>
#include <stdlib.h>
}

namespace Poincare {

Expression::Type Logarithm::type() const {
  return Type::Logarithm;
}

Expression * Logarithm::clone() const {
  return new Logarithm(operands(), numberOfOperands(), true);
}

template<typename T>
std::complex<T> Logarithm::computeOnComplex(const std::complex<T> c, AngleUnit angleUnit) {
  /* log has a branch cut on ]-inf, 0]: it is then multivalued on this cut. We
   * followed the convention chosen by the lib c++ of llvm on ]-inf+0i, 0+0i]
   * (warning: log takes the other side of the cut values on ]-inf-0i, 0-0i]). */
  return std::log10(c);
}

Expression * Logarithm::simpleShallowReduce(Context & context, AngleUnit angleUnit) {
  Expression * op = editableOperand(0);
  // log(x,x)->1
  if (numberOfOperands() == 2 && op->isIdenticalTo(operand(1))) {
    return replaceWith(new Rational(1), true);
  }
  if (op->type() == Type::Rational) {
    const Rational * r = static_cast<const Rational *>(operand(0));
    // log(0) = undef
    if (r->isZero()) {
      return replaceWith(new Undefined(), true);
    }
    // log(1) = 0;
    if (r->isOne()) {
      return replaceWith(new Rational(0), true);
    }
    // log(10) ->1
    if (numberOfOperands() == 1 && r->isTen()) {
      return replaceWith(new Rational(1), true);
    }
  }
  return this;
}

Expression * Logarithm::shallowReduce(Context& context, AngleUnit angleUnit) {
  Expression * e = Expression::shallowReduce(context, angleUnit);
  if (e != this) {
    return e;
  }
  Expression * op = editableOperand(0);
#if MATRIX_EXACT_REDUCING
  if (numberOfOperands() == 1 && op->type() == Type::Matrix) {
    return SimplificationEngine::map(this, context, angleUnit);
  }
  if (numberOfOperands() == 2 && (op->type() == Type::Matrix || operand(1)->type() == Type::Matrix)) {
    return replaceWith(new Undefined(), true);
  }
#endif
  if (op->sign() == Sign::Negative || (numberOfOperands() == 2 && operand(1)->sign() == Sign::Negative)) {
    return this;
  }
  Expression * f = simpleShallowReduce(context, angleUnit);
  if (f != this) {
    return f;
  }

  /* We do not apply some rules if the parent node is a power of b. In this
   * case there is a simplication of form e^ln(3^(1/2))->3^(1/2) */
  bool letLogAtRoot = parentIsAPowerOfSameBase();
  // log(x^y, b)->y*log(x, b) if x>0
  if (!letLogAtRoot && op->type() == Type::Power && op->operand(0)->sign() == Sign::Positive) {
    Power * p = static_cast<Power *>(op);
    Expression * x = p->editableOperand(0);
    Expression * y = p->editableOperand(1);
    p->detachOperands();
    replaceOperand(p, x, true);
    Expression * newLog = shallowReduce(context, angleUnit);
    newLog = newLog->replaceWith(new Multiplication(y, newLog->clone(), false), true);
    return newLog->shallowReduce(context, angleUnit);
  }
  // log(x*y, b)->log(x,b)+log(y, b) if x,y>0
  if (!letLogAtRoot && op->type() == Type::Multiplication) {
    Addition * a = new Addition();
    for (int i = 0; i<op->numberOfOperands()-1; i++) {
      Expression * factor = op->editableOperand(i);
      if (factor->sign() == Sign::Positive) {
        Expression * newLog = clone();
        static_cast<Multiplication *>(op)->removeOperand(factor, false);
        newLog->replaceOperand(newLog->editableOperand(0), factor, true);
        a->addOperand(newLog);
        newLog->shallowReduce(context, angleUnit);
      }
    }
    if (a->numberOfOperands() > 0) {
      op->shallowReduce(context, angleUnit);
      Expression * reducedLastLog = shallowReduce(context, angleUnit);
      reducedLastLog->replaceWith(a, false);
      a->addOperand(reducedLastLog);
      return a->shallowReduce(context, angleUnit);
    } else {
      delete a;
    }
  }
  // log(r) = a0log(p0)+a1log(p1)+... with r = p0^a0*p1^a1*... (Prime decomposition)
  if (!letLogAtRoot && op->type() == Type::Rational) {
    const Rational * r = static_cast<const Rational *>(operand(0));
    Expression * n = splitInteger(r->numerator(), false, context, angleUnit);
    Expression * d = splitInteger(r->denominator(), true, context, angleUnit);
    Addition * a = new Addition(n, d, false);
    replaceWith(a, true);
    return a->shallowReduce(context, angleUnit);
  }
  return this;
}

bool Logarithm::parentIsAPowerOfSameBase() const {
  // We look for expressions of types e^ln(x) or e^(ln(x)) where ln is this
  const Expression * parentExpression = parent();
  bool thisIsPowerExponent = parentExpression->type() == Type::Power ? parentExpression->operand(1) == this : false;
  if (parentExpression->type() == Type::Parenthesis) {
    const Expression * parentParentExpression = parentExpression->parent();
    if (parentExpression == nullptr) {
      return false;
    }
    thisIsPowerExponent = parentParentExpression->type() == Type::Power ? parentParentExpression->operand(1) == parentExpression : false;
    parentExpression = parentParentExpression;
  }
  if (thisIsPowerExponent) {
    const Expression * powerOperand0 = parentExpression->operand(0);
    if (numberOfOperands() == 1) {
      if (powerOperand0->type() == Type::Rational && static_cast<const Rational *>(powerOperand0)->isTen()) {
        return true;
      }
    }
    if (numberOfOperands() == 2) {
      if (powerOperand0->isIdenticalTo(operand(1))){
        return true;
      }
    }
  }
  return false;
}

Expression * Logarithm::splitInteger(Integer i, bool isDenominator, Context & context, AngleUnit angleUnit) {
  assert(!i.isZero());
  assert(!i.isNegative());
  if (i.isOne()) {
    return new Rational(0);
  }
  assert(!i.isOne());
  Integer factors[Arithmetic::k_maxNumberOfPrimeFactors];
  Integer coefficients[Arithmetic::k_maxNumberOfPrimeFactors];
  Arithmetic::PrimeFactorization(&i, factors, coefficients, Arithmetic::k_maxNumberOfPrimeFactors);
  if (coefficients[0].isMinusOne()) {
    /* We could not break i in prime factor (either it might take too many
     * factors or too much time). */
    Expression * e = clone();
    e->replaceOperand(e->operand(0), new Rational(i), true);
    if (!isDenominator) {
      return e;
    }
    Multiplication * m = new Multiplication(new Rational(-1), e, false);
    return m;
  }
  Addition * a = new Addition();
  int index = 0;
  while (!coefficients[index].isZero() && index < Arithmetic::k_maxNumberOfPrimeFactors) {
    if (isDenominator) {
      coefficients[index].setNegative(true);
    }
    Expression * e = clone();
    e->replaceOperand(e->operand(0), new Rational(factors[index]), true);
    Multiplication * m = new Multiplication(new Rational(coefficients[index]), e, false);
    static_cast<Logarithm *>(e)->simpleShallowReduce(context, angleUnit);
    a->addOperand(m);
    m->shallowReduce(context, angleUnit);
    index++;
  }
  return a;
}

Expression * Logarithm::shallowBeautify(Context & context, AngleUnit angleUnit) {
  Symbol e = Symbol(Ion::Charset::Exponential);
  const Expression * op = operand(0);
  Rational one(1);
  if (numberOfOperands() == 2 && (operand(1)->isIdenticalTo(&e) || operand(1)->isIdenticalTo(&one))) {
    detachOperand(op);
    Expression * nl = operand(1)->isIdenticalTo(&e) ? static_cast<Expression *>(new NaperianLogarithm(op, false)) : static_cast<Expression *> (new Logarithm(op, false));
    return replaceWith(nl, true);
  }
  return this;
}

template<typename T>
Evaluation<T> * Logarithm::templatedApproximate(Context& context, AngleUnit angleUnit) const {
  if (numberOfOperands() == 1) {
    return ApproximationEngine::map(this, context, angleUnit, computeOnComplex<T>);
  }
  Evaluation<T> * x = operand(0)->privateApproximate(T(), context, angleUnit);
  Evaluation<T> * n = operand(1)->privateApproximate(T(), context, angleUnit);
  std::complex<T> result = std::complex<T>(NAN, NAN);
  if (x->type() == Evaluation<T>::Type::Complex && n->type() == Evaluation<T>::Type::Complex) {
    Complex<T> * xc = static_cast<Complex<T> *>(x);
    Complex<T> * nc = static_cast<Complex<T> *>(n);
    result = Division::compute<T>(computeOnComplex(*xc, angleUnit), computeOnComplex(*nc, angleUnit));
  }
  delete x;
  delete n;
  return new Complex<T>(result);
}

ExpressionLayout * Logarithm::createLayout(PrintFloat::Mode floatDisplayMode, int numberOfSignificantDigits) const {
  if (numberOfOperands() == 1) {
    return LayoutEngine::createPrefixLayout(this, floatDisplayMode, numberOfSignificantDigits, "log");
  }
  return LayoutEngine::createLogLayout(operand(0)->createLayout(floatDisplayMode, numberOfSignificantDigits), operand(1)->createLayout(floatDisplayMode, numberOfSignificantDigits));
}

}