/*

  * 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;

         }

     }

 }