package org.opentrafficsim.road.network.lane.object.sensor;
   
   import java.awt.Color;
   import java.rmi.RemoteException;
   import java.util.ArrayList;
   import java.util.HashSet;
   import java.util.List;
   import java.util.Map;
   import java.util.Set;
  
  import javax.media.j3d.Bounds;
  import javax.naming.NamingException;
  
  import org.djunits.value.vdouble.scalar.Length;
  import org.opentrafficsim.core.dsol.OTSDEVSSimulatorInterface;
  import org.opentrafficsim.core.dsol.OTSSimulatorInterface;
  import org.opentrafficsim.core.geometry.OTSGeometryException;
  import org.opentrafficsim.core.geometry.OTSLine3D;
  import org.opentrafficsim.core.geometry.OTSPoint3D;
  import org.opentrafficsim.core.gtu.GTUDirectionality;
  import org.opentrafficsim.core.gtu.GTUException;
  import org.opentrafficsim.core.gtu.GTUType;
  import org.opentrafficsim.core.gtu.RelativePosition.TYPE;
  import org.opentrafficsim.core.network.NetworkException;
  import org.opentrafficsim.road.gtu.lane.LaneBasedGTU;
  import org.opentrafficsim.road.network.animation.SensorAnimation;
  import org.opentrafficsim.road.network.animation.TrafficLightSensorAnimation;
  import org.opentrafficsim.road.network.lane.CrossSectionElement;
  import org.opentrafficsim.road.network.lane.Lane;
  
  import nl.tudelft.simulation.dsol.animation.Locatable;
  import nl.tudelft.simulation.event.EventInterface;
  import nl.tudelft.simulation.event.EventListenerInterface;
  import nl.tudelft.simulation.event.EventProducer;
  import nl.tudelft.simulation.event.EventProducerInterface;
  import nl.tudelft.simulation.language.Throw;
  import nl.tudelft.simulation.language.d3.DirectedPoint;
  
  /**
   * This traffic light sensor reports whether it whether any GTUs are within its area. The area is a sub-section of a Lane. This
   * traffic sensor does <b>not</b> report the total number of GTUs within the area; only whether that number is zero or non-zero.
   * <p>
   * Copyright (c) 2013-2017 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 Oct 27, 2016 <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 class TrafficLightSensor extends EventProducer
          implements EventListenerInterface, NonDirectionalOccupancySensor, EventProducerInterface, Locatable, Sensor
  {
      /** */
      private static final long serialVersionUID = 20161103L;
  
      /** Id of this TrafficLightSensor. */
      private final String id;
  
      /** The sensor that detects when a GTU enters the sensor area at point A. */
      private final FlankSensor entryA;
  
      /** The sensor that detects when a GTU exits the sensor area at point A. */
      private final FlankSensor exitA;
  
      /** The sensor that detects when a GTU enters the sensor area at point B. */
      private final FlankSensor entryB;
  
      /** The sensor that detects when a GTU exits the sensor area at point B. */
      private final FlankSensor exitB;
  
      /** GTUs detected by the upSensor, but not yet removed by the downSensor. */
      private final Set<LaneBasedGTU> currentGTUs = new HashSet<>();
  
      /** The lanes that the detector (partly) covers. */
      private final Set<Lane> lanes = new HashSet<>();
  
      /** Which side of the position of flank sensor A is the TrafficLightSensor. */
      private final GTUDirectionality directionalityA;
  
      /** Which side of the position of flank sensor B is the TrafficLightSensor. */
      private final GTUDirectionality directionalityB;
  
      /** Design line of the sensor. */
      private final OTSLine3D path;
  
      /**
       * Construct a new traffic light sensor.<br>
       * TODO Possibly provide the GTUTypes that trigger the sensor as an argument for the constructor
       * @param id String; id of this sensor
       * @param laneA Lane; the lane of the A detection point of this traffic light sensor
       * @param positionA Length; the position of the A detection point of this traffic light sensor
       * @param laneB Lane; the lane of the B detection point of this traffic light sensor
       * @param positionB Length; the position of the B detection point of this traffic light sensor
       * @param intermediateLanes List&lt;Lane&gt;; list of intermediate lanes
       * @param entryPosition RelativePosition; the position on the GTUs that trigger the entry events
       * @param exitPosition RelativePosition; the position on the GTUs that trigger the exit events
       * @param simulator OTSDEVSSimulatorInterface; the simulator
       * @throws NetworkException when the network is inconsistent.
      */
     @SuppressWarnings("checkstyle:parameternumber")
     public TrafficLightSensor(final String id, final Lane laneA, final Length positionA, final Lane laneB,
             final Length positionB, final List<Lane> intermediateLanes, final TYPE entryPosition, final TYPE exitPosition,
             final OTSDEVSSimulatorInterface simulator) throws NetworkException
     {
         Throw.whenNull(id, "id may not be null");
         this.id = id;
         this.entryA = new FlankSensor(id + ".entryA", laneA, positionA, entryPosition, simulator, this);
         this.exitA = new FlankSensor(id + ".exitA", laneA, positionA, exitPosition, simulator, this);
         this.entryB = new FlankSensor(id + ".entryB", laneB, positionB, entryPosition, simulator, this);
         this.exitB = new FlankSensor(id + ".exitB", laneB, positionB, exitPosition, simulator, this);
         // Set up detection of GTUs that enter or leave the sensor laterally or appear due to a generator or disappear due to a
         // sink
         this.lanes.add(laneA);
         if (null != intermediateLanes)
         {
             this.lanes.addAll(intermediateLanes);
         }
         this.lanes.add(laneB);
         for (Lane lane : this.lanes)
         {
             lane.addListener(this, Lane.GTU_ADD_EVENT);
             lane.addListener(this, Lane.GTU_REMOVE_EVENT);
         }
         if (laneA.equals(laneB))
         {
             this.directionalityA = positionA.le(positionB) ? GTUDirectionality.DIR_PLUS : GTUDirectionality.DIR_MINUS;
             this.directionalityB = this.directionalityA;
         }
         else
         {
             this.directionalityA = findDirectionality(laneA);
             this.directionalityB = GTUDirectionality.DIR_PLUS == findDirectionality(laneB) ? GTUDirectionality.DIR_MINUS
                     : GTUDirectionality.DIR_PLUS;
             // System.out.println("Directionality on B is " + this.directionalityB);
         }
         List<OTSPoint3D> outLine = new ArrayList<>();
         outLine.add(fixElevation(this.entryA.getGeometry().getCentroid()));
         if (null != intermediateLanes && intermediateLanes.size() > 0)
         {
             Lane prevLane = laneA;
             List<Lane> remainingLanes = new ArrayList<>();
             remainingLanes.addAll(intermediateLanes);
             remainingLanes.add(laneB);
             while (remainingLanes.size() > 0)
             {
                 Lane continuingLane = null;
                 for (Lane nextLane : intermediateLanes)
                 {
                     if (prevLane.nextLanes(GTUType.ALL).containsKey(nextLane))
                     {
                         continuingLane = nextLane;
                         outLine.add(fixElevation(prevLane.getCenterLine().getLast()));
                         break;
                     }
                     else if (prevLane.prevLanes(GTUType.ALL).containsKey(nextLane))
                     {
                         continuingLane = nextLane;
                         outLine.add(fixElevation(prevLane.getCenterLine().getFirst()));
                         break;
                     }
                 }
                 if (null == continuingLane)
                 {
                     throw new NetworkException("Cannot find route from laneA to laneB using the provided intermediateLanes");
                 }
                 remainingLanes.remove(continuingLane);
             }
         }
         outLine.add(fixElevation(this.exitB.getGeometry().getCentroid()));
         try
         {
             this.path = OTSLine3D.createAndCleanOTSLine3D(outLine);
         }
         catch (OTSGeometryException exception)
         {
             // This happens if A and B are the same
             throw new NetworkException(exception);
         }
         try
         {
             new TrafficLightSensorAnimation(this, simulator);
         }
         catch (RemoteException | NamingException | OTSGeometryException exception)
         {
             throw new NetworkException(exception);
         }
     }
 
     /**
      * Increase the elevation of an OTSPoint3D.
      * @param point OTSPoint3D; the point
      * @return OTSPoint3D
      */
     private OTSPoint3D fixElevation(final OTSPoint3D point)
     {
         return new OTSPoint3D(point.x, point.y, point.z + SingleSensor.DEFAULT_SENSOR_ELEVATION.si);
     }
 
     /**
      * Figure out which part of a lane is covered by the TrafficLightSensor.
      * @param lane Lane; the lane
      * @return GTUDirectionality; DIR_PLUS if the detector covers the section with higher longitudinal position; DIR_MINUS if
      *         the detector covers the section with lower longitudinal position
      * @throws NetworkException if the lane is not connected to any of the lanes in this.lanes
      */
     private GTUDirectionality findDirectionality(final Lane lane) throws NetworkException
     {
         for (Lane nextLane : lane.nextLanes(GTUType.ALL).keySet())
         {
             if (this.lanes.contains(nextLane))
             {
                 return GTUDirectionality.DIR_PLUS;
             }
         }
         for (Lane prevLane : lane.prevLanes(GTUType.ALL).keySet())
         {
             if (this.lanes.contains(prevLane))
             {
                 return GTUDirectionality.DIR_MINUS;
             }
         }
         throw new NetworkException("lane " + lane + " is not connected to any intermediate lane or the other lane");
     }
 
     /**
      * Add a GTU to the set.
      * @param gtu LaneBasedGTU; the GTU that must be added
      */
     protected final void addGTU(final LaneBasedGTU gtu)
     {
         if (this.currentGTUs.add(gtu) && this.currentGTUs.size() == 1)
         {
             fireTimedEvent(NonDirectionalOccupancySensor.NON_DIRECTIONAL_OCCUPANCY_SENSOR_TRIGGER_ENTRY_EVENT,
                     new Object[] { getId() }, getSimulator().getSimulatorTime());
         }
     }
 
     /**
      * Remove a GTU from the set.
      * @param gtu LaneBasedGTU; the GTU that must be removed
      */
     protected final void removeGTU(final LaneBasedGTU gtu)
     {
         if (this.currentGTUs.remove(gtu) && this.currentGTUs.size() == 0)
         {
             fireTimedEvent(NonDirectionalOccupancySensor.NON_DIRECTIONAL_OCCUPANCY_SENSOR_TRIGGER_EXIT_EVENT,
                     new Object[] { getId() }, getSimulator().getSimulatorTime());
         }
     }
 
     /** {@inheritDoc} */
     @Override
     public final void notify(final EventInterface event) throws RemoteException
     {
         // System.out.println("Received notification: " + event);
         LaneBasedGTU gtu = (LaneBasedGTU) ((Object[]) event.getContent())[1];
         if (Lane.GTU_REMOVE_EVENT.equals(event.getType()))
         {
             if (!this.currentGTUs.contains(gtu))
             {
                 return; // GTU is not currently detected; nothing to do
             }
             try
             {
                 Map<Lane, Length> frontPositions = gtu.positions(gtu.getRelativePositions().get(this.entryA.getPositionType()));
                 Set<Lane> remainingLanes = new HashSet<>(frontPositions.keySet());
                 remainingLanes.retainAll(this.lanes);
                 if (remainingLanes.size() == 0)
                 {
                     removeGTU(gtu);
                 }
                 // else: GTU is still in one of our lanes and we will get another GTU_REMOVE_EVENT or the GTU will trigger one
                 // of our exit flank sensors or when the GTU leaves this detector laterally
                 return;
             }
             catch (GTUException exception)
             {
                 System.err.println("Caught GTU exception trying to get the frontPositions");
                 exception.printStackTrace();
             }
         }
         else if (Lane.GTU_ADD_EVENT.equals(event.getType()))
         {
             if (this.currentGTUs.contains(gtu))
             {
                 return; // GTU is already detected; nothing to do
             }
             // Determine whether the GTU is in our range
             try
             {
                 Map<Lane, Length> frontPositions = gtu.positions(gtu.getRelativePositions().get(this.entryA.getPositionType()));
                 Set<Lane> remainingLanes = new HashSet<>(frontPositions.keySet());
                 remainingLanes.retainAll(this.lanes);
                 if (remainingLanes.size() == 0)
                 {
                     System.err.println("GTU is not in any or our lanes - CANNOT HAPPEN");
                 }
                 Map<Lane, Length> rearPositions = gtu.positions(gtu.getRelativePositions().get(this.exitA.getPositionType()));
                 for (Lane remainingLane : remainingLanes)
                 {
                     Length frontPosition = frontPositions.get(remainingLane);
                     Length rearPosition = rearPositions.get(remainingLane);
                     Length laneLength = remainingLane.getLength();
                     // System.out.println("frontPosition " + frontPosition + ", rearPosition " + rearPosition + ", laneLength "
                     // + laneLength + ", directionalityB " + this.directionalityB);
 
                     if (frontPosition.lt0() && rearPosition.lt0()
                             || frontPosition.gt(laneLength) && rearPosition.gt(laneLength))
                     {
                         continue; // Not detected on this lane
                     }
                     // The active part of the GTU covers some part of this lane
                     if (this.entryA.getLane() != remainingLane && this.entryB.getLane() != remainingLane)
                     {
                         // The active part covers (part of) an intermediate lane; therefore this detector detects the GTU
                         addGTU(gtu);
                         return;
                     }
                     // The GTU is on the A lane and/or the B lane; in this case the driving direction matters
                     GTUDirectionality drivingDirection = gtu.getDirection(remainingLane);
                     if (this.entryA.getLane().equals(this.entryB.getLane()))
                     {
                         // A lane equals B lane; does the active part of the GTU cover the detector?
                         // TODO: not handling backwards driving GTU
                         if (GTUDirectionality.DIR_PLUS == drivingDirection)
                         {
                             // GTU is driving in direction of increasing longitudinal distance
                             if (this.directionalityA == GTUDirectionality.DIR_PLUS)
                             {
                                 if (frontPosition.ge(this.entryA.getLongitudinalPosition())
                                         && rearPosition.lt(this.exitB.getLongitudinalPosition()))
                                 {
                                     addGTU(gtu);
                                     return;
                                 }
                             }
                             else
                             {
                                 if (frontPosition.le(this.entryB.getLongitudinalPosition())
                                         && rearPosition.gt(this.exitA.getLongitudinalPosition()))
                                 {
                                     addGTU(gtu);
                                     return;
                                 }
                             }
                         }
                         else
                         {
                             // GTU is driving in direction of decreasing longitudinal distance
                             if (this.directionalityA == GTUDirectionality.DIR_MINUS)
                             {
                                 if (frontPosition.le(this.entryB.getLongitudinalPosition())
                                         && rearPosition.gt(this.entryA.getLongitudinalPosition()))
                                 {
                                     addGTU(gtu);
                                     return;
                                 }
                             }
                             else
                             {
                                 if (frontPosition.le(this.entryB.getLongitudinalPosition())
                                         && rearPosition.gt(this.exitA.getLongitudinalPosition()))
                                 {
                                     addGTU(gtu);
                                     return;
                                 }
                             }
                         }
                     }
                     else
                     // Lane A is not equal to lane B; the GTU is on of these
                     {
                         Length detectionPosition;
                         GTUDirectionality detectorDirectionality;
                         if (this.entryA.getLane() == remainingLane)
                         {
                             detectionPosition = this.entryA.getLongitudinalPosition();
                             detectorDirectionality = this.directionalityA;
                         }
                         else
                         {
                             detectionPosition = this.entryB.getLongitudinalPosition();
                             detectorDirectionality = this.directionalityB;
                         }
                         if (GTUDirectionality.DIR_PLUS == drivingDirection)
                         {
                             if (GTUDirectionality.DIR_PLUS == detectorDirectionality)
                             {
                                 if (frontPosition.ge(detectionPosition))
                                 {
                                     addGTU(gtu);
                                     return;
                                 }
                             }
                             else
                             {
                                 if (rearPosition.le(detectionPosition))
                                 {
                                     addGTU(gtu);
                                     return;
                                 }
                             }
                         }
                         else
                         {
                             // GTU is driving in direction of decreasing longitudinal distance
                             if (GTUDirectionality.DIR_PLUS == detectorDirectionality)
                             {
                                 if (rearPosition.ge(detectionPosition))
                                 {
                                     addGTU(gtu);
                                     return;
                                 }
                             }
                             else
                             {
                                 if (frontPosition.le(detectionPosition))
                                 {
                                     addGTU(gtu);
                                     return;
                                 }
                             }
                         }
                     }
                 }
                 return;
             }
             catch (GTUException exception)
             {
                 System.err.println("Caught GTU exception trying to get the frontPositions");
                 exception.printStackTrace();
             }
         }
         else
         {
             System.err.println("Unexpected event: " + event);
         }
     }
 
     /** {@inheritDoc} */
     @Override
     public final TYPE getPositionTypeEntry()
     {
         return this.entryA.getPositionType();
     }
 
     /** {@inheritDoc} */
     @Override
     public final TYPE getPositionTypeExit()
     {
         return this.exitA.getPositionType();
     }
 
     /** {@inheritDoc} */
     @Override
     public final Length getLanePositionA()
     {
         return this.entryA.getLongitudinalPosition();
     }
 
     /** {@inheritDoc} */
     @Override
     public final Length getLanePositionB()
     {
         return this.entryB.getLongitudinalPosition();
     }
 
     /**
      * One of our flank sensors has triggered.
      * @param sensor FlankSensor; the sensor that was triggered
      * @param gtu LaneBasedGTU; the gtu that triggered the flank sensor
      */
     final void signalDetection(final FlankSensor sensor, final LaneBasedGTU gtu)
     {
         GTUDirectionality gtuDirection = null;
         try
         {
             gtuDirection = gtu.getDirection(sensor.getLane());
         }
         catch (GTUException exception)
         {
             exception.printStackTrace();
         }
         // String source =
         // this.entryA == sensor ? "entryA" : this.entryB == sensor ? "entryB" : this.exitA == sensor ? "exitA"
         // : this.exitB == sensor ? "exitB" : "???";
         // System.out.println("Time " + sensor.getSimulator().getSimulatorTime().get() + ": " + this.id + " " + source
         // + " triggered on " + gtu + " driving direction is " + gtuDirection);
         if (this.entryA == sensor && gtuDirection == this.directionalityA
                 || this.entryB == sensor && gtuDirection != this.directionalityB)
         {
             addGTU(gtu);
         }
         else if (this.exitA == sensor && gtuDirection != this.directionalityA
                 || this.exitB == sensor && gtuDirection == this.directionalityB)
         // Some exit sensor has triggered
         {
             removeGTU(gtu);
         }
         // else
         // {
         // // System.out.println("Ignoring event (GTU is driving in wrong direction)");
         // }
     }
 
     /** {@inheritDoc} */
     @Override
     public final String getId()
     {
         return this.id;
     }
 
     /** {@inheritDoc} */
     @Override
     public final OTSDEVSSimulatorInterface getSimulator()
     {
         return this.entryA.getSimulator();
     }
 
     /** {@inheritDoc} */
     @Override
     public final DirectedPoint getLocation() throws RemoteException
     {
         return this.path.getLocation();
     }
 
     /** {@inheritDoc} */
     @Override
     public final Bounds getBounds() throws RemoteException
     {
         return this.path.getBounds();
     }
 
     /**
      * Return the path of this traffic light sensor.
      * @return OTSLine3D; the path of this traffic light sensor
      */
     public final OTSLine3D getPath()
     {
         return this.path;
     }
 
     /**
      * Return the state of this traffic light sensor.
      * @return boolean; true if one or more GTUs are currently detected; false of no GTUs are currently detected
      */
     public final boolean getOccupancy()
     {
         return this.currentGTUs.size() > 0;
     }
 
 }
 
 /**
  * The embedded sensors of a TrafficLightSensor.
  */
 class FlankSensor extends AbstractSensor
 {
     /** */
     private static final long serialVersionUID = 20161104L;
 
     /** The parent that must be informed of all flanks. */
     private final TrafficLightSensor parent;
 
     /**
      * Construct a new FlankSensor.
      * @param id String; the name of the new FlankSensor
      * @param lane Lane; the lane of the new FlankSensor
      * @param longitudinalPosition Length; the longitudinal position of the new FlankSensor
      * @param positionType TYPE; the position on the GTUs that triggers the new FlankSensor
      * @param simulator OTSDEVSSimulatorInterface; the simulator engine
      * @param parent TrafficLightSensor; the traffic light sensor that deploys this FlankSensor
      * @throws NetworkException when the network is inconsistent
      */
     FlankSensor(final String id, final Lane lane, final Length longitudinalPosition, final TYPE positionType,
             final OTSDEVSSimulatorInterface simulator, final TrafficLightSensor parent) throws NetworkException
     {
         super(id, lane, longitudinalPosition, positionType, simulator);
         this.parent = parent;
         try
         {
             new SensorAnimation(this, longitudinalPosition, simulator, Color.BLUE);
         }
         catch (RemoteException | NamingException exception)
         {
             throw new NetworkException(exception);
         }
     }
 
     /** {@inheritDoc} */
     @Override
     protected void triggerResponse(final LaneBasedGTU gtu)
     {
         this.parent.signalDetection(this, gtu);
     }
 
     /** {@inheritDoc} */
     @Override
     public FlankSensor clone(final CrossSectionElement newCSE, final OTSSimulatorInterface newSimulator,
             final boolean animation) throws NetworkException
     {
         Throw.when(!(newCSE instanceof Lane), NetworkException.class, "sensors can only be cloned for Lanes");
         Throw.when(!(newSimulator instanceof OTSDEVSSimulatorInterface), NetworkException.class,
                 "simulator should be a DEVSSimulator");
         // XXX should the parent of the clone be our parent??? And should the (cloned) parent not construct its own flank
         // sensors?
         return new FlankSensor(getId(), (Lane) newCSE, getLongitudinalPosition(), getPositionType(),
                 (OTSDEVSSimulatorInterface) newSimulator, this.parent);
     }
 
 }