package org.opentrafficsim.sim0mq.publisher;
   
   import java.io.Serializable;
   import java.rmi.RemoteException;
   
   import org.djutils.event.Event;
   import org.djutils.event.EventListener;
   import org.djutils.event.EventProducer;
   import org.djutils.event.EventType;
  import org.djutils.event.LocalEventProducer;
  import org.djutils.event.TimedEvent;
  import org.djutils.metadata.MetaData;
  import org.djutils.metadata.ObjectDescriptor;
  import org.djutils.serialization.SerializationException;
  import org.opentrafficsim.core.dsol.OtsSimulatorInterface;
  import org.sim0mq.Sim0MQException;
  
  import nl.tudelft.simulation.dsol.simulators.SimulatorInterface;
  
  /**
   * Transceiver for simulator state change events.
   * <p>
   * Copyright (c) 2020-2024 Delft University of Technology, PO Box 5, 2600 AA, Delft, the Netherlands. All rights reserved. <br>
   * BSD-style license. See <a href="https://opentrafficsim.org/docs/license.html">OpenTrafficSim License</a>.
   * </p>
   * @author <a href="https://tudelft.nl/staff/p.knoppers-1">Peter Knoppers</a>
   */
  public class SimulatorStateTransceiver extends AbstractTransceiver
  {
      /** The simulator. */
      private final OtsSimulatorInterface simulator;
  
      /** Multiplexes SimulatorInterface.START_EVENT and SimulatorInterface.STOP_EVENT. */
      @SuppressWarnings("checkstyle:visibilitymodifier")
      final EventProducer eventMultiplexer;
  
      /** The event that will be emitted for either the START_EVENT or the STOP_EVENT. */
      public static final EventType SIMULATOR_STATE_CHANGED = new EventType(new MetaData("SIMULATOR_STATE_CHANGED_EVENT",
              "simulator started or stopped", new ObjectDescriptor[] {new ObjectDescriptor("New simulator state",
                      "New simulator state; true if running; false if stopped", Boolean.class)}));
  
      /**
       * Construct a new SimulatorStateTransceiver.
       * @param simulator OtsSimulatorInterface; the simulator
       * @throws RemoteException on network error
       */
      public SimulatorStateTransceiver(final OtsSimulatorInterface simulator) throws RemoteException
      {
          super("Simulator state transceiver", MetaData.EMPTY,
                  new MetaData("SIMULATOR_STATE_CHANGED_EVENT", "simulator state changed"));
          this.simulator = simulator;
          this.eventMultiplexer = new EventMultiplexer(simulator);
      }
  
      /** {@inheritDoc} */
      @Override
      public Object[] get(final Object[] address, final ReturnWrapper returnWrapper)
              throws RemoteException, Sim0MQException, SerializationException
      {
          AbstractTransceiver.verifyMetaData(MetaData.EMPTY, address);
          String result = null;
          if (this.simulator.isInitialized())
          {
              if (this.simulator.isStartingOrRunning())
              {
                  result = "Starting or running";
              }
              else
              {
                  result = "Stopping or stopped";
              }
          }
          else
          {
              result = "Not (yet) initialized";
          }
          return new Object[] {result};
      }
  
      /** Result of the getLookupEventProducer method. */
      private LookupEventProducer lepi = new LookupEventProducer()
      {
          @Override
          public EventProducer lookup(final Object[] address, final ReturnWrapper returnWrapper)
                  throws Sim0MQException, SerializationException
          {
              String bad = AbstractTransceiver.verifyMetaData(MetaData.EMPTY, address);
              if (null != bad)
              {
                  returnWrapper.nack(bad);
                  return null;
              }
              return SimulatorStateTransceiver.this.eventMultiplexer;
          }
  
          @Override
          public MetaData getAddressMetaData()
          {
              return MetaData.EMPTY;
         }
     };
 
     /**
      * Retrieve the event LookupEventProducer.
      * @return EventProducerInterface; the event multiplexer
      */
     public LookupEventProducer getLookupEventProducer()
     {
         return this.lepi;
     }
 
 }
 
 /**
  * Create a subscription to SimulatorInterface.START_EVENT and SimulatorInterface.STOP_EVENT and emit a SIMULATOR_STATE_CHANGED
  * event for each.
  */
 class EventMultiplexer extends LocalEventProducer implements EventListener
 {
     /** ... */
     private static final long serialVersionUID = 20200618L;
 
     /**
      * @param simulator OtsSimulatorInterface; the simulator
      * @throws RemoteException on network error
      */
     EventMultiplexer(final OtsSimulatorInterface simulator) throws RemoteException
     {
         simulator.addListener(this, SimulatorInterface.START_EVENT);
         simulator.addListener(this, SimulatorInterface.STOP_EVENT);
     }
 
     /** {@inheritDoc} */
     @Override
     public void notify(final Event event) throws RemoteException
     {
         notifyTimedEvent(event);
     }
 
     /**
      * Avoid a compilation error with Java 11. Could be bug https://bugs.openjdk.java.net/browse/JDK-8206142 which is
      * unsolved...
      * @param <C> the casting class for the event timestamp
      * @param event the event to be notified of
      */
     private <C extends Serializable & Comparable<C>> void notifyTimedEvent(final Event event)
     {
         @SuppressWarnings("unchecked")
         TimedEvent<C> timedEvent = (TimedEvent<C>) event;
         fireTimedEvent(SimulatorStateTransceiver.SIMULATOR_STATE_CHANGED,
                 event.getType().equals(SimulatorInterface.START_EVENT), timedEvent.getTimeStamp());
     }
 
 }