/*
 * Jalview - A Sequence Alignment Editor and Viewer
 * Copyright (C) 2005 AM Waterhouse, J Procter, G Barton, M Clamp, S Searle
 *
 * This program 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 2
 * of the License, or (at your option) any later version.
 *
 * This program 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 this program; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA
 */
package jalview.datamodel;

import java.util.*;

/**
 * NOTE: Columns are zero based.
 */
public class ColumnSelection
{
    Vector selected = new Vector();

    //Vector of int [] {startCol, endCol}
    Vector hiddenColumns;

    /**
     * Add a column to the selection
     *
     * @param col index of column
     */
    public void addElement(int col)
    {
        Integer column = new Integer(col);
        if (!selected.contains(column))
        {
            selected.addElement(column);
        }
    }

    /**
     * clears column selection
     */
    public void clear()
    {
        selected.removeAllElements();
    }

    /**
     * removes col from selection
     *
     * @param col index of column to be removed
     */
    public void removeElement(int col)
    {
        Integer colInt = new Integer(col);

        if (selected.contains(colInt))
        {
            selected.removeElement(colInt);
        }
    }

    /**
     * removes a range of columns from the selection
     * @param start int - first column in range to be removed
     * @param end int - last col
     */
    public void removeElements(int start, int end)
    {
      Integer colInt;
      for(int i=start; i<end; i++)
      {
        colInt = new Integer(i);
        if (selected.contains(colInt))
        {
            selected.removeElement(colInt);
        }
      }
    }
    /**
     *
     * @return Vector containing selected columns as Integers
     */
    public Vector getSelected()
    {
      return selected;
    }

    /**
     *
     * @param col index to search for in column selection
     *
     * @return true if Integer(col) is in selection.
     */
    public boolean contains(int col)
    {
        return selected.contains(new Integer(col));
    }

    /**
     * DOCUMENT ME!
     *
     * @param i DOCUMENT ME!
     *
     * @return DOCUMENT ME!
     */
    public int columnAt(int i)
    {
        return ((Integer) selected.elementAt(i)).intValue();
    }

    /**
     * DOCUMENT ME!
     *
     * @return DOCUMENT ME!
     */
    public int size()
    {
        return selected.size();
    }

    /**
     * DOCUMENT ME!
     *
     * @return DOCUMENT ME!
     */
    public int getMax()
    {
        int max = -1;

        for (int i = 0; i < selected.size(); i++)
        {
            if (columnAt(i) > max)
            {
                max = columnAt(i);
            }
        }

        return max;
    }

    /**
     * DOCUMENT ME!
     *
     * @return DOCUMENT ME!
     */
    public int getMin()
    {
        int min = 1000000000;

        for (int i = 0; i < selected.size(); i++)
        {
            if (columnAt(i) < min)
            {
                min = columnAt(i);
            }
        }

        return min;
    }


    /**
     * DOCUMENT ME!
     *
     * @param start DOCUMENT ME!
     * @param change DOCUMENT ME!
     */
    public void compensateForEdit(int start, int change)
    {
        for (int i = 0; i < size(); i++)
        {
            int temp = columnAt(i);

            if (temp >= start)
            {
                selected.setElementAt(new Integer(temp - change), i);
            }
        }

        if(hiddenColumns!=null)
        {
          for(int i=0; i<hiddenColumns.size(); i++)
          {
            int[] region = (int[]) hiddenColumns.elementAt(i);
            if(region[0] > start)
            {
              region[0] -= change;
              region[1] -= change;
            }
            if(region[0]<0)
              region[0] = 0;
            if(region[1] <0)
             region[1] = 0;
          }
        }
    }

    /**
     * This Method is used to return all the HiddenColumn regions
     * less than the given index.
     * @param end int
     * @return Vector
     */
    public Vector getHiddenColumns()
    {
      return hiddenColumns;
    }
    /**
     * Return absolute column index for a visible column index
     * @param column int column index in alignment view
     * @return alignment column index for column
     */
    public int adjustForHiddenColumns(int column)
    {
      int result = column;
      if (hiddenColumns != null)
      {
        for (int i = 0; i < hiddenColumns.size(); i++)
        {
          int[] region = (int[]) hiddenColumns.elementAt(i);
          if (result >= region[0])
          {
            result += region[1] - region[0] + 1;
          }
        }
      }
      return result;
    }

    /**
     * Use this method to find out where a visible column is in the alignment
     * when hidden columns exist
     * @param hiddenColumn int
     * @return int
     */
    public int findColumnPosition(int hiddenColumn)
    {
      int result = hiddenColumn;
      if (hiddenColumns != null)
      {
        int index = 0;
        int gaps = 0;
        do
        {
          int[] region = (int[]) hiddenColumns.elementAt(index);
          if (hiddenColumn > region[1])
          {
            result -= region[1]+1-region[0];
          }
          index++;
        }
        while (index < hiddenColumns.size());

        result -= gaps;
      }

      return result;
    }

    /**
     * Use this method to determine where the next hiddenRegion starts
    */
    public int findHiddenRegionPosition(int hiddenRegion)
    {
      int result = 0;
      if (hiddenColumns != null)
      {
        int index = 0;
        int gaps = 0;
        do
        {
          int[] region = (int[]) hiddenColumns.elementAt(index);
          if(hiddenRegion==0)
          {
            return region[0];
          }

            gaps +=  region[1] +1 - region[0];
            result = region[1] +1;
            index++;
        }
        while(index < hiddenRegion+1);

        result -= gaps;
      }

      return result;
    }

    /**
     * THis method returns the rightmost limit of a
     * region of an alignment with hidden columns.
     * In otherwords, the next hidden column.
     * @param index int
     */
    public int getHiddenBoundaryRight(int alPos)
    {
      if (hiddenColumns != null)
      {
        int index = 0;
        do
        {
          int[] region = (int[]) hiddenColumns.elementAt(index);
          if(alPos < region[0])
            return region[0];

          index++;
        }
        while(index < hiddenColumns.size());
      }

      return alPos;

    }
    /**
     * THis method returns the rightmost limit of a
     * region of an alignment with hidden columns.
     * In otherwords, the next hidden column.
     * @param index int
     */
    public int getHiddenBoundaryLeft(int alPos)
    {
      if (hiddenColumns != null)
      {
        int index = hiddenColumns.size()-1;
        do
        {
          int[] region = (int[]) hiddenColumns.elementAt(index);
          if(alPos > region[1])
            return region[1];

          index--;
        }
        while(index >-1);
      }

      return alPos;

    }

    public void hideSelectedColumns()
    {
      while (size() > 0)
      {
        int column = ( (Integer) getSelected().firstElement()).intValue();
        hideColumns(column);
      }

    }

    public void hideColumns(int start, int end)
    {
      if(hiddenColumns==null)
        hiddenColumns = new Vector();

      boolean added = false;
      boolean overlap = false;

      for (int i = 0; i < hiddenColumns.size(); i++)
      {
        int[] region = (int[]) hiddenColumns.elementAt(i);
        if ( start<=region[1] && end>=region[0])
        {
          hiddenColumns.removeElementAt(i);
          overlap = true;
          break;
        }
        else if (end < region[0] && start < region[0])
        {
          hiddenColumns.insertElementAt(new int[]
                                        {start, end}, i);
          added = true;
          break;
        }
      }

      if(overlap)
      {
         hideColumns(start, end);
      }
      else if (!added)
        hiddenColumns.addElement(new int[] {start, end});

    }

    /**
     * This method will find a range of selected columns
     * around the column specified
     * @param res int
     */
    public void hideColumns(int col)
    {
      // First find out range of columns to hide
      int min = col, max = col+1;
      while( contains(min) )
      {  removeElement(min); min --;  }

      while( contains(max) )
      { removeElement(max);  max ++;  }

      min++; max--;

      hideColumns(min, max);
    }

    public void revealAllHiddenColumns()
    {
      if(hiddenColumns!=null)
      {
        for (int i = 0; i < hiddenColumns.size(); i++)
        {
          int[] region = (int[]) hiddenColumns.elementAt(i);
          for (int j = region[0]; j < region[1]; j++)
          {
            addElement(j);
          }
        }
      }

      hiddenColumns = null;
    }

    public void revealHiddenColumns(int res)
    {
      for(int i=0; i<hiddenColumns.size(); i++)
      {
        int [] region = (int[])hiddenColumns.elementAt(i);
        if( res == region[0])
        {
          for (int j = region[0]; j < region[1]; j++)
          {
            addElement(j);
          }

          hiddenColumns.removeElement(region);
          break;
        }
      }
      if(hiddenColumns.size()==0)
        hiddenColumns = null;
    }

    public boolean isVisible(int column)
    {
      for(int i=0; i<hiddenColumns.size(); i++)
      {
        int [] region = (int[])hiddenColumns.elementAt(i);
        if( column >= region[0] && column <= region[1])
        {
          return false;
        }
      }
      return true;
    }

}