/**
    * This file Copyright (c) 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 java.util.stream.Collectors.toMap;
  
  import info.magnolia.config.NamedDefinition;
  import info.magnolia.i18nsystem.util.AnnotationUtils;
  import info.magnolia.objectfactory.CandidateParameterResolver;
  import info.magnolia.objectfactory.ComponentProvider;
  import info.magnolia.objectfactory.ParameterResolver;
  import info.magnolia.objectfactory.guice.GuiceComponentProvider;
  import info.magnolia.ui.UIComponent;
  import info.magnolia.ui.api.ioc.ViewScoped;
  import info.magnolia.ui.datasource.DatasourceDefinition;
  import info.magnolia.ui.datasource.WithDatasource;
  import info.magnolia.util.Util;
  
  import java.io.Serializable;
  import java.util.Arrays;
  import java.util.HashMap;
  import java.util.Map;
  import java.util.Optional;
  import java.util.function.Function;
  import java.util.function.Supplier;
  import java.util.stream.Stream;
  
  import org.slf4j.Logger;
  import org.slf4j.LoggerFactory;
  
  import com.google.common.base.Suppliers;
  import com.google.inject.Key;
  import com.vaadin.server.VaadinServlet;
  
  /**
   * Specialised component provider supplied with additional {@link ParameterResolver parameter resolvers}.
   * <ul>
   * <li>{@link UiComponentContextParameterResolver}</li>
   * </ul>
   */
  public class UiComponentProvider implements ComponentProvider, Serializable {
  
      private static final Logger log = LoggerFactory.getLogger(UiComponentProvider.class);
  
      private final transient GuiceComponentProvider parentComponentProvider;
      private final CurrentUiContextReference currentUiContextReference = CurrentUiContextReference.get();
      private final UiContextReference viewContextReference;
      private final Supplier<DatasourceDefinition> datasourceDefinition;
  
      public UiComponentProvider(UiContextReference viewContextReference, GuiceComponentProvider parentComponentProvider) {
          this.parentComponentProvider = parentComponentProvider;
          this.viewContextReference = viewContextReference;
          this.datasourceDefinition = Suppliers.memoize(() -> this.getComponent(DatasourceDefinition.class));
      }
  
      public UiComponentProvider(UiContextReference viewContextReference) {
          this(viewContextReference, (GuiceComponentProvider) VaadinServlet.getCurrent().getServletContext().getAttribute("componentProvider"));
      }
  
      public UiContextReference getUiContextReference() {
          return viewContextReference;
      }
  
      public UiComponentProvider inChildContext(String name, Object definition) {
          Builder builder = builder(name, viewContextReference).withInstances(definition);
          if (definition instanceof WithDatasource) {
              Map<Class, Object> instances = new HashMap<>();
              Optional.ofNullable(((WithDatasource) definition).getDatasource())
                     .ifPresent(datasourceDefinition -> instances.put(DatasourceDefinition.class, datasourceDefinition));
             builder = builder.withInstances(instances);
         }
 
         return builder.build();
     }
 
     public UiComponentProvider inChildContext(NamedDefinition definition) {
         return inChildContext(definition.getName(), definition);
     }
 
     @Override
     public <T> T getComponent(Class<T> type) {
         return provideInCurrentScope(() -> getParent().getComponent(type));
     }
 
     @Override
     public <T> Class<? extends T> getImplementation(Class<T> type) {
         return getParent().getImplementation(getClosestMappedType(type));
     }
 
     @Override
     public <T> T getSingleton(Class<T> type) {
         return getParent().getSingleton(type);
     }
 
     @Override
     public <T> T newInstance(Class<T> type, Object... parameters) {
         return newInstanceWithParameterResolvers(type, new CandidateParameterResolver(parameters));
     }
 
     @Override
     public <T> T newInstanceWithParameterResolvers(Class<T> type, ParameterResolver... parameters) {
         ParameterResolver[] combinedParameters = new ParameterResolver[parameters.length + 1];
         combinedParameters[parameters.length] = new UiComponentContextParameterResolver(viewContextReference);
         System.arraycopy(parameters, 0, combinedParameters, 0, parameters.length);
 
         T instance = provideInCurrentScope(() -> getParent().newInstanceWithParameterResolvers(getClosestMappedType(type), combinedParameters));
 
         if (instance instanceof UIComponent) {
             BeanStore beanStore = SessionStore.access().getBeanStore(getUiContextReference());
             if (beanStore.hasInstanceOf(UIComponent.class)) {
                 log.warn("Attempted to cache a UIComponent ({}) instance in bean store containing another UIComponent ({})",
                         type.getSimpleName(), beanStore.get(UIComponent.class).getClass().getSimpleName());
             }
 
             beanStore.put(type, instance);
         }
 
         // Cache instance if marked as ViewScoped
         if (AnnotationUtils.hasAnnotationOn(type, ViewScoped.class)) {
             //noinspection unchecked
             SessionStore.access().getBeanStore(getUiContextReference()).put(type, instance);
         }
 
         return instance;
     }
 
     @Override
     public GuiceComponentProvider getParent() {
         return this.parentComponentProvider;
     }
 
     protected Stream<UiContextReference> getReachableUiContextReferences() {
         Stream<UiContextReference> datasourceReference = Optional.ofNullable(datasourceDefinition.get())
                 .map(DatasourceDefinition::getName)
                 .map(UiContextReference::ofDatasourceComponent)
                 .map(Stream::of)
                 .orElse(Stream.empty());
 
         return Stream.concat(currentUiContextReference.getAvailableContextReferences().stream(), datasourceReference);
     }
 
     private <T> T provideInCurrentScope(Supplier<T> provider) {
         final UiContextReference previousUiContextReference = currentUiContextReference.getUiContextReference();
             currentUiContextReference.setUiContextReference(viewContextReference);
         try {
             return provider.get();
         } finally {
             currentUiContextReference.setUiContextReference(previousUiContextReference);
         }
     }
 
     private <T> Key<T> getClosestMappedType(Class<T> type) {
         return getReachableUiContextReferences()
                 .map(key -> Key.get(type, key.getAnnotation()))
                 // first check if there is a matching annotated type mapping
                 .filter(key -> getParent().getTypeMappings().containsKey(key))
                 .findFirst()
                 // otherwise just fetch the un-annotated type mapping
                 .orElseGet(() -> Key.get(type));
     }
 
     public static Builder builder(String name, UiContextReference parentReference) {
         String id = name;
         UiContextReference viewContextReference;
         do {
             viewContextReference = UiContextReference.ofView(id, parentReference);
             id = Util.createUniqueName(id);
         } while (SessionStore.access().getBeanStore(viewContextReference) != null);
 
         return new Builder().withUiContextReference(viewContextReference);
     }
 
     public static class Builder {
 
         private Builder() {
         }
 
         private UiContextReference uiContextReference;
         private Map<Class, Object> instances = new HashMap<>();
 
         public Builder withUiContextReference(UiContextReference uiContextReference) {
             this.uiContextReference = uiContextReference;
             return this;
         }
 
         public Builder withInstances(Object... instances) {
             this.instances.putAll(Arrays.stream(instances)
                     .collect(toMap(Object::getClass, Function.identity(), (first, second) -> second)));
             return this;
         }
 
         public Builder withInstances(Map<Class, Object> instances) {
             this.instances.putAll(instances);
             return this;
         }
 
         public UiComponentProvider build() {
             BeanStore beanStore = SessionStore.access().createBeanStore(uiContextReference);
             instances.forEach(beanStore::put);
 
             UiContextBoundComponentProviderhtml#UiContextBoundComponentProvider">UiContextBoundComponentProvider uiComponentProvider = new UiContextBoundComponentProvider(uiContextReference);
             beanStore.put(UiContextBoundComponentProvider.class, uiComponentProvider);
             beanStore.put(ComponentProvider.class, uiComponentProvider);
 
             return uiComponentProvider;
         }
     }
 }