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

import java.io.*;
import java.net.*;
import java.util.*;
import java.util.jar.*;

import javax.swing.*;

import jalview.binding.*;
import jalview.io.*;
import jalview.schemes.*;

public class Jalview2XML
{
  // SAVES SEVERAL ALIGNEMENT WINDOWS TO SAME JARFILE
  public static void SaveState(File statefile)
  {
    long creation = System.currentTimeMillis();
    JInternalFrame[] frames = Desktop.desktop.getAllFrames();

    if (frames == null)
    {
      return;
    }

    try
    {
      FileOutputStream fos = new FileOutputStream(statefile);
      JarOutputStream jout = new JarOutputStream(fos);

      //NOTE UTF-8 MUST BE USED FOR WRITING UNICODE CHARS
      ////////////////////////////////////////////////////
      PrintWriter out = new PrintWriter(new OutputStreamWriter(jout,
          "UTF-8"));

      Vector shortNames = new Vector();
      int treeCount=1;

      //REVERSE ORDER
      for (int i = frames.length - 1; i > -1; i--)
      {
        if (frames[i] instanceof AlignFrame)
        {
          AlignFrame af = (AlignFrame) frames[i];

          String shortName = af.getTitle();

          if (shortName.indexOf(File.separatorChar) > -1)
          {
            shortName = shortName.substring(shortName.lastIndexOf(
                File.separatorChar) + 1);
          }

          int count = 1;

          while (shortNames.contains(shortName))
          {
            if (shortName.endsWith("_" + (count - 1)))
            {
              shortName = shortName.substring(0,
                                              shortName.lastIndexOf("_"));
            }

            shortName = shortName.concat("_" + count);
            count++;
          }

          shortNames.addElement(shortName);

          if (!shortName.endsWith(".xml"))
          {
            shortName = shortName + ".xml";
          }

          SaveState(af, creation, shortName, jout, out);
        }
      }

      out.close();
      jout.close();
    }
    catch (Exception ex)
    {
      ex.printStackTrace();
    }
  }


  // USE THIS METHOD TO SAVE A SINGLE ALIGNMENT WINDOW
  public static void SaveAlignment(AlignFrame af, String jarFile, String fileName)
  {
    try
    {
      FileOutputStream fos = new FileOutputStream(jarFile);
      JarOutputStream jout = new JarOutputStream(fos);

      //NOTE UTF-8 MUST BE USED FOR WRITING UNICODE CHARS
      ////////////////////////////////////////////////////
      PrintWriter out = new PrintWriter(new OutputStreamWriter(jout,
          "UTF-8"));

      SaveState(af, System.currentTimeMillis(), fileName, jout, out);
      out.close();
      jout.close();
    }
    catch (Exception ex)
    {
    }
  }

  public static void SaveState(AlignFrame af, long timeStamp,
                               String fileName, JarOutputStream jout,
                               PrintWriter out)
  {
    Vector seqids = new Vector();
    Vector userColours = new Vector();

    AlignViewport av = af.viewport;

    JalviewModel object = new JalviewModel();
    object.setVamsasModel(new VamsasModel());

    object.setCreationDate(new java.util.Date(timeStamp));
    object.setVersion(jalview.bin.Cache.VERSION);

    jalview.datamodel.AlignmentI jal = af.viewport.alignment;

    SequenceSet vamsasSet = new SequenceSet();
    Sequence vamsasSeq;
    JalviewModelSequence jms = new JalviewModelSequence();

    vamsasSet.setGapChar(jal.getGapCharacter() + "");

    JSeq jseq;

    //SAVE SEQUENCES
    int id = 0;

    for (int i = 0; i < jal.getHeight(); i++)
    {
      seqids.add(jal.getSequenceAt(i));

      vamsasSeq = new Sequence();
      vamsasSeq.setId(id + "");
      vamsasSeq.setName(jal.getSequenceAt(i).getName());
      vamsasSeq.setSequence(jal.getSequenceAt(i).getSequence());

      jseq = new JSeq();
      jseq.setStart(jal.getSequenceAt(i).getStart());
      jseq.setEnd(jal.getSequenceAt(i).getEnd());

      jseq.setColour(jal.getSequenceAt(i).getColor().getRGB());

      jseq.setId(id);

      jms.addJSeq(jseq);
      vamsasSet.addSequence(vamsasSeq);
      id++;
    }

    //SAVE TREES
    ///////////////////////////////////
    if (af.viewport.currentTree != null)
    {
      // FIND ANY ASSOCIATED TREES
      JInternalFrame[] frames = Desktop.desktop.getAllFrames();
      for(int t=0; t<frames.length; t++)
      {
        if (frames[t] instanceof TreePanel)
        {
          TreePanel tp = (TreePanel) frames[t];
          if(tp.treeCanvas.av.alignment==jal)
          {
            Tree tree = new Tree();
            tree.setTitle(tp.getTitle());
            tree.setCurrentTree((af.viewport.currentTree == tp.getTree()));
            tree.setNewick(tp.getTree().toString());
            tree.setThreshold(tp.treeCanvas.threshold);

            tree.setFitToWindow(tp.fitToWindow.getState());
            tree.setFontSize(tp.treeCanvas.fontSize);
            tree.setMarkUnlinked( tp.placeholdersMenu.getState() );
            tree.setShowBootstrap( tp.bootstrapMenu.getState() );
            tree.setShowDistances( tp.distanceMenu.getState() );

            tree.setHeight(tp.getHeight());
            tree.setWidth(tp.getWidth());
            tree.setXpos(tp.getX());
            tree.setYpos(tp.getY());

            jms.addTree(tree);
          }
        }
      }
    }

    //SAVE ANNOTATIONS
    if (jal.getAlignmentAnnotation() != null)
    {
      jalview.datamodel.AlignmentAnnotation[] aa = jal.getAlignmentAnnotation();

      for (int i = 0; i < aa.length; i++)
      {
        if (aa[i].label.equals("Quality") ||
            aa[i].label.equals("Conservation") ||
            aa[i].label.equals("Consensus"))
        {
          continue;
        }

        Annotation an = new Annotation();
        an.setDescription(aa[i].description);
        an.setGraph(aa[i].isGraph);
        an.setLabel(aa[i].label);

        AnnotationElement ae;

        for (int a = 0; a < aa[i].annotations.length; a++)
        {
          if ( (aa[i] == null) || (aa[i].annotations[a] == null))
          {
            continue;
          }

          ae = new AnnotationElement();
          ae.setDescription(aa[i].annotations[a].description);
          ae.setDisplayCharacter(aa[i].annotations[a].displayCharacter);
          ae.setValue(aa[i].annotations[a].value);
          ae.setPosition(a);
          ae.setSecondaryStructure(aa[i].annotations[a].secondaryStructure +
                                   "");
          an.addAnnotationElement(ae);
        }

        vamsasSet.addAnnotation(an);
      }
    }

    //SAVE GROUPS
    if (jal.getGroups() != null)
    {
      JGroup[] groups = new JGroup[jal.getGroups().size()];

      for (int i = 0; i < groups.length; i++)
      {
        groups[i] = new JGroup();

        jalview.datamodel.SequenceGroup sg = (jalview.datamodel.SequenceGroup)
            jal.getGroups()
            .elementAt(i);
        groups[i].setStart(sg.getStartRes());
        groups[i].setEnd(sg.getEndRes());
        groups[i].setName(sg.getName());

        if (sg.cs instanceof ConservationColourScheme)
        {
          groups[i].setConsThreshold( ( (ConservationColourScheme) sg.cs).inc);
        }

        if (sg.cs instanceof ResidueColourScheme)
        {
          groups[i].setPidThreshold( ( (ResidueColourScheme) sg.cs).
                                    getThreshold());
        }
        else if (sg.cs instanceof ScoreColourScheme)
        {
          groups[i].setPidThreshold( ( (ScoreColourScheme) sg.cs).getThreshold());
        }

        if (sg.cs instanceof jalview.schemes.UserColourScheme)
        {
          groups[i].setColour(SetUserColourScheme(sg.cs, userColours,
                                                  jms));
        }
        else
        {
          groups[i].setColour(ColourSchemeProperty.getColourName(
              sg.cs));
        }

        groups[i].setOutlineColour(sg.getOutlineColour().getRGB());
        groups[i].setDisplayBoxes(sg.getDisplayBoxes());
        groups[i].setDisplayText(sg.getDisplayText());
        groups[i].setColourText(sg.getColourText());

        for (int s = 0; s < sg.getSize(); s++)
        {
          jalview.datamodel.Sequence seq = (jalview.datamodel.Sequence) sg.
              getSequenceAt(s);
          int index = seqids.indexOf(seq);
          groups[i].addSeq(index);
        }
      }

      jms.setJGroup(groups);
    }

    ///////////SAVE VIEWPORT
    Viewport view = new Viewport();
    view.setTitle(af.getTitle());
    view.setXpos(af.getX());
    view.setYpos(af.getY());
    view.setWidth(af.getWidth());
    view.setHeight(af.getHeight());
    view.setStartRes(av.startRes);
    view.setStartSeq(av.startSeq);

    if (av.getGlobalColourScheme() instanceof jalview.schemes.UserColourScheme)
    {
      view.setBgColour(SetUserColourScheme(av.getGlobalColourScheme(),
                                           userColours, jms));
    }
    else
    {
      view.setBgColour(ColourSchemeProperty.getColourName(
          av.getGlobalColourScheme()));
    }

    ColourSchemeI cs = av.getGlobalColourScheme();

    if (cs instanceof ConservationColourScheme)
    {
      view.setConsThreshold( ( (ConservationColourScheme) cs).inc);
    }

    if (cs instanceof ResidueColourScheme)
    {
      view.setPidThreshold( ( (ResidueColourScheme) cs).getThreshold());
    }
    else if (cs instanceof ScoreColourScheme)
    {
      view.setPidThreshold( ( (ScoreColourScheme) cs).getThreshold());
    }

    view.setConservationSelected(av.getConservationSelected());
    view.setPidSelected(av.getAbovePIDThreshold());
    view.setFontName(av.font.getFontName());
    view.setFontSize(av.font.getSize());
    view.setFontStyle(av.font.getStyle());
    view.setRenderGaps(av.renderGaps);
    view.setShowAnnotation(av.getShowAnnotation());
    view.setShowBoxes(av.getShowBoxes());
    view.setShowColourText(av.getColourText());
    view.setShowConservation(av.showConservation);
    view.setShowFullId(av.getShowFullId());
    view.setShowIdentity(av.showIdentity);
    view.setShowQuality(av.showQuality);
    view.setShowSequenceFeatures(av.showSequenceFeatures);
    view.setShowText(av.getShowText());
    view.setWrapAlignment(av.getWrapAlignment());

    jms.addViewport(view);

    object.setJalviewModelSequence(jms);
    object.getVamsasModel().addSequenceSet(vamsasSet);

    try
    {
      if (!fileName.endsWith(".xml"))
      {
        fileName = fileName + ".xml";
      }

      JarEntry entry = new JarEntry(fileName);
      jout.putNextEntry(entry);

      object.marshal(out);
    }
    catch (Exception ex)
    {
      ex.printStackTrace();
    }
  }

  static String SetUserColourScheme(jalview.schemes.ColourSchemeI cs,
                                    Vector userColours,
                                    JalviewModelSequence jms)
  {
    String id = null;
    jalview.schemes.UserColourScheme ucs = (jalview.schemes.UserColourScheme)
        cs;

    if (!userColours.contains(ucs))
    {
      userColours.add(ucs);

      java.awt.Color[] colours = ucs.getColours();
      jalview.binding.UserColours uc = new jalview.binding.UserColours();
      jalview.binding.UserColourScheme jbucs = new jalview.binding.
          UserColourScheme();

      for (int i = 0; i < colours.length; i++)
      {
        jalview.binding.Colour col = new jalview.binding.Colour();
        col.setRGB(jalview.util.Format.getHexString(colours[i]));
        jbucs.addColour(col);
      }

      id = "ucs" + userColours.indexOf(ucs);
      uc.setId(id);
      uc.setUserColourScheme(jbucs);
      jms.addUserColours(uc);
    }

    return id;
  }

  static jalview.schemes.UserColourScheme GetUserColourScheme(
      JalviewModelSequence jms, String id)
  {
    UserColours[] uc = jms.getUserColours();
    UserColours colours = null;

    for (int i = 0; i < uc.length; i++)
    {
      if (uc[i].getId().equals(id))
      {
        colours = uc[i];

        break;
      }
    }

    int csize = colours.getUserColourScheme().getColourCount();
    java.awt.Color[] newColours = new java.awt.Color[csize];

    for (int i = 0; i < csize; i++)
    {
      newColours[i] = new java.awt.Color(Integer.parseInt(
          colours.getUserColourScheme().getColour(i).getRGB(), 16));
    }

    return new jalview.schemes.UserColourScheme(newColours);
  }

  public static void LoadJalviewAlign(String file)
  {
    JalviewModel object = new JalviewModel();

    try
    {
      //UNMARSHALLER SEEMS TO CLOSE JARINPUTSTREAM, MOST ANNOYING
      URL url = null;

      if (file.startsWith("http://"))
      {
        url = new URL(file);
      }

      JarInputStream jin = null;
      JarEntry jarentry = null;
      int entryCount = 1;

      do
      {
        if (url != null)
        {
          jin = new JarInputStream(url.openStream());
        }
        else
        {
          jin = new JarInputStream(new FileInputStream(file));
        }

        for (int i = 0; i < entryCount; i++)
        {
          jarentry = jin.getNextJarEntry();
        }

        if (jarentry != null)
        {
          InputStreamReader in = new InputStreamReader(jin, "UTF-8");
          object = (JalviewModel) object.unmarshal(in);
          LoadFromObject(object);
          entryCount++;
        }
      }
      while (jarentry != null);
    }
    catch (Exception ex)
    {
      System.err.println("Exception whilst loading jalview XML file : " +
                         ex + "\n");
      ex.printStackTrace();

      return;
    }
  }

  static void LoadFromObject(JalviewModel object)
  {
    Vector seqids = new Vector();
    SequenceSet vamsasSet = object.getVamsasModel().getSequenceSet(0);
    Sequence[] vamsasSeq = vamsasSet.getSequence();

    JalviewModelSequence jms = object.getJalviewModelSequence();

    //////////////////////////////////
    //LOAD SEQUENCES
    jalview.datamodel.Sequence[] jseqs = new jalview.datamodel.Sequence[
        vamsasSeq.length];
    JSeq[] JSEQ = object.getJalviewModelSequence().getJSeq();

    for (int i = 0; i < vamsasSeq.length; i++)
    {
      jseqs[i] = new jalview.datamodel.Sequence(vamsasSeq[i].getName(),
                                                vamsasSeq[i].getSequence());

      jseqs[i].setStart(JSEQ[i].getStart());
      jseqs[i].setEnd(JSEQ[i].getEnd());
      jseqs[i].setColor(new java.awt.Color(JSEQ[i].getColour()));
      seqids.add(jseqs[i]);
    }

    /////////////////////////////////
    jalview.datamodel.Alignment al = new jalview.datamodel.Alignment(jseqs);

    /////////////////////////////////
    //////////////////////////////////
    //LOAD ANNOTATIONS
    if (vamsasSet.getAnnotation() != null)
    {
      Annotation[] an = vamsasSet.getAnnotation();

      for (int i = 0; i < an.length; i++)
      {
        AnnotationElement[] ae = an[i].getAnnotationElement();
        jalview.datamodel.Annotation[] anot = new jalview.datamodel.Annotation[
            al.getWidth()];

        for (int aa = 0; aa < ae.length; aa++)
        {
          anot[ae[aa].getPosition()] = new jalview.datamodel.Annotation(ae[aa].
              getDisplayCharacter(),
              ae[aa].getDescription(),
              ae[aa].getSecondaryStructure().charAt(0),
              ae[aa].getValue());
        }

        jalview.datamodel.AlignmentAnnotation jaa = null;

        if (an[i].getGraph())
        {
          jaa = new jalview.datamodel.AlignmentAnnotation(an[i].getLabel(),
              an[i].getDescription(), anot, 0, 0, 1);
        }
        else
        {
          jaa = new jalview.datamodel.AlignmentAnnotation(an[i].getLabel(),
              an[i].getDescription(), anot);
        }

        al.addAnnotation(jaa);
      }
    }

    /////////////////////////////////
    // LOAD VIEWPORT
    Viewport[] views = jms.getViewport();
    Viewport view = views[0]; // DEAL WITH MULTIPLE VIEWPORTS LATER

    AlignFrame af = new AlignFrame(al);

    //  af.changeColour() );
    /////////////////////////
    //LOAD GROUPS
    if (jms.getJGroupCount() > 0)
    {
      JGroup[] groups = jms.getJGroup();

      for (int i = 0; i < groups.length; i++)
      {
        ColourSchemeI cs = null;

        if (groups[i].getColour() != null)
        {
          if (groups[i].getColour().startsWith("ucs"))
          {
            cs = GetUserColourScheme(jms, groups[i].getColour());
          }
          else
          {
            cs = ColourSchemeProperty.getColour(al,
                                                groups[i].getColour());
          }

          if (cs instanceof ResidueColourScheme)
          {
            ( (ResidueColourScheme) cs).setThreshold(groups[i].getPidThreshold());
          }
          else if (cs instanceof ScoreColourScheme)
          {
            ( (ScoreColourScheme) cs).setThreshold(groups[i].getPidThreshold());
          }
        }

        Vector seqs = new Vector();
        int[] ids = groups[i].getSeq();

        for (int s = 0; s < ids.length; s++)
        {
          seqs.addElement( (jalview.datamodel.SequenceI) seqids.elementAt(
              ids[s]));
        }

        jalview.datamodel.SequenceGroup sg = new jalview.datamodel.
            SequenceGroup(seqs, groups[i].getName(),
                          cs, groups[i].getDisplayBoxes(),
                          groups[i].getDisplayText(), groups[i].getColourText(),
                          groups[i].getStart(), groups[i].getEnd());

        sg.setOutlineColour(new java.awt.Color(
            groups[i].getOutlineColour()));


        if (groups[i].getConsThreshold() != 0)
        {
          jalview.analysis.Conservation c = new jalview.analysis.Conservation(
              "All",
              ResidueProperties.propHash, 3, sg.sequences, 0,
              sg.getWidth() - 1);
          c.calculate();
          c.verdict(false, 25);
          cs = new ConservationColourScheme(c, cs);
          sg.cs = cs;
        }

        al.addGroup(sg);
      }
    }

    Desktop.addInternalFrame(af, view.getTitle(),
                             AlignFrame.NEW_WINDOW_WIDTH,
                             AlignFrame.NEW_WINDOW_HEIGHT);
    af.setBounds(view.getXpos(), view.getYpos(), view.getWidth(),
                 view.getHeight());
    af.viewport.setStartRes(view.getStartRes());
    af.viewport.setStartSeq(view.getStartSeq());
    af.viewport.showConservation = view.getShowConservation();
    af.viewport.showQuality = view.getShowQuality();
    af.viewport.showIdentity = view.getShowIdentity();
    af.viewport.setAbovePIDThreshold(view.getPidSelected());
    af.abovePIDThreshold.setSelected(view.getPidSelected());
    af.viewport.setColourText(view.getShowColourText());
    af.colourTextMenuItem.setSelected(view.getShowColourText());
    af.viewport.setConservationSelected(view.getConservationSelected());
    af.conservationMenuItem.setSelected(view.getConservationSelected());

    af.viewport.setShowFullId(view.getShowFullId());
    af.fullSeqId.setSelected(view.getShowFullId());

    af.viewport.setFont(new java.awt.Font(view.getFontName(),
                                          view.getFontStyle(), view.getFontSize()));
    af.alignPanel.fontChanged();

    af.viewport.setRenderGaps(view.getRenderGaps());
    af.renderGapsMenuItem.setSelected(view.getRenderGaps());

    af.viewport.setWrapAlignment(view.getWrapAlignment());
    af.wrapMenuItem.setSelected(view.getWrapAlignment());

    if (view.getWrapAlignment())
    {
      af.alignPanel.setWrapAlignment(view.getWrapAlignment());
    }
    else
    {
      af.annotationPanelMenuItem.setState(view.getShowAnnotation());
      af.viewport.setShowAnnotation(view.getShowAnnotation());
      af.alignPanel.setAnnotationVisible(view.getShowAnnotation());
    }

    af.viewport.setShowBoxes(view.getShowBoxes());
    af.viewBoxesMenuItem.setSelected(view.getShowBoxes());
    af.viewport.setShowText(view.getShowText());
    af.viewTextMenuItem.setSelected(view.getShowText());

    ColourSchemeI cs = null;

    if (view.getBgColour() != null)
    {
      if (view.getBgColour().startsWith("ucs"))
      {
        cs = GetUserColourScheme(jms, view.getBgColour());
      }
      else
      {
        cs = ColourSchemeProperty.getColour(al, view.getBgColour());
      }

      if (cs instanceof ConservationColourScheme)
      {
        ( (ConservationColourScheme) cs).inc = view.getConsThreshold();
      }

      if (cs instanceof ResidueColourScheme)
      {
        ( (ResidueColourScheme) cs).setThreshold(view.getPidThreshold());
      }
      else if (cs instanceof ScoreColourScheme)
      {
        ( (ScoreColourScheme) cs).setThreshold(view.getPidThreshold());
      }
    }

    af.viewport.setGlobalColourScheme(cs);

    af.viewport.setColourAppliesToAllGroups(false);
    af.changeColour(af.viewport.getGlobalColourScheme());
    af.viewport.setColourAppliesToAllGroups(true);

    if (view.getShowSequenceFeatures())
    {
      af.viewport.showSequenceFeatures = true;
      af.sequenceFeatures.setSelected(true);
      new SequenceFeatureFetcher(al, af.alignPanel);
       al.featuresAdded = true;
    }

    //LOAD TREES
    ///////////////////////////////////////
    if (jms.getTreeCount() > 0)
    {
      try
      {
        for(int t = 0; t<jms.getTreeCount(); t++)
        {
          Tree tree = jms.getTree(t);

          TreePanel tp = af.ShowNewickTree(new jalview.io.NewickFile(
                  tree.getNewick()), tree.getTitle());

          tp.setBounds( tree.getXpos(),
                        tree.getYpos(),
                        tree.getWidth(),
                        tree.getHeight());

          tp.fitToWindow.setState(tree.getFitToWindow());
          tp.fitToWindow_actionPerformed(null);
          tp.treeCanvas.fontSize = tree.getFontSize();
          tp.fontSize.setText("Font Size - "+tree.getFontSize());
          tp.placeholdersMenu.setState(tree.getMarkUnlinked());
          tp.placeholdersMenu_actionPerformed(null);
          tp.bootstrapMenu.setState(tree.getShowBootstrap());
          tp.bootstrapMenu_actionPerformed(null);
          tp.distanceMenu.setState(tree.getShowDistances());
          tp.distanceMenu_actionPerformed(null);
          tp.treeCanvas.threshold = tree.getThreshold();
          if(tree.getCurrentTree());
             af.viewport.setCurrentTree(tp.getTree());
        }
      }
      catch (Exception ex)
      {
        ex.printStackTrace();
      }
    }
  }
}