package jalview.io;

import java.io.*;
import jalview.datamodel.*;
import java.util.StringTokenizer;
import jalview.schemes.UserColourScheme;
import jalview.gui.FeatureRenderer;

public class AnnotationReader
{
  public boolean readGroupsFile(FeatureRenderer fr, AlignmentI al, String file)
  {
    try
    {
      BufferedReader in = new BufferedReader(new FileReader(file));
      SequenceI seq = null;
      String line, type, desc, token;

      int index, start, end;
      StringTokenizer st;
      SequenceFeature sf;
      int lineNo = 0;
      while ( (line = in.readLine()) != null)
      {
        lineNo++;
        st = new StringTokenizer(line, "\t");
        if (st.countTokens() == 2)
        {
          type = st.nextToken();
          UserColourScheme ucs = new UserColourScheme(st.nextToken());
          fr.setColour(type, ucs.findColour("A"));
          continue;
        }

        while (st.hasMoreElements())
        {
          desc = st.nextToken();
          token = st.nextToken();
          if (!token.equals("ID_NOT_SPECIFIED"))
          {
            index = al.findIndex(al.findName(token));
            st.nextToken();
          }
          else
          {
            index = Integer.parseInt(st.nextToken());
          }

          start = Integer.parseInt(st.nextToken());
          end = Integer.parseInt(st.nextToken());

          seq = al.getSequenceAt(index);
          start = seq.findIndex(start) - 1;
          end = seq.findIndex(end) - 1;

          type = st.nextToken();

          if (fr.getColour(type) == null)
          {
            // Probably the old style groups file
            UserColourScheme ucs = new UserColourScheme(type);
            fr.setColour(type, ucs.findColour("A"));
          }

          sf = new SequenceFeature(type, desc, "", start, end);

          seq.getDatasetSequence().addSequenceFeature(sf);
        }
      }
    }
    catch (Exception ex)
    {
      System.out.println("Error parsing groups file: " + ex);
      return false;
    }

    return true;
  }

  public boolean readAnnotationFile(AlignmentI al, String file)
  {
    try
    {
      BufferedReader in = new BufferedReader(new FileReader(file));
      String line, label, description, token;
      int graphStyle, index;
      SequenceI refSeq = null;
      int refSeqIndex = -1;


      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(NumberFormatException ex)
          {
            refSeqIndex = 0;
          }

          continue;
        }

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

        line = st.nextToken();
        st = new StringTokenizer(line, "|", true);
        annotations = new Annotation[st.countTokens()];
        index = 0;
        boolean emptyColumn = true;
        while (st.hasMoreElements())
        {
          token = st.nextToken().trim();

          if(token.equals("|"))
          {
            if(emptyColumn)
              annotations[index++] = parseAnnotation("");

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

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

       al.addAnnotation(annotation, refSeq, refSeqIndex);

      }
    }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;
    StringTokenizer st = new StringTokenizer(string, ",");
    String token;
    while(st.hasMoreTokens())
    {
      token = st.nextToken().trim();
      if(token.length()==0)
        continue;

      if(value==0)
      {  try{
          value = Float.parseFloat(token);
        }catch(NumberFormatException ex){}
      }

      if(token.length()==1)
      {
        // Either this character represents a helix or sheet
        // or an integer which can be displayed
        if(token.equals("H") || token.equals("E"))
        {
          ss = token.charAt(0);
        }
        else //if(value!=0)
        {
          displayChar = token;
        }
      }
      else if(desc.length()<1)
        desc = token;
      else
        displayChar = 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 = Float.parseFloat(st.nextToken());
    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.addGraphLine(new GraphLine(value, label, colour));

  }
}