/*
    * Copyright (C) 2006  Tom Gibara
    *
    * This library is free software; you can redistribute it and/or
    * modify it under the terms of the GNU Lesser General Public
    * License as published by the Free Software Foundation; either
    * version 2.1 of the License, or (at your option) any later version.
    *
    * This library is distributed in the hope that it will be useful,
   * but WITHOUT ANY WARRANTY; without even the implied warranty of
   * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
   * Lesser General Public License for more details.
   *
   * You should have received a copy of the GNU Lesser General Public
   * License along with this library; if not, write to the Free Software
   * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
   */
  package com.tomgibara.pronto.control.impl;
  
  import java.util.Set;
  import java.util.logging.Level;
  
  import com.tomgibara.pronto.control.SignalControllerSettings;
  import com.tomgibara.pronto.state.PathType;
  import com.tomgibara.pronto.state.ProntoStateException;
  import com.tomgibara.pronto.state.StateEngine;
  import com.tomgibara.pronto.util.Waiter;
  
  /**
   * A ControllerPart implementation that provides functionality for the
   * SignalControllerSettings interface.
   * 
   * @param <S>
   *            the type of state
   * @param <L>
   *            the type of label
   * @param <P>
   *            the type of parameter
   * 
   * @author Tom Gibara
   * 
   */
  
  public class SignalControllerPart<S, L, P> implements ControllerPart<S, L, P> {
  
      // fields
  
      /**
       * The lock that must be held when performing any action that is dependent
       * upon the object's lifespan.
       */
      private final Object lock = new Object();
  
      /**
       * The controller that aggregates this part.
       */
      private final ControllerImpl<S, L, P> controller;
  
      /**
       * The settings used to construct this part. Currently unused because there
       * are no settings.
       */
      private final SignalControllerSettings settings;
  
      /**
       * The thread that is registered as a shutdown hook to perform termination
       * on the state engine. The value of this field is used to record whether
       * the part has been started (null=stopped, not-null=started).
       */
      private SignalThread thread = null;
  
      /**
       * Indicates that the termination state transitions have been completed.
       */
      private boolean finished = false;
  
      // constructors
  
      /**
       * Creates a new SignalControllerPart.
       * 
       * @param controller
       *            the controller that aggregates this part
       * @param settings
       *            the settings for this part
       */
  
      public SignalControllerPart(final ControllerImpl<S, L, P> controller, final SignalControllerSettings settings) {
          this.controller = controller;
          this.settings = settings;
      }
  
      // controller part methods
  
      /**
       * Causes a shutdown hook to be registered for the purpose of performing
       * termination state transitions.
       */
  
     public void start() {
         synchronized (lock) {
             if (thread != null) return;
 
             thread = new SignalThread();
             Runtime.getRuntime().addShutdownHook(thread);
         }
     }
 
     /**
      * If a shutdown hook as been registered, the hook is deregistered and the
      * method returns immediately unless JVM shutdown is in progress in which
      * case the method blocks (subject to the specified timeout) until
      * termination state transitions have been completed.
      * 
      * @param timeout
      *            the (approx.) number of milliseconds for which a call to the
      *            method will block, or 0L.
      * @return true if the part was able to confirm that all operation had
      *         ceased
      */
 
     public boolean stop(final long timeout) {
         synchronized (lock) {
             if (thread == null) return true;
 
             try {
                 Runtime.getRuntime().removeShutdownHook(thread);
                 return true;
             } catch (IllegalStateException e) {
                 // this means we are shutting down so
                 // wait until any ongoing checking has ceased
                 return new Waiter(lock).waitForCondition(timeout, new Waiter.Condition() {
                     public boolean isMet() {
                         return finished;
                     }
                 });
             } finally {
                 thread = null;
             }
         }
     }
 
     public ControllerImpl<S, L, P> getController() {
         return controller;
     }
 
     // private utility methods
 
     private void terminate() {
         StateEngine<S, L, P> engine = controller.engine;
         Set<S> terminalStates = engine.getGraph().getTerminalStates();
         if (terminalStates.size() != 1) return;
         S terminalState = terminalStates.iterator().next();
         //TODO identify a more sound way to deal with this
         if (engine.getState() == terminalState) return; //nothing to do
         try {
             engine.pathTransition(terminalState, null, PathType.strictlyUniqueStates, null);
         } catch (ProntoStateException e) {
             ControlFactoryImpl.LOGGER.log(Level.WARNING, "State transition failed in response to signal", e);
         }
     }
 
     // inner classes
 
     /**
      * An instance of this thread remains registered as a shutdown hook while
      * the part is running. Its sole duty is to perform the termination
      * transitions on the state engine.
      */
 
     class SignalThread extends Thread {
 
         public SignalThread() {
             super("pronto controller shutdown");
         }
         
         @Override
         public void run() {
             synchronized (lock) {
                 try {
                     terminate();
                 } finally {
                     finished = true;
                 }
             }
         }
 
     }
 
 }