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

/**
 * 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
    private int QuerySeqPosition;

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

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

    public void setQuerySeqPosition(int QuerySeqPosition) {
        this.QuerySeqPosition = QuerySeqPosition;
    }

    public int getQuerySeqPosition() {
        return QuerySeqPosition;
    }

    public Hashtable getScores() {
        return Scores;
    }

    public Hashtable getSymscores() {
        return Symscores;
    }

    public void initData() {
        super.initData();
        Scores = new Hashtable();
        ids = null;
        conf = null;
    }

    /**
 * parse a JPred concise file into a sequence-alignment like object.
 */
    public void parse() throws IOException {
        // JBPNote log.System.out.println("all read in ");
        String line;
        QuerySeqPosition = -1;
        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 = "";

            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);
                    }

                    Scores.put(id, scores);
                } 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")) {
                // log.debug System.out.println("here");
                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");
            }

            if (newSeq.getName().startsWith("QUERY") &&
                    (QuerySeqPosition == -1)) {
                QuerySeqPosition = seqs.size();
            }

            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.err.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);
  }
 }

 }
 */