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

/**
 * <p>Title: </p>
 *  PileUpfile
 * <p>Description: </p>
 *
 *  Read and write PileUp style MSF Files.
 *  This used to be the MSFFile class, and was written according to the EBI's idea
 *  of a subset of the MSF alignment format. But, that was updated to reflect current
 *  GCG style IO fashion, as found in Emboss (thanks David Martin!)
 *
 **/
import java.io.*;
import java.util.*;

import jalview.datamodel.*;
import jalview.util.*;

public class PileUpfile
    extends AlignFile
{
  public PileUpfile()
  {
  }

  public PileUpfile(String inStr)
  {
    super(inStr);
  }

  public PileUpfile(String inFile, String type)
      throws IOException
  {
    super(inFile, type);
  }

  public void parse()
  {
    int i = 0;
    boolean seqFlag = false;
    String key = new String();
    Vector headers = new Vector();
    Hashtable seqhash = new Hashtable();
    String line;

    try
    {
      while ( (line = nextLine()) != null)
      {
        StringTokenizer str = new StringTokenizer(line);

        while (str.hasMoreTokens())
        {
          String inStr = str.nextToken();

          //If line has header information add to the headers vector
          if (inStr.indexOf("Name:") != -1)
          {
            key = str.nextToken();
            headers.addElement(key);
          }

          //if line has // set SeqFlag to 1 so we know sequences are coming
          if (inStr.indexOf("//") != -1)
          {
            seqFlag = true;
          }

          //Process lines as sequence lines if seqFlag is set
          if ( (inStr.indexOf("//") == -1) && (seqFlag == true))
          {
            //seqeunce id is the first field
            key = inStr;

            StringBuffer tempseq;

            //Get sequence from hash if it exists
            if (seqhash.containsKey(key))
            {
              tempseq = (StringBuffer) seqhash.get(key);
            }
            else
            {
              tempseq = new StringBuffer();
              seqhash.put(key, tempseq);
            }

            //loop through the rest of the words
            while (str.hasMoreTokens())
            {
              //append the word to the sequence
              tempseq.append(str.nextToken());
            }
          }
        }
      }
    }
    catch (IOException e)
    {
      System.err.println("Exception parsing PileUpfile " + e);
      e.printStackTrace();
    }

    this.noSeqs = headers.size();

    //Add sequences to the hash
    for (i = 0; i < headers.size(); i++)
    {
      if (seqhash.get(headers.elementAt(i)) != null)
      {
        String head = headers.elementAt(i).toString();
        String seq = seqhash.get(head).toString();

        int start = 1;
        int end = -1;

        if (maxLength < head.length())
        {
          maxLength = head.length();
        }

        if (head.indexOf("/") > 0)
        {
          StringTokenizer st = new StringTokenizer(head, "/");

          if (st.countTokens() == 2)
          {
            head = st.nextToken();

            String tmp = st.nextToken();
            st = new StringTokenizer(tmp, "-");

            if (st.countTokens() == 2)
            {
              start = Integer.valueOf(st.nextToken()).intValue();
              end = Integer.valueOf(st.nextToken()).intValue();
            }
          }
        }

        Sequence newSeq = new Sequence(head, seq, start, end);

        seqs.addElement(newSeq);
      }
      else
      {
        System.err.println(
            "PileUpfile Parser: Can't find sequence for " +
            headers.elementAt(i));
      }
    }
  }

  public static int checkSum(String seq)
  {

    int check = 0;

    String sequence = seq.toUpperCase();

    for (int i = 0; i < sequence.length(); i++)
    {
        if (i < sequence.length())
        {
          int value = sequence.charAt(i);
          if (value != -1)
          {
            check += (i % 57 + 1) * value;
          }
        }

    }

    return check % 10000;
  }

  public static String print(SequenceI[] s)
  {
    StringBuffer out = new StringBuffer("PileUp\n\n");

    int max = 0;
    int maxid = 0;

    int i = 0;
    int bigChecksum = 0;
    int[] checksums = new int[s.length];
    while (i < s.length)
    {
      checksums[i] = checkSum(s[i].getSequence());
      bigChecksum += checksums[i];
      i++;
    }

    out.append("   MSF: " + s[0].getSequence().length() +
               "   Type: P    Check:  " + bigChecksum%10000 + "   ..\n\n\n");

    i=0;
    while ( (i < s.length) && (s[i] != null))
    {
      String seq = s[i].getSequence();
      out.append(" Name: " + s[i].getName() + " oo  Len:  " +
                 s[i].getSequence().length() + "  Check:  " + checksums[i] +
                 "  Weight:  1.00\n");

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

      if (s[i].getName().length() > maxid)
      {
        maxid = s[i].getName().length();
      }

      i++;
    }

    if (maxid < 10)
    {
      maxid = 10;
    }

    maxid++;
    out.append("\n\n//\n\n");

    int len = 50;

    int nochunks = (max / len) + 1;

    if ( (max % len) == 0)
    {
      nochunks--;
    }

    for (i = 0; i < nochunks; i++)
    {
      int j = 0;

      while ( (j < s.length) && (s[j] != null))
      {
        String name = s[j].getName();
        out.append(new Format("%-" + maxid + "s").form(name) + " ");

        for (int k = 0; k < 5; k++)
        {
          int start = (i * 50) + (k * 10);
          int end = start + 10;

          if ( (end < s[j].getSequence().length()) &&
              (start < s[j].getSequence().length()))
          {
            out.append(s[j].getSequence().substring(start, end));

            if (k < 4)
            {
              out.append(" ");
            }
            else
            {
              out.append("\n");
            }
          }
          else
          {
            if (start < s[j].getSequence().length())
            {
              out.append(s[j].getSequence().substring(start));
              out.append("\n");
            }
            else
            {
              if (k == 0)
              {
                out.append("\n");
              }
            }
          }
        }

        j++;
      }

      out.append("\n");
    }

    return out.toString();
  }

  public String print()
  {
    return print(getSeqsAsArray());
  }
}