/*
 * 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.awt.*;
import java.awt.event.*;
import java.awt.image.*;

import javax.swing.*;


/**
 * DOCUMENT ME!
 *
 * @author $author$
 * @version $Revision$
 */
public class OverviewPanel extends JPanel implements Runnable
{
    BufferedImage miniMe;
    AlignViewport av;
    AlignmentPanel ap;
    float scalew = 1f;
    float scaleh = 1f;
    int width;
    int sequencesHeight;
    int graphHeight = 30;
    int boxX = -1;
    int boxY = -1;
    int boxWidth = -1;
    int boxHeight = -1;
    boolean resizing = false;

    /**
     * Creates a new OverviewPanel object.
     *
     * @param ap DOCUMENT ME!
     */
    public OverviewPanel(AlignmentPanel ap)
    {
        this.av = ap.av;
        this.ap = ap;
        setLayout(null);

        // scale the initial size of overviewpanel to shape of alignment
        float initialScale = (float) av.alignment.getWidth() / (float) av.alignment.getHeight();

        if (av.alignment.getWidth() > av.alignment.getHeight())
        {
            // wider
            width = 400;
            sequencesHeight = (int) (400f / initialScale);
        }
        else
        {
            // taller
            width = (int) (400f * initialScale);
            sequencesHeight = 300;

            if (width < 120)
            {
                width = 120;
            }
        }

        addComponentListener(new ComponentAdapter()
            {
                public void componentResized(ComponentEvent evt)
                {
                    if ((getWidth() != width) ||
                            (getHeight() != (sequencesHeight + graphHeight)))
                    {
                        updateOverviewImage();
                    }
                }
            });

        addMouseMotionListener(new MouseMotionAdapter()
            {
                public void mouseDragged(MouseEvent evt)
                {
                    doMouseDragged(evt);
                }
            });

        addMouseListener(new MouseAdapter()
            {
                public void mousePressed(MouseEvent evt)
                {
                    doMousePressed(evt);
                }

                public void mouseReleased(MouseEvent evt)
                {
                    doMouseReleased(evt);
                }
            });

        updateOverviewImage();
    }

    /**
     * DOCUMENT ME!
     *
     * @param evt DOCUMENT ME!
     */
    public void doMousePressed(MouseEvent evt)
    {
        boxX = evt.getX();
        boxY = evt.getY();

        checkValid();
        repaint();
    }

    /**
     * DOCUMENT ME!
     *
     * @param evt DOCUMENT ME!
     */
    public void doMouseReleased(MouseEvent evt)
    {
        boxX = evt.getX();
        boxY = evt.getY();
        checkValid();

        if (!resizing)
        {
            ap.setScrollValues((int) (boxX / scalew / av.getCharWidth()),
                (int) (boxY / scaleh / av.getCharHeight()));
        }
    }

    /**
     * DOCUMENT ME!
     *
     * @param evt DOCUMENT ME!
     */
    public void doMouseDragged(MouseEvent evt)
    {
        boxX = evt.getX();
        boxY = evt.getY();
        checkValid();

        if (!resizing)
        {
            ap.setScrollValues((int) (boxX / scalew / av.getCharWidth()),
                (int) (boxY / scaleh / av.getCharHeight()));
        }
    }

    /**
     * DOCUMENT ME!
     */
    void checkValid()
    {
        if (boxY < 0)
        {
            boxY = 0;
        }

        if (boxY > (sequencesHeight - boxHeight))
        {
            boxY = sequencesHeight - boxHeight + 1;
        }

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

        if (boxX > (width - boxWidth))
        {
            boxX = width - boxWidth;
        }
    }

    /**
     * DOCUMENT ME!
     */
    public void updateOverviewImage()
    {
        if (resizing)
        {
            return;
        }

        resizing = true;

        Thread thread = new Thread(this);
        thread.start();
        repaint();
    }

    /**
     * DOCUMENT ME!
     */
    public void run()
    {
        miniMe = null;

        int alwidth = av.alignment.getWidth();
        int alheight = av.alignment.getHeight();

        if ((getWidth() > 0) && (getHeight() > 0))
        {
            width = getWidth();
            sequencesHeight = getHeight() - graphHeight;
        }

        setPreferredSize(new Dimension(width, sequencesHeight + graphHeight));

        int fullsizeWidth = alwidth * av.getCharWidth();
        int fullsizeHeight = alheight * av.getCharHeight();

        scalew = (float) width / (float) fullsizeWidth;
        scaleh = (float) sequencesHeight / (float) fullsizeHeight;

        miniMe = new BufferedImage(width, sequencesHeight + graphHeight,
                BufferedImage.TYPE_INT_RGB);

        Graphics mg = miniMe.getGraphics();
        BufferedImage consensus = new BufferedImage(fullsizeWidth, 60,
                BufferedImage.TYPE_3BYTE_BGR);
        Graphics g = consensus.getGraphics();
        ap.annotationPanel.drawGraph(g, av.conservation, fullsizeWidth, 60);
        mg.drawImage(consensus, 0, sequencesHeight, width,
            sequencesHeight + graphHeight, 0, 0, fullsizeWidth, 60, this);

        boolean oldRenderGaps = av.renderGaps;

        try
        {
            // We'll have to draw the full size alignment in chunks, as an image of the
            // whole alignment requires too much memory
            // Max size depends on the font size, the following is a
            // guess at a size which works
            int maxSize = 2000 / av.getFont().getSize();
            BufferedImage block;
            int blockx = 0;
            int blocky = 0;
            int blockw = 0;
            int blockh = 0;
            int eRes = 0;
            int eSeq = 0;

            av.setRenderGaps(false);

            for (int sRes = 0, chunkx = 0; sRes < alwidth;
                    sRes += maxSize, chunkx++)
            {
                eSeq = 0;
                eRes += maxSize;

                if (eRes > alwidth)
                {
                    eRes = alwidth;
                }

                for (int sSeq = 0, chunky = 0; sSeq < alheight;
                        sSeq += maxSize, chunky++)
                {
                    eSeq += maxSize;

                    if (eSeq > alheight)
                    {
                        eSeq = alheight;
                    }

                    blocky = 0;
                    blockx = (int) ((float) sRes / (float) alwidth * width);

                    block = new BufferedImage((eRes - sRes) * av.charWidth,
                            (eSeq - sSeq) * av.charHeight,
                            BufferedImage.TYPE_3BYTE_BGR);
                    g = block.getGraphics();

                    ap.seqPanel.seqCanvas.drawPanel(g, sRes, eRes, sSeq, eSeq,
                        sRes, sSeq, 0);

                    blockh = (int) ((float) (eSeq - sSeq) / (float) alheight * sequencesHeight) +
                        1;
                    blockw = (int) ((float) (eRes - sRes) / (float) alwidth * width) +
                        1;

                    blocky += (int) ((float) sSeq / (float) alheight * sequencesHeight);

                    mg.drawImage(block, blockx, blocky, blockx + blockw,
                        blocky + blockh, 0, 0, block.getWidth(),
                        block.getHeight(), this);

                    block = null;
                }
            }
        }
        catch (OutOfMemoryError error)
        {
            System.err.println(
                "Out of memory when trying to calculate the overview window image!");
        }

        av.setRenderGaps(oldRenderGaps);
        resizing = false;

        setBoxPosition();
    }

    /**
     * DOCUMENT ME!
     */
    public void setBoxPosition()
    {
        boxX = (int) (av.getStartRes() * av.getCharWidth() * scalew);
        boxY = (int) (av.getStartSeq() * av.getCharHeight() * scaleh);
        boxWidth = (int) ((av.getEndRes() - av.getStartRes() + 1) * av.getCharWidth() * scalew);
        boxHeight = (int) (av.getEndSeq() * av.getCharHeight() * scaleh) -
            boxY;
        repaint();
    }

    /**
     * DOCUMENT ME!
     *
     * @param g DOCUMENT ME!
     */
    public void paintComponent(Graphics g)
    {
        g.setColor(Color.white);
        g.fillRect(0, 0, getWidth(), getHeight());
        g.setColor(Color.black);

        if (resizing)
        {
            g.setFont(new Font("Verdana", Font.BOLD, 15));
            g.drawString("Recalculating", 5, sequencesHeight / 2);
            g.drawString("Overview.....", 5, (sequencesHeight / 2) + 20);
        }
        else
        {
            if (miniMe != null)
            {
                g.drawImage(miniMe, 0, 0, this);
            }

            g.setColor(Color.red);
            g.drawRect(boxX, boxY, boxWidth, boxHeight);
            g.drawRect(boxX + 1, boxY + 1, boxWidth - 2, boxHeight - 2);
        }
    }
}