/**
    * 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.action.service;
  
  import info.magnolia.cms.core.version.VersionManager;
  import info.magnolia.event.EventBus;
  import info.magnolia.objectfactory.ComponentProvider;
  import info.magnolia.objectfactory.Components;
  import info.magnolia.ui.api.action.ActionExecutor;
  import info.magnolia.ui.api.app.SubApp;
  import info.magnolia.ui.api.app.SubAppContext;
  import info.magnolia.ui.api.availability.AvailabilityChecker;
  import info.magnolia.ui.api.availability.AvailabilityDefinition;
  import info.magnolia.ui.api.event.AdmincentralEventBus;
  import info.magnolia.ui.api.event.ContentChangedEvent;
  import info.magnolia.ui.api.ioc.UiContextScoped;
  import info.magnolia.ui.contentapp.browser.ActionExecutionService;
  import info.magnolia.ui.contentapp.browser.context.ValueContext;
  import info.magnolia.ui.contentapp.detail.ContentDetailSubApp;
  import info.magnolia.ui.datasource.jcr.JcrDatasourceDefinition;
  import info.magnolia.ui.dialog.formdialog.FormDialogPresenter;
  import info.magnolia.ui.form.EditorCallback;
  import info.magnolia.ui.form.EditorValidator;
  import info.magnolia.ui.framework.UiFrameworkView;
  import info.magnolia.ui.framework.databinding.ItemProviderStrategy;
  import info.magnolia.ui.framework.databinding.view.EditorView;
  import info.magnolia.ui.framework.message.MessagesManager;
  import info.magnolia.ui.vaadin.integration.contentconnector.ConfiguredJcrContentConnectorDefinition;
  import info.magnolia.ui.vaadin.integration.contentconnector.ConfiguredNodeTypeDefinition;
  import info.magnolia.ui.vaadin.integration.contentconnector.JcrContentConnector;
  import info.magnolia.ui.vaadin.integration.jcr.JcrItemUtil;
  import info.magnolia.ui.vaadin.integration.jcr.JcrNodeAdapter;
  import info.magnolia.util.OptionalConsumer;
  
  import java.util.ArrayList;
  import java.util.Arrays;
  import java.util.Collection;
  import java.util.List;
  import java.util.Optional;
  import java.util.Set;
  import java.util.concurrent.Callable;
  import java.util.function.Predicate;
  import java.util.stream.Collectors;
  import java.util.stream.Stream;
  
  import javax.inject.Inject;
  import javax.inject.Named;
  import javax.inject.Provider;
  import javax.jcr.Item;
  import javax.jcr.Node;
  import javax.jcr.RepositoryException;
  
  import com.google.common.collect.Sets;
  import com.vaadin.data.BinderValidationStatus;
  
  /**
   * Compatibility action execution service.
   * Adds compatibility parameters:
   * {@link info.magnolia.ui.vaadin.integration.jcr.JcrNodeAdapter}s,
   * {@link info.magnolia.ui.vaadin.integration.contentconnector.JcrContentConnector},
   * {@link info.magnolia.ui.form.EditorCallback} and {@link info.magnolia.ui.form.EditorValidator}
   * as action parameters.
   */
  @UiContextScoped
  public class CompatibilityActionExecutionService extends ActionExecutionService {
  
      private final ComponentProvider componentProvider;
      private final EventBus eventBus;
 
     @Inject
     public CompatibilityActionExecutionService(ActionExecutor actionExecutor, MessagesManager messagesManager, AvailabilityChecker availabilityChecker, ComponentProvider componentProvider, @Named(AdmincentralEventBus.NAME) EventBus eventBus) {
         super(actionExecutor, messagesManager, availabilityChecker);
         this.componentProvider = componentProvider;
         this.eventBus = eventBus;
     }
 
     @Override
     public void executeAction(String actionName, Object... parameters) {
         Collection<Object> compatibilityParameters = new ArrayList<>(Arrays.asList(parameters));
 
         Optional<ValueContextProvider> valueContextProviderOptional = invokeComponentProviderSafely(() -> componentProvider.newInstance(ValueContextProvider.class));
 
         Optional<Collection> selectedItems = valueContextProviderOptional
                 .map(InjectedComponentProvider::get)
                 .map(ValueContext::get)
                 .map(nodeStream ->  nodeStream.collect(Collectors.toList()));
 
         OptionalConsumer.of(Stream.of(parameters)
                 .filter(FormDialogPresenter.class::isInstance)
                 .findFirst())
                 .ifNotPresent(() -> invokeComponentProviderSafely(() -> Components.getComponent(FormDialogPresenter.class))
                         .ifPresent(compatibilityParameters::add));
 
         Optional<SubAppContext> subAppContext = invokeComponentProviderSafely(() -> componentProvider.newInstance((SubAppContext.class)));
         Optional<EditorView> editorView = subAppContext
                 .map(SubAppContext::getSubApp)
                 .map(SubApp::getView)
                 .filter(UiFrameworkView.class::isInstance)
                 .map(view -> ((UiFrameworkView) view).accessViewBeanStore().get(EditorView.class));
 
         Set<Node> jcrNodes = findJcrNodes(selectedItems);
 
         if (jcrNodes.size() == 0) {
             Optional<ItemProviderStrategyProvider> itemProviderStrategyProvider = invokeComponentProviderSafely(() -> componentProvider.newInstance(ItemProviderStrategyProvider.class));
             itemProviderStrategyProvider
                     .map(InjectedComponentProvider::get)
                     .map(ItemProviderStrategy::read)
                     .filter(Optional::isPresent)
                     .filter(v -> Node.class.isInstance(v.get()))
                     .map(Optional::get)
                     .map(Node.class::cast)
                     .ifPresent(jcrNodes::add);
         }
 
         if (jcrNodes.size() > 0) {
             compatibilityParameters.add(wrapForLegacyActionExecution(jcrNodes.iterator().next(), editorView)); //JcrNodeAdapter
             compatibilityParameters.add(jcrNodes.stream()
                     .map(node -> wrapForLegacyActionExecution(node, editorView)) //List<JcrNodeAdapter>
                     .collect(Collectors.toList())
             );
             mimicContentConnector(compatibilityParameters); //JcrContentConnector
             mimicEditor(compatibilityParameters, jcrNodes, subAppContext, editorView, invokeComponentProviderSafely(() -> componentProvider.newInstance(ValueContextProvider.class))); //EditorValidator, EditorCallback
         } else {
             selectedItems.ifPresent(o -> o.stream().findFirst().ifPresent(compatibilityParameters::add)); //single, non JCR item
         }
         super.executeAction(actionName, compatibilityParameters.toArray(new Object[0]));
     }
 
     @Override
     public <T> Predicate<AvailabilityDefinition> getAvailabilityFilter(Stream<T> selectedItems) {
         final Stream<Object> wrappedLegacyItems = selectedItems.map(this::wrapForLegacyAvailabilityChecking);
 //        wrappedLegacyItems.addAll(items); //TODO we should support a new availability, so the old one has to filter these out
         return super.getAvailabilityFilter(wrappedLegacyItems);
     }
 
     private void mimicEditor(Collection<Object> compatibilityParameters, Set<Node> jcrNodes, Optional<SubAppContext> subAppContext, Optional<EditorView> editorView, Optional<ValueContextProvider> valueContextProviderOptional) {
         editorView.ifPresent(nodeEditorView -> compatibilityParameters.add(new EditorValidator() {
             @Override
             public void showValidation(boolean visible) {
                 //validation is shown automatically in the new framework
             }
 
             @Override
             public boolean isValid() {
                 List<BinderValidationStatus<?>> validate = nodeEditorView.validate();
                 return validate.stream().allMatch(BinderValidationStatus::isOk);
             }
         }));
 
         compatibilityParameters.add(new EditorCallback() {
             @Override
             public void onCancel() {
                 subAppContext.ifPresent(subAppContext -> {
                     if (subAppContext.getSubApp() instanceof ContentDetailSubApp) { //TODO support for not implemented overlay dialogs
                         subAppContext.close();
                     }
                 });
             }
 
             @Override
             public void onSuccess(String actionName) {
                 onCancel();
             }
         });
 
         valueContextProviderOptional
                 .map(InjectedComponentProvider::get)
                 .ifPresent(context -> eventBus.addHandler(ContentChangedEvent.class, event -> context.set(jcrNodes)));
     }
 
     private void mimicContentConnector(Collection<Object> compatibilityParameters) {
         invokeComponentProviderSafely(() -> componentProvider.newInstance(JcrDatasourceDefinitionProvider.class))
                 .map(InjectedComponentProvider::get)
                 .ifPresent(datasourceDefinition -> {
                     ConfiguredJcrContentConnectorDefinition contentConnectorDefinition = new ConfiguredJcrContentConnectorDefinition();
                     contentConnectorDefinition.setWorkspace(datasourceDefinition.getWorkspace());
                     contentConnectorDefinition.setRootPath(datasourceDefinition.getRootPath());
                     contentConnectorDefinition.setNodeTypes(datasourceDefinition.getAllowedNodeTypes()
                             .stream()
                             .map(nodeType -> {
                                 ConfiguredNodeTypeDefinition nodeTypeDefinition = new ConfiguredNodeTypeDefinition();
                                 nodeTypeDefinition.setName(nodeType);
                                 return nodeTypeDefinition;
                             })
                             .collect(Collectors.toList()));
                     compatibilityParameters.add(new JcrContentConnector(componentProvider.getComponent(VersionManager.class), contentConnectorDefinition));
                 });
     }
 
     private Set<Node> findJcrNodes(Optional<Collection> selectedItems) {
         return (Set<Node>) selectedItems.map(items -> items.stream()
                 .filter(Node.class::isInstance)
                 .map(Node.class::cast)
                 .collect(Collectors.toSet()))
                 .orElse(Sets.newHashSet());
     }
 
     private Object wrapForLegacyAvailabilityChecking(Object potentialJcrItem) {
         try {
             if (potentialJcrItem instanceof Item) {
                 return JcrItemUtil.getItemId((Item) potentialJcrItem);
             } else {
                 return potentialJcrItem;
             }
         } catch (RepositoryException e) {
             throw new RuntimeException(e);
         }
     }
 
     private JcrNodeAdapter wrapForLegacyActionExecution(Object potentialJcrItem, Optional<EditorView> editorView) {
         return new JcrNodeAdapter((Node) potentialJcrItem) {
             @Override
             public Node applyChanges() throws RepositoryException {
                 editorView.ifPresent(editorView -> editorView.write(getJcrItem()));
                 return super.applyChanges();
             }
         };
     }
 
     private <C> Optional<C> invokeComponentProviderSafely(Callable<C> callable) {
         try {
             return Optional.of(callable.call());
         } catch (Exception e) {
             return Optional.empty();
         }
     }
 
     private static class ItemProviderStrategyProvider extends InjectedComponentProvider<ItemProviderStrategy<Node>> {
         @Inject
         private ItemProviderStrategyProvider(ItemProviderStrategy<Node> strategy) {
             super(strategy);
         }
     }
 
     private static class ValueContextProvider extends InjectedComponentProvider<ValueContext<Node>> {
         @Inject
         private ValueContextProvider(ValueContext<Node> valueContext) {
             super(valueContext);
         }
     }
 
     private static class JcrDatasourceDefinitionProvider extends InjectedComponentProvider<JcrDatasourceDefinition> {
         @Inject
         private JcrDatasourceDefinitionProvider(JcrDatasourceDefinition datasourceDefinition) {
             super(datasourceDefinition);
         }
     }
 
     /**
      * Some components can't be retrieved as a component, can only be injected.
      */
     private static class InjectedComponentProvider<T> implements Provider<T> {
 
         private final T component;
 
         private InjectedComponentProvider(T component) {
             this.component = component;
         }
 
         @Override
         public T get() {
             return component;
         }
     }
 }