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

public class AlignmentPanel extends GAlignmentPanel implements AdjustmentListener, Printable
{

  AlignViewport     av;
  OverviewPanel overviewPanel;
  SeqPanel   seqPanel;
  IdPanel    idPanel;
  SecondaryStructurePanel ssPanel;
  public AlignFrame alignFrame;
  ScalePanel scalePanel;
  ScorePanel scorePanel;

  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);
    scorePanel = new ScorePanel(av);
    ssPanel = new SecondaryStructurePanel(av);

    secondaryPanelHolder.add(ssPanel, BorderLayout.CENTER);
    idPanelHolder.add(idPanel, BorderLayout.CENTER);
    idPanel.addNotify();
    scalePanelHolder.add(scalePanel, BorderLayout.CENTER);
    scorePanelHolder.add(scorePanel, BorderLayout.CENTER);
    seqPanelHolder.add(seqPanel, BorderLayout.CENTER);
    setScrollValues(0,0);

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

    addComponentListener(new ComponentAdapter()
   {
     public void componentResized(ComponentEvent evt)
     {
          RefreshPanels();
     }
   });


   hscroll.setFocusable(false);
   vscroll.setFocusable(false);
   setFocusable(true);

   addKeyListener(new KeyAdapter()
   {
     public void keyPressed(KeyEvent evt)
     {
       switch(evt.getKeyCode())
       {
         case 27: // escape key
           av.setRubberbandGroup(null);
           RefreshPanels();
           break;
         case KeyEvent.VK_X:
           alignFrame.cut_actionPerformed(null);
           break;
         case KeyEvent.VK_C:
           alignFrame.copy_actionPerformed(null);
           break;
         case KeyEvent.VK_V:
           alignFrame.paste(true);
           break;
         case KeyEvent.VK_A:
           alignFrame.selectAllSequenceMenuItem_actionPerformed(null);
           break;

       }

      /* public void doKeyPressed(KeyEvent evt)
       {

         if (evt.isControlDown() && evt.getKeyChar() == 'f')
           findMenuItem_actionPerformed(null);
       }*/

     }
   });


  }

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

   // do we need to scroll the panel?
   if(results!=null && (av.getStartSeq()>results[0]
                        || av.getEndSeq()<results[0]
                        || av.getStartRes()>results[1]
                        || av.getEndRes()<results[2]))
       setScrollValues(results[1], results[0]);


 }


 public OverviewPanel getOverviewPanel()
 {
   return overviewPanel;
 }

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


  public void setGraphPanelVisible(boolean b)
  {
    idSpaceFillerPanel.setVisible(b);
    scorePanelHolder.setVisible(b);

    RefreshPanels();
    // bit annoying to call this twice, can you do better?
    RefreshPanels();
  }

  public void setSecondaryStructureVisible(boolean b)
  {
    secondaryPanelHolder.setVisible(b);
    RefreshPanels();
  }

  public void setWrapAlignment(boolean wrap)
  {
    scorePanelHolder.setVisible(!wrap);
    scalePanelHolder.setVisible(!wrap);
    secondaryPanelHolder.setVisible(!wrap);

    hscroll.setVisible(!wrap);

    idSpaceFillerPanel.setVisible(!wrap);
    idSpaceFillerPanel1.setVisible(!wrap);

    RefreshPanels();

  }


  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, 100);
       ConservationColourScheme ccs = new ConservationColourScheme(c, cs);

       av.setGlobalColourScheme( ccs );

    }

    RefreshPanels();
  }

  public void RefreshPanels()
  {
    requestFocus();
    invalidate();
    seqPanel.seqCanvas.paintFlag = true;
    idPanel.idCanvas.paintFlag = true;
    idPanelHolder.setPreferredSize( idPanel.idCanvas.getPreferredSize() );

    if(av.getWrapAlignment())
    {
      int max = av.alignment.getWidth()/ (seqPanel.seqCanvas.getWidth()/av.charWidth)+1;

      int h  = (av.alignment.getHeight() + 2)*av.charHeight;
      vextent = seqPanel.seqCanvas.getHeight()/h;
      vscroll.setValues(0,vextent,0,max);
    }
    else

    setScrollValues(av.getStartRes(), av.getStartSeq());
    av.getConsensus(true);
    if(overviewPanel!=null)
      overviewPanel.updateOverviewImage();

    validate();
    repaint();

  }

  int hextent = 0;
  int vextent = 0;

  public void setScrollValues(int x, int y)
  {
    hextent = seqPanel.seqCanvas.getWidth()/av.getCharWidth();
    vextent = seqPanel.seqCanvas.getHeight()/av.getCharHeight();

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


    repaint();

  }


  public void adjustmentValueChanged(AdjustmentEvent evt)
  {

    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())
      {
        av.setStartRes( vscroll.getValue() * av.getChunkWidth());
        // System.out.println(vscroll.getValue()+" "+ av.getChunkWidth());
      //  int resSpan = av.alignment.getWidth()/ (seqPanel.seqCanvas.getWidth()/av.charWidth)+1;
     //   int h  = (av.alignment.getHeight() + 2)*av.charHeight;
      //  vextent = seqPanel.seqCanvas.getHeight()/h;
     //   vscroll.setValues(0,vextent,0,max);


      // av.setStartSeq(  );
      }
      else
      {
        av.setStartSeq(offy);
        av.setEndSeq(offy + seqPanel.seqCanvas.getHeight() / av.getCharHeight());
      }
    }


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

    seqPanel.seqCanvas.paintFlag=true;
    repaint();
  }



  public int print(Graphics pg, PageFormat pf, int pi) throws PrinterException
  {
    if(av.getWrapAlignment())
    {
     return PrintWrappedAlignment(pg, pf, pi);
    }

    pg.translate((int)pf.getImageableX(), (int)pf.getImageableY());

    int pwidth = (int)pf.getImageableWidth();
    int pheight = (int)pf.getImageableHeight();
    int idWidth = (int)idPanel.idCanvas.getLabelWidth().getWidth();


    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 - 30)/av.getCharHeight())-1;
    int pagesWide = av.getAlignment().getWidth() / totalRes +1;
    int pagesHigh = av.getAlignment().getHeight() / totalSeq +1;

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

    /////////////////////////////
    /// 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())
      endRes = av.getAlignment().getWidth();

     startSeq = (pi / pagesWide) * totalSeq;
     endSeq = startSeq + totalSeq;
     if(endSeq > av.getAlignment().getHeight())
       endSeq = av.getAlignment().getHeight();


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

    pg.translate(-idWidth, 30);
    ////////////////
    // Draw the ids
    Color currentColor=null;
    Color currentTextColor=null;
    for(int i=startSeq; i<endSeq; i++)
    {
      if (av.getSelection().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).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);
    pg.setClip(0,0,pwidth-idWidth, pheight);
    seqPanel.seqCanvas.drawPanel(pg,startRes,endRes,startSeq,endSeq,startRes,startSeq,0);

    return Printable.PAGE_EXISTS;
  }

  class VPanel extends javax.swing.JPanel
  {
    Image image;
    public VPanel(Image i)
    {
      image = i;
      repaint();
    }
    public void paintComponent(Graphics g)
    {
      if(image!=null)
        g.drawImage(image,0,0,this);
    }

  }

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

    int pwidth = (int)pf.getImageableWidth();
    int pheight = (int)pf.getImageableHeight();
    int idWidth = (int)idPanel.idCanvas.getLabelWidth().getWidth();

    if( seqPanel.seqCanvas.getWidth() < pwidth-idWidth)
      pwidth = seqPanel.seqCanvas.getWidth() + idWidth;

    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?
    AlignmentI da = av.alignment;
    int endy   = da.getHeight();
    int chunkHeight =  (da.getHeight() + 2)*av.charHeight;
    int chunkWidth  =   (pwidth-idWidth)/av.charWidth;

    int noChunksOnPage = pheight / chunkHeight;
    int totalChunks = endy / chunkHeight;

    if ( pi*noChunksOnPage > totalChunks )
     return Printable.NO_SUCH_PAGE;

    ////////////////
    // Draw the ids
    pg.setClip(0,0,pwidth, noChunksOnPage*chunkHeight);

    int row = pi*noChunksOnPage;
    pg.setColor(Color.black);
    for(int ypos=2*av.charHeight;
        ypos <= pheight && row*chunkWidth<da.getWidth();
        ypos += chunkHeight, row++ )
    {
      for (int i = 0; i < endy; i++)
      {
        SequenceI s = da.getSequenceAt(i);
        pg.drawString(s.getDisplayId(), 0,
                      AlignmentUtil.getPixelHeight(0, i, av.charHeight) + ypos +
                      av.charHeight - (av.charHeight / 5));
      }
    }

    // draw main sequence panel
    pg.translate(idWidth,0);
    seqPanel.seqCanvas.drawWrappedPanel(pg, pwidth-idWidth, pheight, pi*noChunksOnPage*chunkWidth);


    return Printable.NO_SUCH_PAGE;//.PAGE_EXISTS;

  }
}