package jalview.gui;

import jalview.jbgui.GAlignmentPanel;
import jalview.schemes.*;
import jalview.analysis.*;
import jalview.datamodel.*;
import java.awt.*;
import java.awt.event.*;
import java.awt.print.*;
import java.io.*;
import java.awt.image.*;
import org.jibble.epsgraphics.*;
import javax.imageio.*;
import javax.swing.*;



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;

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


  int hextent = 0;
  int vextent = 0;

  // 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, endRes, startSeq, 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");
  }
}