package org.opentrafficsim.graphs;

import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertTrue;
import static org.junit.Assert.fail;
import static org.opentrafficsim.road.gtu.lane.RoadGTUTypes.CAR;

import java.awt.Component;
import java.awt.Container;
import java.awt.event.ActionEvent;
import java.awt.event.MouseListener;
import java.util.ArrayList;
import java.util.HashSet;
import java.util.List;
import java.util.Set;

import javax.swing.JLabel;
import javax.swing.JOptionPane;

import org.djunits.unit.AccelerationUnit;
import org.djunits.unit.LengthUnit;
import org.djunits.unit.TimeUnit;
import org.djunits.unit.UNITS;
import org.djunits.value.vdouble.scalar.Acceleration;
import org.djunits.value.vdouble.scalar.DoubleScalar;
import org.djunits.value.vdouble.scalar.Duration;
import org.djunits.value.vdouble.scalar.Length;
import org.djunits.value.vdouble.scalar.Speed;
import org.djunits.value.vdouble.scalar.Time;
import org.jfree.chart.ChartPanel;
import org.jfree.data.DomainOrder;
import org.opentrafficsim.core.dsol.OTSModelInterface;
import org.opentrafficsim.core.dsol.OTSSimTimeDouble;
import org.opentrafficsim.core.geometry.OTSPoint3D;
import org.opentrafficsim.core.gtu.GTUType;
import org.opentrafficsim.core.gtu.behavioralcharacteristics.ParameterTypes;
import org.opentrafficsim.core.network.LongitudinalDirectionality;
import org.opentrafficsim.core.network.Network;
import org.opentrafficsim.core.network.OTSNetwork;
import org.opentrafficsim.core.network.OTSNode;
import org.opentrafficsim.road.car.CarTest;
import org.opentrafficsim.road.gtu.lane.LaneBasedIndividualGTU;
import org.opentrafficsim.road.gtu.lane.tactical.following.FixedAccelerationModel;
import org.opentrafficsim.road.gtu.lane.tactical.following.SequentialFixedAccelerationModel;
import org.opentrafficsim.road.gtu.lane.tactical.lanechangemobil.Egoistic;
import org.opentrafficsim.road.gtu.lane.tactical.lanechangemobil.LaneChangeModel;
import org.opentrafficsim.road.network.factory.LaneFactory;
import org.opentrafficsim.road.network.lane.Lane;
import org.opentrafficsim.road.network.lane.LaneType;
import org.opentrafficsim.simulationengine.SimpleSimulator;

import nl.tudelft.simulation.dsol.SimRuntimeException;
import nl.tudelft.simulation.dsol.simulators.SimulatorInterface;

/**
 * Test the non-GUI part of the ContourPlot class.
 * <p>
 * Copyright (c) 2013-2016 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/docs/license.html">OpenTrafficSim License</a>.
 * <p>
 * $LastChangedDate: 2015-09-14 01:33:02 +0200 (Mon, 14 Sep 2015) $, @version $Revision: 1401 $, by $Author: averbraeck $,
 * initial version Aug 21, 2014 <br>
 * @author <a href="http://www.tudelft.nl/pknoppers">Peter Knoppers</a>
 */
public class ContourPlotTest implements UNITS
{
    /**
     * Create a dummy path for the tests.
     * @param network Network; the network
     * @param laneType the lane type
     * @param gtuType the GTU type
     * @return List&lt;Lane&gt;; the dummy path
     * @throws Exception when something goes wrong (should not happen)
     */
    private List<Lane> dummyPath(final Network network, final LaneType laneType, final GTUType gtuType) throws Exception
    {
        OTSNode b = new OTSNode(network, "B", new OTSPoint3D(12345, 0, 0));
        ArrayList<Lane> result = new ArrayList<Lane>();
        Lane[] lanes = LaneFactory.makeMultiLane(network, "AtoB", new OTSNode(network, "A", new OTSPoint3D(1234, 0, 0)), b,
                null, 1, laneType, new Speed(100, KM_PER_HOUR), null, LongitudinalDirectionality.DIR_PLUS);
        result.add(lanes[0]);
        // Make a continuation lane to prevent errors when the operational plan exceeds the available remaining length
        lanes = LaneFactory.makeMultiLane(network, "BtoC", b, new OTSNode(network, "C", new OTSPoint3D(99999, 0, 0)), null, 1,
                laneType, new Speed(100, KM_PER_HOUR), null, LongitudinalDirectionality.DIR_PLUS);
        // System.out.println("continuation lane is " + lanes[0] + " length is " + lanes[0].getLength());
        // System.out.println("next lanes is " + result.get(0).nextLanes(gtuType));
        return result;
    }

    /**
     * Test the AccelerationContourPlot.
     * @throws Exception when something goes wrong (should not happen)
     */
    @SuppressWarnings("static-method")
    // TODO @Test
    public final void accelerationContourTest() throws Exception
    {
        Network network = new OTSNetwork("contour test network");
        GTUType gtuType = CAR;
        Set<GTUType> compatibility = new HashSet<GTUType>();
        compatibility.add(gtuType);
        LaneType laneType = new LaneType("CarLane", compatibility);
        List<Lane> path = dummyPath(network, laneType, gtuType);
        AccelerationContourPlot acp = new AccelerationContourPlot("Acceleration", path);
        assertTrue("newly created AccelerationContourPlot should not be null", null != acp);
        assertEquals("SeriesKey should be \"acceleration\"", "acceleration", acp.getSeriesKey(0));
        standardContourTests(acp, path.get(0), gtuType, Double.NaN, 0);
    }

    /**
     * Test the DensityContourPlot.
     * @throws Exception when something goes wrong (should not happen)
     */
    @SuppressWarnings("static-method")
    // TODO @Test
    public final void densityContourTest() throws Exception
    {
        Network network = new OTSNetwork("contour test network");
        GTUType gtuType = CAR;
        Set<GTUType> compatibility = new HashSet<GTUType>();
        compatibility.add(gtuType);
        LaneType laneType = new LaneType("CarLane", compatibility);
        List<Lane> path = dummyPath(network, laneType, gtuType);
        DensityContourPlot dcp = new DensityContourPlot("Density", path);
        assertTrue("newly created DensityContourPlot should not be null", null != dcp);
        assertEquals("SeriesKey should be \"density\"", "density", dcp.getSeriesKey(0));
        standardContourTests(dcp, path.get(0), gtuType, 0, Double.NaN);
    }

    /**
     * Debugging method.
     * @param cp cp
     * @param fromX fromX
     * @param toX toX
     * @param fromY fromY
     * @param toY toY
     */
    static void printMatrix(ContourPlot cp, int fromX, int toX, int fromY, int toY)
    {
        System.out.println("Contour plot data:");
        int maxItem = cp.getItemCount(0);
        for (int y = fromY; y <= toY; y++)
        {
            System.out.print(String.format("y=%3d ", y));
            for (int x = fromX; x <= toX; x++)
            {
                // Find the item with the requested x and y
                int item;
                for (item = 0; item < maxItem; item++)
                {
                    if (cp.getXValue(0, item) == x && cp.getYValue(0, item) == y)
                    {
                        break;
                    }
                }
                if (item < maxItem)
                {
                    System.out.print(String.format("%10.6f", cp.getZValue(0, item)));
                }
                else
                {
                    System.out.print(" -------- ");
                }
            }
            System.out.println("");
        }
        System.out.print("");
    }

    /**
     * Test the FlowContourPlot.
     * @throws Exception when something goes wrong (should not happen)
     */
    @SuppressWarnings("static-method")
    // TODO @Test
    public final void flowContourTest() throws Exception
    {
        Network network = new OTSNetwork("contour test network");
        GTUType gtuType = CAR;
        Set<GTUType> compatibility = new HashSet<GTUType>();
        compatibility.add(gtuType);
        LaneType laneType = new LaneType("CarLane", compatibility);
        List<Lane> path = dummyPath(network, laneType, gtuType);
        FlowContourPlot fcp = new FlowContourPlot("Density", path);
        assertTrue("newly created DensityContourPlot should not be null", null != fcp);
        assertEquals("SeriesKey should be \"flow\"", "flow", fcp.getSeriesKey(0));
        standardContourTests(fcp, path.get(0), gtuType, 0, Double.NaN);
    }

    /**
     * Test the SpeedContourPlot.
     * @throws Exception when something goes wrong (should not happen)
     */
    @SuppressWarnings("static-method")
    // TODO@Test
    public final void speedContourTest() throws Exception
    {
        Network network = new OTSNetwork("contour test network");
        GTUType gtuType = CAR;
        Set<GTUType> compatibility = new HashSet<GTUType>();
        compatibility.add(gtuType);
        LaneType laneType = new LaneType("CarLane", compatibility);
        List<Lane> path = dummyPath(network, laneType, gtuType);
        SpeedContourPlot scp = new SpeedContourPlot("Density", path);
        assertTrue("newly created DensityContourPlot should not be null", null != scp);
        assertEquals("SeriesKey should be \"speed\"", "speed", scp.getSeriesKey(0));
        standardContourTests(scp, path.get(0), gtuType, Double.NaN, 50);
    }

    /**
     * Test various properties of a ContourPlot that has no observed data added.
     * @param cp ContourPlot; the ContourPlot to test
     * @param lane Lane; the lane on which the test GTUs are run
     * @param gtuType GTUType; the type of GTU
     * @param expectedZValue double; the value that getZ and getZValue should return for a valid item when no car has passed
     * @param expectedZValueWithTraffic double; the value that getZ and getZValue should return a valid item where a car has
     *            traveled at constant speed of 50 km/h. Supply Double.NaN if the value varies but differs from the value
     *            expected when no car has passed
     * @throws Exception when something goes wrong (should not happen)
     */
    public static void standardContourTests(final ContourPlot cp, Lane lane, GTUType gtuType, final double expectedZValue,
            final double expectedZValueWithTraffic) throws Exception
    {
        assertEquals("seriesCount should be 1", 1, cp.getSeriesCount());
        assertEquals("domainOrder should be ASCENDING", DomainOrder.ASCENDING, cp.getDomainOrder());
        assertEquals("indexOf always returns 0", 0, cp.indexOf(0));
        assertEquals("indexOf always returns 0", 0, cp.indexOf("abc"));
        assertEquals("getGroup always returns null", null, cp.getGroup());
        int xBins = cp.xAxisBins();
        int yBins = cp.yAxisBins();
        int expectedXBins = (int) Math
                .ceil((DoubleScalar.minus(ContourPlot.INITIALUPPERTIMEBOUND, ContourPlot.INITIALLOWERTIMEBOUND).getSI())
                        / ContourPlot.STANDARDTIMEGRANULARITIES[ContourPlot.STANDARDINITIALTIMEGRANULARITYINDEX]);
        assertEquals("Initial xBins should be " + expectedXBins, expectedXBins, xBins);
        int expectedYBins = (int) Math.ceil(lane.getLength().getSI()
                / ContourPlot.STANDARDDISTANCEGRANULARITIES[ContourPlot.STANDARDINITIALDISTANCEGRANULARITYINDEX]);
        assertEquals("yBins should be " + expectedYBins, expectedYBins, yBins);
        int bins = cp.getItemCount(0);
        assertEquals("Total bin count is product of xBins * yBins", xBins * yBins, bins);
        // Cache the String equivalents of minimumDistance and maximumDistance, INITIALLOWERTIMEBOUND and
        // INITUALUPPERTIMEBOUND
        String initialLowerTimeBoundString = ContourPlot.INITIALLOWERTIMEBOUND.toString();
        String initialUpperTimeBoundString = ContourPlot.INITIALUPPERTIMEBOUND.toString();
        // Vary the x granularity
        for (double timeGranularity : ContourPlot.STANDARDTIMEGRANULARITIES)
        {
            cp.actionPerformed(new ActionEvent(cp, 0, "setTimeGranularity " + timeGranularity));
            for (double distanceGranularity : ContourPlot.STANDARDDISTANCEGRANULARITIES)
            {
                cp.actionPerformed(new ActionEvent(cp, 0, "setDistanceGranularity " + distanceGranularity));
                cp.reGraph();
                expectedXBins = (int) Math
                        .ceil((DoubleScalar.minus(ContourPlot.INITIALUPPERTIMEBOUND, ContourPlot.INITIALLOWERTIMEBOUND).getSI())
                                / timeGranularity);
                xBins = cp.xAxisBins();
                assertEquals("Modified xBins should be " + expectedXBins, expectedXBins, xBins);
                expectedYBins = (int) Math.ceil(lane.getLength().getSI() / distanceGranularity);
                yBins = cp.yAxisBins();
                assertEquals("Modified yBins should be " + expectedYBins, expectedYBins, yBins);
                bins = cp.getItemCount(0);
                assertEquals("Total bin count is product of xBins * yBins", xBins * yBins, bins);
                for (int item = 0; item < bins; item++)
                {
                    double x = cp.getXValue(0, item);
                    assertTrue("X should be >= " + initialLowerTimeBoundString, x >= ContourPlot.INITIALLOWERTIMEBOUND.getSI());
                    assertTrue("X should be <= " + initialUpperTimeBoundString, x <= ContourPlot.INITIALUPPERTIMEBOUND.getSI());
                    Number alternateX = cp.getX(0, item);
                    assertEquals("getXValue and getX should return things that have the same value", x,
                            alternateX.doubleValue(), 0.000001);
                    double y = cp.getYValue(0, item);
                    Number alternateY = cp.getY(0, item);
                    assertEquals("getYValue and getY should return things that have the same value", y,
                            alternateY.doubleValue(), 0.000001);
                    double z = cp.getZValue(0, item);
                    if (Double.isNaN(expectedZValue))
                    {
                        assertTrue("Z value should be NaN", Double.isNaN(z));
                    }
                    else
                    {
                        assertEquals("Z value should be " + expectedZValue, expectedZValue, z, 0.0001);
                    }
                    Number alternateZ = cp.getZ(0, item);
                    if (Double.isNaN(expectedZValue))
                    {
                        assertTrue("Alternate Z value should be NaN", Double.isNaN(alternateZ.doubleValue()));
                    }
                    else
                    {
                        assertEquals("Alternate Z value should be " + expectedZValue, expectedZValue, alternateZ.doubleValue(),
                                0.0000);
                    }
                }
                try
                {
                    cp.getXValue(0, -1);
                    fail("Should have thrown an Exception");
                }
                catch (RuntimeException e)
                {
                    // Ignore
                }
                try
                {
                    cp.getXValue(0, bins);
                    fail("Should have thrown an Exception");
                }
                catch (RuntimeException e)
                {
                    // Ignore
                }
                try
                {
                    cp.yAxisBin(-1);
                    fail("Should have thrown an Exception");
                }
                catch (RuntimeException e)
                {
                    // Ignore
                }
                try
                {
                    cp.yAxisBin(bins);
                    fail("Should have thrown an Exception");
                }
                catch (RuntimeException e)
                {
                    // Ignore
                }
            }
        }
        // Test some ActionEvents that ContourPlot can not handle
        try
        {
            cp.actionPerformed(new ActionEvent(cp, 0, "blabla"));
            fail("Should have thrown an Exception");
        }
        catch (RuntimeException e)
        {
            // Ignore
        }
        try
        {
            cp.actionPerformed(new ActionEvent(cp, 0, "setDistanceGranularity -1"));
            fail("Should have thrown an Exception");
        }
        catch (RuntimeException e)
        {
            // ignore
        }
        try
        {
            cp.actionPerformed(new ActionEvent(cp, 0, "setDistanceGranularity abc"));
            fail("Should have thrown an Exception");
        }
        catch (RuntimeException e)
        {
            // ignore
        }
        try
        {
            cp.actionPerformed(new ActionEvent(cp, 0, "setDistanceGranularitIE 10")); // typo in the event name
            fail("Should have thrown an Exception");
        }
        catch (RuntimeException e)
        {
            // ignore
        }
        // Make the time granularity a bit more reasonable
        final double useTimeGranularity = 30; // [s]
        cp.actionPerformed(new ActionEvent(cp, 0, "setTimeGranularity " + useTimeGranularity));
        final double useDistanceGranularity =
                ContourPlot.STANDARDDISTANCEGRANULARITIES[ContourPlot.STANDARDDISTANCEGRANULARITIES.length - 1];
        cp.actionPerformed(new ActionEvent(cp, 0, "setDistanceGranularity " + useDistanceGranularity));
        cp.reGraph();
        bins = cp.getItemCount(0);
        Time initialTime = new Time(0, SECOND);
        Length initialPosition = new Length(100, METER);
        Speed initialSpeed = new Speed(50, KM_PER_HOUR);
        ContourPlotModel model = new ContourPlotModel();
        SimpleSimulator simulator =
                new SimpleSimulator(initialTime, new Duration(0, SECOND), new Duration(1800, SECOND), model);
        // Create a car running 50 km.h
        SequentialFixedAccelerationModel gtuFollowingModel =
                new SequentialFixedAccelerationModel(simulator, new Acceleration(2.0, AccelerationUnit.METER_PER_SECOND_2));
        // Make the car run at constant speed for one minute
        gtuFollowingModel
                .addStep(new FixedAccelerationModel(new Acceleration(0, METER_PER_SECOND_2), new Duration(60, SECOND)));
        // Make the car run at constant speed for another minute
        gtuFollowingModel
                .addStep(new FixedAccelerationModel(new Acceleration(0, METER_PER_SECOND_2), new Duration(600, SECOND)));
        // Make the car run at constant speed for five more minutes
        gtuFollowingModel
                .addStep(new FixedAccelerationModel(new Acceleration(0, METER_PER_SECOND_2), new Duration(300, SECOND)));
        LaneChangeModel laneChangeModel = new Egoistic();
        OTSNetwork network = new OTSNetwork("network");

        // Check that the initial data in the graph contains no trace of any car.
        for (int item = 0; item < bins; item++)
        {
            double x = cp.getXValue(0, item);
            assertTrue("X should be >= " + ContourPlot.INITIALLOWERTIMEBOUND, x >= ContourPlot.INITIALLOWERTIMEBOUND.getSI());
            assertTrue("X should be <= " + ContourPlot.INITIALUPPERTIMEBOUND, x <= ContourPlot.INITIALUPPERTIMEBOUND.getSI());
            Number alternateX = cp.getX(0, item);
            assertEquals("getXValue and getX should return things that have the same value", x, alternateX.doubleValue(),
                    0.000001);
            double y = cp.getYValue(0, item);
            Number alternateY = cp.getY(0, item);
            assertEquals("getYValue and getY should return things that have the same value", y, alternateY.doubleValue(),
                    0.000001);
            double z = cp.getZValue(0, item);
            if (Double.isNaN(expectedZValue))
            {
                assertTrue("Z value should be NaN (got " + z + ")", Double.isNaN(z));
            }
            else
            {
                assertEquals("Z value should be " + expectedZValue, expectedZValue, z, 0.0001);
            }
            Number alternateZ = cp.getZ(0, item);
            if (Double.isNaN(expectedZValue))
            {
                assertTrue("Alternate Z value should be NaN", Double.isNaN(alternateZ.doubleValue()));
            }
            else
            {
                assertEquals("Alternate Z value should be " + expectedZValue, expectedZValue, alternateZ.doubleValue(), 0.0000);
            }
        }

        LaneBasedIndividualGTU car = CarTest.makeReferenceCar("0", gtuType, lane, initialPosition, initialSpeed, simulator,
                gtuFollowingModel, laneChangeModel, network);
        car.getStrategicalPlanner().getBehavioralCharacteristics().setParameter(ParameterTypes.LOOKAHEAD,
                new Length(10, LengthUnit.KILOMETER));

        // System.out.println("Running simulator from " + simulator.getSimulatorTime().get() + " to "
        // + gtuFollowingModel.timeAfterCompletionOfStep(0));
        double stopTime = gtuFollowingModel.timeAfterCompletionOfStep(0).si;
        simulator.runUpToAndIncluding(new Time(stopTime, TimeUnit.SI));
        while (simulator.isRunning())
        {
            try
            {
                Thread.sleep(10);
            }
            catch (InterruptedException ie)
            {
                ie = null; // ignore
            }
        }
        // System.out.println("Simulator is now at " + simulator.getSimulatorTime().get());
        // System.out.println("Car at start time " + car.getOperationalPlan().getStartTime() + " is at "
        // + car.getPosition(car.getOperationalPlan().getStartTime()));
        // System.out.println("At time " + simulator.getSimulator().getSimulatorTime().getTime() + " car is at " + car);
        for (int item = 0; item < bins; item++)
        {
            double x = cp.getXValue(0, item);
            assertTrue("X should be >= " + ContourPlot.INITIALLOWERTIMEBOUND, x >= ContourPlot.INITIALLOWERTIMEBOUND.getSI());
            assertTrue("X should be <= " + ContourPlot.INITIALUPPERTIMEBOUND, x <= ContourPlot.INITIALUPPERTIMEBOUND.getSI());
            Number alternateX = cp.getX(0, item);
            assertEquals("getXValue and getX should return things that have the same value", x, alternateX.doubleValue(),
                    0.000001);
            double y = cp.getYValue(0, item);
            Number alternateY = cp.getY(0, item);
            assertEquals("getYValue and getY should return things that have the same value", y, alternateY.doubleValue(),
                    0.000001);
            double z = cp.getZValue(0, item);
            // figure out if the car has traveled through this cell
            // if (x >= 180)
            // System.out.println(String.format("t=%.3f, x=%.3f z=%f, exp=%.3f, carLastEval=%s, carNextEval=%s", x, y, z,
            // expectedZValue, car.getOperationalPlan().getStartTime().getSI(), car.getOperationalPlan().getEndTime()
            // .getSI()));
            boolean hit = false;
            if (x + useTimeGranularity >= 0// car.getOperationalPlan().getStartTime().getSI()
                    && x < 60)// car.getOperationalPlan().getEndTime().getSI())
            {
                // the car MAY have contributed to this cell
                Time cellStartTime = new Time(Math.max(car.getOperationalPlan().getStartTime().getSI(), x), SECOND);
                Time cellEndTime =
                        new Time(Math.min(car.getOperationalPlan().getEndTime().getSI(), x + useTimeGranularity), SECOND);
                // System.out.println("cellStartTime=" + cellStartTime + ", cellEndTime=" + cellEndTime);
                // The next if statement is the problem
                // if (cellStartTime.lt(cellEndTime)
                // && car.position(lane, car.getRear(), cellStartTime).getSI() <= y + useDistanceGranularity
                // && car.position(lane, car.getRear(), cellEndTime).getSI() >= y)
                double xAtCellStartTime = initialPosition.si + initialSpeed.si * cellStartTime.si;
                double xAtCellEndTime = initialPosition.si + initialSpeed.si * cellEndTime.si;
                if (xAtCellStartTime < y + useDistanceGranularity && xAtCellEndTime >= y)
                {
                    hit = true;
                }
            }
            // System.out.println(String.format(
            // "hit=%s, t=%.3f, x=%.3f z=%f, exp=%.3f, carLastEval=%s, carNextEval=%s, simulatortime=%s", hit, x, y, z,
            // expectedZValue, car.getOperationalPlan().getStartTime().getSI(), car.getOperationalPlan().getEndTime()
            // .getSI(), car.getSimulator().getSimulatorTime().get()));
            Number alternateZ = cp.getZ(0, item);
            if (hit)
            {
                if (!Double.isNaN(expectedZValueWithTraffic))
                {
                    if (Double.isNaN(z))
                    {
                        printMatrix(cp, 0, 10, 0, 10);
                        System.out.println("Oops - z is NaN, expected z value with traffic is " + expectedZValueWithTraffic);
                    }
                    assertEquals("Z value should be " + expectedZValueWithTraffic, expectedZValueWithTraffic, z, 0.0001);
                    assertEquals("Z value should be " + expectedZValueWithTraffic, expectedZValueWithTraffic,
                            alternateZ.doubleValue(), 0.0001);
                }
                else
                {
                    if (Double.isNaN(expectedZValue))
                    { // FIXME looks wrong / PK
                        assertFalse("Z value should not be NaN", Double.isNaN(z));
                    }
                }
            }
            else
            {
                if (Double.isNaN(expectedZValue))
                {
                    // if (!Double.isNaN(z))
                    // {
                    // System.out.println("Oops");
                    // Time cellStartTime = new Time(x, SECOND);
                    // Time cellEndTime =
                    // new Time(Math.min(car.getOperationalPlan().getEndTime().getSI(), x + useTimeGranularity),
                    // SECOND);
                    // double xAtCellStartTime = initialPosition.si + initialSpeed.si * cellStartTime.si;
                    // double xAtCellEndTime = initialPosition.si + initialSpeed.si * cellEndTime.si;
                    // System.out.println("cellStartTime=" + cellStartTime + " cellEndTime=" + cellEndTime
                    // + " xAtCellStartTime=" + xAtCellStartTime + " xAtCellEndTime=" + xAtCellEndTime);
                    // double cellX = cp.getXValue(0, item);
                    // double cellY = cp.getYValue(0, item);
                    // double cellZ = cp.getZValue(0, item);
                    // System.out.println("cellX=" + cellX + " cellY=" + cellY + " cellZ=" + cellZ + " timeGranularity="
                    // + useTimeGranularity + " distanceGranularity=" + useDistanceGranularity);
                    // cp.getZValue(0, item);
                    // }
                    assertTrue("Z value should be NaN", Double.isNaN(z));
                }
                else
                {
                    assertEquals("Z value should be " + expectedZValue, expectedZValue, z, 0.0001);
                }
                if (Double.isNaN(expectedZValue))
                {
                    assertTrue("Alternate Z value should be NaN", Double.isNaN(alternateZ.doubleValue()));
                }
                else
                {
                    assertEquals("Alternate Z value should be " + expectedZValue, expectedZValue, alternateZ.doubleValue(),
                            0.0000);
                }
            }
        }
        // System.out.println("Running simulator from " + simulator.getSimulatorTime().get() + " to "
        // + gtuFollowingModel.timeAfterCompletionOfStep(1));
        stopTime = gtuFollowingModel.timeAfterCompletionOfStep(1).si;
        simulator.runUpToAndIncluding(new Time(stopTime, TimeUnit.SI));
        while (simulator.isRunning())
        {
            try
            {
                Thread.sleep(10);
            }
            catch (InterruptedException ie)
            {
                ie = null; // ignore
            }
        }
        // System.out.println("Simulator is now at " + simulator.getSimulatorTime().get());
        // Check that the time range has expanded
        xBins = cp.xAxisBins();
        bins = cp.getItemCount(0);
        double observedHighestTime = Double.MIN_VALUE;
        for (int bin = 0; bin < bins; bin++)
        {
            double xValue = cp.getXValue(0, bin);
            if (xValue > observedHighestTime)
            {
                observedHighestTime = xValue;
            }
        }
        double expectedHighestTime =
                Math.floor((car.getSimulator().getSimulatorTime().get().si - 0.001) / useTimeGranularity) * useTimeGranularity;
        assertEquals("Time range should run up to " + expectedHighestTime, expectedHighestTime, observedHighestTime, 0.0001);
        // Check the updateHint method in the PointerHandler
        // First get the panel that stores the result of updateHint (this is ugly)
        JLabel hintPanel = null;
        ChartPanel chartPanel = null;
        for (Component c0 : cp.getComponents())
        {
            for (Component c1 : ((Container) c0).getComponents())
            {
                if (c1 instanceof Container)
                {
                    for (Component c2 : ((Container) c1).getComponents())
                    {
                        // System.out.println("c2 is " + c2);
                        if (c2 instanceof Container)
                        {
                            for (Component c3 : ((Container) c2).getComponents())
                            {
                                // System.out.println("c3 is " + c3);
                                if (c3 instanceof JLabel)
                                {
                                    if (null == hintPanel)
                                    {
                                        hintPanel = (JLabel) c3;
                                    }
                                    else
                                    {
                                        fail("There should be only one JPanel in a ContourPlot");
                                    }
                                }
                                if (c3 instanceof ChartPanel)
                                {
                                    if (null == chartPanel)
                                    {
                                        chartPanel = (ChartPanel) c3;
                                    }
                                    else
                                    {
                                        fail("There should be only one ChartPanel in a ContourPlot");
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
        if (null == hintPanel)
        {
            fail("Could not find a JLabel in ContourPlot");
        }
        if (null == chartPanel)
        {
            fail("Could not find a ChartPanel in ContourPlot");
        }
        assertEquals("Initially the text should be a single space", " ", hintPanel.getText());
        PointerHandler ph = null;
        for (MouseListener ml : chartPanel.getMouseListeners())
        {
            if (ml instanceof PointerHandler)
            {
                if (null == ph)
                {
                    ph = (PointerHandler) ml;
                }
                else
                {
                    fail("There should be only one PointerHandler on the chartPanel");
                }
            }
        }
        if (null == ph)
        {
            fail("Could not find the PointerHandler for the chartPanel");
        }
        ph.updateHint(1, 2);
        // System.out.println("Hint text is now " + hintPanel.getText());
        assertFalse("Hint should not be a single space", " ".equals(hintPanel.getText()));
        ph.updateHint(Double.NaN, Double.NaN);
        assertEquals("The text should again be a single space", " ", hintPanel.getText());
    }

    /**
     * Run the DensityContourPlot stand-alone for profiling.
     * @param args String[]; the command line arguments (not used)
     * @throws Exception when something goes wrong (should not happen)
     */
    public static void main(final String[] args) throws Exception
    {
        ContourPlotTest cpt = new ContourPlotTest();
        System.out.println("Click the OK button");
        JOptionPane.showMessageDialog(null, "ContourPlot", "Start experiment", JOptionPane.INFORMATION_MESSAGE);
        System.out.println("Running ...");
        cpt.densityContourTest();
        System.out.println("Finished");
    }

}

/**
 * <p>
 * Copyright (c) 2013-2016 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/docs/license.html">OpenTrafficSim License</a>.
 * <p>
 * $LastChangedDate: 2015-09-14 01:33:02 +0200 (Mon, 14 Sep 2015) $, @version $Revision: 1401 $, by $Author: averbraeck $,
 * initial version feb. 2015 <br>
 * @author <a href="http://www.tudelft.nl/pknoppers">Peter Knoppers</a>
 */
class ContourPlotModel implements OTSModelInterface
{

    /** */
    private static final long serialVersionUID = 20150209L;

    /** {@inheritDoc} */
    @Override
    public void constructModel(SimulatorInterface<Time, Duration, OTSSimTimeDouble> simulator) throws SimRuntimeException
    {
        // NOT USED
    }

    /** {@inheritDoc} */
    @Override
    public SimulatorInterface<Time, Duration, OTSSimTimeDouble> getSimulator()

    {
        return null;
    }

    /** {@inheritDoc} */
    @Override
    public OTSNetwork getNetwork()
    {
        return null;
    }

}