/*
 *                    BioJava development code
 *
 * This code may be freely distributed and modified under the
 * terms of the GNU Lesser General Public Licence.  This should
 * be distributed with the code.  If you do not have a copy,
 * see:
 *
 *      http://www.gnu.org/copyleft/lesser.html
 *
 * Copyright for this code is held jointly by the individual
 * authors.  These should be listed in @author doc comments.
 *
 * For more information on the BioJava project and its aims,
 * or to join the biojava-l mailing list, visit the home page
 * at:
 *
 *      http://www.biojava.org/
 *
 */
package org.biojava.bio.gui.sequence;

import java.awt.Color;
import java.awt.Font;
import java.awt.Graphics;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

import javax.swing.BoxLayout;
import javax.swing.JPanel;

import org.biojava.bio.gui.sequence.tracklayout.SimpleTrackLayout;
import org.biojava.bio.gui.sequence.tracklayout.TrackLayout;
import org.biojava.bio.seq.Sequence;
import org.biojava.bio.symbol.RangeLocation;
import org.biojava.utils.ChangeVetoException;

/**
 * Handles multiple SequencePanels and Ranges so that a Sequence can be wrapped
 * over more than one line on screen. This is particularly useful for viewing
 * Protein sequences that would be viewed at a single residue resolution.
 * 
 * The interface is very similar to that of the SequencePanels that it wraps
 * 
 * @author Mark Southern
 * @see SequencePanel
 * @since 1.5
 */
public class SequencePanelWrapper extends JPanel {

        /**
         * Generated Serial Version UID
         */
        private static final long serialVersionUID = 8749249181471157230L;
        protected SequencePanel[] seqPanels = new SequencePanel[0];
        private RangeLocation range;
        private Sequence sequence;
        private SequenceRenderer renderer;
        private double scale = 14.0;
        private java.awt.RenderingHints hints;
        private int direction = SequencePanel.HORIZONTAL;
        private TrackLayout trackLayout = new SimpleTrackLayout();
        private List<SequenceViewerListener> viewerListeners = new ArrayList<SequenceViewerListener>();
        private List<SequenceViewerMotionListener> motionListeners = new ArrayList<SequenceViewerMotionListener>();

        /**
         * Creates a new instance of WrappedSequencePanel
         */
        public SequencePanelWrapper() {
                initComponents();
        }

        protected void initComponents() {
                setLayout(new BoxLayout(this, BoxLayout.Y_AXIS));
                setBackground(Color.WHITE);
        }

        /*
         * Sets the track (line) layout strategy. Layouts include a simple wrapping
         * at a given number of residues and user-defined layouts that can contain
         * arbitrary length rows.
         */
        public void setTrackLayout(TrackLayout tl) {
                this.trackLayout = tl;
                trackLayout.setSequence(getSequence());
                trackLayout.setRange(getRange());

                if (isActive()) {
                        refreshSequencePanels();
                }
        }

        public TrackLayout getTrackLayout() {
                return this.trackLayout;
        }

        protected boolean isActive() {
                return (sequence != null) && (renderer != null) && (range != null);
        }

        public void setScale(double scale) {
                this.scale = scale;

                for (int i = 0; i < seqPanels.length; i++) {
                        seqPanels[i].setScale(scale);
                }
        }

        public double getScale() {
                return scale;
        }

        public void setDirection(int direction) {
                this.direction = direction;

                for (int i = 0; i < seqPanels.length; i++) {
                        seqPanels[i].setDirection(direction);
                }

                if (isActive()) {
                        refreshSequencePanels();
                }
        }

        public int getDirection() {
                return direction;
        }

        /*
         * a convenience method. The wrap is passed through to the TrackLayout
         * implementation.
         */
        public synchronized void setWrap(int w) {
                trackLayout.setWrap(w);

                if (!isActive()) {
                        return;
                }

                refreshSequencePanels();
        }

        public int getWrap() {
                return trackLayout.getWrap();
        }

        public void setRenderingHints(java.awt.RenderingHints hints) {
                this.hints = hints;

                for (int i = 0; i < seqPanels.length; i++) {
                        seqPanels[i].setRenderingHints(hints);
                }
        }

        public java.awt.RenderingHints getRenderingHints() {
                return hints;
        }

        public void setRenderer(SequenceRenderer renderer) {
                this.renderer = renderer;

                for (int i = 0; i < seqPanels.length; i++) {
                        try {
                                seqPanels[i].setRenderer(renderer);
                        } catch (ChangeVetoException e) {
                                // should never get here
                                e.printStackTrace();
                        }
                }
        }

        public SequenceRenderer getRenderer() {
                return renderer;
        }

        public void setSequence(Sequence seq) {
                if (seq == null) {
                        removeSeqPanels();

                        return;
                }

                trackLayout.setSequence(sequence = seq);
                trackLayout.setRange(range = new RangeLocation(1, seq.length()));
                refreshSequencePanels();
        }

        public Sequence getSequence() {
                return sequence;
        }

        public void setRange(RangeLocation loc) {
                trackLayout.setRange(range = loc);
                refreshSequencePanels();
        }

        public RangeLocation getRange() {
                return range;
        }

        private void removeSeqPanels() {
                for (int i = 0; i < seqPanels.length; i++) {
                        remove(seqPanels[i]);
                }

                setSize(0, 0); // make sure view is refreshed properly
                setLayout(null);
                revalidate();
        }

        public void resizeAndValidate() {
                for (int i = 0; i < seqPanels.length; i++) {
                        seqPanels[i].resizeAndValidate();
                }
        }

        protected void refreshSequencePanels() {
                removeSeqPanels();

                RangeLocation[] ranges = trackLayout.getRanges();
                seqPanels = new SequencePanel[ranges.length];

                if (getDirection() == SequencePanel.HORIZONTAL) {
                        setLayout(new BoxLayout(this, BoxLayout.Y_AXIS));
                } else {
                        setLayout(new BoxLayout(this, BoxLayout.X_AXIS));
                }

                for (int i = 0; i < ranges.length; i++) {
                        // logger.debug("Setting sequence panel " + i);
                        seqPanels[i] = new SequencePanel();
                        seqPanels[i].setFont(getFont());
                        seqPanels[i].setAlignmentX(LEFT_ALIGNMENT);
                        seqPanels[i].setAlignmentY(TOP_ALIGNMENT);
                        seqPanels[i].setSequence(getSequence());

                        // seqPanels[i].setRange( ranges[i] );
                        // bug in biojava-1.4pre1 - add +1 to max range
                        seqPanels[i].setRange(new RangeLocation(ranges[i].getMin(),
                                        ranges[i].getMax() + 1));
                        seqPanels[i].setDirection(getDirection());
                        seqPanels[i].setScale(getScale());

                        for (Iterator<SequenceViewerListener> it = viewerListeners
                                        .iterator(); it.hasNext();) {
                                seqPanels[i].addSequenceViewerListener(it.next());
                        }

                        for (Iterator<SequenceViewerMotionListener> jt = motionListeners
                                        .iterator(); jt.hasNext();) {
                                seqPanels[i].addSequenceViewerMotionListener(jt.next());
                        }

                        add(seqPanels[i]);
                }

                setRenderer(getRenderer());
        }

        public void addSequenceViewerListener(SequenceViewerListener l) {
                viewerListeners.add(l);

                for (int i = 0; i < seqPanels.length; i++) {
                        seqPanels[i].addSequenceViewerListener(l);
                }
        }

        public void removeSequenceViewerListener(SequenceViewerListener l) {
                viewerListeners.remove(l);

                for (int i = 0; i < seqPanels.length; i++) {
                        seqPanels[i].removeSequenceViewerListener(l);
                }
        }

        public void addSequenceViewerMotionListener(SequenceViewerMotionListener l) {
                motionListeners.add(l);

                for (int i = 0; i < seqPanels.length; i++) {
                        seqPanels[i].addSequenceViewerMotionListener(l);
                }
        }

        public void removeSequenceViewerMotionListener(
                        SequenceViewerMotionListener l) {
                motionListeners.remove(l);

                for (int i = 0; i < seqPanels.length; i++) {
                        seqPanels[i].removeSequenceViewerMotionListener(l);
                }
        }

        public void setFont(Font f) {
                try {
                        super.setFont(f);

                        for (int i = 0; i < seqPanels.length; i++) {
                                seqPanels[i].setFont(f);
                                seqPanels[i].resizeAndValidate();
                        }
                } catch (NullPointerException e) {
                }
        }

        public void paint(Graphics g) {
                // some wierd sequence graphics exception is going on in biojava
                try {
                        super.paint(g);
                } catch (Exception e) {
                        e.printStackTrace();
                        System.out.println("Caught sequence graphics exception in paint() "
                                        + e.toString());
                        repaint();
                }
        }

        public void paintComponent(Graphics g) {
                // some wierd sequence graphics exception is going on in biojava-1.3
                try {
                        super.paintComponent(g);
                } catch (Exception e) {
                        e.printStackTrace();
                        System.out
                                        .println("Caught sequence graphics exception in paintComponent() "
                                                        + e.toString());
                        repaint();
                }
        }
} // class