/*
    * 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.HashSet;
  import java.util.logging.Logger;
  
  import com.tomgibara.pronto.control.ControlFactory;
  import com.tomgibara.pronto.control.Controller;
  import com.tomgibara.pronto.control.ControllerSettings;
  import com.tomgibara.pronto.control.EngineControlAdapter;
  import com.tomgibara.pronto.control.FileControllerSettings;
  import com.tomgibara.pronto.control.ProntoControlException;
  import com.tomgibara.pronto.control.SignalControllerSettings;
  import com.tomgibara.pronto.control.StdinControllerSettings;
  import com.tomgibara.pronto.state.StateEngine;
  import com.tomgibara.pronto.util.Arguments;
  
  /**
   * The standard implementation of the ControlFactory interface.
   * 
   * @author Tom Gibara
   * 
   */
  
  public class ControlFactoryImpl extends ControlFactory {
  
      // statics
  
      /**
       * The log for exceptions and other log worthy events. This logger is
       * intended to be shared by all the classes in this package.
       */
  
      static final Logger LOGGER = Logger.getLogger(ControlFactoryImpl.class.getPackage().getName());
  
      // fields
  
      /**
       * Maintains a set of part factories that are consulted when a control
       * interface (or its implementation) is supplied to the factory.
       */
  
      private final HashSet<PartFactory> factories = new HashSet<PartFactory>();
  
      // constructors
  
      public ControlFactoryImpl() {
          // file controller
          factories.add(new PartFactory() {
              public boolean isSupported(final Class<? extends ControllerSettings> clss) {
                  return FileControllerSettings.class.isAssignableFrom(clss);
              }
  
              public <S, L, P> ControllerPart<S, L, P> newPart(final ControllerImpl<S, L, P> controller,
                      final ControllerSettings settings) throws ProntoControlException {
                  return new FileControllerPart<S, L, P>(controller, (FileControllerSettings) settings);
              }
          });
  
          // stdin controller
          factories.add(new PartFactory() {
              public boolean isSupported(final Class<? extends ControllerSettings> clss) {
                  return StdinControllerSettings.class.isAssignableFrom(clss);
              }
  
              public <S, L, P> ControllerPart<S, L, P> newPart(final ControllerImpl<S, L, P> controller,
                      final ControllerSettings settings) throws ProntoControlException {
                  return new StdinControllerPart<S, L, P>(controller, (StdinControllerSettings) settings);
              }
          });
  
          // signal controller
          factories.add(new PartFactory() {
              public boolean isSupported(final Class<? extends ControllerSettings> clss) {
                  return SignalControllerSettings.class.isAssignableFrom(clss);
              }
  
              public <S, L, P> ControllerPart<S, L, P> newPart(final ControllerImpl<S, L, P> controller,
                      final ControllerSettings settings) throws ProntoControlException {
                  return new SignalControllerPart<S, L, P>(controller, (SignalControllerSettings) settings);
              }
          });
          // TODO add factory for http when we have a stronger adapter interface
         // with all the information we might need
     }
 
     @Override
     public boolean isSettingsIfaceSupported(final Class<? extends ControllerSettings> iface) {
         Arguments.notNull(iface, "iface");
         if (!iface.isInterface()) throw new IllegalArgumentException("iface must be interface");
         for (PartFactory factory : factories) {
             if (factory.isSupported(iface)) return true;
         }
         return false;
     }
 
     @Override
     public <S, L, P> Controller<S, L, P> newController(final ControllerSettings settings,
             final StateEngine<S, L, P> engine, final EngineControlAdapter<S, L, P> adapter)
             throws ProntoControlException {
         Arguments.notNull(settings, "settings");
         Arguments.notNull(engine, "engine");
         Arguments.notNull(adapter, "adapter");
         ControllerImpl<S, L, P> controller = new ControllerImpl<S, L, P>(engine, adapter);
 
         for (PartFactory factory : factories) {
             if (!factory.isSupported(settings.getClass())) continue;
             controller.addPart(factory.newPart(controller, settings));
         }
 
         if (controller.isEmpty()) throw new IllegalArgumentException(String.format("Unsupported interface: %s",
                 settings.getClass()));
         return controller;
     }
 
     // inner classes
 
     /**
      * Part factories create ControllerPart implementations that are combined by
      * this factory to form a Controller.
      */
 
     private interface PartFactory {
 
         /**
          * Whether the part factory recognizes the interface.
          * 
          * @param iface
          *            an interface that has been supplied to the factory
          * @return true if this factory can create a controller from an instance
          *         of the supplied interface
          */
 
         boolean isSupported(Class<? extends ControllerSettings> iface);
 
         /**
          * Creates a new controller part that draws its settings from a supplied
          * settings object. The controller for which the part is being created
          * is supplied to provide access to the state engine and adapter that
          * the part is expected to operate over.
          * 
          * @param <S>
          *            the state type
          * @param <L>
          *            the label type
          * @param <P>
          *            the parameter type
          * @param controller
          *            the controller to which the part will be added
          * @param settings
          *            an implementation of a settings interface
          * @return a new instance of a controller part
          * @throws ProntoControlException
          */
 
         <S, L, P> ControllerPart<S, L, P> newPart(ControllerImpl<S, L, P> controller, ControllerSettings settings)
                 throws ProntoControlException;
 
     }
 
 }