package org.opentrafficsim.draw.graphs;
   
   import java.awt.BorderLayout;
   import java.awt.Color;
   import java.awt.Dimension;
   import java.awt.Font;
   import java.awt.Graphics2D;
   import java.awt.event.ActionEvent;
   import java.awt.event.ActionListener;
  import java.awt.event.WindowAdapter;
  import java.awt.event.WindowEvent;
  import java.awt.geom.AffineTransform;
  import java.awt.geom.Rectangle2D;
  import java.awt.image.BufferedImage;
  import java.io.BufferedOutputStream;
  import java.io.File;
  import java.io.FileOutputStream;
  import java.io.IOException;
  import java.io.OutputStream;
  import java.util.LinkedHashSet;
  import java.util.Set;
  import java.util.UUID;
  
  import javax.swing.JFileChooser;
  import javax.swing.JFrame;
  import javax.swing.JLabel;
  import javax.swing.JMenuItem;
  import javax.swing.JPopupMenu;
  import javax.swing.JTextField;
  import javax.swing.SwingConstants;
  import javax.swing.filechooser.FileNameExtensionFilter;
  
  import org.djunits.value.vdouble.scalar.Duration;
  import org.djunits.value.vdouble.scalar.Time;
  import org.jfree.chart.ChartMouseListener;
  import org.jfree.chart.ChartPanel;
  import org.jfree.chart.ChartUtils;
  import org.jfree.chart.JFreeChart;
  import org.jfree.chart.plot.XYPlot;
  import org.jfree.chart.title.TextTitle;
  import org.jfree.data.general.Dataset;
  import org.jfree.data.general.DatasetChangeEvent;
  import org.jfree.data.general.DatasetChangeListener;
  import org.jfree.data.general.DatasetGroup;
  import org.opentrafficsim.base.Identifiable;
  import org.opentrafficsim.core.dsol.OTSSimulatorInterface;
  
  import nl.tudelft.simulation.dsol.SimRuntimeException;
  import nl.tudelft.simulation.dsol.formalisms.eventscheduling.SimEventInterface;
  import nl.tudelft.simulation.dsol.simtime.SimTimeDoubleUnit;
  import nl.tudelft.simulation.event.EventType;
  
  /**
   * Super class of all plots. This schedules regular updates, creates menus and deals with listeners. There are a number of
   * delegate methods for sub classes to implement.
   * <p>
   * Copyright (c) 2013-2019 Delft University of Technology, PO Box 5, 2600 AA, Delft, the Netherlands. All rights reserved. <br>
   * BSD-style license. See <a href="http://opentrafficsim.org/node/13">OpenTrafficSim License</a>.
   * <p>
   * @version $Revision$, $LastChangedDate$, by $Author$, initial version 4 okt. 2018 <br>
   * @author <a href="http://www.tbm.tudelft.nl/averbraeck">Alexander Verbraeck</a>
   * @author <a href="http://www.tudelft.nl/pknoppers">Peter Knoppers</a>
   * @author <a href="http://www.transport.citg.tudelft.nl">Wouter Schakel</a>
   */
  public abstract class AbstractPlot extends JFrame implements Identifiable, Dataset
  {
  
      /** */
      private static final long serialVersionUID = 20181004L;
  
      /**
       * The (regular, not timed) event type for pub/sub indicating the addition of a graph. Not used internally.<br>
       * Payload: String graph caption (not an array, just a String)
       */
      public static final EventType GRAPH_ADD_EVENT = new EventType("GRAPH.ADD");
  
      /**
       * The (regular, not timed) event type for pub/sub indicating the removal of a graph. Not used internally.<br>
       * Payload: String Graph caption (not an array, just a String)
       */
      public static final EventType GRAPH_REMOVE_EVENT = new EventType("GRAPH.REMOVE");
  
      /** Initial upper bound for the time scale. */
      public static final Time DEFAULT_INITIAL_UPPER_TIME_BOUND = Time.createSI(300.0);
  
      /** Caption. */
      private final String caption;
  
      /** Update interval. */
      private Duration updateInterval;
  
      /** Delay so critical future events have occurred, e.g. GTU's next move's to extend trajectories. */
      private final Duration delay;
  
      /** Simulator. */
      private final OTSSimulatorInterface simulator;
  
      /** Time of last data update. */
      private Time updateTime;
 
     /** Number of updates. */
     private int updates = 0;
 
     /** Unique ID of the chart. */
     private final String id = UUID.randomUUID().toString();
 
     /** The chart, so we can export it. */
     private JFreeChart chart;
 
     /** Status label. */
     private JLabel statusLabel;
 
     /** Detach menu item. */
     private JMenuItem detach;
 
     /** List of parties interested in changes of this plot. */
     private Set<DatasetChangeListener> listeners = new LinkedHashSet<>();
 
     /** Event of next update. */
     private SimEventInterface<SimTimeDoubleUnit> updateEvent;
 
     /**
      * Constructor.
      * @param caption String; caption
      * @param updateInterval Duration; regular update interval (simulation time)
      * @param simulator OTSSimulatorInterface; simulator
      * @param delay Duration; delay so critical future events have occurred, e.g. GTU's next move's to extend trajectories
      */
     public AbstractPlot(final String caption, final Duration updateInterval, final OTSSimulatorInterface simulator,
             final Duration delay)
     {
         this.caption = caption;
         this.updateInterval = updateInterval;
         this.simulator = simulator;
         this.delay = delay;
         update(); // start redraw chain
     }
 
     /**
      * Sets the chart and adds menus and listeners.
      * @param chart JFreeChart; chart
      */
     @SuppressWarnings("methodlength")
     protected void setChart(final JFreeChart chart)
     {
         this.chart = chart;
 
         // make title somewhat smaller
         chart.setTitle(new TextTitle(chart.getTitle().getText(), new Font("SansSerif", java.awt.Font.BOLD, 16)));
 
         // default colors and zoom behavior
         chart.getPlot().setBackgroundPaint(Color.LIGHT_GRAY);
         chart.setBackgroundPaint(Color.WHITE);
         if (chart.getPlot() instanceof XYPlot)
         {
             chart.getXYPlot().setDomainGridlinePaint(Color.WHITE);
             chart.getXYPlot().setRangeGridlinePaint(Color.WHITE);
         }
 
         // status label
         this.statusLabel = new JLabel(" ", SwingConstants.CENTER);
         add(this.statusLabel, BorderLayout.SOUTH);
 
         // override to gain some control over the auto bounds
         ChartPanel chartPanel = new ChartPanel(chart)
         {
             /** */
             private static final long serialVersionUID = 20181006L;
 
             /** {@inheritDoc} */
             @Override
             public void restoreAutoDomainBounds()
             {
                 super.restoreAutoDomainBounds();
                 if (chart.getPlot() instanceof XYPlot)
                 {
                     setAutoBoundDomain(chart.getXYPlot());
                 }
             }
 
             /** {@inheritDoc} */
             @Override
             public void restoreAutoRangeBounds()
             {
                 super.restoreAutoRangeBounds();
                 if (chart.getPlot() instanceof XYPlot)
                 {
                     setAutoBoundRange(chart.getXYPlot());
                 }
             }
 
             /** {@inheritDoc} This implementation adds control over the PNG image size and font size. */
             @Override
             public void doSaveAs() throws IOException
             {
                 // the code in this method is based on the code in the super implementation
 
                 // create setting components
                 JLabel fontSizeLabel = new JLabel("font size");
                 JTextField fontSize = new JTextField("32"); // by default, give more space for labels in a png export
                 fontSize.setToolTipText("Font size of title (other fonts are scaled)");
                 fontSize.setPreferredSize(new Dimension(40, 20));
                 JTextField width = new JTextField("960");
                 width.setToolTipText("Width [pixels]");
                 width.setPreferredSize(new Dimension(40, 20));
                 JLabel x = new JLabel("x");
                 JTextField height = new JTextField("540");
                 height.setToolTipText("Height [pixels]");
                 height.setPreferredSize(new Dimension(40, 20));
 
                 // create file chooser with these components
                 JFileChooser fileChooser = new JFileChooserWithSettings(fontSizeLabel, fontSize, width, x, height);
                 fileChooser.setCurrentDirectory(getDefaultDirectoryForSaveAs());
                 FileNameExtensionFilter filter =
                         new FileNameExtensionFilter(localizationResources.getString("PNG_Image_Files"), "png");
                 fileChooser.addChoosableFileFilter(filter);
                 fileChooser.setFileFilter(filter);
 
                 int option = fileChooser.showSaveDialog(this);
                 if (option == JFileChooser.APPROVE_OPTION)
                 {
                     String filename = fileChooser.getSelectedFile().getPath();
                     if (isEnforceFileExtensions())
                     {
                         if (!filename.endsWith(".png"))
                         {
                             filename = filename + ".png";
                         }
                     }
 
                     // get settings from setting components
                     double fs; // relative scale
                     try
                     {
                         fs = Double.parseDouble(fontSize.getText());
                     }
                     catch (NumberFormatException exception)
                     {
                         fs = 16.0;
                     }
                     int w;
                     try
                     {
                         w = Integer.parseInt(width.getText());
                     }
                     catch (NumberFormatException exception)
                     {
                         w = getWidth();
                     }
                     int h;
                     try
                     {
                         h = Integer.parseInt(height.getText());
                     }
                     catch (NumberFormatException exception)
                     {
                         h = getHeight();
                     }
                     OutputStream out = new BufferedOutputStream(new FileOutputStream(new File(filename)));
                     out.write(encodeAsPng(w, h, fs));
                     out.close();
                 }
             }
         };
         ChartMouseListener chartListener = getChartMouseListener();
         if (chartListener != null)
         {
             chartPanel.addChartMouseListener(chartListener);
         }
 
         // pointer handler
         final PointerHandler ph = new PointerHandler()
         {
             /** {@inheritDoc} */
             @Override
             public void updateHint(final double domainValue, final double rangeValue)
             {
                 if (Double.isNaN(domainValue))
                 {
                     setStatusLabel(" ");
                 }
                 else
                 {
                     setStatusLabel(getStatusLabel(domainValue, rangeValue));
                 }
             }
         };
         chartPanel.addMouseMotionListener(ph);
         chartPanel.addMouseListener(ph);
         add(chartPanel, BorderLayout.CENTER);
         chartPanel.setMouseWheelEnabled(true);
 
         // pop up
         JPopupMenu popupMenu = chartPanel.getPopupMenu();
         popupMenu.add(new JPopupMenu.Separator());
         this.detach = new JMenuItem("Show in detached window");
         this.detach.addActionListener(new ActionListener()
         {
             @SuppressWarnings("synthetic-access")
             @Override
             public void actionPerformed(final ActionEvent e)
             {
                 AbstractPlot.this.detach.setEnabled(false);
                 JFrame window = new JFrame(AbstractPlot.this.caption);
                 window.setDefaultCloseOperation(DISPOSE_ON_CLOSE);
                 window.add(chartPanel, BorderLayout.CENTER);
                 window.add(AbstractPlot.this.statusLabel, BorderLayout.SOUTH);
                 window.addWindowListener(new WindowAdapter()
                 {
                     /** {@inheritDoc} */
                     @Override
                     public void windowClosing(@SuppressWarnings("hiding") final WindowEvent e)
                     {
                         add(chartPanel, BorderLayout.CENTER);
                         add(AbstractPlot.this.statusLabel, BorderLayout.SOUTH);
                         AbstractPlot.this.detach.setEnabled(true);
                         AbstractPlot.this.getContentPane().validate();
                         AbstractPlot.this.getContentPane().repaint();
                     }
                 });
                 window.pack();
                 window.setVisible(true);
                 AbstractPlot.this.getContentPane().repaint();
             }
         });
         popupMenu.add(this.detach);
         addPopUpMenuItems(popupMenu);
     }
 
     /**
      * Returns the chart as a byte array representing a png image.
      * @param width int; width
      * @param height int; height
      * @param fontSize double; font size (16 is the original on screen size)
      * @return byte[]; the chart as a byte array representing a png image
      * @throws IOException on IO exception
      */
     public byte[] encodeAsPng(final int width, final int height, final double fontSize) throws IOException
     {
         // to double the font size, we halve the base dimensions
         // JFreeChart will the assign more area (relatively) to the fixed actual font size
         double baseWidth = width / (fontSize / 16);
         double baseHeight = height / (fontSize / 16);
         // this code is from ChartUtils.writeScaledChartAsPNG
         BufferedImage image = new BufferedImage(width, height, BufferedImage.TYPE_INT_ARGB);
         Graphics2D g2 = image.createGraphics();
         // to compensate for the base dimensions which are not w x h, we scale the drawing
         AffineTransform saved = g2.getTransform();
         g2.transform(AffineTransform.getScaleInstance(width / baseWidth, height / baseHeight));
         getChart().draw(g2, new Rectangle2D.Double(0, 0, baseWidth, baseHeight), null, null);
         g2.setTransform(saved);
         g2.dispose();
         return ChartUtils.encodeAsPNG(image);
     }
 
     /** {@inheritDoc} */
     @Override
     public final DatasetGroup getGroup()
     {
         return null; // not used
     }
 
     /** {@inheritDoc} */
     @Override
     public final void setGroup(final DatasetGroup group)
     {
         // not used
     }
 
     /**
      * Overridable method to add pop up items.
      * @param popupMenu JPopupMenu; pop up menu
      */
     protected void addPopUpMenuItems(final JPopupMenu popupMenu)
     {
         //
     }
 
     /**
      * Overridable; activates auto bounds on domain axis from user input. This class does not force the use of {@code XYPlot}s,
      * but the auto bounds command comes from the {@code ChartPanel} that this class creates. In case the used plot is a
      * {@code XYPlot}, this method is then invoked. Sub classes with auto domain bounds that work with an {@code XYPlot} should
      * implement this. The method is not abstract as the use of {@code XYPlot} is not obligated.
      * @param plot XYPlot; plot
      */
     protected void setAutoBoundDomain(final XYPlot plot)
     {
         //
     }
 
     /**
      * Overridable; activates auto bounds on range axis from user input. This class does not force the use of {@code XYPlot}s,
      * but the auto bounds command comes from the {@code ChartPanel} that this class creates. In case the used plot is a
      * {@code XYPlot}, this method is then invoked. Sub classes with auto range bounds that work with an {@code XYPlot} should
      * implement this. The method is not abstract as the use of {@code XYPlot} is not obligated.
      * @param plot XYPlot; plot
      */
     protected void setAutoBoundRange(final XYPlot plot)
     {
         //
     }
 
     /**
      * Overridable; may return a chart listener for additional functions.
      * @return ChartMouseListener, {@code null} by default
      */
     protected ChartMouseListener getChartMouseListener()
     {
         return null;
     }
 
     /**
      * Return the graph type for transceiver.
      * @return GraphType; the graph type.
      */
     public abstract GraphType getGraphType();
 
     /**
      * Returns the status label when the mouse is over the given location.
      * @param domainValue double; domain value (x-axis)
      * @param rangeValue double; range value (y-axis)
      * @return String; status label when the mouse is over the given location
      */
     protected abstract String getStatusLabel(double domainValue, double rangeValue);
 
     /**
      * Increase the simulated time span.
      * @param time Time; time to increase to
      */
     protected abstract void increaseTime(Time time);
 
     /**
      * Redraws the plot and schedules the next update.
      */
     protected void update()
     {
         this.updateTime = this.simulator.getSimulatorTime();
         increaseTime(this.updateTime.minus(this.delay));
         notifyPlotChange();
         scheduleNextUpdateEvent();
     }
 
     /**
      * Schedules the next update event.
      */
     private void scheduleNextUpdateEvent()
     {
         try
         {
             this.updates++;
             // events are scheduled slightly later, so all influencing movements have occurred
             this.updateEvent = this.simulator.scheduleEventAbs(
                     Time.createSI(this.updateInterval.si * this.updates + this.delay.si), this, this, "update", null);
         }
         catch (SimRuntimeException exception)
         {
             throw new RuntimeException("Unexpected exception while updating plot.", exception);
         }
     }
 
     /**
      * Notify all change listeners.
      */
     public final void notifyPlotChange()
     {
         DatasetChangeEvent event = new DatasetChangeEvent(this, this);
         for (DatasetChangeListener dcl : this.listeners)
         {
             dcl.datasetChanged(event);
         }
     }
 
     /**
      * Sets a new update interval.
      * @param interval Duration; update interval
      */
     protected final void setUpdateInterval(final Duration interval)
     {
         if (this.updateEvent != null)
         {
             this.simulator.cancelEvent(this.updateEvent);
         }
         this.updates = (int) (this.simulator.getSimulatorTime().si / interval.si);
         this.updateInterval = interval;
         this.updateTime = Time.createSI(this.updates * this.updateInterval.si);
         scheduleNextUpdateEvent();
     }
 
     /**
      * Returns time until which data should be plotted.
      * @return Time; time until which data should be plotted
      */
     protected final Time getUpdateTime()
     {
         return this.updateTime;
     }
 
     /**
      * Returns the chart.
      * @return JFreeChart; chart
      */
     protected final JFreeChart getChart()
     {
         return this.chart;
     }
 
     /** {@inheritDoc} */
     @Override
     public final String getId()
     {
         return this.id;
     }
 
     /** {@inheritDoc} */
     @Override
     public final void addChangeListener(final DatasetChangeListener listener)
     {
         this.listeners.add(listener);
     }
 
     /** {@inheritDoc} */
     @Override
     public final void removeChangeListener(final DatasetChangeListener listener)
     {
         this.listeners.remove(listener);
     }
 
     /**
      * Manually set status label from sub class. Will be overwritten by a moving mouse pointer over the axes.
      * @param label String; label to set
      */
     protected final void setStatusLabel(final String label)
     {
         if (this.statusLabel != null)
         {
             this.statusLabel.setText(label);
         }
     }
 
     /**
      * Return the caption of this graph.
      * @return String; the caption of this graph
      */
     public final String getCaption()
     {
         return this.caption;
     }
 
 }