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

import java.awt.*;
import java.awt.event.*;
import java.awt.image.*;
import java.awt.print.*;
import javax.swing.*;

import org.jibble.epsgraphics.*;
import jalview.analysis.*;
import jalview.datamodel.*;
import jalview.jbgui.*;
import jalview.schemes.*;

public class AlignmentPanel
    extends GAlignmentPanel implements AdjustmentListener, Printable
{
  AlignViewport av;
  OverviewPanel overviewPanel;
  SeqPanel seqPanel;
  IdPanel idPanel;
  IdwidthAdjuster idwidthAdjuster;
  public AlignFrame alignFrame;
  ScalePanel scalePanel;
  AnnotationPanel annotationPanel;
  AnnotationLabels alabels;

  // this value is set false when selection area being dragged
  boolean fastPaint = true;
  int hextent = 0;
  int vextent = 0;

  public AlignmentPanel(AlignFrame af, final AlignViewport av)
  {
    alignFrame = af;
    this.av = av;
    seqPanel = new SeqPanel(av, this);
    idPanel = new IdPanel(av, this);

    scalePanel = new ScalePanel(av, this);

    idPanelHolder.add(idPanel, BorderLayout.CENTER);
    idwidthAdjuster = new IdwidthAdjuster(this);
    idSpaceFillerPanel1.add(idwidthAdjuster, BorderLayout.CENTER);

    annotationPanel = new AnnotationPanel(this);
    alabels = new AnnotationLabels(this);

    annotationSpaceFillerHolder.setPreferredSize(annotationPanel.
                                                 getPreferredSize());
    annotationScroller.setPreferredSize(annotationPanel.getPreferredSize());
    annotationScroller.setViewportView(annotationPanel);
    annotationSpaceFillerHolder.add(alabels, BorderLayout.CENTER);

    fontChanged();

    scalePanelHolder.add(scalePanel, BorderLayout.CENTER);
    seqPanelHolder.add(seqPanel, BorderLayout.CENTER);

    setScrollValues(0, 0);

    hscroll.addAdjustmentListener(this);
    vscroll.addAdjustmentListener(this);

    setFocusable(true);
    addKeyListener(new KeyAdapter()
    {
      public void keyPressed(KeyEvent evt)
      {
        switch (evt.getKeyCode())
        {
          case 27: // escape key
            av.setSelectionGroup(null);
            repaint();

            break;

          case KeyEvent.VK_DOWN:
            alignFrame.moveSelectedSequences(false);

            break;

          case KeyEvent.VK_UP:
            alignFrame.moveSelectedSequences(true);

            break;
        }
      }
    });
  }

  public void fontChanged()
  {
    // set idCanvas bufferedImage to null
    // to prevent drawing old image
    FontMetrics fm = getFontMetrics(av.getFont());

    scalePanelHolder.setPreferredSize(new Dimension(10,
        av.charHeight + fm.getDescent()));
    idSpaceFillerPanel1.setPreferredSize(new Dimension(10,
        av.charHeight + fm.getDescent()));

    idPanel.idCanvas.gg = null;
    annotationPanel.adjustPanelHeight();

    Dimension d = calculateIdWidth();
    d.setSize(d.width + 4, d.height);
    idPanel.idCanvas.setPreferredSize(d);
    hscrollFillerPanel.setPreferredSize(d);
    repaint();
  }

  Dimension calculateIdWidth()
  {
    Graphics g = this.getGraphics();

    if (g == null)
    {
      javax.swing.JFrame f = new javax.swing.JFrame();
      f.addNotify();
      g = f.getGraphics();
    }

    FontMetrics fm = g.getFontMetrics(av.font);
    AlignmentI al = av.getAlignment();

    int i = 0;
    int idWidth = 0;
    String id;

    while ( (i < al.getHeight()) && (al.getSequenceAt(i) != null))
    {
      SequenceI s = al.getSequenceAt(i);

      if (av.getShowFullId())
      {
        id = s.getDisplayId();
      }
      else
      {
        id = s.getName();
      }

      if (fm.stringWidth(id) > idWidth)
      {
        idWidth = fm.stringWidth(id);
      }

      i++;
    }

    // Also check annotation label widths
    i = 0;

    if (al.getAlignmentAnnotation() != null)
    {
      fm = g.getFontMetrics(alabels.getFont());

      while (i < al.getAlignmentAnnotation().length)
      {
        String label = al.getAlignmentAnnotation()[i].label;

        if (fm.stringWidth(label) > idWidth)
        {
          idWidth = fm.stringWidth(label);
        }

        i++;
      }
    }

    return new Dimension(idWidth, 12);
  }

  public void highlightSearchResults(int[] results)
  {
    seqPanel.seqCanvas.highlightSearchResults(results);

    // do we need to scroll the panel?
    if (results != null)
    {
      SequenceI seq = av.alignment.getSequenceAt(results[0]);
      int start = seq.findIndex(results[1]) - 1;
      int end = seq.findIndex(results[2]) - 1;

      if ( (av.getStartRes() > start) || (av.getEndRes() < end) ||
          ( (av.getStartSeq() > results[0]) ||
           (av.getEndSeq() < results[0])))
      {
        setScrollValues(start, results[0]);
      }
    }
  }

  public OverviewPanel getOverviewPanel()
  {
    return overviewPanel;
  }

  public void setOverviewPanel(OverviewPanel op)
  {
    overviewPanel = op;
  }

  public void setAnnotationVisible(boolean b)
  {
    annotationSpaceFillerHolder.setVisible(b);
    annotationScroller.setVisible(b);
  }

  public void setWrapAlignment(boolean wrap)
  {
    scalePanelHolder.setVisible(!wrap);
    hscroll.setVisible(!wrap);
    idwidthAdjuster.setVisible(!wrap);

    av.setShowAnnotation(!wrap);
    annotationScroller.setVisible(!wrap);
    annotationSpaceFillerHolder.setVisible(!wrap);
    idSpaceFillerPanel1.setVisible(!wrap);

    repaint();
  }

  public void setColourScheme()
  {
    ColourSchemeI cs = av.getGlobalColourScheme();

    if (av.getConservationSelected())
    {
      Alignment al = (Alignment) av.getAlignment();
      Conservation c = new Conservation("All",
                                        ResidueProperties.propHash, 3,
                                        al.getSequences(), 0,
                                        al.getWidth());

      c.calculate();
      c.verdict(false, av.ConsPercGaps);

      ConservationColourScheme ccs = new ConservationColourScheme(c, cs);

      av.setGlobalColourScheme(ccs);
    }

    repaint();
  }

  // return value is true if the scroll is valid
  public boolean scrollUp(boolean up)
  {
    if (up)
    {
      if (vscroll.getValue() < 1)
      {
        return false;
      }

      fastPaint = false;
      vscroll.setValue(vscroll.getValue() - 1);
    }
    else
    {
      if ( (vextent + vscroll.getValue()) >= av.getAlignment().getHeight())
      {
        return false;
      }

      fastPaint = false;
      vscroll.setValue(vscroll.getValue() + 1);
    }

    fastPaint = true;

    return true;
  }

  public boolean scrollRight(boolean right)
  {
    if (right)
    {
      if (hscroll.getValue() < 1)
      {
        return false;
      }

      fastPaint = false;
      hscroll.setValue(hscroll.getValue() - 1);
    }
    else
    {
      if ( (hextent + hscroll.getValue()) >= av.getAlignment().getWidth())
      {
        return false;
      }

      fastPaint = false;
      hscroll.setValue(hscroll.getValue() + 1);
    }

    fastPaint = true;

    return true;
  }

  public void setScrollValues(int x, int y)
  {
    av.setEndRes( (x + (seqPanel.seqCanvas.getWidth() / av.getCharWidth())) -
                 1);

    hextent = seqPanel.seqCanvas.getWidth() / av.charWidth;
    vextent = seqPanel.seqCanvas.getHeight() / av.charHeight;

    if (hextent > av.alignment.getWidth())
    {
      hextent = av.alignment.getWidth();
    }

    if (vextent > av.alignment.getHeight())
    {
      vextent = av.alignment.getHeight();
    }

    if ( (hextent + x) > av.getAlignment().getWidth())
    {
      x = av.getAlignment().getWidth() - hextent;
    }

    if ( (vextent + y) > av.getAlignment().getHeight())
    {
      y = av.getAlignment().getHeight() - vextent;
    }

    if (y < 0)
    {
      y = 0;
    }

    if (x < 0)
    {
      x = 0;
    }

    hscroll.setValues(x, hextent, 0, av.getAlignment().getWidth());
    vscroll.setValues(y, vextent, 0, av.getAlignment().getHeight());
  }

  public void adjustmentValueChanged(AdjustmentEvent evt)
  {
    int oldX = av.getStartRes();
    int oldY = av.getStartSeq();

    if (evt.getSource() == hscroll)
    {
      int x = hscroll.getValue();
      av.setStartRes(x);
      av.setEndRes( (x +
                     (seqPanel.seqCanvas.getWidth() / av.getCharWidth())) - 1);
    }

    if (evt.getSource() == vscroll)
    {
      int offy = vscroll.getValue();

      if (av.getWrapAlignment())
      {
        int rowSize = seqPanel.seqCanvas.getWrappedCanvasWidth(seqPanel.
            seqCanvas.getWidth());
        av.setStartRes(vscroll.getValue() * rowSize);
        av.setEndRes( (vscroll.getValue() + 1) * rowSize);
      }
      else
      {
        av.setStartSeq(offy);
        av.setEndSeq(offy +
                     (seqPanel.seqCanvas.getHeight() / av.getCharHeight()));
      }
    }

    if (overviewPanel != null)
    {
      overviewPanel.setBoxPosition();
    }

    if (av.getWrapAlignment() || !fastPaint)
    {
      repaint();
    }
    else
    {
      idPanel.idCanvas.fastPaint(av.getStartSeq() - oldY);
      seqPanel.seqCanvas.fastPaint(av.getStartRes() - oldX,
                                   av.getStartSeq() - oldY);

      scalePanel.repaint();

      if (av.getShowAnnotation())
      {
        annotationPanel.fastPaint(av.getStartRes() - oldX);
      }
    }
  }

  public void paintComponent(Graphics g)
  {
    invalidate();

    Dimension d = idPanel.idCanvas.getPreferredSize();
    idPanelHolder.setPreferredSize(d);
    hscrollFillerPanel.setPreferredSize(new Dimension(d.width, 12));
    validate();

    if (av.getWrapAlignment())
    {
      int max = av.alignment.getWidth() /
          seqPanel.seqCanvas.getWrappedCanvasWidth(seqPanel.seqCanvas.getWidth());
      vscroll.setMaximum(max);
      vscroll.setUnitIncrement(1);
      vscroll.setVisibleAmount(1);
    }
    else
    {
      setScrollValues(av.getStartRes(), av.getStartSeq());
    }
  }

  public int print(Graphics pg, PageFormat pf, int pi)
      throws PrinterException
  {
    pg.translate( (int) pf.getImageableX(), (int) pf.getImageableY());

    int pwidth = (int) pf.getImageableWidth();
    int pheight = (int) pf.getImageableHeight();

    if (av.getWrapAlignment())
    {
      return printWrappedAlignment(pg, pwidth, pheight, pi);
    }
    else
    {
      return printUnwrapped(pg, pwidth, pheight, pi);
    }
  }

  public int printUnwrapped(Graphics pg, int pwidth, int pheight, int pi)
      throws PrinterException
  {
    int idWidth = calculateIdWidth().width + 4;
    FontMetrics fm = getFontMetrics(av.getFont());
    int scaleHeight = av.charHeight + fm.getDescent();

    pg.setColor(Color.white);
    pg.fillRect(0, 0, pwidth, pheight);
    pg.setFont(av.getFont());

    ////////////////////////////////////
    /// How many sequences and residues can we fit on a printable page?
    int totalRes = (pwidth - idWidth) / av.getCharWidth();

    int totalSeq = (int) ( (pheight - scaleHeight) / av.getCharHeight()) -
        1;

    int pagesWide = (av.getAlignment().getWidth() / totalRes) + 1;

    /////////////////////////////
    /// Only print these sequences and residues on this page
    int startRes;

    /////////////////////////////
    /// Only print these sequences and residues on this page
    int endRes;

    /////////////////////////////
    /// Only print these sequences and residues on this page
    int startSeq;

    /////////////////////////////
    /// Only print these sequences and residues on this page
    int endSeq;
    startRes = (pi % pagesWide) * totalRes;
    endRes = (startRes + totalRes) - 1;

    if (endRes > (av.getAlignment().getWidth() - 1))
    {
      endRes = av.getAlignment().getWidth() - 1;
    }

    startSeq = (pi / pagesWide) * totalSeq;
    endSeq = startSeq + totalSeq;

    if (endSeq > av.getAlignment().getHeight())
    {
      endSeq = av.getAlignment().getHeight();
    }

    int pagesHigh = ( (av.alignment.getHeight() / totalSeq) + 1) * pheight;

    if (av.showAnnotation)
    {
      pagesHigh += annotationPanel.getHeight();
    }

    pagesHigh /= pheight;

    if (pi >= (pagesWide * pagesHigh))
    {
      return Printable.NO_SUCH_PAGE;
    }

    //draw Scale
    pg.translate(idWidth, 0);
    scalePanel.drawScale(pg, startRes, endRes, pwidth - idWidth, scaleHeight);
    pg.translate( -idWidth, scaleHeight);

    ////////////////
    // Draw the ids
    Color currentColor = null;
    Color currentTextColor = null;

    for (int i = startSeq; i < endSeq; i++)
    {
      if ( (av.getSelectionGroup() != null) &&
          av.getSelectionGroup().sequences.contains(
              av.getAlignment().getSequenceAt(i)))
      {
        currentColor = Color.gray;
        currentTextColor = Color.black;
      }
      else
      {
        currentColor = av.getAlignment().getSequenceAt(i).getColor();
        currentTextColor = Color.black;
      }

      pg.setColor(currentColor);
      pg.fillRect(0,
                  jalview.analysis.AlignmentUtil.getPixelHeight(startSeq, i,
          av.getCharHeight()), idWidth, av.getCharHeight());

      pg.setColor(currentTextColor);

      String string = av.getAlignment().getSequenceAt(i).getName();

      if (av.getShowFullId())
      {
        string = av.getAlignment().getSequenceAt(i).getDisplayId();
      }

      pg.drawString(string, 0,
                    (jalview.analysis.AlignmentUtil.getPixelHeight(startSeq, i,
          av.getCharHeight()) + av.getCharHeight()) -
                    (av.getCharHeight() / 5));
    }

    // draw main sequence panel
    pg.translate(idWidth, 0);
    seqPanel.seqCanvas.drawPanel(pg, startRes, endRes, startSeq, endSeq,
                                 startRes, startSeq, 0);

    if (av.showAnnotation && (endSeq == av.alignment.getHeight()))
    {
      pg.translate( -idWidth, (endSeq - startSeq) * av.charHeight);
      alabels.drawComponent( (Graphics2D) pg);
      pg.translate(idWidth, 0);
      annotationPanel.drawComponent( (Graphics2D) pg, startRes, endRes +
                                    1);
    }

    return Printable.PAGE_EXISTS;
  }

  public int printWrappedAlignment(Graphics pg, int pwidth, int pheight,
                                   int pi)
      throws PrinterException
  {
    int idWidth = calculateIdWidth().width + 4;

    int resWidth = seqPanel.seqCanvas.getWrappedCanvasWidth(pwidth -
        idWidth);
    int totalHeight = totalHeight = (av.alignment.getHeight() + 2) *
        ( (av.alignment.getWidth() / resWidth) +
         1) * av.charHeight;

    pg.setColor(Color.white);
    pg.fillRect(0, 0, pwidth, pheight);
    pg.setFont(av.getFont());

    ////////////////
    // Draw the ids
    pg.setColor(Color.black);

    pg.translate(0, -pi * pheight);

    pg.setClip(0, pi * pheight, pwidth, pheight);

    int ypos = 2 * av.charHeight;

    do
    {
      for (int i = 0; i < av.alignment.getHeight(); i++)
      {
        SequenceI s = av.alignment.getSequenceAt(i);
        String string = s.getName();

        if (av.getShowFullId())
        {
          string = s.getDisplayId();
        }

        pg.drawString(string, 0,
                      (AlignmentUtil.getPixelHeight(0, i, av.charHeight) + ypos +
                       av.charHeight) - (av.charHeight / 5));
      }

      ypos += ( (av.alignment.getHeight() + 2) * av.charHeight);
    }
    while (ypos < totalHeight);

    pg.translate(idWidth, 0);

    seqPanel.seqCanvas.drawWrappedPanel(pg, pwidth - idWidth, totalHeight, 0);

    if ( (pi * pheight) < totalHeight)
    {
      return Printable.PAGE_EXISTS;
    }
    else
    {
      return Printable.NO_SUCH_PAGE;
    }
  }

  public void makeEPS()
  {
    int height = ( (av.alignment.getWidth() / av.getChunkWidth()) + 1) *
        av.chunkHeight;
    int width = seqPanel.getWidth() + idPanel.getWidth();

    if (!av.getWrapAlignment())
    {
      height = ( (av.alignment.getHeight() + 1) * av.charHeight) + 30;
      width = idPanel.getWidth() +
          (av.alignment.getWidth() * av.charWidth);
    }

    if (av.getShowAnnotation())
    {
      height += annotationPanel.getPreferredSize().height;
    }

    try
    {
      jalview.io.JalviewFileChooser chooser = new jalview.io.JalviewFileChooser(
          jalview.bin.Cache.getProperty(
              "LAST_DIRECTORY"), new String[]
          {"eps"},
          new String[]
          {"Encapsulated Postscript"},
          "Encapsulated Postscript");
      chooser.setFileView(new jalview.io.JalviewFileView());
      chooser.setDialogTitle("Create EPS file from alignment");
      chooser.setToolTipText("Save");

      int value = chooser.showSaveDialog(this);

      if (value != jalview.io.JalviewFileChooser.APPROVE_OPTION)
      {
        return;
      }

      jalview.bin.Cache.setProperty("LAST_DIRECTORY",
                                    chooser.getSelectedFile().getParent());

      FileOutputStream out = new FileOutputStream(chooser.getSelectedFile());
      EpsGraphics2D pg = new EpsGraphics2D("Example", out, 0, 0, width,
                                           height);

      if (av.getWrapAlignment())
      {
        printWrappedAlignment(pg, width, height, 0);
      }
      else
      {
        printUnwrapped(pg, width, height, 0);
      }

      pg.flush();
      pg.close();
    }
    catch (Exception ex)
    {
      ex.printStackTrace();
    }
  }

  public void makePNG()
  {
    int height = ( (av.alignment.getWidth() / av.getChunkWidth()) + 1) *
        av.chunkHeight;
    int width = seqPanel.getWidth() + idPanel.getWidth();

    if (!av.getWrapAlignment())
    {
      height = ( (av.alignment.getHeight() + 1) * av.charHeight) + 30;
      width = idPanel.getWidth() +
          (av.alignment.getWidth() * av.charWidth);
    }

    if (av.getShowAnnotation())
    {
      height += annotationPanel.getPreferredSize().height;
    }

    try
    {
      jalview.io.JalviewFileChooser chooser = new jalview.io.JalviewFileChooser(
          jalview.bin.Cache.getProperty(
              "LAST_DIRECTORY"), new String[]
          {"png"},
          new String[]
          {"Portable network graphics"},
          "Portable network graphics");
      chooser.setFileView(new jalview.io.JalviewFileView());
      chooser.setDialogTitle("Create EPS file from alignment");
      chooser.setToolTipText("Save");

      int value = chooser.showSaveDialog(this);

      if (value != jalview.io.JalviewFileChooser.APPROVE_OPTION)
      {
        return;
      }

      jalview.bin.Cache.setProperty("LAST_DIRECTORY",
                                    chooser.getSelectedFile().getParent());

      FileOutputStream out = new FileOutputStream(chooser.getSelectedFile());

      BufferedImage bi = new BufferedImage(width, height,
                                           BufferedImage.TYPE_INT_RGB);
      Graphics2D png = (Graphics2D) bi.getGraphics();

      png.setRenderingHint(RenderingHints.KEY_ANTIALIASING,
                           RenderingHints.VALUE_ANTIALIAS_ON);

      if (av.getWrapAlignment())
      {
        printWrappedAlignment(png, width, height, 0);
      }
      else
      {
        printUnwrapped(png, width, height, 0);
      }

      ImageIO.write(bi, "png", out);
      out.close();
    }
    catch (Exception ex)
    {
      ex.printStackTrace();
    }
  }
}

class Preview
    extends JFrame
{
  public Preview(Image image)
  {
    setResizable(true);
    setSize(image.getWidth(this), image.getHeight(this));
    setVisible(true);
    getContentPane().setLayout(new BorderLayout());
    getContentPane().add(new PreviewPanel(image), BorderLayout.CENTER);
    validate();
    repaint();
  }
}

class PreviewPanel
    extends JPanel
{
  Image image;

  public PreviewPanel(Image image)
  {
    this.image = image;
  }

  public void paintComponent(Graphics g)
  {
    if (image != null)
    {
      g.drawImage(image, 0, 0, this);
    }
    else
    {
      System.out.println("DEBUG:image is null");
    }
  }
}