package org.opentrafficsim.road.gtu.lane.perception.mental.sdm;
   
   import org.djunits.unit.DurationUnit;
   import org.djunits.value.vdouble.scalar.Duration;
   import org.djunits.value.vdouble.scalar.Frequency;
   import org.djutils.exceptions.Throw;
   import org.opentrafficsim.core.units.distributions.ContinuousDistDoubleScalar;
   
   import nl.tudelft.simulation.jstats.distributions.DistLogNormal;
  import nl.tudelft.simulation.jstats.streams.StreamInterface;
  
  /**
   * Task as seen by the Stochastic Distraction Model.
   * <p>
   * Copyright (c) 2013-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://github.com/averbraeck">Alexander Verbraeck</a>
   * @author <a href="https://github.com/peter-knoppers">Peter Knoppers</a>
   * @author <a href="https://github.com/wjschakel">Wouter Schakel</a>
   */
  public class Distraction
  {
  
      /** Id. */
      private final String id;
  
      /** Description. */
      private final String description;
  
      /** Frequency. */
      private final Frequency frequency;
  
      /** Exposure (value in range [0...1]). */
      private final double exposure;
  
      /** Random number stream. */
      private final StreamInterface stream;
  
      /** Distribution of duration. */
      private final ContinuousDistDoubleScalar.Rel<Duration, DurationUnit> dist;
  
      /** Level of task demand. */
      private final double taskDemand;
  
      /**
       * Constructor.
       * @param id id
       * @param description description
       * @param frequency frequency per exposed driver
       * @param exposure exposure (value in range [0...1])
       * @param averageDuration average duration
       * @param stdDuration standard deviation of duration
       * @param taskDemand task demand
       * @param stream random number stream
       */
      public Distraction(final String id, final String description, final Frequency frequency, final double exposure,
              final Duration averageDuration, final Duration stdDuration, final double taskDemand, final StreamInterface stream)
      {
          Throw.whenNull(id, "Id may not be null.");
          Throw.whenNull(description, "Description may not be null.");
          Throw.whenNull(frequency, "Frequency may not be null.");
          Throw.whenNull(averageDuration, "Average duration may not be null.");
          Throw.whenNull(stream, "Random stream may not be null.");
          Throw.when(exposure < 0.0 || exposure > 1.0, IllegalArgumentException.class, "Exposure should be in the range [0...1]");
          Throw.when(taskDemand < 0.0 || taskDemand > 1.0, IllegalArgumentException.class,
                  "Task demand should be in the range [0...1]");
          this.id = id;
          this.description = description;
          this.frequency = frequency;
          this.exposure = exposure;
          this.stream = stream;
          this.taskDemand = taskDemand;
  
          double var = stdDuration.si * stdDuration.si;
          double avgSqrd = averageDuration.si * averageDuration.si;
          double mu = Math.log(avgSqrd / Math.sqrt(var + avgSqrd));
          double sigma = Math.sqrt(Math.log(var / avgSqrd + 1.0));
          this.dist = new ContinuousDistDoubleScalar.Rel<>(new DistLogNormal(stream, mu, sigma), DurationUnit.SECOND);
      }
  
      /**
       * Returns the id.
       * @return id
       */
      public String getId()
      {
          return this.id;
      }
  
      /**
       * Returns the description.
       * @return description
       */
      public String getDescription()
      {
          return this.description;
      }
  
     /**
      * Returns the level of task demand.
      * @return taskDemand level of task demand
      */
     public double getTaskDemand()
     {
         return this.taskDemand;
     }
 
     /**
      * Returns the next exposure.
      * @return next exposure
      */
     public boolean nextExposure()
     {
         return this.stream.nextDouble() <= this.exposure;
     }
 
     /**
      * Returns the next inter-arrival time of this secondary task.
      * @return next inter-arrival time of this secondary task
      */
     public Duration nextInterArrival()
     {
         return Duration.ofSI(-Math.log(this.stream.nextDouble()) / this.frequency.si);
     }
 
     /**
      * Returns the next duration of this secondary task.
      * @return next duration of this secondary task
      */
     public Duration nextDuration()
     {
         return this.dist.get();
     }
 
     @Override
     public String toString()
     {
         return "Distraction [id=" + this.id + ", description=" + this.description + ", frequency=" + this.frequency
                 + ", exposure=" + this.exposure + "]";
     }
 
 }