/*
    * 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.integration.cdi.extension;
  
  import static de.smartics.properties.integration.cdi.extension.ConfigurationMessageBean.noClassAnnotated;
  import static de.smartics.properties.integration.cdi.extension.ConfigurationMessageBean.tooManyClassesAnnotated;
  
  import java.lang.annotation.Annotation;
  import java.util.Iterator;
  import java.util.LinkedList;
  import java.util.List;
  import java.util.Set;
  
  import javax.enterprise.context.Dependent;
  import javax.enterprise.inject.Any;
  import javax.enterprise.inject.Produces;
  import javax.enterprise.inject.spi.Bean;
  import javax.enterprise.inject.spi.BeanManager;
  import javax.enterprise.util.AnnotationLiteral;
  
  import de.smartics.properties.api.config.domain.key.ConfigurationKey;
  import de.smartics.properties.api.config.domain.key.ConfigurationKeyHelper;
  import de.smartics.properties.integration.cdi.Application;
  import de.smartics.properties.spi.config.domain.key.ConfigurationKeyContext;
  import de.smartics.properties.spi.config.domain.key.ConfigurationKeyContextManager;
  
  /**
   * Factory with cdi producer to create the current valid configuration key.
   */
  public class ConfigurationKeyFactory
  {
  
    /**
     * Factory method that produces the actual (runtime dependent) configuration
     * key.
     *
     * @param manager the {@link BeanManager}.
     * @return the current valid configuration key.
     */
    @Produces
    @Dependent
    @SuppressWarnings("rawtypes")
    // CDI does not accept generics here.
    public ConfigurationKey createConfigurationKey(final BeanManager manager)
    {
      final ConfigurationKey<?> key = identifyConfigurationKey(manager);
      return key;
    }
  
    private ConfigurationKey<?> identifyConfigurationKey(
        final BeanManager beanManager)
    {
      final ConfigurationKeyContext context =
          ConfigurationKeyContextManager.INSTANCE.context();
  
      final ConfigurationKeyHelper kh = context.configurationKeyHelper(true);
      final Class<?> clazz = fetchTypeWithAnnotation(beanManager);
      final ConfigurationKey<?> key = kh.load(clazz);
      return key;
    }
  
    private Class<?> fetchTypeWithAnnotation(final BeanManager beanManager)
    {
      final Annotation anyAnnotation = new AnnotationLiteral<Any>()
      {
        private static final long serialVersionUID = 1L;
      };
      final Set<Bean<?>> beans =
          beanManager.getBeans(Object.class, anyAnnotation);
  
      final Bean<?> annotatedBean = fetchBeanWithAnnotation(beans);
  
      return annotatedBean.getBeanClass();
    }
  
    private Bean<?> fetchBeanWithAnnotation(final Set<Bean<?>> beans)
    {
      final List<Bean<?>> annotatedBeans = new LinkedList<Bean<?>>();
      for (final Iterator<Bean<?>> iterator = beans.iterator(); iterator
          .hasNext();)
      {
        final Bean<?> bean = (Bean<?>) iterator.next();
        if (isAnnotated(bean))
        {
          annotatedBeans.add(bean);
        }
     }
     final int size = annotatedBeans.size();
     if (size == 0)
     {
       throw new ConfigurationException(noClassAnnotated());
     }
     else if (size == 1)
     {
       return annotatedBeans.get(0);
     }
     else
     {
       throw new ConfigurationException(tooManyClassesAnnotated(annotatedBeans));
     }
   }
 
   private boolean isAnnotated(final Bean<?> bean)
   {
     boolean isAnnotated = false;
     final Set<Annotation> qualifiers = bean.getQualifiers();
     for (final Iterator<Annotation> iterator2 = qualifiers.iterator(); iterator2
         .hasNext();)
     {
       final Annotation annotation = (Annotation) iterator2.next();
       isAnnotated |= annotation.annotationType().equals(Application.class);
     }
     return isAnnotated;
   }
 
 }