/*
 * Jalview - A Sequence Alignment Editor and Viewer
 * Copyright (C) 2006 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;

import java.io.*;
import jalview.datamodel.*;
import java.util.*;
import jalview.schemes.UserColourScheme;
import java.net.URL;


public class AnnotationFile
{

  public String printAnnotations(AlignmentAnnotation [] annotations)
  {
    StringBuffer text = new StringBuffer(
      "JALVIEW_ANNOTATION\n"
      +"# Created: "
      +new java.util.Date()+"\n\n");

    AlignmentAnnotation row;
    String comma;
    String seqref = null;

    StringBuffer colours = new StringBuffer();
    StringBuffer graphLine = new StringBuffer();

    Hashtable graphGroup = new Hashtable();

    java.awt.Color color;

    for(int i=0; i<annotations.length; i++)
    {
      row = annotations[i];
      color = null;

      if( row.sequenceRef == null)
        seqref = null;

      else if (seqref == null
           || !seqref.equals(row.sequenceRef.getName()))
      {
        seqref = row.sequenceRef.getName();
        text.append("\nSEQUENCE_REF\t" + seqref + "\n");
      }


      if( row.graph == AlignmentAnnotation.NO_GRAPH)
      {
          text.append("NO_GRAPH\t");
      }
      else
      {
        if( row.graph == AlignmentAnnotation.BAR_GRAPH)
          text.append("BAR_GRAPH\t");
        else if(row.graph == AlignmentAnnotation.LINE_GRAPH)
          text.append("LINE_GRAPH\t");

        if(row.getThreshold()!=null)
            graphLine.append("GRAPHLINE\t"
                             + row.label + "\t"
                             + row.getThreshold().value + "\t"
                             + row.getThreshold().label + "\t"
                             + jalview.util.Format.getHexString(
                                 row.getThreshold().colour)+"\n"
                );

          if(row.graphGroup>-1)
          {
            String key = String.valueOf(row.graphGroup);
            if(graphGroup.containsKey(key))
              graphGroup.put(key, graphGroup.get(key)
                             +"\t"+row.label);
            else
              graphGroup.put(key, row.label);
          }
      }

      text.append(row.label+"\t");

      for(int j=0; j<row.annotations.length; j++)
      {
        if(row.annotations[j]!=null)
        {
          comma = "";
          if (row.annotations[j].secondaryStructure!=' ')
          {
            text.append(comma + row.annotations[j].secondaryStructure);
            comma = ",";
          }
          if (row.annotations[j].displayCharacter.length() > 0 
                  && !row.annotations[j].displayCharacter.equals(" "))
              {
                text.append(comma + row.annotations[j].displayCharacter);
                comma = ",";
              }
          if (row.annotations[j].value!=0f)
          {
            color = row.annotations[j].colour;
            text.append(comma + row.annotations[j].value);
          }
        }
        text.append("|");
      }

      text.append("\n");

      if(color!=null && color!=java.awt.Color.black)
      {
        colours.append("COLOUR\t"
                       +row.label+"\t"
                       +jalview.util.Format.getHexString(color)+"\n");
      }

    }

    text.append("\n");

    text.append(colours.toString());
    text.append(graphLine.toString());
    if(graphGroup.size()>0)
    {
      text.append("COMBINE\t");
      Enumeration en = graphGroup.elements();
      while(en.hasMoreElements())
      {
        text.append(en.nextElement()+"\n");
      }
    }

    return text.toString();
  }

  public boolean readAnnotationFile(AlignmentI al, String file)
  {
    try
    {
      BufferedReader in = null;
      java.io.InputStream is = getClass().getResourceAsStream("/" + file);
      if (is != null)
      {
        in = new BufferedReader(new java.io.InputStreamReader(is));
      }
      else
      {
        try
        {
          URL url = new URL(file);
          in = new BufferedReader(new InputStreamReader(url.openStream()));
        }
        catch (java.net.MalformedURLException ex)
        {
          in = new BufferedReader(new FileReader(file));
        }
      }

      String line, label, description, token;
      int graphStyle, index;
      SequenceI refSeq = null;
      int refSeqIndex = 1;
      int existingAnnotations = 0;
      if(al.getAlignmentAnnotation()!=null)
       existingAnnotations = al.getAlignmentAnnotation().length;

      int alWidth = al.getWidth();

      StringTokenizer st;
      Annotation[] annotations;
      AlignmentAnnotation annotation = null;

      // First confirm this is an Annotation file
      boolean jvAnnotationFile = false;
      while ( (line = in.readLine()) != null)
      {
        if (line.indexOf("#") == 0 )
          continue;

        if (line.indexOf("JALVIEW_ANNOTATION") > -1)
        {
          jvAnnotationFile = true;
          break;
        }
      }

      if(!jvAnnotationFile)
      {
        in.close();
        return false;
      }

      while ( (line = in.readLine()) != null)
      {
        if(line.indexOf("#")==0
           || line.indexOf("JALVIEW_ANNOTATION")>-1
           || line.length()==0)
          continue;

        st = new StringTokenizer(line, "\t");
        token = st.nextToken();
        if(token.equalsIgnoreCase("COLOUR"))
        {
          colourAnnotations(al, st.nextToken(), st.nextToken());
          continue;
        }

        if(token.equalsIgnoreCase("COMBINE") )
        {
          combineAnnotations(al, st);
          continue;
        }

        if (token.equalsIgnoreCase("GRAPHLINE"))
        {
          addLine(al, st);
          continue;
        }


        if(token.equalsIgnoreCase("SEQUENCE_REF") )
        {
          refSeq = al.findName(st.nextToken());
          try{
            refSeqIndex = Integer.parseInt(st.nextToken());
          }
          catch(Exception ex)
          {
            refSeqIndex = 1;
          }

          continue;
        }


        graphStyle = AlignmentAnnotation.getGraphValueFromString(token);
        label = description = st.nextToken();

        line = st.nextToken();

        st = new StringTokenizer(line, "|", true);
        annotations = new Annotation[alWidth];

        index = 0;
        boolean emptyColumn = true;


        while (st.hasMoreElements() && index<alWidth)
        {
          token = st.nextToken().trim();
          if(token.equals("|"))
          {
            if(emptyColumn)
              index++;

            emptyColumn = true;
          }
          else
          {
            annotations[index++] = parseAnnotation(token);
            emptyColumn = false;
          }
        }

       annotation = new AlignmentAnnotation(label,
                                          description,
                                          annotations,
                                          0,
                                          0,
                                          graphStyle);

       if(refSeq!=null)
       {
         annotation.createSequenceMapping(refSeq, refSeqIndex, false);
         refSeq.addAlignmentAnnotation(annotation);
       }

       al.addAnnotation(annotation);

       al.setAnnotationIndex(annotation,  al.getAlignmentAnnotation().length - existingAnnotations-1);
      }

    }catch(Exception ex)
    {
      ex.printStackTrace();
      System.out.println("Problem reading annotation file: "+ex);
      return false;
    }
    return true;
  }

  Annotation parseAnnotation(String string)
  {
    String desc = "", displayChar="";
    char ss = ' '; // secondaryStructure
    float value = 0;
    boolean parsedValue = false;
    StringTokenizer st = new StringTokenizer(string, ",");
    String token;
    while(st.hasMoreTokens())
    {
      token = st.nextToken().trim();
      if(token.length()==0)
        continue;

      if(!parsedValue)
      {
        try{
          displayChar = token;
          value = new Float(token).floatValue();
          parsedValue = true;
        }catch(NumberFormatException ex){}
      }

      if(token.equals("H") || token.equals("E"))
      {
        // Either this character represents a helix or sheet
        // or an integer which can be displayed
        ss = token.charAt(0);
        if(displayChar.equals(token.substring(0,1)))
          displayChar = "";
      }
      else if(desc.length()<1)
        desc = token;

    }

    return new Annotation(displayChar, desc, ss, value);
  }

  void colourAnnotations(AlignmentI al, String label, String colour)
  {
    UserColourScheme ucs = new UserColourScheme(colour);
    Annotation[] annotations;
    for(int i=0; i<al.getAlignmentAnnotation().length; i++)
    {
      if(al.getAlignmentAnnotation()[i].label.equalsIgnoreCase(label))
      {
        annotations = al.getAlignmentAnnotation()[i].annotations;
        for(int j=0; j<annotations.length; j++)
        {
          if(annotations[j]!=null)
            annotations[j].colour = ucs.findColour('A');
        }
      }
    }
  }

  void combineAnnotations(AlignmentI al, StringTokenizer st)
  {
    int graphGroup = -1;
    String group = st.nextToken();
    //First make sure we are not overwriting the graphIndex
    for(int i=0; i<al.getAlignmentAnnotation().length; i++)
    {
      if(al.getAlignmentAnnotation()[i].label.equalsIgnoreCase(group))
      {
        graphGroup = al.getAlignmentAnnotation()[i].graphGroup +1;
        al.getAlignmentAnnotation()[i].graphGroup = graphGroup;
        break;
      }
    }

    //Now update groups
    while(st.hasMoreTokens())
    {
      group = st.nextToken();
      for(int i=0; i<al.getAlignmentAnnotation().length; i++)
      {
        if (al.getAlignmentAnnotation()[i].label.equalsIgnoreCase(group))
        {
          al.getAlignmentAnnotation()[i].graphGroup = graphGroup;
          break;
        }
      }
    }
  }

  void addLine(AlignmentI al, StringTokenizer st)
  {
    String group = st.nextToken();
    AlignmentAnnotation annotation = null;

    for (int i = 0; i < al.getAlignmentAnnotation().length; i++)
    {
      if (al.getAlignmentAnnotation()[i].label.equalsIgnoreCase(group))
      {
        annotation = al.getAlignmentAnnotation()[i];
        break;
      }
    }

    if(annotation==null)
      return;
    float value = new Float(st.nextToken()).floatValue();
    String label = st.hasMoreTokens() ?  st.nextToken() : null;
    java.awt.Color colour = null;
    if(st.hasMoreTokens())
    {
      UserColourScheme ucs = new UserColourScheme(st.nextToken());
      colour = ucs.findColour('A');
    }

    annotation.setThreshold(new GraphLine(value, label, colour));

  }
}