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

import java.awt.*;
import java.awt.image.*;

import javax.swing.*;
import jalview.schemes.*;


/**
 * DOCUMENT ME!
 *
 * @author $author$
 * @version $Revision$
 */
public class SeqCanvas extends JComponent
{
    FeatureRenderer fr;
    SequenceRenderer sr;
    BufferedImage img;
    Graphics2D gg;
    int imgWidth;
    int imgHeight;
    AlignViewport av;
    boolean displaySearch = false;
    int[] searchResults = null;
    boolean fastPaint = false;
    int LABEL_WEST;
    int LABEL_EAST;

    boolean isOverview = false;

    /**
     * Creates a new SeqCanvas object.
     *
     * @param av DOCUMENT ME!
     */
    public SeqCanvas(AlignViewport av)
    {
        this.av = av;
        fr = new FeatureRenderer(av);
        sr = new SequenceRenderer(av);
        setLayout(new BorderLayout());
        PaintRefresher.Register(this, av.alignment);
        setBackground(Color.white);
    }

    MCview.PDBCanvas pdbCanvas;
    public SequenceRenderer getSequenceRenderer()
    {
      return sr;
    }

    public FeatureRenderer getFeatureRenderer()
    {
      return fr;
    }

    public void setPDBCanvas(MCview.PDBCanvas pc)
    {
      pdbCanvas = pc;
    }

    public AlignViewport getViewport()
    {
      return av;
    }


    /**
     * DOCUMENT ME!
     *
     * @param g DOCUMENT ME!
     * @param startx DOCUMENT ME!
     * @param endx DOCUMENT ME!
     * @param ypos DOCUMENT ME!
     */
    void drawNorthScale(Graphics g, int startx, int endx, int ypos)
    {
        int scalestartx = startx - (startx % 10) + 10;

        g.setColor(Color.black);

        // NORTH SCALE
        for (int i = scalestartx; i < endx; i += 10)
        {
            String string = String.valueOf(i);
            g.drawString(string, (i - startx - 1) * av.charWidth,
                ypos - (av.charHeight / 2));

            g.drawLine(((i - startx - 1) * av.charWidth) + (av.charWidth / 2),
                (ypos + 2) - (av.charHeight / 2),
                ((i - startx - 1) * av.charWidth) + (av.charWidth / 2), ypos -
                2);
        }
    }

    /**
     * DOCUMENT ME!
     *
     * @param g DOCUMENT ME!
     * @param startx DOCUMENT ME!
     * @param endx DOCUMENT ME!
     * @param ypos DOCUMENT ME!
     */
    void drawWestScale(Graphics g, int startx, int endx, int ypos)
    {
        FontMetrics fm = getFontMetrics(av.getFont());
        ypos += av.charHeight;

        // EAST SCALE
        for (int i = 0; i < av.alignment.getHeight(); i++)
        {
            SequenceI seq = av.alignment.getSequenceAt(i);
            int index = startx;
            int value = -1;

            while (index < endx)
            {
                if (jalview.util.Comparison.isGap(seq.getCharAt(index)))
                {
                    index++;

                    continue;
                }

                value = av.alignment.getSequenceAt(i).findPosition(index);

                break;
            }

            if (value != -1)
            {
                int x = LABEL_WEST - fm.stringWidth(String.valueOf(value))-av.charWidth/2;
                g.drawString(value + "", x,
                    (ypos + (i * av.charHeight)) - (av.charHeight / 5));
            }
        }
    }

    /**
     * DOCUMENT ME!
     *
     * @param g DOCUMENT ME!
     * @param startx DOCUMENT ME!
     * @param endx DOCUMENT ME!
     * @param ypos DOCUMENT ME!
     */
    void drawEastScale(Graphics g, int startx, int endx, int ypos)
    {
        ypos += av.charHeight;

        // EAST SCALE
        for (int i = 0; i < av.alignment.getHeight(); i++)
        {
            SequenceI seq = av.alignment.getSequenceAt(i);
            int index = endx;
            int value = -1;

            while (index > startx)
            {
                if (jalview.util.Comparison.isGap(seq.getCharAt(index)))
                {
                    index--;

                    continue;
                }

                value = av.alignment.getSequenceAt(i).findPosition(index);

                break;
            }

            if (value != -1)
            {
                g.drawString(String.valueOf(value), av.charWidth/2,
                    (ypos + (i * av.charHeight)) - (av.charHeight / 5));
            }
        }
    }

    /**
     * DOCUMENT ME!
     *
     * @param horizontal DOCUMENT ME!
     * @param vertical DOCUMENT ME!
     */
    public void fastPaint(int horizontal, int vertical)
    {
        if (gg == null)
        {
            return;
        }

        gg.copyArea(horizontal * av.charWidth,
                    vertical * av.charHeight,
                    imgWidth,
                    imgHeight,
                    -horizontal * av.charWidth,
                    -vertical * av.charHeight);

        int sr = av.startRes;
        int er = av.endRes;
        int ss = av.startSeq;
        int es = av.endSeq;
        int transX = 0;
        int transY = 0;

        if (horizontal > 0) // scrollbar pulled right, image to the left
        {
            er ++;
            transX = (er - sr - horizontal) * av.charWidth;
            sr = er - horizontal;
        }
        else if (horizontal < 0)
        {
            er = sr - horizontal-1;
        }
        else if (vertical > 0) // scroll down
        {
            ss = es - vertical;

            if (ss < av.startSeq)
            { // ie scrolling too fast, more than a page at a time
                ss = av.startSeq;
            }
            else
            {
                transY = imgHeight - (vertical * av.charHeight);
            }
        }
        else if (vertical < 0)
        {
            es = ss - vertical;

            if (es > av.endSeq)
            {
                es = av.endSeq;
            }
        }

        gg.translate(transX, transY);
        drawPanel(gg, sr, er, ss, es, sr, ss, 0);
        gg.translate(-transX, -transY);

        fastPaint = true;
        repaint();
    }

    /**
     * Definitions of startx and endx (hopefully):
     * SMJS This is what I'm working towards!
     *   startx is the first residue (starting at 0) to display.
     *   endx   is the last residue to display (starting at 0).
     *   starty is the first sequence to display (starting at 0).
     *   endy   is the last sequence to display (starting at 0).
     * NOTE 1: The av limits are set in setFont in this class and
     * in the adjustment listener in SeqPanel when the scrollbars move.
     */

    // Set this to false to force a full panel paint
    public void paintComponent(Graphics g)
    {
        sr.renderGaps(av.renderGaps);

        if ((img != null) &&
                (fastPaint && getVisibleRect() != g.getClipBounds()))
        {
            g.drawImage(img, 0, 0, this);
            fastPaint = false;
            return;
        }




        // this draws the whole of the alignment
        imgWidth = getWidth();
        imgHeight = getHeight();

        imgWidth -= (imgWidth % av.charWidth);
        imgHeight -= (imgHeight % av.charHeight);

        if ((imgWidth < 1) || (imgHeight < 1))
        {
            return;
        }

        img = new BufferedImage(imgWidth, imgHeight, BufferedImage.TYPE_INT_RGB);
        gg = (Graphics2D) img.getGraphics();
        gg.setFont(av.getFont());
        gg.setRenderingHint(RenderingHints.KEY_ANTIALIASING,
          RenderingHints.VALUE_ANTIALIAS_ON);

        gg.setColor(Color.white);
        gg.fillRect(0, 0, imgWidth, imgHeight);


        if (av.getWrapAlignment())
        {
            drawWrappedPanel(gg, getWidth(), getHeight(), av.startRes);
        }
        else
        {
            drawPanel(gg, av.startRes, av.endRes, av.startSeq, av.endSeq,
                av.startRes, av.startSeq, 0);
        }

        g.drawImage(img, 0, 0, this);

        if (pdbCanvas != null)
        {
          pdbCanvas.updateSeqColours();
        }

    }

    /**
     * DOCUMENT ME!
     *
     * @param cwidth DOCUMENT ME!
     *
     * @return DOCUMENT ME!
     */
    public int getWrappedCanvasWidth(int cwidth)
    {
        FontMetrics fm = getFontMetrics(av.getFont());

        LABEL_EAST = 0;
        LABEL_WEST = 0;

        if (av.scaleRightWrapped)
        {
            LABEL_EAST = fm.stringWidth(getMask()+"0");
        }

        if (av.scaleLeftWrapped)
        {
            LABEL_WEST = fm.stringWidth(getMask());
        }

        return (cwidth - LABEL_EAST - LABEL_WEST) / av.charWidth;
    }


    /**
     * Generates a string of zeroes.
     * @return String
     */
    String getMask()
    {
      String mask = "0";
      for (int i = av.alignment.getWidth(); i > 0; i /= 10)
      {
        mask += "0";
      }
      return mask;
    }

    /**
     * DOCUMENT ME!
     *
     * @param g DOCUMENT ME!
     * @param canvasWidth DOCUMENT ME!
     * @param canvasHeight DOCUMENT ME!
     * @param startRes DOCUMENT ME!
     */
    public void drawWrappedPanel(Graphics g, int canvasWidth, int canvasHeight,
        int startRes)
    {

        AlignmentI al = av.getAlignment();

        FontMetrics fm = getFontMetrics(av.getFont());

        int LABEL_EAST = 0;

        if (av.scaleRightWrapped)
        {
            LABEL_EAST = fm.stringWidth(getMask()+"0");
        }

        int LABEL_WEST = 0;

        if (av.scaleLeftWrapped)
        {
            LABEL_WEST = fm.stringWidth(getMask());
        }

        int hgap = av.charHeight;
        if(av.scaleAboveWrapped)
          hgap += av.charHeight;

        int cWidth = (canvasWidth - LABEL_EAST - LABEL_WEST) / av.charWidth;
        int cHeight = av.getAlignment().getHeight() * av.charHeight;

        av.setWrappedWidth(cWidth);

        av.endRes = av.startRes + cWidth;


        int endx = (startRes + cWidth) - 1;
        int ypos = hgap;


        while ((ypos <= canvasHeight) && (startRes < av.alignment.getWidth()))
        {
            g.setFont(av.getFont());
            g.setColor(Color.black);

            if (av.scaleLeftWrapped)
            {
                drawWestScale(g, startRes, endx, ypos);
            }

            if (av.scaleRightWrapped)
            {
                g.translate(canvasWidth - LABEL_EAST, 0);
                drawEastScale(g, startRes, endx, ypos);
                g.translate(-(canvasWidth - LABEL_EAST), 0);
            }

            g.translate(LABEL_WEST, 0);

            if (av.scaleAboveWrapped)
            {
                drawNorthScale(g, startRes, endx, ypos);
            }

            // When printing we have an extra clipped region,
            // the Printable page which we need to account for here
            Shape clip = g.getClip();

            if (clip == null)
            {
                g.setClip(0, 0, cWidth * av.charWidth, canvasHeight);
            }
            else
            {
                g.setClip(0, (int) clip.getBounds().getY(),
                    cWidth * av.charWidth, (int) clip.getBounds().getHeight());
            }

            if (av.vconsensus!=null && av.alignment.getWidth() >= av.vconsensus.size())
            {
              endx = av.vconsensus.size() - 2;
            }


            drawPanel(g, startRes, endx, 0, al.getHeight(), startRes, 0, ypos);

            if(av.showAnnotation)
            {
              g.translate(0, cHeight + ypos + 3);
              if(annotations==null)
                annotations = new AnnotationPanel(av);

              annotations.drawComponent( (Graphics2D) g, startRes, endx + 1);
              g.translate(0, -cHeight - ypos);
            }
            g.setClip(clip);
            g.translate(-LABEL_WEST, 0);

            ypos += cHeight+getAnnotationHeight()+hgap;
            if(av.showAnnotation)
              ypos -= 3;

            startRes += cWidth;
            endx = (startRes + cWidth) - 1;

            if (endx > al.getWidth())
            {
                endx = al.getWidth();
            }
        }
    }

    AnnotationPanel annotations;
    int getAnnotationHeight()
    {
      if(!av.showAnnotation)
        return 0;

      if(annotations==null)
        annotations = new AnnotationPanel(av);

      return annotations.adjustPanelHeight();
    }

    /**
     * DOCUMENT ME!
     *
     * @param g1 DOCUMENT ME!
     * @param x1 DOCUMENT ME!
     * @param x2 DOCUMENT ME!
     * @param y1 DOCUMENT ME!
     * @param y2 DOCUMENT ME!
     * @param startx DOCUMENT ME!
     * @param starty DOCUMENT ME!
     * @param offset DOCUMENT ME!
     */

    float aaRatio = 2f/3f;
    public void increaseAARatio()
    {
      aaRatio += .025;
      if(aaRatio>1)
        aaRatio = 1;

      repaint();
    }

    public void decreaseAARation()
    {
      aaRatio -= .025;
      if(aaRatio<0)
        aaRatio = 0;

      repaint();
    }


    synchronized public void drawPanel(Graphics g1, int x1, int x2, int y1,
        int y2, int startx, int starty, int offset)
    {
      Graphics2D g = (Graphics2D) g1;
      g.setFont(av.getFont());

      SequenceI nextSeq, dna = null;
      int aaHeight = av.charHeight, dnaHeight = av.charHeight;
      Font dnafont = null, aafont = av.getFont();

 /*     if (av.getShowTranslation())
      {
        aaHeight = (int) (av.getCharHeight() * aaRatio);
        dnaHeight = (int) (av.getCharHeight() * (1 - aaRatio));
        java.awt.geom.AffineTransform transform = new java.awt.geom.AffineTransform();
        transform.scale(1f / 3f, 1);
        dnafont = new Font(av.getFont().getName(), av.getFont().getStyle(),
                                dnaHeight);
        dnafont = dnafont.deriveFont(transform);

        aafont = new Font(av.getFont().getName(), av.getFont().getStyle(),
                               aaHeight);
        transform = new java.awt.geom.AffineTransform();
        transform.scale(1 / aaRatio, 1);
        aafont = aafont.deriveFont(transform);
      }
*/

      ColourSchemeI cs = av.getGlobalColourScheme();

        /// First draw the sequences
        /////////////////////////////
        for (int i = y1; i < y2; i++)
        {
            nextSeq = av.alignment.getSequenceAt(i);
            g.setFont(aafont);
         /*   if(av.getShowTranslation())
            {
              dna = nextSeq;
              StringBuffer sb = new StringBuffer();
              for(int r = 0; r<nextSeq.getLength(); r+=3)
              {
                String codon = nextSeq.getSequence(r, r+3);
                codon = codon.replace('U', 'T');
                String res = ResidueProperties.codonTranslate(codon);
                if(res !=null )
                {
                  if (res.equals("STOP"))
                    sb.append("X");
                  else
                    sb.append(res);
                }
              }
              nextSeq = new Sequence("d", sb.toString());
            }*/

            sr.drawSequence(g, nextSeq, av.alignment.findAllGroups(nextSeq),
                            x1, x2, (x1 - startx) * av.charWidth,
                            offset + ( (i - starty) * av.charHeight), av.charWidth,
                            aaHeight);

         /*   if(av.getShowTranslation())
            {
              av.setGlobalColourScheme(new NucleotideColourScheme());
              g.setFont(dnafont);
              sr.drawSequence(g, dna, null,
                              x1*3, (x2+2) * 3, ( (x1 - startx) * av.charWidth) / 3,
                              offset + ( (i - starty) * av.charHeight) + aaHeight,
                              av.charWidth / 3,
                              dnaHeight);
              av.setGlobalColourScheme(cs);
            }*/

            if (av.showSequenceFeatures)
            {
                fr.drawSequence(g, nextSeq, x1, x2,
                    (x1 - startx) * av.charWidth,
                    offset + ((i - starty) * av.charHeight), av.charWidth,
                    av.charHeight);
            }
        }

        //
        /////////////////////////////////////
        // Now outline any areas if necessary
        /////////////////////////////////////
        SequenceGroup group = av.getSelectionGroup();

        int sx = -1;
        int sy = -1;
        int ex = -1;
        int groupIndex = -1;

        if ((group == null) && (av.alignment.getGroups().size() > 0))
        {
            group = (SequenceGroup) av.alignment.getGroups().elementAt(0);
            groupIndex = 0;
        }

        if (group != null && !isOverview)
        {
            do
            {
                int oldY = -1;
                int i = 0;
                boolean inGroup = false;
                int top = -1;
                int bottom = -1;

                for (i = y1; i < y2; i++)
                {
                    sx = (group.getStartRes() - startx) * av.charWidth;
                    sy = offset + ((i - starty) * av.charHeight);
                    ex = (((group.getEndRes() + 1) - group.getStartRes()) * av.charWidth) -
                        1;

                    if(sx+ex<0 || sx>imgWidth)
                    {
                      continue;
                    }

                    if ( (sx <= (x2-x1)*av.charWidth) &&
                            group.sequences.contains(av.alignment.getSequenceAt(
                                    i)))
                    {
                        if ((bottom == -1) &&
                                !group.sequences.contains(
                                    av.alignment.getSequenceAt(i + 1)))
                        {
                            bottom = sy + av.charHeight;
                        }

                        if (!inGroup)
                        {
                            if (((top == -1) && (i == 0)) ||
                                    !group.sequences.contains(
                                        av.alignment.getSequenceAt(i - 1)))
                            {
                                top = sy;
                            }

                            oldY = sy;
                            inGroup = true;

                            if (group == av.getSelectionGroup())
                            {
                                g.setStroke(new BasicStroke(1,
                                        BasicStroke.CAP_BUTT,
                                        BasicStroke.JOIN_ROUND, 3f,
                                        new float[] { 5f, 3f }, 0f));
                                g.setColor(Color.RED);
                            }
                            else
                            {
                                g.setStroke(new BasicStroke());
                                g.setColor(group.getOutlineColour());
                            }
                        }
                    }
                    else
                    {
                      if (inGroup)
                      {
                        if (sx >= 0 && sx < imgWidth)
                          g.drawLine(sx, oldY, sx, sy);

                        if (sx + ex < imgWidth)
                          g.drawLine(sx + ex, oldY, sx + ex, sy);

                        if (sx < 0)
                        {
                          ex += sx;
                          sx = 0;
                        }

                        if (sx + ex > imgWidth)
                          ex = imgWidth;

                        else if (sx + ex >= (x2 - x1 + 1) * av.charWidth)
                          ex = (x2 - x1 + 1) * av.charWidth;

                        if (top != -1)
                        {
                          g.drawLine(sx, top, sx + ex, top);
                          top = -1;
                        }

                        if (bottom != -1)
                        {
                          g.drawLine(sx, bottom, sx + ex, bottom);
                          bottom = -1;
                        }

                        inGroup = false;
                        }
                    }
                }

                if (inGroup)
                {
                  sy = offset + ( (i - starty) * av.charHeight);
                  if (sx >= 0 && sx < imgWidth)
                    g.drawLine(sx, oldY, sx, sy);

                  if (sx + ex < imgWidth)
                    g.drawLine(sx + ex, oldY, sx + ex, sy);

                  if (sx < 0)
                  {
                    ex += sx;
                    sx = 0;
                  }

                  if (sx + ex > imgWidth)
                    ex = imgWidth;
                  else if (sx + ex >= (x2 - x1 + 1) * av.charWidth)
                    ex = (x2 - x1 + 1) * av.charWidth;

                  if (top != -1)
                  {
                    g.drawLine(sx, top, sx + ex, top);
                    top = -1;
                  }

                  if (bottom != -1)
                  {
                    g.drawLine(sx, bottom - 1, sx + ex, bottom - 1);
                    bottom = -1;
                  }

                    inGroup = false;
                }

                groupIndex++;

                if (groupIndex >= av.alignment.getGroups().size())
                {
                    break;
                }

                group = (SequenceGroup) av.alignment.getGroups().elementAt(groupIndex);
            }
            while (groupIndex < av.alignment.getGroups().size());
        }

        /// Highlight search Results once all sequences have been drawn
        //////////////////////////////////////////////////////////
        if (displaySearch)
        {
            for (int r = 0; r < searchResults.length; r += 3)
            {
                int searchSeq = searchResults[r];

                if ((searchSeq >= y1) && (searchSeq < y2))
                {
                    SequenceI seq = av.getAlignment().getSequenceAt(searchSeq);

                    int searchStart = seq.findIndex(searchResults[r + 1]) - 1;
                    int searchEnd = seq.findIndex(searchResults[r + 2]) - 1;

                    SequenceRenderer ssr = (SequenceRenderer) sr;

                    if (searchStart < x1)
                    {
                        searchStart = x1;
                    }

                    if (searchEnd > x2)
                    {
                        searchEnd = x2;
                    }

                    ssr.drawHighlightedText(seq, searchStart, searchEnd,
                        (searchStart - startx) * av.charWidth,
                        offset + ((searchSeq - starty) * av.charHeight),
                        av.charWidth, av.charHeight);
                }
            }
        }
    }

    /**
     * DOCUMENT ME!
     *
     * @param results DOCUMENT ME!
     */
    public void highlightSearchResults(int[] results)
    {
        // results are in the order sequence, startRes, endRes
        if (results == null)
        {
            displaySearch = false;
        }
        else
        {
            displaySearch = true;
        }

        searchResults = results;

        repaint();
    }
}