/**
    * 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 static info.magnolia.ui.framework.ioc.GuiceSpi.rawType;
  
  import info.magnolia.objectfactory.Components;
  
  import java.lang.reflect.Constructor;
  import java.util.ArrayList;
  import java.util.Arrays;
  import java.util.Iterator;
  import java.util.List;
  import java.util.Objects;
  import java.util.Optional;
  
  import javax.inject.Inject;
  
  import org.slf4j.Logger;
  import org.slf4j.LoggerFactory;
  
  import com.google.common.collect.ArrayListMultimap;
  import com.google.common.collect.ListMultimap;
  import com.google.common.collect.Multimaps;
  import com.google.inject.AbstractModule;
  import com.google.inject.Binding;
  import com.google.inject.Key;
  import com.google.inject.Module;
  import com.google.inject.TypeLiteral;
  import com.google.inject.binder.LinkedBindingBuilder;
  import com.google.inject.binder.ScopedBindingBuilder;
  import com.google.inject.internal.Scoping;
  import com.google.inject.spi.Element;
  import com.google.inject.spi.Elements;
  import com.google.inject.spi.LinkedKeyBinding;
  import com.google.inject.spi.ProviderInstanceBinding;
  import com.google.inject.spi.ProviderKeyBinding;
  
  /**
   * Wrapper Guice module which goes over the bindings of the source module
   * and analyses the bindings annotated with custom Magnolia
   * {@link com.google.inject.BindingAnnotation binding annotations}.
   * <p>
   * The goal is to detect the bindings which map the same type to different
   * implementations bound to different Magnolia UI contexts. There are two scenarios
   * that we are interested in.
   * </p>
   * <p>
   * First scenario is when there are several bindings of the same type to the same
   * implementation in the same scope with only binding annotations different. In such
   * case there is no need to have all those bindings, because apparently the
   * implementation choice does not depend on the UI context. We then remove
   * all such context-bound bindings and replace them with a single un-annotated
   * binding.
   * </p>
   * <p>
   * Second scenario is when there are different bindings of the same type
   * that map it to several different implementations depepnding on the UI
   * context. In such case our job is make sure that when the un-annotated
   * injection is supported and the implementation
   * is chosen automatically (i.e. we're injecting some type {@code Foo}
   * without any binding annotation specified). In order to provide such
   * support we bind the un-annotated type to {@link UiContextApplyingProvider}.
   * <strong>NOTE:</strong> there is a caveat with such an approach: without
   * proper care it might cause infinite injection cycle when some non-abstract
   * types are bound to themselves.
   * </p>
   * <p>For example imagine a non-abstract type {@code Foo} which is bound to
  * itself in app context {@code Foo@App -> Foo} and to {@code FooBar} in
  * sub-app scope {@code Foo@SubApp -> FooBar}. In such case un-annotated {@code Foo}
  * will end up being bound to the provider {@code Foo -> UiInjectionContextResolvingProvider}.
  * However, when in app context, the request to inject {@code Foo} through the
  * provider will boil down to {@code Foo} again, which will trigger the provider
  * again and again and so on. In order to avoid that, we detect such cases
  * and bind non-abstract types with annotation via {@link com.google.inject.spi.ConstructorBinding}.
  * </p>
  */
 final class DeflateUiContextDependentBindings extends AbstractModule {
 
     private static final Logger log = LoggerFactory.getLogger(DeflateUiContextDependentBindings.class);
 
     private List<Element> sourceElements;
 
     DeflateUiContextDependentBindings(Module sourceModule) {
         this.sourceElements = Elements.getElements(sourceModule);
     }
 
     @Override
     @SuppressWarnings("unchecked")
     protected void configure() {
         final List<Element> elementsToWrite = new ArrayList<>(sourceElements);
 
         // Group all the module bindings by the raw type of the key
         final ListMultimap<TypeLiteral, Binding> annotatedBindings = ArrayListMultimap.create();
         GuiceSpi.getBindings(sourceElements).forEach(binding -> {
             final Key<?> key = binding.getKey();
             if (key.getAnnotation() instanceof UiContextAnnotation) {
                 annotatedBindings.put(key.getTypeLiteral(), binding);
             }
         });
 
         Multimaps.asMap(annotatedBindings).forEach((typeLiteral, bindings) -> {
             // If all the bindings are the same then we replace them
             // all with a single one that has no binding annotation at all
             if (mayDeflateBindings(bindings)) {
                 elementsToWrite.removeAll(bindings);
 
                 // if the 'bare' type literal is already bound to something - nothing to do here, simply discarding the
                 // context-specific bindings is enough
                 if (GuiceSpi.findBinding(sourceElements, Key.get(typeLiteral)).isPresent()) {
                     return;
                 }
 
                 // We just use the first binding from the list as a 'sample'
                 final Scoping scope = GuiceSpi.resolveScope(bindings.get(0));
                 GuiceSpi.<ScopedBindingBuilder> inspect(bindings.get(0))
                         // provider key binding is replaced by the same binding, but we don't use binding annotation for the key anymore
                         .onProviderKeyBinding(binding -> bind(typeLiteral).toProvider(binding.getProviderKey()))
                         // provider instance binding is replaced by the same binding, but we don't use binding annotation for the key anymore
                         .onProviderInstanceBinding(binding -> bind(typeLiteral).toProvider(binding.getUserSuppliedProvider()))
                         // interface-to-implementation binding has to be handled carefully: binding of type Key<Foo@App> -> Key<Foo> will work fine,
                         // but if we replace it with Key<Foo> -> Key<Foo>, Guice will bail with a self-bound type error. In such case the type
                         // should be bound without a target.
                         .onLinkedBinding(binding -> {
                             final Key linkedKey = binding.getLinkedKey();
                             final Key sourceKey = Key.get(typeLiteral);
 
                             if (linkedKey.equals(sourceKey)) {
                                 return bind(typeLiteral);
                             } else {
                                 return bind(typeLiteral).to(linkedKey);
                             }
                         })
                         .visit()
                         .ifPresent(scopedBindingBuilder -> {
                             if (!Scoping.UNSCOPED.equals(scope)) {
                                 scope.applyTo(scopedBindingBuilder);
                             }
                         });
 
             } else {
                 // If UI context actually does matter then bind the un-annotated type to the special provider...
                 final UiContextApplyingProvider resolvingProvider = UiContextApplyingProvider.of(typeLiteral.getRawType());
                 // ...but first make that any annotated binding does use the current type as implementation (that would lead to circular dependencies!),
                 // in order to avoid that - replace such linked key bindings with a c-tor binding (see #bindNonAbstractType(...))
                 bindings.forEach(binding -> GuiceSpi.<Void>inspect(binding)
                         .consumeLinkedBinding(linkedKeyBinding -> {
                             // Handle non-abstract self-bindings separately
                             Class rawType = rawType(linkedKeyBinding.getLinkedKey());
                             Key rawKey = Key.get(rawType);
                             if (Objects.equals(typeLiteral.getRawType(), rawType)) {
                                 elementsToWrite.remove(linkedKeyBinding);
                                 elementsToWrite.removeIf(element -> element instanceof Binding && ((Binding) element).getKey().equals(rawKey));
                                 bindNonAbstractType(linkedKeyBinding.getKey(), GuiceSpi.resolveScope(linkedKeyBinding));
                             }
                         })
                         .visit());
                 bind(typeLiteral).toProvider(resolvingProvider);
             }
         });
 
         elementsToWrite.forEach(element -> element.applyTo(binder()));
     }
 
     /**
      * When binding non-abstract type to itself, enforce the
      * {@link com.google.inject.spi.ConstructorBinding} to be used in order to avoid the
      * circular dependencies (described in class JavaDoc).
      */
     @SuppressWarnings("unchecked")
     private <T> void bindNonAbstractType(Key<T> key, Scoping fallbackScope) {
         Class type = rawType(key);
         LinkedBindingBuilder bind = bind(key);
         Key rawKey = Key.get(rawType(key));
 
         // First locate possible existing [provider] binding of the type
         Optional<Binding<T>> existingBinding = GuiceSpi.findBinding(sourceElements, rawKey);
 
         // Start re-building the binding
         Optional<ScopedBindingBuilder> scopedBindingBuilder = existingBinding
                 .map(GuiceSpi::<ScopedBindingBuilder>inspect)
                 .flatMap(visitor ->
                                 visitor.onProviderKeyBinding(providerKeyBinding -> bind.toProvider(providerKeyBinding.getProviderKey()))
                                        .onProviderInstanceBinding(providerInstanceBinding -> bind.toProvider(providerInstanceBinding.getUserSuppliedProvider()))
                                        .visit());
 
         // If it is there - update the scoping to be applied
         Scoping scoping = existingBinding
                 .map(GuiceSpi::resolveScope)
                 .filter(scope -> scope != Scoping.UNSCOPED)
                 .orElse(fallbackScope);
 
         // Apply resulting scoping to the binding builder
         scoping.applyTo(scopedBindingBuilder.orElseGet(() -> {
             // Look-up an @Inject-annotated constructor
             final Optional<Constructor> injectConstructor =
                     Arrays.stream(type.getConstructors())
                             .filter(constructor -> constructor.isAnnotationPresent(Inject.class))
                             .findFirst();
             // If it's there - bind the type to the constructor
             if (injectConstructor.isPresent()) {
                 return bind.toConstructor(injectConstructor.get());
             } else {
                 // otherwise - use the provider which lets the Mgnl factory machinery create an instance
                 return bind.toProvider(() -> Components.newInstance(type));
             }
         }));
     }
 
     /**
      * Go over all the bindings related to the same type
      * and see if there's at least one that is different
      * from the others.
      */
     private boolean mayDeflateBindings(List<Binding> bindings) {
         boolean allBindingsIdentical = true;
 
         Binding currentBinding = bindings.get(0);
         final Iterator<Binding> bindingIterator = bindings.subList(1, bindings.size()).iterator();
         while (allBindingsIdentical && bindingIterator.hasNext()) {
             final Binding<?> nextBinding = bindingIterator.next();
             allBindingsIdentical = isSameBinding(nextBinding, currentBinding);
             currentBinding = nextBinding;
         }
 
         if (!allBindingsIdentical) {
             return false;
         }
 
         // If all bindings are the same but none of them is generic
         // (i.e. the same binding is related for instance to several
         // specific apps), then do not let such bindings be squashed
         // into one.
         for (final Binding<?> binding : bindings) {
             if (UiAnnotations.cast(binding.getKey().getAnnotation()).isGeneric()) {
                 return true;
             }
         }
 
         return false;
     }
 
     private boolean isSameBinding(Binding currentBinding, Binding previousBinding) {
         return Objects.equals(resolveTarget(currentBinding), resolveTarget(previousBinding)) &&
                Objects.equals(GuiceSpi.resolveScope(currentBinding), GuiceSpi.resolveScope(previousBinding));
     }
 
     private Object resolveTarget(Binding<?> binding) {
         return GuiceSpi.inspect(binding)
                 .onLinkedBinding(LinkedKeyBinding::getLinkedKey)
                 .onProviderKeyBinding(ProviderKeyBinding::getProviderKey)
                 .onProviderInstanceBinding(ProviderInstanceBinding::getUserSuppliedProvider)
                 .visit()
                 .orElseThrow(() -> new IllegalArgumentException("Unable ot resolve target key of the binding: " + binding));
     }
 }