/*
    * 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.
   */
  package org.apache.onami.factoryannotation;
  
  import static com.google.common.base.Preconditions.checkNotNull;
  import static com.google.common.base.Preconditions.checkState;
  
  import java.lang.annotation.Annotation;
  import java.util.HashMap;
  import java.util.Map;
  
  import org.apache.onami.factoryannotation.PrivilegedHelper.PrivilegedHelperCallback;
  import org.apache.onami.factoryannotation.builder.BindFactoryAnnotationBindingBuilder;
  import org.apache.onami.factoryannotation.builder.CombinedListenerCacheableBindingBuilder;
  import org.apache.onami.factoryannotation.builder.FactoryAnnotationAnnotationBindingBuilder;
  import org.apache.onami.factoryannotation.builder.FactoryAnnotationBaseProviderBindingBuilder;
  
  import com.google.common.base.Preconditions;
  import com.google.inject.Binder;
  import com.google.inject.BindingAnnotation;
  import com.google.inject.Key;
  import com.google.inject.Module;
  import com.google.inject.Scope;
  import com.google.inject.ScopeAnnotation;
  import com.google.inject.TypeLiteral;
  import com.google.inject.binder.ScopedBindingBuilder;
  import com.google.inject.internal.Annotations;
  import com.google.inject.internal.Errors;
  import com.google.inject.internal.Scoping;
  
  /**
   * A module builder for configuring annotation factory based injections. <h3>Creating a factory annotation</h3> Factory
   * annotations used to create an factory annotation based binding for injections. These annotations itself must be
   * annotated by Guice' own {@literal @}{@link BindingAnnotation} annotation to be recognized as injection point and have
   * at least one method (or annotation property);
   * 
   * <pre>
   * {@literal @}BindingAnnotation
   * {@literal @}Retention(RetentionPolicy.RUNTIME)
   * {@literal @}Target({ ElementType.FIELD, ElementType.PARAMETER })
   * public {@literal @}interface User {
   * 
   *     int byId();
   *     
   * }
   * </pre>
   * 
   * In this example we define a {@literal @}User annotation to hold the value of the userId to be retrieved from the
   * datastore. <h3>Implementing a FactoryAnnotationProvider</h3> An {@link FactoryAnnotationProvider} is a special
   * provider to return the actual instance of a injection type in combination with the actual factoey annotation at the
   * injection point. At this point we omit the UserEntity class. It can be a simple POJO, a JPA entity or whatever class
   * you can image.
   * 
   * <pre>
   * public class UserEntityProvider implements FactoryAnnotationProvider<UserEntity, User> {
   * 
   *     {@literal @}Override
   *     public UserEntity buildValue(final User annotation) {
   *         return getRealEntityById(annotation.byId());
   *     }
   *     
   *     {@literal @}Override
   *     public Class<UserEntity> getInjectionType() {
   *         return UserEntity.class;
   *     }
   * 
   *     private UserEntity getRealEntityById(int id) {
   *         ...
   *     }
   *     
   * }
   * </pre>
   * 
   * The provider implementation can get an instance from nearly everywhere. It can have injection points itself, for
   * example an EntityManager for JPA based retrieving of the entities to be injected. <h3>Configure the factory
   * annotation based injection</h3> For configuring an factory annotation based injection {@link FactoryAnnotationModule}
   * class is used. Like the normal {@link Module} it is configured by using the {@link Module#configure()} method. A
   * binding is a combination of the type to be injected, the annotation type the injection should handle (compared to
   * Guice' normal injection mechanism this is just the type, no real annotation is bound here) and at least the
   * {@link FactoryAnnotationProvider} implementation. Additionally a {@link FactoryAnnotationProvisionListener}
   * implementation could be bound to be notified before or after a provision by this {@link FactoryAnnotationProvider}.
   * 
   * <pre>
  * Injector injector = Guice.createInjector(new IdentityModule() {
  *     
  *     {@literal @}Override
  *     public void configure() {
  *         bindType(UserEntity.class).annotatedWith(User.class)
  *                 .toAnnotationFactory(UserEntityProvider.class);
  *                 
  *         bindType(UserEntity.class).annotatedWith(ListenedUser.class)
  *                 .applyListener(getFactoryAnnotationProvisionListener())
  *                 .toAnnotationFactory(UserEntityProvider.class);
  *     }
  *     
  * });
  * </pre>
  */
 public abstract class FactoryAnnotationModule
     implements Module
 {
 
     private final Map<ScopedKey<?>, FactoryAnnotationProviderFactory<?, ?>> providerFactoryCache =
         new HashMap<ScopedKey<?>, FactoryAnnotationProviderFactory<?, ?>>();
 
     private Binder binder;
 
     /**
      * This method starts an actual binding process for a class type
      * 
      * @param injectionType The type of the class that should be bound
      */
     protected <T> FactoryAnnotationAnnotationBindingBuilder bindType( final Class<T> injectionType )
     {
 
         return bindIdentity( TypeLiteral.get( injectionType ) );
     }
 
     /**
      * This method starts an actual binding process for a class type
      * 
      * @param injectionType The {@link TypeLiteral} of the class that should be bound
      */
     protected <T> FactoryAnnotationAnnotationBindingBuilder bindIdentity( final TypeLiteral<T> injectionType )
     {
 
         return new IdentityAnnotationBindingBuilderImpl<T>( injectionType, null, null );
 
     }
 
     /**
      * This scopes an {@link FactoryAnnotationProvider} to an annotation annotated by {@literal @}
      * {@link ScopeAnnotation}.
      * 
      * @param scopeAnnotation Annotation type to use for scope binding
      */
     protected <A extends Annotation> BindFactoryAnnotationBindingBuilder in( final Class<A> scopeAnnotation )
     {
 
         Preconditions.checkNotNull( scopeAnnotation, "scopeAnnotation" );
 
         return new BindIdentityBindingBuilderImpl( scopeAnnotation, null );
     }
 
     /**
      * This scopes an {@link FactoryAnnotationProvider} to the given {@link Scope} annotation.
      * 
      * @param scope {@link Scope} annotation to use for scope binding
      */
     protected BindFactoryAnnotationBindingBuilder in( final Scope scope )
     {
         Preconditions.checkNotNull( scope, "scope" );
 
         return new BindIdentityBindingBuilderImpl( null, scope );
     }
 
     public void configure( final Binder binder )
     {
         checkState( this.binder == null, "Re-entry is not allowed." );
 
         this.binder = checkNotNull( binder, "binder" );
         try
         {
             configure();
         }
         finally
         {
             this.binder = null;
         }
     }
 
     protected Binder binder()
     {
         return binder;
     }
 
     protected abstract void configure();
 
     private final class BindIdentityBindingBuilderImpl
         implements BindFactoryAnnotationBindingBuilder
     {
 
         private final Scope scope;
 
         private final Class<? extends Annotation> scopeAnnotation;
 
         private BindIdentityBindingBuilderImpl( final Class<? extends Annotation> scopeAnnotation, final Scope scope )
         {
 
             this.scopeAnnotation = scopeAnnotation;
             this.scope = scope;
         }
 
         public <T> FactoryAnnotationAnnotationBindingBuilder bindIdentity( final Class<T> injectionType )
         {
 
             return new IdentityAnnotationBindingBuilderImpl<T>( TypeLiteral.get( injectionType ), scopeAnnotation,
                                                                 scope );
         }
 
         public <T> FactoryAnnotationAnnotationBindingBuilder bindIdentity( final TypeLiteral<T> injectionType )
         {
 
             return new IdentityAnnotationBindingBuilderImpl<T>( injectionType, scopeAnnotation, scope );
         }
     }
 
     private final class IdentityAnnotationBindingBuilderImpl<T>
         implements FactoryAnnotationAnnotationBindingBuilder
     {
 
         private final TypeLiteral<T> injectionType;
 
         private final Scope scope;
 
         private final Class<? extends Annotation> scopeAnnotation;
 
         private IdentityAnnotationBindingBuilderImpl( final TypeLiteral<T> injectionType,
                                                       final Class<? extends Annotation> scopeAnnotation,
                                                       final Scope scope )
         {
 
             Preconditions.checkNotNull( injectionType );
 
             this.injectionType = injectionType;
             this.scopeAnnotation = scopeAnnotation;
             this.scope = scope;
         }
 
         public <I extends Annotation> CombinedListenerCacheableBindingBuilder annotatedWith( final Class<I> annotationType )
         {
 
             Preconditions.checkNotNull( annotationType, "annotationType" );
 
             Preconditions.checkArgument( Annotations.isRetainedAtRuntime( annotationType ),
                                          "%s is not retained at runtime. Please annotate it with @Retention(RUNTIME).",
                                          annotationType.getName() );
 
             Preconditions.checkArgument( Annotations.isBindingAnnotation( annotationType ),
                                          "%s is not a binding annotation. Please annotate it with @BindingAnnotation.",
                                          annotationType.getName() );
 
             final boolean cacheable = annotationType.isAnnotationPresent( FactoryAnnotationCacheable.class );
 
             return new IdentityProviderBindingBuilderImpl<T>( injectionType, scopeAnnotation, scope, null,
                                                               annotationType, cacheable );
         }
     }
 
     private final class IdentityProviderBindingBuilderImpl<T>
         implements CombinedListenerCacheableBindingBuilder
     {
 
         private final TypeLiteral<T> injectionType;
 
         private final Scope scope;
 
         private final Class<? extends Annotation> scopeAnnotation;
 
         private final Class<? extends Annotation> annotationType;
 
         private final FactoryAnnotationProvisionListener<?, ?> provisionListener;
 
         private final boolean cacheable;
 
         private IdentityProviderBindingBuilderImpl( final TypeLiteral<T> injectionType,
                                                     final Class<? extends Annotation> scopeAnnotation,
                                                     final Scope scope,
                                                     final FactoryAnnotationProvisionListener<?, ?> provisionListener,
                                                     final Class<? extends Annotation> annotationType,
                                                     final boolean cacheable )
         {
 
             this.injectionType = injectionType;
             this.scopeAnnotation = scopeAnnotation;
             this.scope = scope;
             this.provisionListener = provisionListener;
             this.annotationType = annotationType;
             this.cacheable = cacheable;
         }
 
         @SuppressWarnings( "unchecked" )
         public <I, A extends Annotation> void toAnnotationFactory( final FactoryAnnotationProvider<I, A> factoryAnnotationProvider )
         {
 
             Preconditions.checkNotNull( factoryAnnotationProvider, "factoryAnnotationProvider" );
 
             final Class<I> keyType = factoryAnnotationProvider.getInjectionType();
 
             if ( !keyType.equals( injectionType.getRawType() ) )
             {
                 new Errors().cannotInjectTypeLiteralOf( keyType ).throwConfigurationExceptionIfErrorsExist();
             }
 
             final ScopedKey<T> cacheKey =
                 buildScopedKey( factoryAnnotationProvider.getClass(), annotationType, scopeAnnotation, scope );
 
             final FactoryAnnotationProviderFactory<I, A> provider;
             if ( providerFactoryCache.containsKey( cacheKey ) )
             {
                 provider = (FactoryAnnotationProviderFactory<I, A>) providerFactoryCache.get( cacheKey );
 
             }
             else
             {
                 provider =
                     new FactoryAnnotationProviderFactory<I, A>(
                                                                 binder(),
                                                                 (Class<A>) annotationType,
                                                                 factoryAnnotationProvider,
                                                                 (FactoryAnnotationProvisionListener<I, A>) provisionListener,
                                                                 cacheable );
 
                 providerFactoryCache.put( cacheKey, provider );
 
                 final ScopedBindingBuilder scopeBuilder =
                     binder().bind( keyType ).annotatedWith( annotationType ).toProvider( provider );
 
                 if ( scope != null )
                 {
                     scopeBuilder.in( scope );
 
                 }
                 else if ( scopeAnnotation != null )
                 {
                     scopeBuilder.in( scopeAnnotation );
                 }
             }
         }
 
         public <I, A extends Annotation> void toIdentityProvider( final Class<FactoryAnnotationProvider<I, A>> factoryAnnotationProviderType )
         {
 
             Preconditions.checkNotNull( factoryAnnotationProviderType, "factoryAnnotationProviderType" );
 
             final FactoryAnnotationProvider<I, A> identityProvider =
                 PrivilegedHelper.executePrivileged( factoryAnnotationProviderType,
                                                     new PrivilegedHelperCallback<FactoryAnnotationProvider<I, A>>()
                                                     {
 
                                                         public FactoryAnnotationProvider<I, A> execute( final Class<FactoryAnnotationProvider<I, A>> clazz )
                                                         {
 
                                                             try
                                                             {
                                                                 return clazz.newInstance();
 
                                                             }
                                                             catch ( final InstantiationException e )
                                                             {
                                                                 throw new RuntimeException( e );
 
                                                             }
                                                             catch ( final IllegalAccessException e )
                                                             {
                                                                 throw new RuntimeException( e );
                                                             }
                                                         }
                                                     } );
 
             toAnnotationFactory( identityProvider );
         }
 
         @SuppressWarnings( "unchecked" )
         public <I, A extends Annotation> FactoryAnnotationBaseProviderBindingBuilder applyListener( final FactoryAnnotationProvisionListener<I, A> provisionListener )
         {
 
             Preconditions.checkNotNull( provisionListener, "provisionListener" );
 
             return new IdentityProviderBindingBuilderImpl<I>( (TypeLiteral<I>) injectionType, scopeAnnotation, scope,
                                                               provisionListener, annotationType, cacheable );
         }
 
         @SuppressWarnings( "unchecked" )
         public <I, A extends Annotation> CombinedListenerCacheableBindingBuilder cacheable()
         {
             return new IdentityProviderBindingBuilderImpl<I>( (TypeLiteral<I>) injectionType, scopeAnnotation, scope,
                                                               provisionListener, annotationType, true );
         }
 
         @SuppressWarnings( "unchecked" )
         public <I, A extends Annotation> CombinedListenerCacheableBindingBuilder nonCacheable()
         {
             return new IdentityProviderBindingBuilderImpl<I>( (TypeLiteral<I>) injectionType, scopeAnnotation, scope,
                                                               provisionListener, annotationType, false );
         }
 
         @SuppressWarnings( "unchecked" )
         private ScopedKey<T> buildScopedKey( final Class<?> type, final Class<? extends Annotation> annotationType,
                                              final Class<? extends Annotation> scopeAnnotation, final Scope scope )
         {
 
             final Scoping scoping;
             if ( scopeAnnotation != null )
             {
                 scoping = Scoping.forAnnotation( scopeAnnotation );
 
             }
             else if ( scope != null )
             {
                 scoping = Scoping.forInstance( scope );
 
             }
             else
             {
                 scoping = null;
             }
 
             return new ScopedKey<T>( (Key<T>) Key.get( type, annotationType ), scoping );
         }
     }
 
     private class ScopedKey<T>
     {
         private final Key<T> key;
 
         private final Scoping scoping;
 
         private ScopedKey( final Key<T> key, final Scoping scoping )
         {
             this.key = key;
             this.scoping = scoping;
         }
 
         @Override
         public int hashCode()
         {
             final int prime = 31;
             int result = 1;
             result = prime * result + getOuterType().hashCode();
             result = prime * result + ( ( key == null ) ? 0 : key.hashCode() );
             result = prime * result + ( ( scoping == null ) ? 0 : scoping.hashCode() );
             return result;
         }
 
         @Override
         public boolean equals( final Object obj )
         {
             if ( this == obj )
             {
                 return true;
             }
             if ( obj == null )
             {
                 return false;
             }
             if ( getClass() != obj.getClass() )
             {
                 return false;
             }
             final ScopedKey<?> other = (ScopedKey<?>) obj;
             if ( !getOuterType().equals( other.getOuterType() ) )
             {
                 return false;
             }
             if ( key == null )
             {
                 if ( other.key != null )
                 {
                     return false;
                 }
             }
             else if ( !key.equals( other.key ) )
             {
                 return false;
             }
             if ( scoping == null )
             {
                 if ( other.scoping != null )
                 {
                     return false;
                 }
             }
             else if ( !scoping.equals( other.scoping ) )
             {
                 return false;
             }
             return true;
         }
 
         private FactoryAnnotationModule getOuterType()
         {
             return FactoryAnnotationModule.this;
         }
 
     }
 
 }