/*
 * Jalview - A Sequence Alignment Editor and Viewer ($$Version-Rel$$)
 * Copyright (C) $$Year-Rel$$ The Jalview Authors
 * 
 * This file is part of Jalview.
 * 
 * Jalview is free software: you can redistribute it and/or
 * modify it under the terms of the GNU General Public License 
 * as published by the Free Software Foundation, either version 3
 * of the License, or (at your option) any later version.
 *  
 * Jalview is distributed in the hope that it will be useful, but 
 * WITHOUT ANY WARRANTY; without even the implied warranty 
 * of MERCHANTABILITY or FITNESS FOR A PARTICULAR 
 * PURPOSE.  See the GNU General Public License for more details.
 * 
 * You should have received a copy of the GNU General Public License
 * along with Jalview.  If not, see <http://www.gnu.org/licenses/>.
 * The Jalview Authors are detailed in the 'AUTHORS' file.
 */
package jalview.datamodel;

import java.util.ArrayList;
import java.util.List;

public class HiddenColumnsCursor
{
  // absolute position of first hidden column
  private int firstColumn;

  private List<int[]> hiddenColumns = new ArrayList<>();

  private HiddenCursorPosition cursorPos = new HiddenCursorPosition(0, 0);

  protected HiddenColumnsCursor()
  {

  }

  protected HiddenColumnsCursor(List<int[]> hiddenCols)
  {
    resetCursor(hiddenCols, 0, 0);
  }

  protected HiddenColumnsCursor(List<int[]> hiddenCols, int index,
          int hiddencount)
  {
    resetCursor(hiddenCols, index, hiddencount);
  }

  /**
   * Reset the cursor with a new hidden columns collection, where we know in
   * advance the index and hidden columns count of a particular location.
   * 
   * @param hiddenCols
   *          new hidden columns collection
   * @param index
   *          cursor index to reset to
   * @param hiddencount
   *          hidden columns count to reset to
   */
  private void resetCursor(List<int[]> hiddenCols, int index,
          int hiddencount)
  {
    hiddenColumns = hiddenCols;
    if (!hiddenCols.isEmpty())
    {
      firstColumn = hiddenColumns.get(0)[0];
      cursorPos = new HiddenCursorPosition(index,
              hiddencount);
    }
  }

  /**
   * Delete the region the cursor is currently at. Avoids having to reset the
   * cursor just because we deleted a region.
   * 
   * Calls to updateForDeletedRegion should be made from within a writeLock in
   * the HiddenColumns class - since changes to the hiddenColumns collection
   * require a writeLock the lock should already exist.
   *
   * @param hiddenCols
   */
  protected void updateForDeletedRegion(List<int[]> hiddenCols)
  {

    if (!hiddenCols.isEmpty())
    {
      // if there is a region to the right of the current region,
      // nothing changes; otherwise
      // we deleted the last region (index=hiddenCols.size()-1)
      // or the index was at the end of the alignment (index=hiddenCols.size())
      HiddenCursorPosition oldpos = cursorPos;

      int index = oldpos.getRegionIndex();
      if (index >= hiddenColumns.size() - 1)
      {
        // deleted last region, index is now end of alignment
        index = hiddenCols.size();

        cursorPos = new HiddenCursorPosition(index,
                oldpos.getHiddenSoFar());
      }
    }
    hiddenColumns = hiddenCols;
  }

  /**
   * Get the cursor pointing to the hidden region that column is within (if
   * column is hidden) or which is to the right of column (if column is
   * visible). If no hidden columns are to the right, returns a cursor pointing
   * to an imaginary hidden region beyond the end of the hidden columns
   * collection (this ensures the count of previous hidden columns is correct).
   * If hidden columns is empty returns null.
   * 
   * @param column
   *          absolute position of a column in the alignment
   * @return cursor pointing to hidden region containing the column (if hidden)
   *         or to the right of the column (if visible)
   */
  /*protected HiddenCursorPosition findRegionForColumn(int column)
  {
    return findRegionForColumn(column, false);
  }*/

  /**
   * Get the cursor pointing to the hidden region just after a visible column
   * 
   * @param column
   *          index of column in *visible* alignment (therefore by definition
   *          column is visible)
   * @return cursor pointing to hidden region to the right of the column
   */
  /* protected HiddenCursorPosition findRegionForVisColumn(int column)
  {
    return findRegionForColumn(column, true);
  }*/

  /**
   * Get the cursor pointing to the hidden region that column is within (if
   * column is hidden) or which is to the right of column (if column is
   * visible). If no hidden columns are to the right, returns a cursor pointing
   * to an imaginary hidden region beyond the end of the hidden columns
   * collection (this ensures the count of previous hidden columns is correct).
   * If hidden columns is empty returns null.
   * 
   * @param column
   *          index of column in visible or absolute coordinates
   * @param useVisible
   *          true if column is in visible coordinates, false if absolute
   * @return cursor pointing to hidden region containing the column (if hidden)
   *         or to the right of the column (if visible)
   */
  protected HiddenCursorPosition findRegionForColumn(int column,
          boolean useVisible)
  {
    if (hiddenColumns.isEmpty())
    {
      return null;
    }

    // used to add in hiddenColumns offset when working with visible columns
    int offset = (useVisible ? 1 : 0);

    HiddenCursorPosition oldpos = cursorPos;
    int index = oldpos.getRegionIndex();
    int hiddenCount = oldpos.getHiddenSoFar();

    if (column < firstColumn)
    {
      index = 0;
      hiddenCount = 0;
    }

    // column is after current region
    else if ((index < hiddenColumns.size())
            && (hiddenColumns.get(index)[0] <= column
                    + offset * hiddenCount))
    {
      // iterate from where we are now, if we're lucky we'll be close by
      // (but still better than iterating from 0)
      // stop when we find the region *before* column
      // i.e. the next region starts after column or if not, ends after column
      while ((index < hiddenColumns.size())
              && (((useVisible && hiddenColumns.get(index)[0] <= column
                      + offset * hiddenCount))
                      || (!useVisible
                              && hiddenColumns.get(index)[1] < column)))
      {
        int[] region = hiddenColumns.get(index);
        hiddenCount += region[1] - region[0] + 1;
        index++;
      }
    }

    // column is before current region
    else
    {
      // column is before or in the previous region
      while ((index > 0) && (hiddenColumns.get(index - 1)[1] >= column
              + offset * hiddenCount))
      {
        index--;
        int[] region = hiddenColumns.get(index);
        hiddenCount -= region[1] - region[0] + 1;
      }
    }

    if (index != oldpos.getRegionIndex()
            || hiddenCount != oldpos.getHiddenSoFar())
    {
      return new HiddenCursorPosition(index, hiddenCount);
    }
    return oldpos;
  }

}