#include "vertical_offset_layout.h"
#include "empty_layout.h"
#include "left_parenthesis_layout.h"
#include "right_parenthesis_layout.h"
#include <ion/charset.h>
#include <poincare/expression_layout_cursor.h>
#include <poincare/layout_engine.h>
#include <string.h>
#include <assert.h>

namespace Poincare {

VerticalOffsetLayout::VerticalOffsetLayout(ExpressionLayout * indice, Type type, bool cloneOperands) :
  StaticLayoutHierarchy(indice, cloneOperands),
  m_type(type)
{
}

ExpressionLayout * VerticalOffsetLayout::clone() const {
  VerticalOffsetLayout * layout = new VerticalOffsetLayout(const_cast<VerticalOffsetLayout *>(this)->indiceLayout(), m_type, true);
  return layout;
}

void VerticalOffsetLayout::deleteBeforeCursor(ExpressionLayoutCursor * cursor) {
  if (cursor->pointedExpressionLayout() == indiceLayout()) {
    assert(cursor->position() == ExpressionLayoutCursor::Position::Left);
    ExpressionLayout * base = baseLayout();
    if (indiceLayout()->isEmpty()) {
      int indexInParent = m_parent->indexOfChild(this);
      if (base->isEmpty()) {
        // Case: Empty base and indice.
        // Remove both the base and the indice layout.
        ExpressionLayout * parent = m_parent;
        cursor->setPointedExpressionLayout(this);
        cursor->setPosition(ExpressionLayoutCursor::Position::Right);
        parent->removePointedChildAtIndexAndMoveCursor(indexInParent, true, cursor);
        cursor->setPointedExpressionLayout(parent->editableChild(indexInParent-1));
        cursor->setPosition(ExpressionLayoutCursor::Position::Right);
        parent->removePointedChildAtIndexAndMoveCursor(indexInParent-1, true, cursor);
        return;
      }
      // Case: Empty indice only.
      // Delete the layout.
      cursor->setPointedExpressionLayout(base);
      cursor->setPosition(ExpressionLayoutCursor::Position::Right);
      m_parent->removeChildAtIndex(indexInParent, true);
      return;
    }
    // Case: Non-empty indice.
    // Move Left of the VerticalOffsetLayout.
    cursor->setPointedExpressionLayout(this);
    cursor->setPosition(ExpressionLayoutCursor::Position::Left);
    return;
  }
  if (cursor->pointedExpressionLayout() == this
      && cursor->position() == ExpressionLayoutCursor::Position::Right)
  {
    // Case: Right.
    // Move to the indice.
    cursor->setPointedExpressionLayout(indiceLayout());
    return;
  }
  ExpressionLayout::deleteBeforeCursor(cursor);
}

ExpressionLayoutCursor VerticalOffsetLayout::cursorLeftOf(ExpressionLayoutCursor cursor, bool * shouldRecomputeLayout) {
  // Case: Left of the indice. Go Left.
  if (indiceLayout()
      && cursor.pointedExpressionLayout() == indiceLayout()
      && cursor.position() == ExpressionLayoutCursor::Position::Left)
  {
    return ExpressionLayoutCursor(this, ExpressionLayoutCursor::Position::Left);
  }

  assert(cursor.pointedExpressionLayout() == this);
  // Case: Right. Go to the indice.
  if (cursor.position() == ExpressionLayoutCursor::Position::Right) {
    assert(indiceLayout() != nullptr);
    return ExpressionLayoutCursor(indiceLayout(), ExpressionLayoutCursor::Position::Right);
  }
  // Case: Left. Ask the parent.
  assert(cursor.position() == ExpressionLayoutCursor::Position::Left);
  if (m_parent) {
    return m_parent->cursorLeftOf(cursor, shouldRecomputeLayout);
  }
  return ExpressionLayoutCursor();
}

ExpressionLayoutCursor VerticalOffsetLayout::cursorRightOf(ExpressionLayoutCursor cursor, bool * shouldRecomputeLayout) {
  // Case: Right of the indice. Go Right.
  if (indiceLayout()
      && cursor.pointedExpressionLayout() == indiceLayout()
      && cursor.position() == ExpressionLayoutCursor::Position::Right)
  {
    return ExpressionLayoutCursor(this, ExpressionLayoutCursor::Position::Right);
  }

  assert(cursor.pointedExpressionLayout() == this);
  // Case: Left. Go to the indice.
  if (cursor.position() == ExpressionLayoutCursor::Position::Left) {
    assert(indiceLayout() != nullptr);
    return ExpressionLayoutCursor(indiceLayout(), ExpressionLayoutCursor::Position::Left);
  }
  // Case: Right. Ask the parent.
  assert(cursor.position() == ExpressionLayoutCursor::Position::Right);
  if (m_parent) {
    return m_parent->cursorRightOf(cursor, shouldRecomputeLayout);
  }
  return ExpressionLayoutCursor();
}

ExpressionLayoutCursor VerticalOffsetLayout::cursorAbove(ExpressionLayoutCursor cursor, bool * shouldRecomputeLayout, bool equivalentPositionVisited) {
  // Case: Superscript.
  if (m_type == VerticalOffsetLayout::Type::Superscript) {
    // Case: Right. Move to the indice.
    if (cursor.isEquivalentTo(ExpressionLayoutCursor(this, ExpressionLayoutCursor::Position::Right))) {
      assert(indiceLayout() != nullptr);
      return ExpressionLayoutCursor(indiceLayout(), ExpressionLayoutCursor::Position::Right);
    }
    // Case: Left. Move to the indice.
    if (cursor.isEquivalentTo(ExpressionLayoutCursor(this, ExpressionLayoutCursor::Position::Left))) {
      assert(indiceLayout() != nullptr);
      return ExpressionLayoutCursor(indiceLayout(), ExpressionLayoutCursor::Position::Left);
    }
  }
  /* Case: Subscript, Left or Right of the indice. Put the cursor at the same
   * position, pointing this. */
  if (m_type == VerticalOffsetLayout::Type::Subscript
    && indiceLayout() != nullptr
    && (cursor.isEquivalentTo(ExpressionLayoutCursor(indiceLayout(), ExpressionLayoutCursor::Position::Left))
      || cursor.isEquivalentTo(ExpressionLayoutCursor(indiceLayout(), ExpressionLayoutCursor::Position::Right))))
  {
      return ExpressionLayoutCursor(this, cursor.position());
  }
  return ExpressionLayout::cursorAbove(cursor, shouldRecomputeLayout, equivalentPositionVisited);
}

ExpressionLayoutCursor VerticalOffsetLayout::cursorUnder(ExpressionLayoutCursor cursor, bool * shouldRecomputeLayout, bool equivalentPositionVisited) {
  // Case: Subscript.
  if (m_type == VerticalOffsetLayout::Type::Subscript) {
    // Case: Right. Move to the indice.
    if (cursor.isEquivalentTo(ExpressionLayoutCursor(this, ExpressionLayoutCursor::Position::Right))) {
      assert(indiceLayout() != nullptr);
      return ExpressionLayoutCursor(indiceLayout(), ExpressionLayoutCursor::Position::Right);
    }
    // Case: Left. Move to the indice.
    if (cursor.isEquivalentTo(ExpressionLayoutCursor(this, ExpressionLayoutCursor::Position::Left))) {
      assert(indiceLayout() != nullptr);
      return ExpressionLayoutCursor(indiceLayout(), ExpressionLayoutCursor::Position::Left);
    }
  }
  /* Case: Superscript, Left or Right of the indice. Put the cursor at the same
   * position, pointing this. */
  if (m_type == VerticalOffsetLayout::Type::Superscript
    && indiceLayout() != nullptr
    && cursor.pointedExpressionLayout() == indiceLayout())
  {
    return ExpressionLayoutCursor(this, cursor.position());
  }
  return ExpressionLayout::cursorUnder(cursor, shouldRecomputeLayout, equivalentPositionVisited);
}

int VerticalOffsetLayout::writeTextInBuffer(char * buffer, int bufferSize) const {
  if (m_type == Type::Subscript) {
    if (bufferSize == 0) {
      return -1;
    }
    buffer[bufferSize-1] = 0;
    if (bufferSize == 1) {
      return 0;
    }
    // If the layout is a subscript, write "_{indice}"
    int numberOfChar = LayoutEngine::writeOneCharInBuffer(buffer, bufferSize, '_');
    if (numberOfChar >= bufferSize-1) { return bufferSize-1; }

    numberOfChar += LayoutEngine::writeOneCharInBuffer(buffer+numberOfChar, bufferSize-numberOfChar, '{');
    if (numberOfChar >= bufferSize-1) { return bufferSize-1; }

    numberOfChar += const_cast<VerticalOffsetLayout *>(this)->indiceLayout()->writeTextInBuffer(buffer+numberOfChar, bufferSize-numberOfChar);
    if (numberOfChar >= bufferSize-1) { return bufferSize-1; }

    numberOfChar += LayoutEngine::writeOneCharInBuffer(buffer+numberOfChar, bufferSize-numberOfChar, '}');
    if (numberOfChar >= bufferSize-1) { return bufferSize-1; }

    return numberOfChar;
  }
  assert(m_type == Type::Superscript);
  // If the layout is a superscript, write "^(indice)"
  int numberOfChar = LayoutEngine::writePrefixExpressionLayoutTextInBuffer(this, buffer, bufferSize, "^");
  if (numberOfChar >= bufferSize-1) { return bufferSize-1; }

  // Add a multiplication if omitted.
  int indexInParent = -1;
  if (m_parent) {
    indexInParent = m_parent->indexOfChild(this);
  }
  if (indexInParent >= 0 && indexInParent < (m_parent->numberOfChildren() - 1) && m_parent->isHorizontal() && m_parent->child(indexInParent + 1)->canBeOmittedMultiplicationRightFactor()) {
    buffer[numberOfChar++] = Ion::Charset::MiddleDot;
    if (numberOfChar >= bufferSize-1) { return bufferSize-1;}
  }
  buffer[numberOfChar] = 0;
  return numberOfChar;
}

ExpressionLayout * VerticalOffsetLayout::baseLayout() {
  int indexInParent = parent()->indexOfChild(this);
  assert(indexInParent > 0);
  return editableParent()->editableChild(indexInParent - 1);
}

KDSize VerticalOffsetLayout::computeSize() {
  KDSize indiceSize = indiceLayout()->size();
  KDCoordinate width = indiceSize.width();
  if (m_type == Type::Superscript) {
    assert(m_parent != nullptr);
    assert(m_parent->isHorizontal());
    int indexInParent = m_parent->indexOfChild(this);
    if (indexInParent < m_parent-> numberOfChildren() - 1 && m_parent->editableChild(indexInParent + 1)->hasUpperLeftIndex()) {
      width += k_separationMargin;
    }
  }
  KDCoordinate height = baseLayout()->size().height() - k_indiceHeight + indiceLayout()->size().height();
  return KDSize(width, height);
}

void VerticalOffsetLayout::computeBaseline() {
  if (m_type == Type::Subscript) {
    m_baseline = baseLayout()->baseline();
  } else {
    m_baseline = indiceLayout()->size().height() - k_indiceHeight + baseLayout()->baseline();
  }
  m_baselined = true;
}

KDPoint VerticalOffsetLayout::positionOfChild(ExpressionLayout * child) {
  assert(child == indiceLayout());
  if (m_type == Type::Superscript) {
    return KDPointZero;
  }
  assert(m_type == Type::Subscript);
  ExpressionLayout * base = baseLayout();
  return KDPoint(0, base->size().height() - k_indiceHeight);
}

void VerticalOffsetLayout::privateAddSibling(ExpressionLayoutCursor * cursor, ExpressionLayout * sibling, bool moveCursor) {
  if (sibling->isVerticalOffset()) {
    VerticalOffsetLayout * verticalOffsetSibling = static_cast<VerticalOffsetLayout *>(sibling);
    if (verticalOffsetSibling->type() == Type::Superscript) {
      assert(m_parent->isHorizontal());
      // Add the Left parenthesis
      int indexInParent = m_parent->indexOfChild(this);
      int leftParenthesisIndex = indexInParent;
      LeftParenthesisLayout * leftParenthesis = new LeftParenthesisLayout();
      int numberOfOpenParenthesis = 0;
      while (leftParenthesisIndex > 0
          && editableParent()->editableChild(leftParenthesisIndex-1)->isCollapsable(&numberOfOpenParenthesis, true))
      {
        leftParenthesisIndex--;
      }
      m_parent->addChildAtIndex(leftParenthesis, leftParenthesisIndex);
      indexInParent = m_parent->indexOfChild(this);

      // Add the Right parenthesis
      RightParenthesisLayout * rightParenthesis = new RightParenthesisLayout();
      if (cursor->position() == ExpressionLayoutCursor::Position::Right) {
        m_parent->addChildAtIndex(rightParenthesis, indexInParent + 1);
      } else {
        assert(cursor->position() == ExpressionLayoutCursor::Position::Left);
        m_parent->addChildAtIndex(rightParenthesis, indexInParent);
      }
      cursor->setPointedExpressionLayout(rightParenthesis);
      if (moveCursor) {
        rightParenthesis->addSiblingAndMoveCursor(cursor, sibling);
      } else {
        rightParenthesis->addSibling(cursor, sibling);
      }
      return;
    }
  }
  ExpressionLayout::privateAddSibling(cursor, sibling, moveCursor);
}


}