/*
    * Copyright 2012-2013 smartics, Kronseder & Reiner GmbH
    *
    * Licensed under the Apache License, Version 2.0 (the "License");
    * you may not use this file except in compliance with the License.
    * You may obtain a copy of the License at
    *
    *     http://www.apache.org/licenses/LICENSE-2.0
    *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   */
  package de.smartics.properties.resource.util;
  
  import java.util.Iterator;
  import java.util.ServiceConfigurationError;
  import java.util.ServiceLoader;
  
  import org.slf4j.Logger;
  import org.slf4j.LoggerFactory;
  
  import de.smartics.properties.resource.domain.ResourceException;
  import de.smartics.util.lang.Arg;
  
  /**
   * A factory to create instances of a given type using the Java Service API.
   *
   * @param <T> the type of the service to instantiate.
   */
  public abstract class AbstractServiceFactory<T>
  {
    // ********************************* Fields *********************************
  
    // --- constants ------------------------------------------------------------
  
    /**
     * Reference to the logger for this class.
     */
    private static final Logger LOG = LoggerFactory
        .getLogger(AbstractServiceFactory.class);
  
    // --- members --------------------------------------------------------------
  
    private final InstanceCreator<T> creator;
  
    // ****************************** Initializer *******************************
  
    // ****************************** Constructors ******************************
  
    /**
     * Default constructor.
     *
     * @param creator the creator of instances created as defaults by this
     *          factory.
     * @throws NullPointerException if {@code creator} is <code>null</code>.
     */
    protected AbstractServiceFactory(final InstanceCreator<T> creator)
    {
      this.creator = Arg.checkNotNull("creator", creator);
    }
  
    // ****************************** Inner Classes *****************************
  
    // ********************************* Methods ********************************
  
    // --- init -----------------------------------------------------------------
  
    // --- get&set --------------------------------------------------------------
  
    // --- business -------------------------------------------------------------
  
    /**
     * Creates an instance of a service in <code>META-INF/services</code>.
     *
     * @return instance of the desired type.
     * @throws ResourceException if a type cannot be instantiated.
     */
    public final T create() throws ResourceException
    {
      return create(null);
    }
  
    /**
     * Creates an instance of a service in <code>META-INF/services</code>.
     *
     * @param defaultType the default type to use if there is no configuration
     *          file found in <code>META-INF/services</code>.
     * @return instance of the desired type.
     * @throws ResourceException if a type cannot be instantiated.
     */
    public final T create(final Class<? extends T> defaultType)
      throws ResourceException
    {
      final Class<T> type = creator.getType();
      final Iterator<T> iterator = ServiceLoader.load(type).iterator();
  
     final TypeProblemMessageBean.Builder builder =
         new TypeProblemMessageBean.Builder().with(type);
 
     T instance = fetchInstance(iterator, builder);
 
     if (instance == null)
     {
       if (builder.hasReportedProblems())
       {
         throw new ResourceException(builder.build());
       }
       else
       {
         instance = creator.create();
         if (instance == null)
         {
           instance = handleWithDefaultType(defaultType);
         }
       }
     }
     else
     {
       if (builder.hasReportedProblems())
       {
         LOG.warn(builder.toMessage());
       }
     }
 
     return instance;
   }
 
   private T fetchInstance(final Iterator<T> iterator,
       final TypeProblemMessageBean.Builder builder)
   {
     T instance = null;
     while (iterator.hasNext())
     {
       try
       {
         if (instance != null)
         {
           final String implementation = iterator.next().getClass().getName();
           builder.withDuplicate(implementation);
           continue;
         }
 
         instance = iterator.next();
       }
       catch (final ServiceConfigurationError e)
       {
         builder.withError(e.getMessage());
       }
     }
     return instance;
   }
 
   private T handleWithDefaultType(final Class<? extends T> defaultType)
     throws ResourceException
   {
     if (defaultType != null)
     {
       try
       {
         final T instance = defaultType.newInstance();
         return instance;
       }
       catch (final Exception e)
       {
         throw new ResourceException(new TypeProblemMessageBean(e,
             creator.getType()));
       }
     }
     else
     {
       throw new ResourceException(new TypeProblemMessageBean(creator.getType()));
     }
   }
 
   // --- object basics --------------------------------------------------------
 }