package org.opentrafficsim.draw.graphs;
   
   import org.djunits.value.vdouble.scalar.Duration;
   import org.djutils.exceptions.Throw;
   import org.jfree.chart.JFreeChart;
   import org.jfree.chart.axis.ValueAxis;
   import org.jfree.chart.event.AxisChangeEvent;
   import org.jfree.chart.event.AxisChangeListener;
   import org.jfree.chart.plot.XYPlot;
  import org.opentrafficsim.core.dsol.OTSSimulatorInterface;
  
  /**
   * Plot that allows hard bounds to be set, with upper and lower bound independent. Manual zooming and auto ranges are bounded
   * within the bounds.
   * <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 21 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 AbstractBoundedPlot extends AbstractPlot
  {
  
      /** */
      private static final long serialVersionUID = 20182021L;
  
      /** Lower bound of domain axis. */
      private Double lowerDomainBound = null;
  
      /** Upper bound of domain axis. */
      private Double upperDomainBound = null;
  
      /** Lower bound of range axis. */
      private Double lowerRangeBound = null;
  
      /** Upper bound of range axis. */
      private Double upperRangeBound = null;
  
      /**
       * 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 AbstractBoundedPlot(final String caption, final Duration updateInterval, final OTSSimulatorInterface simulator,
              final Duration delay)
      {
          super(caption, updateInterval, simulator, delay);
      }
  
      /** {@inheritDoc} */
      @Override
      protected void setChart(final JFreeChart chart)
      {
          Throw.when(!(chart.getPlot() instanceof XYPlot), IllegalArgumentException.class,
                  "AbstractBoundedPlot can only work with XYPlot.");
  
          super.setChart(chart);
  
          XYPlot xyPlot = chart.getXYPlot();
          xyPlot.getDomainAxis().addChangeListener(new AxisChangeListener()
          {
              /** Whether to listen, this prevents a stack overflow. */
              private boolean listen = true;
  
              /** {@inheritDoc} */
              @SuppressWarnings("synthetic-access")
              @Override
              public void axisChanged(final AxisChangeEvent event)
              {
                  if (!this.listen)
                  {
                      return;
                  }
                  this.listen = false;
                  constrainAxis(xyPlot.getDomainAxis(), AbstractBoundedPlot.this.lowerDomainBound,
                          AbstractBoundedPlot.this.upperDomainBound);
                  this.listen = true;
              }
          });
          xyPlot.getRangeAxis().addChangeListener(new AxisChangeListener()
          {
              /** Whether to listen, this prevents a stack overflow. */
              private boolean listen = true;
  
              /** {@inheritDoc} */
              @SuppressWarnings("synthetic-access")
              @Override
              public void axisChanged(final AxisChangeEvent event)
              {
                  if (!this.listen)
                  {
                      return;
                  }
                  this.listen = false;
                 constrainAxis(xyPlot.getRangeAxis(), AbstractBoundedPlot.this.lowerRangeBound,
                         AbstractBoundedPlot.this.upperRangeBound);
                 this.listen = true;
             }
         });
     }
 
     /**
      * Sets the lower domain bound.
      * @param bound Double; use {@code null} to disable bound
      */
     public void setLowerDomainBound(final Double bound)
     {
         this.lowerDomainBound = bound;
         constrainAxis(getChart().getXYPlot().getDomainAxis(), this.lowerDomainBound, this.upperDomainBound);
     }
 
     /**
      * Sets the upper domain bound.
      * @param bound Double; use {@code null} to disable bound
      */
     public void setUpperDomainBound(final Double bound)
     {
         this.upperDomainBound = bound;
         constrainAxis(getChart().getXYPlot().getDomainAxis(), this.lowerDomainBound, this.upperDomainBound);
     }
 
     /**
      * Sets the lower range bound.
      * @param bound Double; use {@code null} to disable bound
      */
     public void setLowerRangeBound(final Double bound)
     {
         this.lowerRangeBound = bound;
         constrainAxis(getChart().getXYPlot().getRangeAxis(), this.lowerRangeBound, this.upperRangeBound);
     }
 
     /**
      * Sets the upper range bound.
      * @param bound Double; use {@code null} to disable bound
      */
     public void setUpperRangeBound(final Double bound)
     {
         this.upperRangeBound = bound;
         constrainAxis(getChart().getXYPlot().getRangeAxis(), this.lowerRangeBound, this.upperRangeBound);
     }
 
     /**
      * Constrains axis.
      * @param axis ValueAxis; axis
      * @param min Double; minimum value, use {@code null} to apply no bound
      * @param max Double; maximum value, use {@code null} to apply no bound
      */
     private void constrainAxis(final ValueAxis axis, final Double min, final Double max)
     {
         double xLow = axis.getLowerBound();
         double xUpp = axis.getUpperBound();
         if (min != null && max != null && xUpp - xLow > max - min)
         {
             axis.setLowerBound(min);
             axis.setUpperBound(max);
         }
         else if (min != null && xLow < min)
         {
             axis.setLowerBound(min);
             axis.setUpperBound(xUpp + (min - xLow));
         }
         else if (max != null && xUpp > max)
         {
             axis.setLowerBound(xLow - (xUpp - max));
             axis.setUpperBound(max);
         }
     }
 
     /** {@inheritDoc} */
     @Override
     protected void setAutoBoundDomain(final XYPlot plot)
     {
         if (this.lowerDomainBound != null)
         {
             plot.getDomainAxis().setLowerBound(this.lowerDomainBound);
         }
         if (this.upperDomainBound != null)
         {
             plot.getDomainAxis().setUpperBound(this.upperDomainBound);
         }
     }
 
     /** {@inheritDoc} */
     @Override
     protected void setAutoBoundRange(final XYPlot plot)
     {
         if (this.lowerRangeBound != null)
         {
             plot.getRangeAxis().setLowerBound(this.lowerRangeBound);
         }
         if (this.upperRangeBound != null)
         {
             plot.getRangeAxis().setUpperBound(this.upperRangeBound);
         }
     }
 
 }