package org.apache.archiva.redback.components.springutils;
   
   /*
    * Licensed to the Apache Software Foundation (ASF) under one
    * or more contributor license agreements.  See the NOTICE file
    * distributed with this work for additional information
    * regarding copyright ownership.  The ASF licenses this file
    * to you 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.
   */
  
  import org.apache.commons.lang.StringUtils;
  import org.slf4j.Logger;
  import org.slf4j.LoggerFactory;
  import org.springframework.context.ApplicationContext;
  import org.springframework.stereotype.Service;
  
  import javax.inject.Inject;
  import java.util.Collections;
  import java.util.HashMap;
  import java.util.Map;
  import java.util.concurrent.ConcurrentHashMap;
  
  /**
   * utility class to mimic some behaviour of the plexus container with role#hint
   * @author Olivier Lamy
   */
  @Service( "componentContainer" )
  public class ComponentContainer
  {
  
      private Logger log = LoggerFactory.getLogger( getClass() );
  
      private static final String DEFAULT_ROLE_HINT = "default";
  
      public static final String BEAN_NAME_ROLEHINTSEPARATOR = "#";
  
      /**
       * To prevent to much use of #buildMapWithRole we store already used values here
       *
       * @see #buildMapWithRole(Class)
       */
      private Map<String, Map<String, ?>> classBeansOfType = new ConcurrentHashMap<String, Map<String, ?>>();
  
      public String getDefaultRoleHint()
      {
          return DEFAULT_ROLE_HINT;
      }
  
      @Inject
      protected ApplicationContext applicationContext;
  
      /**
       * <b>must be used only at startup of container (ie in initialize method as it
       * can cause performance issue http://jira.springframework.org/browse/SPR-5360</b><br/>
       * Returns bean of type T. <br/>
       * <b>It must be unique of not {@link RuntimeException}</b>
       *
       * @param <T>
       * @param clazz
       * @return
       */
      public <T> T getComponent( Class<T> clazz )
      {
          Map<String, T> beansOfType = applicationContext.getBeansOfType( clazz );
          if ( beansOfType == null || beansOfType.isEmpty() )
          {
              throw new RuntimeException( "no beans of Type " + clazz.getName() );
          }
          if ( beansOfType.size() > 1 )
          {
              throw new RuntimeException( "not only one beans of Type " + clazz.getName() );
          }
          return beansOfType.values().iterator().next();
      }
  
      /**
       * <b>must be used only at startup of container (ie in initialize method as it
       * can cause performance issue http://jira.springframework.org/browse/SPR-5360</b><br/>
       * Returns bean of type T and hint . <br/>
       *
       * @param <T>
       * @param clazz
       * @param hint
       * @return
       */
      public <T> T getComponent( Class<T> clazz, String hint )
      {
          Map<String, T> beansOfType = buildMapWithRole( clazz );
         if ( beansOfType == null || beansOfType.isEmpty() )
         {
             throw new RuntimeException( "no beans of Type " + clazz.getName() );
         }
         T bean = beansOfType.get( hint );
         if ( bean == null )
         {
             throw new RuntimeException( "no beans of Type " + clazz.getName() + " with hint " + hint );
         }
         return bean;
     }
 
     /**
      * Return true if one and only bean of type T exists.
      *
      * @param <T>
      * @param clazz
      * @return
      */
     public <T> boolean hasComponent( Class<T> clazz )
     {
         Map<String, T> beansOfType = applicationContext.getBeansOfType( clazz );
         if ( beansOfType == null || beansOfType.isEmpty() )
         {
             return false;
         }
         return beansOfType.size() == 1;
     }
 
     /**
      * Return true if one and only bean of type T and hint exists.
      *
      * @param <T>
      * @param clazz
      * @param hint
      * @return
      */
     public <T> boolean hasComponent( Class<T> clazz, String hint )
     {
         Map<String, T> beansOfType = buildMapWithRole( clazz );
         if ( beansOfType == null || beansOfType.isEmpty() )
         {
             return false;
         }
         return beansOfType.containsKey( hint );
     }
 
     /**
      * <b>must be used only at startup of container (ie in initialize method as it
      * can cause performance issue http://jira.springframework.org/browse/SPR-5360</b><br/>
      * Produce a map with hint as key and bean as value.<br/>
      * An internal map is used to cache call to #buildMapWithRole
      *
      * @param <T>
      * @param clazz
      * @return
      */
     @SuppressWarnings( "unchecked" )
     public <T> Map<String, T> buildMapWithRole( Class<T> clazz )
     {
         try
         {
             Map<String, T> beansOfType = (Map<String, T>) classBeansOfType.get( clazz.getName() );
             if ( beansOfType == null )
             {
                 Map<String, T> map = this.applicationContext.getBeansOfType( clazz );
                 beansOfType = buildMapWithRole( map );
                 classBeansOfType.put( clazz.getName(), beansOfType );
             }
             return beansOfType;
         }
         catch ( Throwable e )
         {
             log.error( e.getMessage(), e );
             throw new RuntimeException( e.getMessage(), e );
         }
     }
 
 
     /**
      * Mimic of lookupMap from plexus. <br/>
      * Ex: if the bean is called "foo#mine" "AvlRqBuilder#1"A
      * then the map will contains mine as key with the bean foo#mine as value </b>
      * <b>if no # in the bean name then the bean name will be as it's returned</b>.
      *
      * @param beansOfType
      * @return
      */
     public static <T> Map<String, T> buildMapWithRole( Map<String, T> beansOfType )
     {
         if ( beansOfType == null || beansOfType.isEmpty() )
         {
             return Collections.emptyMap();
         }
         Map<String, T> beansOfHint = new HashMap<String, T>();
         for ( Map.Entry<String, T> entry : beansOfType.entrySet() )
         {
             int separatorIndex = StringUtils.indexOf( entry.getKey(), '#' );
             if ( separatorIndex >= 0 )
             {
                 String hint = entry.getKey().substring( separatorIndex + 1, entry.getKey().length() );
                 beansOfHint.put( hint, beansOfType.get( entry.getKey() ) );
             }
             else
             {
                 beansOfHint.put( entry.getKey(), beansOfType.get( entry.getKey() ) );
             }
         }
         return beansOfHint;
     }
 }