/*
 * 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 jalview.analysis.*;

import jalview.util.*;

import java.util.*;

/** Data structure to hold and manipulate a multiple sequence alignment
 */
public class Alignment implements AlignmentI
{
    protected Alignment dataset;
    protected Vector sequences;
    protected Vector groups = new Vector();
    protected char gapCharacter = '-';
    protected int type = NUCLEOTIDE;
    public static final int PROTEIN = 0;
    public static final int NUCLEOTIDE = 1;

    /** DOCUMENT ME!! */
    public AlignmentAnnotation[] annotations;

    HiddenSequences hiddenSequences = new HiddenSequences(this);


    /** Make an alignment from an array of Sequences.
     *
     * @param sequences
     */
    public Alignment(SequenceI[] seqs)
    {
        int i=0;

        if( jalview.util.Comparison.isNucleotide(seqs))
          type = NUCLEOTIDE;
        else
          type = PROTEIN;

        sequences = new Vector();

        for (i = 0; i < seqs.length; i++)
        {
            sequences.addElement(seqs[i]);
        }
    }

    /**
     * DOCUMENT ME!
     *
     * @return DOCUMENT ME!
     */
    public Vector getSequences()
    {
        return sequences;
    }

    public SequenceI [] getSequencesArray()
    {
      SequenceI [] reply = new SequenceI[sequences.size()];
      for(int i=0; i<sequences.size(); i++)
      {
        reply[i] = (SequenceI)sequences.elementAt(i);
      }
      return reply;
    }

    /**
     * DOCUMENT ME!
     *
     * @param i DOCUMENT ME!
     *
     * @return DOCUMENT ME!
     */
    public SequenceI getSequenceAt(int i)
    {
        if (i < sequences.size())
        {
            return (SequenceI) sequences.elementAt(i);
        }

        return null;
    }

    /** Adds a sequence to the alignment.  Recalculates maxLength and size.
     *
     * @param snew
     */
    public void addSequence(SequenceI snew)
    {
      if(dataset!=null)
      {
        Sequence ds = new Sequence(snew.getName(),
                                   AlignSeq.extractGaps("-. ", snew.getSequence()),
                                   snew.getStart(),
                                   snew.getEnd());

        snew.setDatasetSequence(ds);
        getDataset().addSequence(ds);
      }

      sequences.addElement(snew);
    }


    /** Adds a sequence to the alignment.  Recalculates maxLength and size.
     *
     * @param snew
     */
    public void setSequenceAt(int i, SequenceI snew)
    {
        SequenceI oldseq = getSequenceAt(i);
        deleteSequence(oldseq);

        sequences.setElementAt(snew, i);
    }

    /**
     * DOCUMENT ME!
     *
     * @return DOCUMENT ME!
     */
    public Vector getGroups()
    {
        return groups;
    }

    /** Takes out columns consisting entirely of gaps (-,.," ")
     */
    public void removeGaps()
    {
        SequenceI current;
        int iSize = getWidth();

        for (int i = 0; i < iSize; i++)
        {
            boolean delete = true;

            for (int j = 0; j < getHeight(); j++)
            {
                current = getSequenceAt(j);

                if (current.getLength() > i)
                {
                    if (!jalview.util.Comparison.isGap(current.getCharAt(i)))
                    {
                        delete = false;
                    }
                }
            }

            if (delete)
            {
                deleteColumns(i, i);
                iSize--;
                i--;
            }
        }
    }

    /** Removes a range of columns (start to end inclusive).
     *
     * @param start Start column in the alignment
     * @param end End column in the alignment
     */
    public void deleteColumns(int start, int end)
    {
        deleteColumns(0, getHeight() - 1, start, end);
    }

    /**
     * DOCUMENT ME!
     *
     * @param seq1 DOCUMENT ME!
     * @param seq2 DOCUMENT ME!
     * @param start DOCUMENT ME!
     * @param end DOCUMENT ME!
     */
    public void deleteColumns(int seq1, int seq2, int start, int end)
    {
        for (int i = 0; i <= (end - start); i++)
        {
            for (int j = seq1; j <= seq2; j++)
            {
                getSequenceAt(j).deleteCharAt(start);
            }
        }
    }

    /**
     * DOCUMENT ME!
     *
     * @param i DOCUMENT ME!
     */
    public void trimLeft(int i)
    {
        int j, jSize = getHeight();
        for (j = 0; j < jSize; j++)
        {
            SequenceI s = getSequenceAt(j);
            int newstart = s.findPosition(i);

            if(i>s.getLength())
            {
              sequences.removeElement(s);
              j--;
              jSize--;
            }
            else
            {
              s.setStart(newstart);
              s.setSequence(s.getSequence().substring(i));
            }
        }
    }

    /**
     * DOCUMENT ME!
     *
     * @param i DOCUMENT ME!
     */
    public void trimRight(int i)
    {
        for (int j = 0; j < getHeight(); j++)
        {
            SequenceI s = getSequenceAt(j);
            int newend = s.findPosition(i);

            s.setEnd(newend);
            if(s.getLength()>i)
              s.setSequence(s.getSequence().substring(0, i + 1));
        }
    }

    /**
     * DOCUMENT ME!
     *
     * @param s DOCUMENT ME!
     */
    public void deleteSequence(SequenceI s)
    {
        for (int i = 0; i < getHeight(); i++)
        {
            if (getSequenceAt(i) == s)
            {
                deleteSequence(i);
            }
        }
    }

    /**
     * DOCUMENT ME!
     *
     * @param i DOCUMENT ME!
     */
    public void deleteSequence(int i)
    {
        sequences.removeElementAt(i);
    }


    /**    */
    public SequenceGroup findGroup(SequenceI s)
    {
        for (int i = 0; i < this.groups.size(); i++)
        {
            SequenceGroup sg = (SequenceGroup) groups.elementAt(i);

            if (sg.getSequences(false).contains(s))
            {
                return sg;
            }
        }

        return null;
    }

    /**
     * DOCUMENT ME!
     *
     * @param s DOCUMENT ME!
     *
     * @return DOCUMENT ME!
     */
    public SequenceGroup[] findAllGroups(SequenceI s)
    {
        Vector temp = new Vector();

        int gSize = groups.size();
        for (int i = 0; i < gSize; i++)
        {
            SequenceGroup sg = (SequenceGroup) groups.elementAt(i);
            if(sg==null || sg.getSequences(false)==null)
            {
              this.deleteGroup(sg);
              gSize--;
              continue;
            }

            if (sg.getSequences(false).contains(s))
            {
                temp.addElement(sg);
            }
        }

        SequenceGroup[] ret = new SequenceGroup[temp.size()];

        for (int i = 0; i < temp.size(); i++)
        {
            ret[i] = (SequenceGroup) temp.elementAt(i);
        }

        return ret;
    }



    /**    */
    public void addGroup(SequenceGroup sg)
    {
        if (!groups.contains(sg))
        {
            groups.addElement(sg);
        }
    }

    /**
     * DOCUMENT ME!
     */
    public void deleteAllGroups()
    {
        groups.removeAllElements();

        int i = 0;

        while (i < sequences.size())
        {
            SequenceI s = getSequenceAt(i);
            s.setColor(java.awt.Color.white);
            i++;
        }
    }

    /**    */
    public void deleteGroup(SequenceGroup g)
    {
        if (groups.contains(g))
        {
            groups.removeElement(g);
        }
    }

    /**    */
    public SequenceI findName(String name)
    {
        int i = 0;

        while (i < sequences.size())
        {
            if (getSequenceAt(i).getName().equals(name))
            {
                return getSequenceAt(i);
            }

            i++;
        }

        return null;
    }


    /**    */
    public int findIndex(SequenceI s)
    {
        int i = 0;

        while (i < sequences.size())
        {
            if (s == getSequenceAt(i))
            {
                return i;
            }

            i++;
        }

        return -1;
    }

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

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

        for (int i = 0; i < sequences.size(); i++)
        {
            if (getSequenceAt(i).getLength() > maxLength)
            {
                maxLength = getSequenceAt(i).getLength();
            }
        }

        return maxLength;
    }

    /**
     * DOCUMENT ME!
     *
     * @return DOCUMENT ME!
     */
    public int getMaxIdLength()
    {
        int max = 0;
        int i = 0;

        while (i < sequences.size())
        {
            SequenceI seq = getSequenceAt(i);
            String tmp = seq.getName() + "/" + seq.getStart() + "-" +
                seq.getEnd();

            if (tmp.length() > max)
            {
                max = tmp.length();
            }

            i++;
        }

        return max;
    }

    /**
     * DOCUMENT ME!
     *
     * @param gc DOCUMENT ME!
     */
    public void setGapCharacter(char gc)
    {
        gapCharacter = gc;

        for (int i = 0; i < sequences.size(); i++)
        {
            Sequence seq = (Sequence) sequences.elementAt(i);
            seq.setSequence( seq.getSequence().replace('.', gc) );
            seq.setSequence( seq.getSequence().replace('-', gc) );
            seq.setSequence( seq.getSequence().replace(' ', gc) );
        }
    }

    /**
     * DOCUMENT ME!
     *
     * @return DOCUMENT ME!
     */
    public char getGapCharacter()
    {
        return gapCharacter;
    }

    /**
     * DOCUMENT ME!
     *
     * @return DOCUMENT ME!
     */
    public Vector getAAFrequency()
    {
        return AAFrequency.calculate(sequences, 0, getWidth());
    }

    /**
     * DOCUMENT ME!
     *
     * @return DOCUMENT ME!
     */
    public boolean isAligned()
    {
        int width = getWidth();

        for (int i = 0; i < sequences.size(); i++)
        {
            if (getSequenceAt(i).getLength() != width)
            {
                return false;
            }
        }

        return true;
    }

    /**
     * DOCUMENT ME!
     *
     * @param aa DOCUMENT ME!
     */
    public void deleteAnnotation(AlignmentAnnotation aa)
    {
        int aSize = 1;

        if (annotations != null)
        {
            aSize = annotations.length;
        }

        AlignmentAnnotation[] temp = new AlignmentAnnotation[aSize - 1];

        int tIndex = 0;

        for (int i = 0; i < aSize; i++)
        {
            if (annotations[i] == aa)
            {
                continue;
            }

            temp[tIndex] = annotations[i];
            tIndex++;
        }

        annotations = temp;
    }


    public void adjustSequenceAnnotations()
    {
      if(annotations!=null)
      {
        for (int a = 0; a < annotations.length; a++)
        {
          if (annotations[a].sequenceRef != null)
          {
            annotations[a].adjustForAlignment();
          }
        }
      }
    }

    /**
     * DOCUMENT ME!
     *
     * @param aa DOCUMENT ME!
     */
    public void addAnnotation(AlignmentAnnotation aa)
    {
        int aSize = 1;
        if (annotations != null)
        {
            aSize = annotations.length + 1;
        }

        AlignmentAnnotation[] temp = new AlignmentAnnotation[aSize];

        temp[aSize-1] = aa;

        int i = 0;

        if (aSize > 1)
        {
            for (i = 0; i < (aSize-1); i++)
            {
                temp[i] = annotations[i];
            }
        }

        annotations = temp;
    }

    public void setAnnotationIndex(AlignmentAnnotation aa, int index)
    {
      if(aa==null || annotations==null || annotations.length-1<index)
        return;

      int aSize = annotations.length;
      AlignmentAnnotation[] temp = new AlignmentAnnotation[aSize];

      temp[index] = aa;

      for (int i = 0; i < aSize; i++)
      {
        if(i==index)
          continue;

        if(i<index)
          temp[i] = annotations[i];
        else
          temp[i] = annotations[i-1];
      }

        annotations = temp;
    }

    /**
     * DOCUMENT ME!
     *
     * @return DOCUMENT ME!
     */
    public AlignmentAnnotation[] getAlignmentAnnotation()
    {
        return annotations;
    }

    public void setNucleotide(boolean b)
    {
      if(b)
        type = NUCLEOTIDE;
      else
        type = PROTEIN;
    }

    public boolean isNucleotide()
    {
      if(type==NUCLEOTIDE)
        return true;
      else
        return false;
    }

    public void setDataset(Alignment data)
    {
      if(dataset==null && data==null)
      {
        // Create a new dataset for this alignment.
        // Can only be done once, if dataset is not null
        // This will not be performed
        Sequence[] seqs = new Sequence[getHeight()];
        for (int i = 0; i < getHeight(); i++)
        {

          seqs[i] = new Sequence(getSequenceAt(i).getName(),
                                 AlignSeq.extractGaps(
                                     jalview.util.Comparison.GapChars,
                                     getSequenceAt(i).getSequence()
                                 ),
                                 getSequenceAt(i).getStart(),
                                 getSequenceAt(i).getEnd());

          getSequenceAt(i).setDatasetSequence(seqs[i]);
        }

        dataset = new Alignment(seqs);
      }
      else if(dataset==null && data!=null)
      {
        dataset = data;
      }
    }

    public Alignment getDataset()
    {
      return dataset;
    }

    public boolean padGaps() {
      boolean modified=false;

      //Remove excess gaps from the end of alignment
      int maxLength = -1;

      SequenceI current;
      for (int i = 0; i < sequences.size(); i++)
      {
        current = getSequenceAt(i);
        for (int j = current.getLength(); j > maxLength; j--)
        {
          if (j > maxLength && !jalview.util.Comparison.isGap(
              current.getCharAt(j)))
          {
            maxLength = j;
            break;
          }
        }
      }

      maxLength++;

      for (int i = 0; i < sequences.size();
           i++)
      {
        current = getSequenceAt(i);

        if (current.getLength() < maxLength)
        {
          current.insertCharAt(maxLength - 1, gapCharacter);
          modified=true;
        }
        else if(current.getLength() > maxLength)
        {
          current.deleteChars(maxLength, current.getLength());
        }
      }
      return modified;
    }

    public HiddenSequences getHiddenSequences()
    {
      return hiddenSequences;
    }

}