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


/** Data structure to hold and manipulate a multiple sequence alignment
 */
public interface AlignmentI
{
    /**
     *  Calculates the number of sequences in an alignment
     *
     * @return Number of sequences in alignment
     */
    public int getHeight();

    /**
     * Calculates the maximum width of the alignment, including gaps.
     *
     * @return Greatest sequence length within alignment.
     */
    public int getWidth();

    /**
     * Calculates the longest sequence Id of the alignment
     *
     * @return Number of characters in longest sequence Id.
     */
    public int getMaxIdLength();

    /**
     * Calculates if this set of sequences is all the same length
     *
     * @return true if all sequences in alignment are the same length
     */
    public boolean isAligned();

    /**
     * Gets sequences as a Vector
     *
     * @return All sequences in alignment.
     */
    public Vector getSequences();

    /**
     * Find a specific sequence in this alignment.
     *
     * @param i Index of required sequence.
     *
     * @return SequenceI at given index.
     */
    public SequenceI getSequenceAt(int i);

    /**
     * Add a new sequence to this alignment.
     *
     * @param seq New sequence will be added at end of alignment.
     */
    public void addSequence(SequenceI seq);

    /**
     * Used to set a particular index of the alignment with the given sequence.
     *
     * @param i Index of sequence to be updated.
     * @param seq New sequence to be inserted.
     */
    public void setSequenceAt(int i, SequenceI seq);

    /**
     * Deletes a sequence from the alignment.
     *
     * @param s Sequence to be deleted.
     */
    public void deleteSequence(SequenceI s);

    /**
     * Deletes a sequence from the alignment.
     *
     * @param i Index of sequence to be deleted.
     */
    public void deleteSequence(int i);

    /**
     * Deletes all residues in every sequence of alignment within given columns.
     *
     * @param start Start index of columns to delete.
     * @param end End index to columns to delete.
     */
    public void deleteColumns(int start, int end);

    /**
     * Deletes all residues in every sequence of alignment within given columns.
     *
     * @param seq1 Index of first sequence to delete columns from.
     * @param seq2 Index of last sequence to delete columns from.
     * @param start Start index of columns to delete.
     * @param end End index of columns to delete.
     */
    public void deleteColumns(int seq1, int seq2, int start, int end);

    /**
     * Finds sequence in alignment using sequence name as query.
     *
     * @param name Id of sequence to search for.
     *
     * @return Sequence matching query, if found. If not found returns null.
     */
    public SequenceI findName(String name);


    /**
     * Finds index of a given sequence in the alignment.
     *
     * @param s Sequence to look for.
     *
     * @return Index of sequence within the alignment.
     */
    public int findIndex(SequenceI s);

    /**
    * All sequences will be cut from beginning to given index.
    *
    * @param i Remove all residues in sequences up to this column.
     */
    public void trimLeft(int i);

    /**
     * All sequences will be cut from given index.
     *
     * @param i Remove all residues in sequences beyond this column.
     */
    public void trimRight(int i);

    /**
     * Removes all columns containing entirely gap characters.
     */
    public void removeGaps();

    /**
     * Removes redundant sequences from alignment.
     *
     * @param threshold Remove all sequences above the given threshold.
     * @param sel Set of sequences which will have redundant sequences removed from.
     *
     * @return All sequences below redundancy threshold.
     */
    public Vector removeRedundancy(float threshold, Vector sel);

    /**
     * Finds group that sequence at index i in alignment is part of.
     *
     * @param i Index in alignment.
     *
     * @return First group found for sequence at position i. WARNING :
     * Sequences may be members of several groups. This method is incomplete.
     */
    public SequenceGroup findGroup(int i);

    /**
     * Finds group that given sequence is part of.
     *
     * @param s Sequence in alignment.
     *
     * @return First group found for sequence. WARNING :
     * Sequences may be members of several groups. This method is incomplete.
     */
    public SequenceGroup findGroup(SequenceI s);

    /**
     * Finds all groups that a given sequence is part of.
     *
     * @param s Sequence in alignment.
     *
     * @return All groups containing given sequence.
     */
    public SequenceGroup[] findAllGroups(SequenceI s);

    /**
     * Adds a new SequenceGroup to this alignment.
     *
     * @param sg New group to be added.
     */
    public void addGroup(SequenceGroup sg);

    /**
     * Deletes a specific SequenceGroup
     *
     * @param g Group will be deleted from alignment.
     */
    public void deleteGroup(SequenceGroup g);

    /**
     * Get all the groups associated with this alignment.
     *
     * @return All groups as a Vector.
     */
    public Vector getGroups();

    /**
     * Deletes all groups from this alignment.
     */
    public void deleteAllGroups();

    /**
     * Adds a super group. A SuperGroup is a group of groups.
     *
     * @param sg Adds a new SuperGroup to alignment
     */
    public void addSuperGroup(SuperGroup sg);

    /**
     * Removes SuperGroup from alignment.
     *
     * @param sg This SuperGroup will be deleted from alignment.
     */
    public void removeSuperGroup(SuperGroup sg);

    /**
     * Finds any SuperGroup that a given SequenceGroup may be part of.
     *
     * @param sg SequenceGroup to search for.
     *
     * @return SuperGroup that contains the given SequenceGroup.
     */
    public SuperGroup getSuperGroup(SequenceGroup sg);

    /**
     * Adds a new AlignmentAnnotation to this alignment
     */
    public void addAnnotation(AlignmentAnnotation aa);

    /**
     * Deletes a specific AlignmentAnnotation from the alignment.
     *
     * @param aa DOCUMENT ME!
     */
    public void deleteAnnotation(AlignmentAnnotation aa);

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

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

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

    /**
     * DOCUMENT ME!
     *
     * @return DOCUMENT ME!
     */
    public Vector getAAFrequency();

    /**
     * Returns true if alignment is nucleotide sequence
     *
     * @return DOCUMENT ME!
     */
    public boolean isNucleotide();

    /**
     * Set true if the alignment is a nucleotide sequence
     *
     * @return
     */
    public void setNucleotide(boolean b);


    public Alignment getDataset();

    public void setDataset(Alignment dataset);

    public Provenance getProvenance();

    public void setProvenance(Provenance prov);



}