package jalview.datamodel;

import java.util.List;

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

  // absolute position of last hidden column
  private int lastColumn;

  // index of last visited region
  private int regionIndex;

  // number of hidden columns before last visited region
  private int hiddenSoFar;

  // flag to indicate if current cursor settings are valid
  private boolean isValid;

  private List<int[]> hiddenColumns;

  protected HiddenColumnsCursor()
  {
    isValid = false;
  }

  /**
   * Set the cursor to a position
   * 
   * @param first
   *          absolute position of first hidden column
   * @param last
   *          absolute position of last hidden column
   * @param index
   *          index of last visited region
   * @param hiddenCount
   *          number of hidden columns before last visited region
   */
  protected void resetCursor(// int first, int last, int index, int hiddenCount,
          List<int[]> hiddenCols)
  {
    isValid = true;
    if ((hiddenCols != null) && (!hiddenCols.isEmpty()))
    {
      hiddenColumns = hiddenCols;
      firstColumn = hiddenColumns.get(0)[0];
      lastColumn = hiddenColumns.get(hiddenColumns.size() - 1)[1];
      regionIndex = 0;
      hiddenSoFar = 0;
    }
  }

  protected void updateCursor(int index, int hiddenCount)
  {
    regionIndex = index;
    hiddenSoFar = hiddenCount;
  }

  /**
   * Get the index of the 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, will return size of hiddenColumns. If hidden
   * columns is empty returns -1.
   * 
   * @param column
   *          absolute position of a column in the alignment
   * @return region index
   */
  protected int findRegionForColumn(int column)
  {
    if (hiddenColumns == null)
    {
      return -1;
    }

    if ((hiddenColumns.get(regionIndex)[0] <= column)
            && (hiddenColumns.get(regionIndex)[1] >= column))
    {
      // we hit the jackpot
      return regionIndex;
    }
    else if (column < firstColumn)
    {
      return 0;
    }
    else if (column > lastColumn)
    {
      return hiddenColumns.size();
    }
    else if (column > hiddenColumns.get(regionIndex)[1])
    {
      // iterate from where we are now, if we're lucky we'll be close by
      // (but still better than iterating from 0)
      while ((regionIndex < hiddenColumns.size())
              && (hiddenColumns.get(regionIndex)[0] <= column))
      {
        int[] region = hiddenColumns.get(regionIndex);
        hiddenSoFar += region[1] - region[0] + 1;
        regionIndex++;
      }

    }
    else // (column < hiddenColumns.get(regionIndex)[0])
    {
      int lastHidden = 0;
      while ((regionIndex >= 0)
              && (hiddenColumns.get(regionIndex)[0] > column))
      {
        int[] region = hiddenColumns.get(regionIndex);
        hiddenSoFar -= lastHidden;
        lastHidden = region[1] - region[0] + 1;
        regionIndex--;
      }
      hiddenSoFar -= lastHidden;
    }
    return regionIndex;
  }

  protected int getHiddenOffset(int column)
  {
    if (hiddenColumns == null)
    {
      return -1;
    }

    if (column < firstColumn)
    {
      return 0;
    }
    else if ((regionIndex < hiddenColumns.size())
      && (hiddenColumns.get(regionIndex)[0] <= column
      + hiddenSoFar))
    {

      // iterate from where we are now, if we're lucky we'll be close by
      // (but still better than iterating from 0)
      while ((regionIndex < hiddenColumns.size())
              && (hiddenColumns.get(regionIndex)[0] <= column
                      + hiddenSoFar))
      {
        int[] region = hiddenColumns.get(regionIndex);
        hiddenSoFar += region[1] - region[0] + 1;
        regionIndex++;
      }
    }
    else if (regionIndex < hiddenColumns.size())
    {
      int lastHidden = hiddenColumns.get(regionIndex)[1]
              - hiddenColumns.get(regionIndex)[0] + 1;

      while ((regionIndex >= 0)
              && (hiddenColumns.get(regionIndex)[0] <= column + hiddenSoFar
                      - lastHidden))
      {
        int[] region = hiddenColumns.get(regionIndex);
        hiddenSoFar -= lastHidden;
        lastHidden = region[1] - region[0] + 1;
        regionIndex--;
      }

    }
  
    int result = hiddenSoFar;
    if ((regionIndex >= 0) && (regionIndex < hiddenColumns.size())
            && (hiddenColumns.get(regionIndex)[0] <= column + hiddenSoFar)
            && (hiddenColumns.get(regionIndex)[1] >= column + hiddenSoFar))
    {
      int[] region = hiddenColumns.get(regionIndex);
      result += region[1] - region[0] + 1;
    }

    return result;
  }

  /* public int findVisiblePositionFromAbsolute(int column)
  {
  
  }
  
  public int findAbsolutePositionFromVisible(int column)
  {
  
  }*/
}