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

import jalview.analysis.*;

import jalview.datamodel.*;

import java.util.*;


/**
 * Takes in a vector of sequences and column start and column end
 * and returns a vector of size (end-start+1). Each element of the
 * vector contains a hashtable with the keys being residues and
 * the values being the count of each residue in that column.
 * This class is used extensively in calculating alignment colourschemes
 * that depend on the amount of conservation in each alignment column.
 * @author $author$
 * @version $Revision$
 */
public class AAFrequency
{
    /** Takes in a vector of sequences and column start and column end
    * and returns a vector of size (end-start+1). Each element of the
    * vector contains a hashtable with the keys being residues and
    * the values being the count of each residue in that column.
    * This class is used extensively in calculating alignment colourschemes
    * that depend on the amount of conservation in each alignment column. */
    public static final Vector calculate(Vector sequences, int start, int end)
    {
      Vector result = new Vector();
      Hashtable residueHash;
      int count, maxCount, nongap, i, j, jSize = sequences.size();
      String maxResidue, sequence, res;
      float percentage;

        for (i = start; i <= end; i++)
        {
            residueHash = new Hashtable();
            maxCount = 0;
            maxResidue = "-";
            nongap = 0;

            for (j = 0; j < jSize; j++)
            {
                if (sequences.elementAt(j) instanceof Sequence)
                {
                    sequence = ((Sequence) sequences.elementAt(j)).getSequence();

                    if (sequence.length() > i)
                    {
                        res = String.valueOf(Character.toUpperCase(sequence.charAt(i)));

                        if (jalview.util.Comparison.isGap(res.charAt(0)))
                        {
                            res = "-"; // we always use this for gaps in the property vectors
                        }
                        else
                        {   nongap++;    }

                        if (residueHash.containsKey(res))
                        {
                            count = ((Integer) residueHash.get(res)).intValue();
                            count++;

                            if (!jalview.util.Comparison.isGap(res.charAt(0)) &&
                                    (count >= maxCount))
                            {
                                if (count > maxCount)
                                {
                                    maxResidue = res;
                                }
                                else if (maxResidue.indexOf(res) == -1)
                                {
                                    maxResidue += res;
                                }

                                maxCount = count;
                            }

                            residueHash.put(res, new Integer(count));
                        }
                        else
                        {
                            residueHash.put(res, new Integer(1));
                        }
                    }
                    else
                    {
                        if (residueHash.containsKey("-"))
                        {
                            count = ((Integer) residueHash.get("-")).intValue();
                            count++;
                            residueHash.put("-", new Integer(count));
                        }
                        else
                        {
                            residueHash.put("-", new Integer(1));
                        }
                    }
                }
            }

            residueHash.put("maxCount", new Integer(maxCount));
            residueHash.put("maxResidue", maxResidue);


            //Size is redundant at present if we calculate percentage here
            //residueHash.put("size", new Integer(jSize));
            //residueHash.put("nogaps", new Integer(nongap));

            percentage = ((float)maxCount*100) / (float)jSize;
            residueHash.put("pid_gaps", new Float(percentage) );

            percentage = ((float)maxCount*100) / (float)nongap;
            residueHash.put("pid_nogaps", new Float(percentage) );
            result.addElement(residueHash);
        }



        return result;
    }
}