/**
    * This file Copyright (c) 2017 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 info.magnolia.event.EventBus;
  import info.magnolia.event.ResettableEventBus;
  import info.magnolia.event.SimpleEventBus;
  import info.magnolia.objectfactory.ComponentProvider;
  import info.magnolia.objectfactory.guice.GuiceComponentProvider;
  import info.magnolia.ui.api.app.AppContext;
  import info.magnolia.ui.api.app.AppEventBus;
  import info.magnolia.ui.api.app.SubAppContext;
  import info.magnolia.ui.api.app.SubAppEventBus;
  import info.magnolia.ui.api.context.UiContext;
  import info.magnolia.ui.api.event.AdmincentralEventBus;
  import info.magnolia.ui.api.event.ChooseDialogEventBus;
  import info.magnolia.ui.api.ioc.AdmincentralScoped;
  import info.magnolia.ui.api.ioc.AdmincentralScopedEager;
  import info.magnolia.ui.api.ioc.AppScoped;
  import info.magnolia.ui.api.ioc.SubAppScoped;
  import info.magnolia.ui.api.ioc.UiContextScoped;
  import info.magnolia.ui.api.shell.Shell;
  
  import java.lang.annotation.Annotation;
  import java.util.HashMap;
  import java.util.Map;
  import java.util.Objects;
  import java.util.Optional;
  import java.util.function.Consumer;
  import java.util.function.Function;
  
  import javax.inject.Named;
  
  import com.google.inject.AbstractModule;
  import com.google.inject.Key;
  import com.google.inject.Provider;
  import com.google.inject.Provides;
  import com.google.inject.Scope;
  import com.google.inject.binder.LinkedBindingBuilder;
  import com.google.inject.name.Names;
  import com.vaadin.server.Page;
  import com.vaadin.server.VaadinServlet;
  import com.vaadin.server.VaadinSession;
  import com.vaadin.ui.UI;
  
  /**
   * Guice module which pre-configures some essential Magnolia UI components like
   * event-buses, UI contexts, Vaadin core components.
   */
  public class UiBaseModule extends AbstractModule {
  
      private final Map<String, EventBusProxyScope> eventBusScopes = new HashMap<>();
  
      private final EventBus systemEventBus;
  
      private final UiScopes uiScopes;
  
      UiBaseModule(EventBus systemEventBus, UiScopes uiScopes) {
          this.systemEventBus = systemEventBus;
          this.uiScopes = uiScopes;
  
          eventBusScopes.put(AdmincentralEventBus.NAME, new EventBusProxyScope(this.uiScopes.eagerAdmincentralScope(), systemEventBus, this.uiScopes));
          eventBusScopes.put(AppEventBus.NAME, new EventBusProxyScope(this.uiScopes.eagerAppScope(), systemEventBus, this.uiScopes));
          eventBusScopes.put(SubAppEventBus.NAME, new EventBusProxyScope(this.uiScopes.eagerSubAppScope(), systemEventBus, this.uiScopes));
          eventBusScopes.put(ChooseDialogEventBus.NAME, new EventBusProxyScope(this.uiScopes.eagerViewScope(), systemEventBus, this.uiScopes));
          // There is a named constant for the media-editor event-bus but it is not accessible from ui-framework module (which seems to be
          // wrong). In order to make the media editor classes accessible to this Guice module, all the IoC stuff would have to be moved
          // all the way up to ui-admincentral, which makes very little sense.
         eventBusScopes.put("mediaeditor", new EventBusProxyScope(this.uiScopes.eagerViewScope(), systemEventBus, this.uiScopes));
     }
 
     public UiBaseModule(EventBus systemEventBus) {
         this(systemEventBus, new UiScopes(systemEventBus));
     }
 
     /**
      * Makes the {@link SubAppContext} injectable. An instance of the
      * context is expected to be present in the corresponding sub-app's
      * bean storage.
      */
     @Provides
     @SubAppScoped
     SubAppContext getSubAppCtx(CurrentUiContextReference currentUiContextReference) {
         Optional<UiContextReference> currentSubAppReference = currentUiContextReference.getSubAppReference();
         return currentSubAppReference
                 .map(reference -> SessionStore.access().getBeanStore(reference).get(SubAppContext.class))
                 .orElseThrow(IllegalStateException::new);
     }
 
     /**
      * Makes the {@link AppContext} injectable. An instance of the
      * context is expected to be present in the corresponding app's
      * bean storage.
      */
     @Provides
     @AppScoped
     AppContext getAppCtx(CurrentUiContextReference currentUiContextReference) {
         Optional<UiContextReference> currentAppKey = currentUiContextReference.getAppReference();
         return currentAppKey
                 .map(key -> SessionStore.access().getBeanStore(key).get(AppContext.class))
                 .orElseThrow(IllegalStateException::new);
     }
 
     @Provides
     @AdmincentralScopedEager
     CurrentUiContextReference getCurrentUiContextReference() {
         return SessionStore.access().getBeanStore(UiContextReference.ofCurrentUi()).get(CurrentUiContextReference.class);
     }
 
     @Provides
     @AdmincentralScoped
     SessionStore getSessionStore() {
         return new SessionStore(VaadinSession.getCurrent(), this.systemEventBus);
     }
 
     /**
      * Allows the only UI's Guice component provider to be injected.
      */
     @Provides
     GuiceComponentProvider getUiGuiceComponentProvider() {
         return (GuiceComponentProvider) VaadinServlet.getCurrent().getServletContext().getAttribute("componentProvider");
     }
 
     /**
      * Provides access to the Guice component provider from 'main'. Should not be needed
      * in any normal case, but might be useful when the more complex UI bindings
      * overlap with the bindings from main.
      */
     @Provides
     @Named("main") GuiceComponentProvider getMainGuiceComponentProvider(GuiceComponentProvider guiceComponentProvider) {
         return guiceComponentProvider.getParent();
     }
 
     @Provides
     @UiContextScoped
     ComponentProvider getComponentProvider(GuiceComponentProvider parentComponentProvider, CurrentUiContextReference currentUiContextReference) {
         return new UiContextBoundComponentProvider(currentUiContextReference.getUiContextReference(), parentComponentProvider, currentUiContextReference);
     }
 
     @Override
     protected void configure() {
         // Bind scope annotations to Magnolia UI scopes
         uiScopes.bind(binder());
 
         // Bind event buses
         bindEventBuses();
 
         // Bind UiContext to UI scopes
         bindUiContext();
 
         // Make Vaadin UI and VaadinSession instances injectable
         bind(UI.class).toProvider(UI::getCurrent);
         bind(VaadinSession.class).toProvider(VaadinSession::getCurrent);
         bind(Page.class).toProvider(Page::getCurrent);
 
         bind(UiScopes.class).toInstance(this.uiScopes);
     }
 
     private void bindUiContext() {
         final Function<Annotation, LinkedBindingBuilder<UiContext>> uiContextKey = annotation -> bind(UiContext.class).annotatedWith(annotation);
 
         uiContextKey.apply(UiAnnotations.forAdmincentral()).to(Shell.class);
         uiContextKey.apply(UiAnnotations.forApps()).to(AppContext.class);
         uiContextKey.apply(UiAnnotations.forSubApps()).to(SubAppContext.class);
         uiContextKey.apply(UiAnnotations.forViews()).toProvider(() ->
                 CurrentUiContextReference.get().getViewReference()
                 .map(viewContextKey -> SessionStore.access().getBeanStore(viewContextKey).get(Key.get(UiContext.class, viewContextKey.getAnnotation())))
                 .orElseThrow(() -> new IllegalStateException("Not in view context, cannot resolve view UiContext")));
 
         bind(UiContext.class).toProvider(new UiContextApplyingProvider<>(UiContext.class));
     }
 
     private void bindEventBuses() {
         // Make event buses injectable. Use EventBusProxyScope to automatically wrap the event buses injected across
         // scopes with ResettableEventBus
         final Provider<EventBus> eventBusProvider = () -> new ResettableEventBus(new SimpleEventBus());
         final Function<String, Key<EventBus>> createEventBusKey = (name) -> Key.get(EventBus.class, Names.named(name));
 
         final Consumer<String> bindEventBus = name ->
                 bind(createEventBusKey.apply(name))
                 .toProvider(eventBusProvider)
                 .in(eventBusScopes.get(name));
 
         bindEventBus.accept(AdmincentralEventBus.NAME);
         bindEventBus.accept(AppEventBus.NAME);
         bindEventBus.accept(SubAppEventBus.NAME);
         bindEventBus.accept(ChooseDialogEventBus.NAME);
         bindEventBus.accept("mediaeditor");
     }
 
     /**
      * Proxies {@link EventBus} injection between UI scopes for the sake of
      * preventing event handler leakages. This class does what {@link info.magnolia.event.EventBusProtector}
      * is essentially doing, but without the need to explicitly configuring it and triggering the clean-up.
      *
      * <p>
      * Actual instance of an {@link EventBus} ends up residing in the original
      * {@link Scope scope} which is specified in c-tor.
      * </p>
      * <p>
      * Whenever there is an injection request corresponding to a different scope
      * (i.e. the state of the {@link CurrentUiContextReference} points to a scope other than
      * the 'original' one) the {@link EventBus} instance from the original scope
      * is wrapped into a {@link ResettableEventBus}.
      * </p>
      * <p>
      * This way, when the current scope will be finalised - it will possible
      * to remove the event handlers bound to event buses other scopes
      * all at once (by resetting the {@link ResettableEventBus}).
      * </p>
      */
     @SuppressWarnings("unchecked")
     private static class EventBusProxyScope extends ProxyScope {
 
         EventBusProxyScope(SessionStoreScope originalScope, EventBus systemEventBus, UiScopes allUiScopes) {
             super(originalScope, allUiScopes);
             systemEventBus.addHandler(BeanStoreLifecycleEvent.BeforeDestroy.class, event -> this.releaseEventHandlers(event.getRelatedContextKey(), event.getStore()));
         }
 
         // When a bean store related to this scope is destroyed - reset all the resettable
         // event buses from that store
         private void releaseEventHandlers(UiContextReference relatedContextReference, BeanStore store) {
             // First - resolve the scope corresponding to the bean store that is being destroyed
             final Scope destroyedScope = getAllUiScopes().getScope(relatedContextReference.getAnnotation().getRelatedScopeAnnotation(true));
             // If that scope is the one that is wrapped - take all the resettable event buses stored in that bean store and reset them,
             // which will effectively remove the handlers related to the UI context that is currently being destroyed
             // (see class JavaDoc which explains how the event buses get wrapped).
             if (Objects.equals(getOriginalScope(), destroyedScope)) {
                 store.forEach((key, value) -> {
                     if (value instanceof ResettableEventBus) {
                         ((ResettableEventBus) value).reset();
                     }
                 });
             }
         }
 
         @Override
         protected <T> Provider<T> proxyScope(Key<T> key, Provider<T> scopedProvider, SessionStoreScope currentScope) {
             if (key.getTypeLiteral().getRawType().isAssignableFrom(EventBus.class)) {
                 return () -> {
                     final BeanStore relatedStore = currentScope.getStore();
                     EventBus protectedEventBus = relatedStore.get((Key<EventBus>) key);
                     if (protectedEventBus == null) {
                         protectedEventBus = new ResettableEventBus((EventBus) scopedProvider.get());
                         relatedStore.put(key, protectedEventBus);
                     }
                     return (T) protectedEventBus;
                     
                 };
             }
 
             throw new IllegalArgumentException("Can only proxy EventBus objects, do not know what to do with [" + key + "]");
         }
     }
 }