/**
 * PredFile.java
 * JalviewX / Vamsas Project
 * JPred.seq.concise reader
 */
package jalview.io;

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

import java.io.*;
import java.util.*;

public class JPredFile
    extends AlignFile
{
  Vector ids;
  Vector conf;
  Hashtable Scores; // Hash of names and score vectors
  Hashtable Symscores; // indexes of symbol annotation properties in sequenceI vector
  public JPredFile(String inStr)
  {
    super(inStr);
  }

  public void initData()
  {

    super.initData();
    Scores = new Hashtable();
  }

  public JPredFile(String inFile, String type)
      throws IOException
  {

    super(inFile, type);
  }

  /**
   * parse a JPred concise file into a sequence-alignment like object.
   */

  public void parse()
      throws IOException
  {

    String line;

    noSeqs = 0;
    Vector seq_entries = new Vector();
    Vector ids = new Vector();
    Hashtable Symscores = new Hashtable();
    while ( (line = nextLine()) != null)
    {
      // Concise format allows no comments or non comma-formatted data
      StringTokenizer str = new StringTokenizer(line, ":");
      String id = "";
      String seq = "";
      if (!str.hasMoreTokens())
      {
        continue;
      }

      id = str.nextToken();
      String seqsym = str.nextToken();
      StringTokenizer symbols = new StringTokenizer(seqsym, ",");
      // decide if we have more than just alphanumeric symbols
      int numSymbols = symbols.countTokens();

      if (numSymbols==0) {
        continue;
      }

      if (seqsym.length() != (2 * numSymbols))
      {
        // Set of scalars for some property
        if (Scores.containsKey(id))
        {
          int i = 1;
          while (Scores.containsKey(id + "_" + i))
          {
            i++;
          }
          id = id + "_" + i;
        }
        Vector scores = new Vector();
        // Typecheck from first entry
        int i = 0;
        String ascore="dead";
        try
        {
          // store elements as floats...
          while (symbols.hasMoreTokens()) {
            ascore = symbols.nextToken();
            Float score = new Float(ascore);
            scores.addElement( (Object) score);
          }
        }
        catch (Exception e)
        {
          // or just keep them as strings
          i = scores.size();
          for (int j = 0; j < i; j++)
          {
            scores.set(j,
                       (Object) ( (Float) scores.get(j)).toString());
          }
          scores.addElement((Object) ascore);
          while (symbols.hasMoreTokens()) {
            {
              ascore = symbols.nextToken();
              scores.addElement( (Object) ascore);
            }
          }
          Scores.put(id, scores);
        }
      } else
      if (id.equals("jnetconf"))
      {
        id = "Prediction Confidence";
        this.conf = new Vector(numSymbols);
        for (int i = 0; i < numSymbols; i++)
        {
          conf.set(i, (Object) symbols.nextToken());
        }
      }
      else
        {
          // Sequence or a prediction string (rendered as sequence)
          
          StringBuffer newseq = new StringBuffer();
          
          for (int i = 0; i < numSymbols; i++) {
            newseq.append(symbols.nextToken());
          }
          
          if (id.indexOf(";") > -1) {
            seq_entries.addElement(newseq);
            int i=1;
            String name = id.substring(id.indexOf(";")+1);
            while (ids.lastIndexOf(name)>-1) {
              name = id.substring(id.indexOf(";")+1)+"_"+1;
            }
            ids.addElement(name);
            noSeqs++;
          }
          else
          {
            if (id.equals("JNETPRED")) {
              id = "Predicted Secondary Structure";
            }
            seq_entries.addElement( newseq.toString() );
            ids.addElement(id);
            Symscores.put((Object) id, (Object) new Integer(ids.size()-1));
          }
      }
    }


    if (noSeqs < 1)
    {
      throw new IOException(
      "JpredFile Parser: No sequence in the prediction!");
    }
    maxLength = seq_entries.elementAt(0).toString().length();
    for (int i = 0; i < ids.size(); i++)
    {
      // Add all sequence like objects

      Sequence newSeq = new Sequence(ids.elementAt(i).toString(),
                                     seq_entries.elementAt(i).toString(), 1,
                                     seq_entries.elementAt(i).toString().
                                     length());
      if (!Symscores.containsKey(ids.elementAt(i))
          && !isValidProteinSequence(newSeq.getSequence()))
      {
        throw new IOException(
      "JPredConcise: Not a valid protein sequence - ("
      + ids.elementAt(i).toString() + ")");
      }

      if (maxLength != seq_entries.elementAt(i).toString().length())
      {
        throw new IOException("JPredConcise: Entry (" +
                              ids.elementAt(i).toString()
                              + ") has an unexpected number of columns");
      }
      seqs.addElement(newSeq);

    }
  }

  /**
   * print
   *
   * @return String
     */

    public String print()
    {
      return "Not Supported";
    }

    public static void main(String[] args)
    {
      try
      {
        JPredFile blc = new JPredFile(args[0], "File");
        for (int i = 0; i < blc.seqs.size(); i++)
        {
          System.out.println( ( (Sequence) blc.seqs.elementAt(i)).getName()
                             + "\n" +
                             ( (Sequence) blc.seqs.elementAt(i)).getSequence()
                             + "\n");
        }
      }
      catch (java.io.IOException e)
      {
        System.out.println("Exception " + e);
        e.printStackTrace();
      }
    }
  }

  /*
   StringBuffer out = new StringBuffer();

   out.append("START PRED\n");
   for (int i = 0; i < s[0].sequence.length(); i++)
   {
    out.append(s[0].sequence.substring(i, i + 1) + " ");
    out.append(s[1].sequence.substring(i, i + 1) + " ");
    out.append(s[1].score[0].elementAt(i) + " ");
    out.append(s[1].score[1].elementAt(i) + " ");
    out.append(s[1].score[2].elementAt(i) + " ");
    out.append(s[1].score[3].elementAt(i) + " ");

    out.append("\n");
   }
   out.append("END PRED\n");
   return out.toString();
   }

      public static void main(String[] args)
   {
    try
    {
      BLCFile blc = new BLCFile(args[0], "File");
      DrawableSequence[] s = new DrawableSequence[blc.seqs.size()];
      for (int i = 0; i < blc.seqs.size(); i++)
      {
        s[i] = new DrawableSequence( (Sequence) blc.seqs.elementAt(i));
      }
      String out = BLCFile.print(s);

      AlignFrame af = new AlignFrame(null, s);
      af.resize(700, 500);
      af.show();
      System.out.println(out);
    }
    catch (java.io.IOException e)
    {
      System.out.println("Exception " + e);
    }
   }

   }
   */