#include "matrix_layout.h"
  #include "empty_layout.h"
  #include "bracket_pair_layout.h"
  #include <poincare/expression_layout_cursor.h>
  #include <poincare/layout_engine.h>
  extern "C" {
  #include <assert.h>
  #include <stdlib.h>
  }
  
  namespace Poincare {
  
  ExpressionLayout * MatrixLayout::clone() const {
    MatrixLayout * layout = new MatrixLayout(children(), m_numberOfRows, m_numberOfColumns, true);
    return layout;
  }
  
  ExpressionLayoutCursor MatrixLayout::cursorLeftOf(ExpressionLayoutCursor cursor, bool * shouldRecomputeLayout) {
    int childIndex = indexOfChild(cursor.pointedExpressionLayout());
    if (childIndex >- 1
        && cursor.position() == ExpressionLayoutCursor::Position::Left
        && childIsLeftOfGrid(childIndex))
    {
      /* Case: Left of a child on the left of the grid.
       * Remove the grey squares of the grid, then go left of the grid. */
      assert(hasGreySquares());
      removeGreySquares();
      *shouldRecomputeLayout = true;
      return ExpressionLayoutCursor(this, ExpressionLayoutCursor::Position::Left);
    }
    /* Case: Right.  Add the grey squares to the matrix, then move to the bottom
     * right non empty nor grey child. */
    if (cursor.pointedExpressionLayout() == this
        && cursor.position() == ExpressionLayoutCursor::Position::Right)
    {
      assert(!hasGreySquares());
      addGreySquares();
      *shouldRecomputeLayout = true;
      ExpressionLayout * lastChild = editableChild((m_numberOfColumns-1)*(m_numberOfRows-1));
      assert(lastChild != nullptr);
      return ExpressionLayoutCursor(lastChild, ExpressionLayoutCursor::Position::Right);
    }
    return GridLayout::cursorLeftOf(cursor, shouldRecomputeLayout);
  }
  
  ExpressionLayoutCursor MatrixLayout::cursorRightOf(ExpressionLayoutCursor cursor, bool * shouldRecomputeLayout) {
    // Case: Left. Add the grey squares to the matrix, then go to the first entry.
    if (cursor.pointedExpressionLayout() == this
        && cursor.position() == ExpressionLayoutCursor::Position::Left)
    {
      assert(!hasGreySquares());
      addGreySquares();
      *shouldRecomputeLayout = true;
      assert(m_numberOfColumns*m_numberOfRows >= 1);
      ExpressionLayout * firstChild = editableChild(0);
      assert(firstChild != nullptr);
      return ExpressionLayoutCursor(firstChild, ExpressionLayoutCursor::Position::Left);
    }
    // Case: The cursor points to a grid's child.
    int childIndex = indexOfChild(cursor.pointedExpressionLayout());
    if (childIndex >- 1
        && cursor.position() == ExpressionLayoutCursor::Position::Right
        && childIsRightOfGrid(childIndex))
    {
      /* Case: Right of a child on the right of the grid. Remove the grey squares
       * of the grid, then go right of the grid. */
      assert(hasGreySquares());
      removeGreySquares();
      *shouldRecomputeLayout = true;
      return ExpressionLayoutCursor(this, ExpressionLayoutCursor::Position::Right);
  
    }
    return GridLayout::cursorRightOf(cursor, shouldRecomputeLayout);
  }
  
  ExpressionLayoutCursor MatrixLayout::cursorVerticalOf(VerticalDirection direction, ExpressionLayoutCursor cursor, bool * shouldRecomputeLayout, bool equivalentPositionVisited) {
    bool shouldRemoveGreySquares = false;
    int firstIndex = direction == VerticalDirection::Up ? 0 : numberOfChildren() - m_numberOfColumns;
    int lastIndex = direction == VerticalDirection::Up ? m_numberOfColumns : numberOfChildren();
    for (int childIndex = firstIndex; childIndex < lastIndex; childIndex++) {
      if (cursor.pointedExpressionLayout()->hasAncestor(child(childIndex), true)) {
        // The cursor is leaving the matrix, so remove the grey squares.
        shouldRemoveGreySquares = true;
        break;
      }
    }
    ExpressionLayoutCursor resultCursor = GridLayout::cursorVerticalOf(direction, cursor, shouldRecomputeLayout, equivalentPositionVisited);
    if (resultCursor.isDefined() && shouldRemoveGreySquares) {
      assert(hasGreySquares());
      removeGreySquares();
      *shouldRecomputeLayout = true;
    }
    return resultCursor;
  }
  
  void MatrixLayout::replaceChild(const ExpressionLayout * oldChild, ExpressionLayout * newChild, bool deleteOldChild) {
    int oldChildIndex = indexOfChild(oldChild);
    GridLayout::replaceChild(oldChild, newChild, deleteOldChild);
    childWasReplacedAtIndex(oldChildIndex);
  }
  
  void MatrixLayout::replaceChildAndMoveCursor(const ExpressionLayout * oldChild, ExpressionLayout * newChild, bool deleteOldChild, ExpressionLayoutCursor * cursor) {
    int oldChildIndex = indexOfChild(oldChild);
    int rowIndex = rowAtChildIndex(oldChildIndex);
    int columnIndex = columnAtChildIndex(oldChildIndex);
    replaceChild(oldChild, newChild, deleteOldChild);
    int newIndex = indexAtRowColumn(rowIndex, columnIndex);
    assert(newIndex < numberOfChildren());
    cursor->setPointedExpressionLayout(editableChild(newIndex));
    cursor->setPosition(ExpressionLayoutCursor::Position::Right);
  }
  
  void MatrixLayout::removePointedChildAtIndexAndMoveCursor(int index, bool deleteAfterRemoval, ExpressionLayoutCursor * cursor) {
    assert(index >= 0 && index < numberOfChildren());
    assert(cursor->pointedExpressionLayout()->hasAncestor(child(index), true));
    replaceChildAndMoveCursor(child(index), new EmptyLayout(), deleteAfterRemoval, cursor);
  }
  
  int MatrixLayout::writeTextInBuffer(char * buffer, int bufferSize) const {
    // The grid is a matrix.
    if (bufferSize == 0) {
      return -1;
    }
    buffer[bufferSize-1] = 0;
    int numberOfChar = 0;
    if (numberOfChar >= bufferSize-1) { return bufferSize-1;}
  
    buffer[numberOfChar++] = '[';
    if (numberOfChar >= bufferSize-1) { return bufferSize-1;}
  
    int maxRowIndex = hasGreySquares() ? m_numberOfRows - 1 : m_numberOfRows;
    int maxColumnIndex = hasGreySquares() ? m_numberOfColumns - 2 :  m_numberOfColumns - 1;
    for (int i = 0; i < maxRowIndex; i++) {
      buffer[numberOfChar++] = '[';
      if (numberOfChar >= bufferSize-1) { return bufferSize-1;}
  
      numberOfChar += LayoutEngine::writeInfixExpressionLayoutTextInBuffer(this, buffer+numberOfChar, bufferSize-numberOfChar, ",", i*m_numberOfColumns, i* m_numberOfColumns + maxColumnIndex);
      if (numberOfChar >= bufferSize-1) { return bufferSize-1; }
  
      buffer[numberOfChar++] = ']';
      if (numberOfChar >= bufferSize-1) { return bufferSize-1; }
    }
    buffer[numberOfChar++] = ']';
    buffer[numberOfChar] = 0;
    return numberOfChar;
  }
  
  void MatrixLayout::newRowOrColumnAtIndex(int index) {
    assert(index >= 0 && index < m_numberOfColumns*m_numberOfRows);
    bool shouldAddNewRow = GridLayout::childIsBottomOfGrid(index);
    int correspondingRow = rowAtChildIndex(index);
    // We need to compute this boolean before modifying the layout
    if (GridLayout::childIsRightOfGrid(index)) {
      // Color the grey EmptyLayouts of the column in yellow.
      int correspondingColumn = m_numberOfColumns - 1;
      for (int i = 0; i < m_numberOfRows - 1; i++) {
        ExpressionLayout * lastLayoutOfRow = editableChild(i*m_numberOfColumns+correspondingColumn);
        if (lastLayoutOfRow->isEmpty()) {
          static_cast<EmptyLayout *>(lastLayoutOfRow)->setColor(EmptyLayout::Color::Yellow);
        }
      }
      // Add a column of grey EmptyLayouts on the right.
      addEmptyColumn(EmptyLayout::Color::Grey);
    }
    if (shouldAddNewRow) {
      // Color the grey EmptyLayouts of the row in yellow.
      for (int i = 0; i < m_numberOfColumns - 1; i++) {
        ExpressionLayout * lastLayoutOfColumn = editableChild(correspondingRow*m_numberOfColumns+i);
        if (lastLayoutOfColumn->isEmpty()) {
          static_cast<EmptyLayout *>(lastLayoutOfColumn)->setColor(EmptyLayout::Color::Yellow);
        }
      }
      // Add a row of grey EmptyLayouts at the bottom.
      addEmptyRow(EmptyLayout::Color::Grey);
    }
  }
  
  void MatrixLayout::childWasReplacedAtIndex(int index) {
    assert(index >= 0 && index < m_numberOfColumns*m_numberOfRows);
    int rowIndex = rowAtChildIndex(index);
    int columnIndex = columnAtChildIndex(index);
    bool rowIsEmpty = isRowEmpty(rowIndex);
    bool columnIsEmpty = isColumnEmpty(columnIndex);
    if (rowIsEmpty && m_numberOfRows > 2) {
      deleteRowAtIndex(rowIndex);
    }
    if (columnIsEmpty && m_numberOfColumns > 2) {
      deleteColumnAtIndex(columnIndex);
    }
    if (!rowIsEmpty && !columnIsEmpty) {
      ExpressionLayout * newChild = editableChild(index);
      if (newChild->isEmpty()
          && (childIsRightOfGrid(index)
           || childIsBottomOfGrid(index)))
      {
        static_cast<EmptyLayout *>(newChild)->setColor(EmptyLayout::Color::Grey);
      }
    }
  }
  
  void MatrixLayout::render(KDContext * ctx, KDPoint p, KDColor expressionColor, KDColor backgroundColor) {
    const ExpressionLayout * dummyGridLayout = new GridLayout(children(), m_numberOfRows, m_numberOfColumns, true);
    BracketPairLayout dummyLayout(dummyGridLayout, false);
    dummyLayout.render(ctx, p, expressionColor, backgroundColor);
  }
  
  KDSize MatrixLayout::computeSize() {
    const ExpressionLayout * dummyGridLayout = new GridLayout(children(), m_numberOfRows, m_numberOfColumns, true);
    BracketPairLayout dummyLayout(dummyGridLayout, false);
    return dummyLayout.size();
  }
  
  KDPoint MatrixLayout::positionOfChild(ExpressionLayout * child) {
    assert(indexOfChild(child) > -1);
    ExpressionLayout * dummyGridLayout = new GridLayout(children(), m_numberOfRows, m_numberOfColumns, true);
    BracketPairLayout dummyLayout(dummyGridLayout, false);
    return GridLayout::positionOfChild(child).translatedBy(dummyLayout.positionOfChild(dummyGridLayout));
  }
  
  bool MatrixLayout::isRowEmpty(int index) const {
    assert(index >= 0 && index < m_numberOfRows);
    for (int i = index * m_numberOfColumns; i < (index+1) * m_numberOfColumns; i++) {
      if (!child(i)->isEmpty()) {
        return false;
      }
    }
    return true;
  }
  
  bool MatrixLayout::isColumnEmpty(int index) const {
    assert(index >= 0 && index < m_numberOfColumns);
    for (int i = index; i < m_numberOfRows * m_numberOfColumns; i+= m_numberOfColumns) {
      if (!child(i)->isEmpty()) {
        return false;
      }
    }
    return true;
  }
  
  void MatrixLayout::addGreySquares() {
    if (!hasGreySquares()) {
      addEmptyRow(EmptyLayout::Color::Grey);
      addEmptyColumn(EmptyLayout::Color::Grey);
    }
  }
  
  void MatrixLayout::removeGreySquares() {
    if (hasGreySquares()) {
      deleteRowAtIndex(m_numberOfRows - 1);
      deleteColumnAtIndex(m_numberOfColumns - 1);
    }
  }
  
  bool MatrixLayout::hasGreySquares() const {
    assert(m_numberOfRows*m_numberOfColumns - 1 >= 0);
    const ExpressionLayout * lastChild = child(m_numberOfRows * m_numberOfColumns - 1);
    if (lastChild->isEmpty()
        && !lastChild->isHorizontal()
        && (static_cast<const EmptyLayout *>(lastChild))->color() == EmptyLayout::Color::Grey)
    {
      assert(isRowEmpty(m_numberOfRows - 1));
      assert(isColumnEmpty(m_numberOfColumns - 1));
      return true;
    }
    return false;
  }
  
  }