/*
    * 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() );
     }
 
 }