/**
    * This file Copyright (c) 2017-2018 Magnolia International
    * Ltd.  (http://www.magnolia-cms.com). All rights reserved.
    *
    *
    * This file is dual-licensed under both the Magnolia
    * Network Agreement and the GNU General Public License.
    * You may elect to use one or the other of these licenses.
    *
   * This file is distributed in the hope that it will be
   * useful, but AS-IS and WITHOUT ANY WARRANTY; without even the
   * implied warranty of MERCHANTABILITY or FITNESS FOR A
   * PARTICULAR PURPOSE, TITLE, or NONINFRINGEMENT.
   * Redistribution, except as permitted by whichever of the GPL
   * or MNA you select, is prohibited.
   *
   * 1. For the GPL license (GPL), you can redistribute and/or
   * modify this file under the terms of the GNU General
   * Public License, Version 3, as published by the Free Software
   * Foundation.  You should have received a copy of the GNU
   * General Public License, Version 3 along with this program;
   * if not, write to the Free Software Foundation, Inc., 51
   * Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
   *
   * 2. For the Magnolia Network Agreement (MNA), this file
   * and the accompanying materials are made available under the
   * terms of the MNA which accompanies this distribution, and
   * is available at http://www.magnolia-cms.com/mna.html
   *
   * Any modifications to this file must keep this entire header
   * intact.
   *
   */
  package info.magnolia.ui.framework.ioc;
  
  import java.lang.annotation.Annotation;
  import java.util.Collection;
  import java.util.Optional;
  import java.util.function.Consumer;
  import java.util.function.Function;
  import java.util.stream.Stream;
  
  import com.google.inject.Binding;
  import com.google.inject.Key;
  import com.google.inject.Scope;
  import com.google.inject.internal.Scoping;
  import com.google.inject.spi.ConstructorBinding;
  import com.google.inject.spi.DefaultBindingScopingVisitor;
  import com.google.inject.spi.DefaultBindingTargetVisitor;
  import com.google.inject.spi.Element;
  import com.google.inject.spi.LinkedKeyBinding;
  import com.google.inject.spi.ProviderInstanceBinding;
  import com.google.inject.spi.ProviderKeyBinding;
  import com.google.inject.spi.UntargettedBinding;
  
  /**
   * Utility class which helps to write a slightly more compact and
   * modern-looking code when dealing with Guice SPI API's. The
   * latter are quite powerful but utilise the visitor pattern quite
   * extensively forcing the developer to use multiple inline vistor
   * classes which makes the code noisy.
   * <p>
   * Current utility allows to traverse and inspect the {@link Element elements}
   * and {@link Binding bindings} with Java 8 lambdas and streams.
   * </p>
   */
  public class GuiceSpi {
  
      /**
       * Takes a collection of {@link Element elements} and presents it
       * a stream of {@link Binding bindings} skipping all the elements
       * that are not bindings on the way. This method is useful since
       * most of the time when we are processing the Guice module elements
       * we are only interested in bindings.
       */
      public static Stream<Binding> getBindings(Collection<Element> elements) {
          return elements.stream()
                  .filter(element -> element instanceof Binding)
                  .map(element -> (Binding) element);
      }
  
      public static <T> Optional<Binding<T>> findBinding(Collection<Element> elements, Key<T> key) {
          return getBindings(elements).filter(binding -> binding.getKey().equals(key)).map(binding -> (Binding<T>) binding).findFirst();
      }
  
      public static <T> Class<? super T> rawType(Key<T> key) {
          return key.getTypeLiteral().getRawType();
      }
  
      /**
       * Resolves the {@link Scoping scoping} information of
       * the {@link Binding binding}.
       */
      public static Scoping resolveScope(Binding<?> currentBinding) {
          return currentBinding.acceptScopingVisitor(new DefaultBindingScopingVisitor<Scoping>() {
              @Override
              public Scoping visitEagerSingleton() {
                  return Scoping.EAGER_SINGLETON;
              }
 
             @Override
             public Scoping visitScopeAnnotation(Class<? extends Annotation> scopeAnnotation) {
                 return Scoping.forAnnotation(scopeAnnotation);
             }
 
             @Override
             public Scoping visitScope(Scope scope) {
                 return Scoping.forInstance(scope);
             }
 
             @Override
             public Scoping visitNoScoping() {
                 return Scoping.UNSCOPED;
             }
         });
     }
 
     /**
      * Shortcut provider of {@link BindingVisitor} instance.
      */
     public static <R> BindingVisitor<R> inspect(Binding<?> binding) {
         return new BindingVisitor<>(binding);
     }
 
     /**
      * Wraps {@link DefaultBindingTargetVisitor} class into a lambda-friendly fluent API.
      * Provides methods to register handlers of the {@link LinkedKeyBinding}, {@link ProviderKeyBinding} and
      * {@link ProviderInstanceBinding} since those are the only that Magnolia UI IoC implementation is
      * currently interested at. Handlers can be registered as functions (i.e. will return a value) or as
      * consumers (i.e. not required to return anything).
      * <p>
      * <strong>NOTE:</strong> feel free to add handlers for other types of bindings should that be needed!
      * </p>
      *
      * @param <R>
      *     type of the result returned by SPI call
      */
     public static class BindingVisitor<R> {
 
         private final Binding<?> binding;
         private Function<LinkedKeyBinding, R> linkedKeyBindingHandler = binding -> null;
         private Function<ProviderKeyBinding, R> providerKeyBindingHandler = binding -> null;
         private Function<ProviderInstanceBinding, R> providerInstanceBindingHandler = binding -> null;
         private Function<UntargettedBinding, R> untargettedBindingHandler = binding -> null;
         private Function<ConstructorBinding<?>,R> constructorBindingHandler = binding -> null;
 
         private BindingVisitor(Binding<?> binding) {
             this.binding = binding;
         }
 
         public BindingVisitor<R> onConstructorBinding(Function<ConstructorBinding<?>, R> handler) {
             this.constructorBindingHandler = handler;
             return this;
         }
 
         public BindingVisitor<R> consumeConstructorBinding(Consumer<ConstructorBinding<?>> handler) {
             this.constructorBindingHandler = constructorBinding -> {
                 handler.accept(constructorBinding);
                 return null;
             };
 
             return this;
         }
 
         public BindingVisitor<R> onLinkedBinding(Function<LinkedKeyBinding, R> handler) {
             this.linkedKeyBindingHandler = handler;
             return this;
         }
 
         public BindingVisitor<R> consumeLinkedBinding(Consumer<LinkedKeyBinding> handler) {
             this.linkedKeyBindingHandler = binding -> {
                 handler.accept(binding);
                 return null;
             };
             return this;
         }
 
         public BindingVisitor<R> onProviderKeyBinding(Function<ProviderKeyBinding, R> handler) {
             this.providerKeyBindingHandler = handler;
             return this;
         }
 
         public BindingVisitor<R> onProviderInstanceBinding(Function<ProviderInstanceBinding, R> handler) {
             this.providerInstanceBindingHandler = handler;
             return this;
         }
 
         public BindingVisitor<R> onUntargettedBinding(Function<UntargettedBinding, R> handler) {
             this.untargettedBindingHandler = handler;
             return this;
         }
 
         public BindingVisitor<R> consumeUntargettedBinding(Consumer<UntargettedBinding<?>> handler) {
             this.untargettedBindingHandler = untargettedBinding -> {
                 handler.accept(untargettedBinding);
                 return null;
             };
 
             return this;
         }
 
         public BindingVisitor<R> consumeProviderInstanceBinding(Consumer<ProviderInstanceBinding> handler) {
             this.providerInstanceBindingHandler = binding -> {
                 handler.accept(binding);
                 return null;
             };
             return this;
         }
 
         public <T> BindingVisitor<R> consumeProviderKeyBinding(Consumer<ProviderKeyBinding<T>> handler) {
             this.providerKeyBindingHandler = binding -> {
                 handler.accept(binding);
                 return null;
             };
             return this;
         }
 
         public Optional<R> visit() {
             return binding.acceptTargetVisitor(new DefaultBindingTargetVisitor<Object, Optional<R>>() {
                 @Override
                 public Optional<R> visit(ConstructorBinding<?> constructorBinding) {
                     return Optional.ofNullable(constructorBindingHandler.apply(constructorBinding));
                 }
 
                 @Override
                 public Optional<R> visit(ProviderKeyBinding<?> providerKeyBinding) {
                     return Optional.ofNullable(providerKeyBindingHandler.apply(providerKeyBinding));
                 }
 
                 @Override
                 public Optional<R> visit(LinkedKeyBinding<?> linkedKeyBinding) {
                     return Optional.ofNullable(linkedKeyBindingHandler.apply(linkedKeyBinding));
                 }
 
                 @Override
                 public Optional<R> visit(ProviderInstanceBinding<?> providerInstanceBinding) {
                     return Optional.ofNullable(providerInstanceBindingHandler.apply(providerInstanceBinding));
                 }
 
                 @Override
                 public Optional<R> visit(UntargettedBinding<?> untargettedBinding) {
                     return Optional.ofNullable(untargettedBindingHandler.apply(untargettedBinding));
                 }
 
                 @Override
                 protected Optional<R> visitOther(Binding<?> binding) {
                     return Optional.empty();
                 }
             });
         };
     }
 }