package cz.cuni.amis.pogamut.sposh.engine;
   
   import cz.cuni.amis.pogamut.sposh.elements.PoshElement;
   import cz.cuni.amis.pogamut.sposh.elements.Sense;
   import cz.cuni.amis.pogamut.sposh.elements.Trigger;
   import cz.cuni.amis.pogamut.sposh.executor.IWorkExecutor;
   import java.util.ArrayList;
   import java.util.Collections;
   import java.util.Iterator;
  import java.util.LinkedList;
  import java.util.List;
  import java.util.logging.Logger;
  
  /**
   * Class that immutably stores the result of evaluation of trigger. Trigger is
   * basically a list of sense calls (i.e. {@link SenseListExecutor}).
   */
  class TriggerResult implements Iterable<SenseResult> {
  
      private final List<SenseResult> senses;
      private final boolean success;
  
      /**
       * Create new result of trigger
       *
       * @param senses list of results, what did each sense ended up as
       * @param success was the trigger as a whole successful
       */
      public TriggerResult(List<SenseResult> senses, boolean success) {
          this.success = success;
          this.senses = Collections.unmodifiableList(new ArrayList<SenseResult>(senses));
      }
  
      /**
       * Create new result of trigger, without specifying any senses.
       *
       * @param success was the trigger successful
       */
      public TriggerResult(boolean success) {
          this(Collections.<SenseResult>emptyList(), success);
      }
  
      public boolean wasSuccess() {
          return success;
      }
  
      /**
       * Get iterator to the all senses of this trigger. Unmodifiable.
       *
       * @return iterator to the start of sens's list.
       */
      @Override
      public Iterator<SenseResult> iterator() {
          return senses.iterator();
      }
  }
  
  /**
   * Executor that decicdes if goal or trigger are fulfilled. That happens only is
   * all its senses are fired.
   *
   * @author Honza
   */
  final class SenseListExecutor<T extends PoshElement> extends AbstractExecutor {
  
      private List<SenseExecutor> sensesExecutors = new ArrayList<SenseExecutor>();
  
      /**
       * Create an executor for triggers.
       *
       * @param trigger source of senses, can be null, then no senses will be
       * used.
       * @param ctx variable context that should be passed to the senses
       * @param log logger to record actions of this executor, can be null
       */
      SenseListExecutor(Trigger<T> trigger, VariableContext ctx, Logger log) {
          this(ctx, log);
  
          for (Sense sense : trigger) {
              sensesExecutors.add(new SenseExecutor(sense, ctx, log));
          }
      }
  
      /**
       * Create an executor without any senses (it will always return
       * defaultReturn).
       *
       * @param ctx variable context that should be passed to the senses.
       * @param log log to write debug info.
       */
      SenseListExecutor(VariableContext ctx, Logger log) {
          super(ctx, log);
      }
  
      /**
       * Evaluate all senses until first one fails. If no senses were specified,
       * consider it a fail.
       *
       * @param defaultReturn what to return if no senses were specified. In
      * trigger true, in goal false
      * @return Result of the senselist. The result is true if none of senses
      * fails, false if at least one fails.
      */
     public TriggerResult fire(IWorkExecutor workExecuter, boolean defaultReturn) {
         List<SenseResult> senses = new LinkedList<SenseResult>();
 
         for (SenseExecutor senseExecutor : sensesExecutors) {
             defaultReturn = true;
 
             SenseResult res = senseExecutor.fire(workExecuter);
             senses.add(res);
 
             if (!res.wasSuccessful()) {
                 return new TriggerResult(senses, false);
             }
         }
         return new TriggerResult(senses, defaultReturn);
     }
 }