/*

  * 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 java.lang.annotation.Annotation;

 import java.lang.reflect.Field;

 import java.util.List;

 import java.util.Set;

 import com.google.common.collect.ImmutableSet;

 import com.google.inject.Binder;

 import com.google.inject.Key;

 import com.google.inject.ProvisionException;

 import com.google.inject.TypeLiteral;

 import com.google.inject.matcher.Matchers;

 import com.google.inject.spi.BindingTargetVisitor;

 import com.google.inject.spi.DefaultBindingTargetVisitor;

 import com.google.inject.spi.Dependency;

 import com.google.inject.spi.DependencyAndSource;

 import com.google.inject.spi.HasDependencies;

 import com.google.inject.spi.InjectionPoint;

 import com.google.inject.spi.ProviderInstanceBinding;

 import com.google.inject.spi.ProviderWithExtensionVisitor;

 import com.google.inject.spi.ProvisionListener;

 import com.google.inject.spi.TypeEncounter;

 import com.google.inject.spi.TypeListener;

 final class FactoryAnnotationProviderFactory<T, A extends Annotation>

     extends DefaultBindingTargetVisitor<T, Object>

     implements TypeListener, ProviderWithExtensionVisitor<T>, HasDependencies, ProvisionListener,

     FactoryAnnotationBinding<T, A>

 {

     private final Class<A> annotationType;

     private final FactoryAnnotationProvider<T, A> factoryAnnotationProvider;

     private final Key<FactoryAnnotationProvider<T, A>> targetKey;

     private final TypeLiteral<T> elementTypeLiteral;

     private final FactoryAnnotationProvisionListener<T, A> provisionListener;

     private final ThreadLocal<A> provision = new ThreadLocal<A>();

     @SuppressWarnings( "unchecked" )

     FactoryAnnotationProviderFactory( final Binder binder, final Class<A> annotationType,

                                       final FactoryAnnotationProvider<T, A> factoryAnnotationProvider,

                                       final FactoryAnnotationProvisionListener<T, A> listener, final boolean cacheable )

     {

         this.annotationType = annotationType;

         this.provisionListener = listener;

         this.targetKey = (Key<FactoryAnnotationProvider<T, A>>) Key.get( factoryAnnotationProvider.getClass() );

         this.elementTypeLiteral = TypeLiteral.get( factoryAnnotationProvider.getInjectionType() );

         final FactoryAnnotationProvider<T, A> adapter =

             new FactoryAnnotationProviderInjectionAdapter<T, A>( factoryAnnotationProvider );

         // Request injection of the FactoryAnnotationProvider and the adapter before we

         // want to use it to meet possible requirements of the inner

         // implementation

         binder.requestInjection( adapter );

         binder.requestInjection( factoryAnnotationProvider );

         // If values can be cached initialize the caching map

         if ( cacheable )

         {

             this.factoryAnnotationProvider = new ProvisionCacheIdentityProviderFacade<T, A>( adapter, elementTypeLiteral );

             // Now we need to request injection for cache provider as well

             binder.requestInjection( this.factoryAnnotationProvider );

         }

         else

         {

             this.factoryAnnotationProvider = adapter;

         }

         binder.bindListener( Matchers.any(), this );

         binder.bindListener( Matchers.any(), (ProvisionListener) this );

     }

     public T get()

     {

         final A annotation = provision.get();

         if ( annotation == null )

         {

             throw new ProvisionException( "No legal provision" );

         }

         // Delete value from ThreadLocal store

         provision.set( null );

         // Return the provisioned (real) value

         return factoryAnnotationProvider.buildValue( annotation );

     }

     public <I> void hear( final TypeLiteral<I> type, final TypeEncounter<I> encounter )

     {

         // Search for fields that needs to be injected

         for ( final Field field : type.getRawType().getDeclaredFields() )

         {

             if ( field.isAnnotationPresent( annotationType ) )

             {

                 final A annotation = annotationType.cast( field.getAnnotation( annotationType ) );

                 final Set<InjectionPoint> injectionPoints =

                     InjectionPoint.forInstanceMethodsAndFields( type.getRawType() );

                 FactoryAnnotationProvision<T, A> identityProvision = null;

                 if ( injectionPoints.size() > 0 )

                 {

                     for ( final InjectionPoint ip : injectionPoints )

                     {

                         if ( ip.getMember().equals( field ) )

                         {

                             identityProvision = FactoryAnnotationProvisionImpl.wrapInjectionPoint( ip, annotation );

                         }

                     }

                 }

                 if ( identityProvision == null )

                 {

                     identityProvision =

                         new FactoryAnnotationProvisionImpl<T, A>( field, annotation, field.getAnnotations(),

                                                                   elementTypeLiteral );

                 }

                 // Register a MembersInjector per field which actually will do

                 // the injection for Guice

                 encounter.register( FactoryAnnotationSingleFieldMemberInjector.buildMemberInjector( factoryAnnotationProvider,

                                                                                                     field,

                                                                                                     provisionListener,

                                                                                                     annotation,

                                                                                                     identityProvision ) );

             }

         }

     }

     public <I> void onProvision( final ProvisionInvocation<I> provision )

     {

         final List<DependencyAndSource> dependencies = provision.getDependencyChain();

         // OK here we are at constructor or method injection so let's get the

         // real annotation at the type

         for ( final DependencyAndSource dependency : dependencies )

         {

             if ( dependency.getDependency() == null )

             {

                 continue;

             }

             final Annotation annotation = dependency.getDependency().getKey().getAnnotation();

             if ( annotation != null )

             {

                 if ( annotation.annotationType().equals( annotationType ) )

                 {

                     // We found the real annotation, let's save it for the

                     // actual provision call!

                     final A specificAnnotation = annotationType.cast( annotation );

                     this.provision.set( specificAnnotation );

                     final InjectionPoint injectionPoint = dependency.getDependency().getInjectionPoint();

                     if ( injectionPoint == null )

                     {

                         checkNotNull( injectionPoint );

                     }

                     final FactoryAnnotationProvision<T, A> identityProvision =

                         FactoryAnnotationProvisionImpl.wrapInjectionPoint( injectionPoint, specificAnnotation );

                     // Notify listener that an provision will occur

                     if ( provisionListener != null )

                     {

                         provisionListener.beforeInjection( identityProvision, specificAnnotation );

                     }

                     // Execute the provision;

                     T value = factoryAnnotationProvider.getInjectionType().cast( provision.provision() );

                     // Notify listener about the provisioned value

                     if ( provisionListener != null )

                     {

                         provisionListener.afterInjection( identityProvision, specificAnnotation, value );

                     }

                     // Explicitly return at this point

                     return;

                 }

             }

         }

     }

     public Set<Dependency<?>> getDependencies()

     {

         return ImmutableSet.<Dependency<?>> of( Dependency.get( targetKey ) );

     }

     @SuppressWarnings( "unchecked" )

     public <B, V> V acceptExtensionVisitor( final BindingTargetVisitor<B, V> visitor,

                                             final ProviderInstanceBinding<? extends B> binding )

     {

         if ( visitor instanceof FactoryAnnotationBindungTargetVisitor )

         {

             return ( (FactoryAnnotationBindungTargetVisitor<T, V>) visitor ).visit( this );

         }

         else

         {

             return visitor.visit( binding );

         }

     }

     public TypeLiteral<T> getElementTypeLiteral()

     {

         return elementTypeLiteral;

     }

     public Class<A> getAnnotationType()

     {

         return annotationType;

     }

     public boolean acceptAnnotation( A annotation )

     {

         return getAnnotationType().equals( annotation.annotationType() );

     }

 }