#include "horizontal_layout.h"
#include "empty_layout.h"
extern "C" {
#include <assert.h>
#include <kandinsky.h>
#include <stdlib.h>
}

namespace Poincare {

ExpressionLayout * HorizontalLayout::clone() const {
  HorizontalLayout * layout = new HorizontalLayout(const_cast<ExpressionLayout **>(children()), numberOfChildren(), true);
  return layout;
}

void HorizontalLayout::deleteBeforeCursor(ExpressionLayoutCursor * cursor) {
  if (cursor->pointedExpressionLayout() == this
      && cursor->position() == ExpressionLayoutCursor::Position::Left
      && m_parent == nullptr)
  {
    // Case: Left and this is the main layout. Return.
    return;
  }
  if (cursor->pointedExpressionLayout() == this
      && cursor->position() == ExpressionLayoutCursor::Position::Right
      && m_parent == nullptr
      && numberOfChildren() == 0)
  {
    // Case: Right and this is the main layout with no children. Return.
    return;
  }
  if (cursor->position() == ExpressionLayoutCursor::Position::Left) {
    int indexOfPointedExpression = indexOfChild(cursor->pointedExpressionLayout());
    if (indexOfPointedExpression >= 0) {
      /* Case: Left of a child.
       * Point Right of the previous child. If there is no previous child, point
       * Left of this. Perform another backspace. */
      if (indexOfPointedExpression == 0) {
        cursor->setPointedExpressionLayout(this);
      } else if (indexOfPointedExpression > 0) {
        cursor->setPointedExpressionLayout(editableChild(indexOfPointedExpression - 1));
        cursor->setPosition(ExpressionLayoutCursor::Position::Right);
      }
      cursor->performBackspace();
      return;
    }
  }
  assert(cursor->pointedExpressionLayout() == this);
  if (cursor->position() == ExpressionLayoutCursor::Position::Right) {
    // Case: Right. Point to the last child and perform backspace.
    cursor->setPointedExpressionLayout(editableChild(numberOfChildren() - 1));
    cursor->performBackspace();
    return;
  }
  ExpressionLayout::deleteBeforeCursor(cursor);
}

void HorizontalLayout::replaceChild(const ExpressionLayout * oldChild, ExpressionLayout * newChild, bool deleteOldChild) {
  privateReplaceChild(oldChild, newChild, deleteOldChild, nullptr);
}

void HorizontalLayout::replaceChildAndMoveCursor(const ExpressionLayout * oldChild, ExpressionLayout * newChild, bool deleteOldChild, ExpressionLayoutCursor * cursor) {
  privateReplaceChild(oldChild, newChild, deleteOldChild, cursor);
}

void HorizontalLayout::privateReplaceChild(const ExpressionLayout * oldChild, ExpressionLayout * newChild, bool deleteOldChild, ExpressionLayoutCursor * cursor) {
  bool oldWasAncestorOfNewLayout = false;
  if (newChild->hasAncestor(this)) {
    newChild->editableParent()->detachChild(newChild);
    oldWasAncestorOfNewLayout = true;
  }
  int oldChildIndex = indexOfChild(oldChild);
  if (newChild->isEmpty()) {
    if (numberOfChildren() > 1) {
      /* If the new layout is empty and the horizontal layout has other
       * children, just delete the old child. */
      if (!newChild->hasAncestor(oldChild)) {
        delete newChild;
      }
      removeChildAtIndex(oldChildIndex, deleteOldChild);
      if (cursor == nullptr) {
        return;
      }
      if (oldChildIndex == 0) {
        cursor->setPointedExpressionLayout(this);
        cursor->setPosition(ExpressionLayoutCursor::Position::Left);
        return;
      }
      cursor->setPointedExpressionLayout(editableChild(oldChildIndex -1));
      cursor->setPosition(ExpressionLayoutCursor::Position::Right);
      return;
    }
    /* If the new layout is empty and it was the only horizontal layout child,
     * replace the horizontal layout with this empty layout (only if this is not
     * the main layout, so only if the layout has a parent). */
    if (m_parent) {
      if (!deleteOldChild) {
        removeChildAtIndex(indexOfChild(oldChild), false);
      }
      if (cursor) {
        replaceWithAndMoveCursor(newChild, true, cursor);
        return;
      }
      replaceWith(newChild, deleteOldChild);
      return;
    }
    /* If this is the main horizontal layout, the old child its only child and
     * the new child is Empty, remove the old child and delete the new child. */
    assert(m_parent == nullptr);
    removeChildAtIndex(0, deleteOldChild);
    delete newChild;
    if (cursor == nullptr) {
      return;
    }
    cursor->setPointedExpressionLayout(this);
    cursor->setPosition(ExpressionLayoutCursor::Position::Left);
    return;
  }
  /* If the new child is also an horizontal layout, steal the children of the
   * new layout then destroy it. */
  if (newChild->isHorizontal()) {
    int indexForInsertion = indexOfChild(oldChild);
    if (cursor != nullptr) {
      /* If the old layout is not an ancestor of the new layout, or if the
       * cursor was on the right of the new layout, place the cursor on the
       * right of the new layout, which is left of the next sibling or right of
       * the parent. */
      if (!oldWasAncestorOfNewLayout || cursor->position() == ExpressionLayoutCursor::Position::Right) {
        if (oldChildIndex == numberOfChildren() - 1) {
          cursor->setPointedExpressionLayout(this);
          cursor->setPosition(ExpressionLayoutCursor::Position::Right);
        } else {
          cursor->setPointedExpressionLayout(editableChild(oldChildIndex + 1));
          cursor->setPosition(ExpressionLayoutCursor::Position::Left);
        }
      } else {
        /* Else place the cursor on the left of the new layout, which is right
         * of the previous sibling or left of the parent. */
        if (oldChildIndex == 0) {
          cursor->setPointedExpressionLayout(this);
          cursor->setPosition(ExpressionLayoutCursor::Position::Left);
        } else {
          cursor->setPointedExpressionLayout(editableChild(oldChildIndex - 1));
          cursor->setPosition(ExpressionLayoutCursor::Position::Right);
        }
      }
    }
    bool oldChildRemovedAtMerge = oldChild->isEmpty();
    mergeChildrenAtIndex(static_cast<HorizontalLayout *>(newChild), indexForInsertion + 1, true);
    if (!oldChildRemovedAtMerge) {
      removeChildAtIndex(indexForInsertion, deleteOldChild);
    }
    return;
  }
  // Else, just replace the child.
  if (cursor != nullptr && !oldWasAncestorOfNewLayout) {
    cursor->setPosition(ExpressionLayoutCursor::Position::Right);
  }
  ExpressionLayout::replaceChild(oldChild, newChild, deleteOldChild);
  if (cursor == nullptr) {
    return;
  }
  cursor->setPointedExpressionLayout(newChild);
}

void HorizontalLayout::addOrMergeChildAtIndex(ExpressionLayout * eL, int index, bool removeEmptyChildren) {
  if (eL->isHorizontal()) {
    mergeChildrenAtIndex(static_cast<HorizontalLayout *>(eL), index, removeEmptyChildren);
  } else {
    addChildAtIndex(eL, index);
  }
}

ExpressionLayoutCursor HorizontalLayout::cursorLeftOf(ExpressionLayoutCursor cursor, bool * shouldRecomputeLayout) {
  // Case: Left. Ask the parent.
  if (cursor.pointedExpressionLayout() == this) {
    if (cursor.position() == ExpressionLayoutCursor::Position::Left) {
      if (m_parent) {
        return m_parent->cursorLeftOf(cursor, shouldRecomputeLayout);
      }
      return ExpressionLayoutCursor();
    }
    assert(cursor.position() == ExpressionLayoutCursor::Position::Right);
    /* Case: Right.
     * Go to the last child if there is one, and move Left.
     * Else go Left and ask the parent. */
    if (numberOfChildren() < 1) {
      cursor.setPosition(ExpressionLayoutCursor::Position::Left);
      if (m_parent) {
        return m_parent->cursorLeftOf(cursor, shouldRecomputeLayout);
      }
      return ExpressionLayoutCursor();
    }
    ExpressionLayout * lastChild = editableChild(numberOfChildren()-1);
    assert(lastChild != nullptr);
    cursor.setPointedExpressionLayout(lastChild);
    return lastChild->cursorLeftOf(cursor, shouldRecomputeLayout);
  }

  // Case: The cursor is Left of a child.
  assert(cursor.position() == ExpressionLayoutCursor::Position::Left);
  int childIndex = indexOfChild(cursor.pointedExpressionLayout());
  assert(childIndex >= 0);
  if (childIndex == 0) {
    // Case: the child is the leftmost. Ask the parent.
    if (m_parent) {
      cursor.setPointedExpressionLayout(this);
      return m_parent->cursorLeftOf(cursor, shouldRecomputeLayout);
    }
    return ExpressionLayoutCursor();
  }
  // Case: the child is not the leftmost. Go to its left sibling and move Left.
  cursor.setPointedExpressionLayout(editableChild(childIndex-1));
  cursor.setPosition(ExpressionLayoutCursor::Position::Right);
  return editableChild(childIndex-1)->cursorLeftOf(cursor, shouldRecomputeLayout);
}

ExpressionLayoutCursor HorizontalLayout::cursorRightOf(ExpressionLayoutCursor cursor, bool * shouldRecomputeLayout) {
  // Case: Right. Ask the parent.
  if (cursor.pointedExpressionLayout() == this) {
    if (cursor.position() == ExpressionLayoutCursor::Position::Right) {
      if (m_parent) {
        return m_parent->cursorRightOf(cursor, shouldRecomputeLayout);
      }
      return ExpressionLayoutCursor();
    }
    assert(cursor.position() == ExpressionLayoutCursor::Position::Left);
    /* Case: Left.
     * Go to the first child if there is one, and move Right.
     * Else go Right and ask the parent. */
    if (numberOfChildren() < 1) {
      cursor.setPosition(ExpressionLayoutCursor::Position::Right);
      if (m_parent) {
        return m_parent->cursorRightOf(cursor, shouldRecomputeLayout);
      }
      return ExpressionLayoutCursor();
    }
    ExpressionLayout * firstChild = editableChild(0);
    assert(firstChild != nullptr);
    cursor.setPointedExpressionLayout(firstChild);
    return firstChild->cursorRightOf(cursor, shouldRecomputeLayout);
  }

  // Case: The cursor is Right of a child.
  assert(cursor.position() == ExpressionLayoutCursor::Position::Right);
  int childIndex = indexOfChild(cursor.pointedExpressionLayout());
  assert(childIndex >= 0);
  if (childIndex == numberOfChildren() - 1) {
    // Case: the child is the rightmost. Ask the parent.
    if (m_parent) {
      cursor.setPointedExpressionLayout(this);
      return m_parent->cursorRightOf(cursor, shouldRecomputeLayout);
    }
    return ExpressionLayoutCursor();
  }
  /* Case: the child is not the rightmost. Go to its right sibling and move
   * Right. */
  cursor.setPointedExpressionLayout(editableChild(childIndex+1));
  cursor.setPosition(ExpressionLayoutCursor::Position::Left);
  return editableChild(childIndex+1)->cursorRightOf(cursor, shouldRecomputeLayout);
}

void HorizontalLayout::addChildrenAtIndex(const ExpressionLayout * const * operands, int numberOfOperands, int indexForInsertion, bool removeEmptyChildren) {
  int newIndex = removeEmptyChildBeforeInsertionAtIndex(indexForInsertion, !operands[0]->mustHaveLeftSibling());
  DynamicLayoutHierarchy::addChildrenAtIndex(operands, numberOfOperands, newIndex, removeEmptyChildren);
}

bool HorizontalLayout::addChildAtIndex(ExpressionLayout * operand, int index) {
  int newIndex = removeEmptyChildBeforeInsertionAtIndex(index, !operand->mustHaveLeftSibling());
  return DynamicLayoutHierarchy::addChildAtIndex(operand, newIndex);
}

void HorizontalLayout::removeChildAtIndex(int index, bool deleteAfterRemoval) {
  privateRemoveChildAtIndex(index, deleteAfterRemoval, false);
}

void HorizontalLayout::mergeChildrenAtIndex(DynamicLayoutHierarchy * eL, int index, bool removeEmptyChildren) {
  /* Before the merge, remove ay empty child that would be on the left or on the
   * right of the inserted layout.
   * If the layout to insert starts with a vertical offset layout, any empty
   * layout child directly on the left of the inserted layout (if there is one)
   * should not be removed: it will be the base for the VerticalOffsetLayout. */
  bool shouldRemoveOnLeft = eL->numberOfChildren() > 0 ? !(eL->child(0)->mustHaveLeftSibling()) : true;
  int newIndex = removeEmptyChildBeforeInsertionAtIndex(index, shouldRemoveOnLeft);
  DynamicLayoutHierarchy::mergeChildrenAtIndex(eL, newIndex, removeEmptyChildren);
}

int HorizontalLayout::writeTextInBuffer(char * buffer, int bufferSize) const {
  if (numberOfChildren() == 0) {
    if (bufferSize == 0) {
      return -1;
    }
    buffer[0] = 0;
    return 0;
  }
  return LayoutEngine::writeInfixExpressionLayoutTextInBuffer(this, buffer, bufferSize, "");
}

ExpressionLayoutCursor HorizontalLayout::equivalentCursor(ExpressionLayoutCursor cursor) {
  ExpressionLayoutCursor result;
  ExpressionLayout * newPointedLayout = nullptr;
  ExpressionLayoutCursor::Position newPosition = ExpressionLayoutCursor::Position::Left;
  if (cursor.pointedExpressionLayout() == this) {
    // First or last child, if any
    if(numberOfChildren() == 0) {
      return result;
    } else {
      newPointedLayout = editableChild(cursor.position() == ExpressionLayoutCursor::Position::Left ? 0 : numberOfChildren() - 1);
      newPosition = cursor.position();
    }
  } else {
    // Left or right child
    int indexOfPointedLayout = indexOfChild(cursor.pointedExpressionLayout());
    if (indexOfPointedLayout < 0) {
      return result;
    } else if (cursor.position() == ExpressionLayoutCursor::Position::Left) {
      if (indexOfPointedLayout == 0) {
        newPointedLayout = this;
        newPosition = ExpressionLayoutCursor::Position::Left;
      } else {
        newPointedLayout = editableChild(indexOfPointedLayout - 1);
        newPosition = ExpressionLayoutCursor::Position::Right;
      }
    } else {
      assert(cursor.position() == ExpressionLayoutCursor::Position::Right);
      if (indexOfPointedLayout == numberOfChildren() - 1) {
        newPointedLayout = this;
        newPosition = ExpressionLayoutCursor::Position::Right;
      } else {
        newPointedLayout = editableChild(indexOfPointedLayout + 1);
        newPosition = ExpressionLayoutCursor::Position::Left;
      }
    }
  }
  result.setPointedExpressionLayout(newPointedLayout);
  result.setPosition(newPosition);
  return result;
}

KDSize HorizontalLayout::computeSize() {
  KDCoordinate totalWidth = 0;
  int i = 0;
  KDCoordinate max_under_baseline = 0;
  KDCoordinate max_above_baseline = 0;
  while (ExpressionLayout * c = editableChild(i++)) {
    KDSize childSize = c->size();
    totalWidth += childSize.width();
    if (childSize.height() - c->baseline() > max_under_baseline) {
      max_under_baseline = childSize.height() - c->baseline() ;
    }
    if (c->baseline() > max_above_baseline) {
      max_above_baseline = c->baseline();
    }
  }
  return KDSize(totalWidth, max_under_baseline + max_above_baseline);
}

void HorizontalLayout::computeBaseline() {
  m_baseline = 0;
  for (int i = 0; i < numberOfChildren(); i++) {
    if (editableChild(i)->baseline() > m_baseline) {
      m_baseline = editableChild(i)->baseline();
    }
  }
  m_baselined = true;
}

KDPoint HorizontalLayout::positionOfChild(ExpressionLayout * child) {
  KDCoordinate x = 0;
  KDCoordinate y = 0;
  int index = indexOfChild(child);
  if (index > 0) {
    ExpressionLayout * previousChild = editableChild(index-1);
    assert(previousChild != nullptr);
    x = previousChild->origin().x() + previousChild->size().width();
  }
  y = baseline() - child->baseline();
  return KDPoint(x, y);
}

void HorizontalLayout::privateAddSibling(ExpressionLayoutCursor * cursor, ExpressionLayout * sibling, bool moveCursor) {
  // Add the "sibling" as a child.
  if (cursor->position() == ExpressionLayoutCursor::Position::Left) {
    int indexForInsertion = 0;
    /* If the first child is empty, remove it before adding the layout, unless
     * the new sibling needs the empty layout as a base. */
    if (numberOfChildren() > 0 && editableChild(0)->isEmpty()) {
      if (sibling->mustHaveLeftSibling()) {
        indexForInsertion = 1;
      } else {
        /* We force the removing of the child even followed by a neighbourg
         * requiring a left sibling as we are about to add a sibling in first
         * position anyway. */
        privateRemoveChildAtIndex(0, true, true);
      }
    }
    if (moveCursor) {
      if (numberOfChildren() > indexForInsertion) {
        cursor->setPointedExpressionLayout(editableChild(indexForInsertion));
      } else {
        cursor->setPointedExpressionLayout(this);
        cursor->setPosition(ExpressionLayoutCursor::Position::Right);
      }
    }
    addOrMergeChildAtIndex(sibling, indexForInsertion, false);
    return;
  }
  assert(cursor->position() == ExpressionLayoutCursor::Position::Right);
  // If the last child is empty, remove it before adding the layout.
  int childrenCount = numberOfChildren();
  if (childrenCount > 0 && editableChild(childrenCount - 1)->isEmpty() && !sibling->mustHaveLeftSibling()) {
    /* Force remove the last child. */
    privateRemoveChildAtIndex(childrenCount - 1, true, true);
  }
  addOrMergeChildAtIndex(sibling, numberOfChildren(), false);
  if (moveCursor) {
    cursor->setPointedExpressionLayout(this);
  }
}

void HorizontalLayout::privateRemoveChildAtIndex(int index, bool deleteAfterRemoval, bool forceRemove) {
  /* Remove the child before potentially adding an EmptyLayout. Indeed, adding
   * a new child would remove any EmptyLayout surrounding the new child and in
   * the case the child to be removed was an Empty layout, it would result in
   * removing it twice if we remove it afterwards. */
  DynamicLayoutHierarchy::removeChildAtIndex(index, deleteAfterRemoval);
  /* If the child to remove is at index 0 and its right sibling must have a left
   * sibling (e.g. it is a VerticalOffsetLayout), replace the child with an
   * EmptyLayout instead of removing it. */
  if (!forceRemove && index == 0 && numberOfChildren() > 0 && child(0)->mustHaveLeftSibling()) {
    addChildAtIndex(new EmptyLayout(), 0);
  }
}

int HorizontalLayout::removeEmptyChildBeforeInsertionAtIndex(int index, bool shouldRemoveOnLeft) {
  int newIndex = index;
  /* If empty, remove the child that would be on the right of the inserted
   * layout. */
  if (newIndex < numberOfChildren()
      && child(newIndex)->isEmpty())
  {
    privateRemoveChildAtIndex(newIndex, true, true);
  }
  /* If empty, remove the child that would be on the left of the inserted
   * layout. */
  if (shouldRemoveOnLeft
      && newIndex - 1 >= 0
      && newIndex - 1 <= numberOfChildren() -1
      && child(newIndex - 1)->isEmpty())
  {
    privateRemoveChildAtIndex(newIndex-1, true, true);
    newIndex = index - 1;
  }
  return newIndex;
}

}