/**
    * This file Copyright (c) 2015 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.resources.app.action;
  
  import info.magnolia.commands.CommandsManager;
  import info.magnolia.context.Context;
  import info.magnolia.event.EventBus;
  import info.magnolia.i18nsystem.SimpleTranslator;
  import info.magnolia.jcr.util.NodeTypes;
  import info.magnolia.jcr.util.NodeUtil;
  import info.magnolia.resources.app.utils.ResourceUtils;
  import info.magnolia.resources.app.workbench.ResourcesContainer;
  import info.magnolia.ui.api.app.SubAppContext;
  import info.magnolia.ui.api.event.AdmincentralEventBus;
  import info.magnolia.ui.api.event.ContentChangedEvent;
  import info.magnolia.ui.framework.action.ActivationAction;
  import info.magnolia.ui.vaadin.integration.jcr.JcrItemAdapter;
  import info.magnolia.ui.vaadin.integration.jcr.JcrNodeAdapter;
  
  import java.util.Collections;
  import java.util.Comparator;
  import java.util.List;
  
  import javax.inject.Named;
  import javax.jcr.Node;
  import javax.jcr.RepositoryException;
  
  import org.apache.commons.lang3.StringUtils;
  import org.slf4j.Logger;
  import org.slf4j.LoggerFactory;
  
  import com.google.common.collect.Lists;
  import com.google.common.collect.Ordering;
  import com.vaadin.data.Item;
  
  /**
   * UI action that allows to publish/un-publish a resource in resources app.
   * <p>
   * All the ancestor nodes have to be activated before the activation of a given node.
   * Thus, initially this class activates ancestors of a given node.
   * <p>
   * Given item expected to have {@code ResourcesContainer#RESOURCES_WORKSPACE} property set.
   */
  public class ResourceActivationAction extends ActivationAction<ResourceActivationActionDefinition> {
  
      private static final Logger log = LoggerFactory.getLogger(ResourceActivationAction.class);
  
      private final List<Item> resourceItems;
      private final ResourceActivationActionDefinition definition;
      private final EventBus eventBus;
      private final Context context;
      private String closestAffectedAncestor;
  
      public ResourceActivationAction(ResourceActivationActionDefinition definition, Item item, CommandsManager commandsManager, @Named(AdmincentralEventBus.NAME) EventBus eventBus, SubAppContext uiContext, SimpleTranslator i18n, Context context) {
          this(definition, Lists.newArrayList(item), commandsManager, eventBus, uiContext, i18n, context);
      }
  
      public ResourceActivationAction(ResourceActivationActionDefinition definition, List<Item> items, CommandsManager commandsManager, @Named(AdmincentralEventBus.NAME) EventBus eventBus, SubAppContext uiContext, SimpleTranslator i18n, Context context) {
          super(definition, Collections.EMPTY_LIST, commandsManager, eventBus, uiContext, i18n);
          this.definition = definition;
          this.resourceItems = items;
          this.eventBus = eventBus;
          this.context = context;
          this.closestAffectedAncestor = StringUtils.EMPTY;
      }
  
      @Override
      protected Comparator<JcrItemAdapter> getItemComparator() {
         return new Comparator<JcrItemAdapter>() {
             @Override
             public int compare(JcrItemAdapter o1, JcrItemAdapter o2) {
                 try {
                     if (getDefinition().isDeletionActivation()) {
                         return o2.getJcrItem().getDepth() - o1.getJcrItem().getDepth();
                     }
                     return o1.getJcrItem().getDepth() - o2.getJcrItem().getDepth();
                 } catch (RepositoryException e) {
                     return 0;
                 }
             }
         };
     }
 
     @Override
     protected List<JcrItemAdapter> getItems() {
         final List<JcrItemAdapter> allItems = Lists.newLinkedList();
 
         for (Item resourceItem : resourceItems) {
             allItems.addAll(resolveJcrItemsToPublish(resourceItem));
         }
 
         this.closestAffectedAncestor = resolveClosestAffectedAncestor(allItems);
         return allItems;
     }
 
     private String resolveClosestAffectedAncestor(List<JcrItemAdapter> resourcePaths) {
         String commonPath = "";
         String[][] directories = new String[resourcePaths.size()][];
 
         for (int i = 0; i < resourcePaths.size(); i++) {
             try {
                 directories[i] = resourcePaths.get(i).getJcrItem().getPath().split("/");
             } catch (RepositoryException e) {
                 log.error("JcrItem is not being found", e);
             }
         }
 
         for (int j = 0; j < directories[0].length; j++) {
             String nextDirectory = directories[0][j];
             for (int i = 1; i < resourcePaths.size(); i++) {
                 if (!nextDirectory.equals(directories[i][j])) {
                     // starting from here, path is not common anymore, hence, we return the closestAffectedAncestor.
                     return commonPath;
                 }
             }
             commonPath += nextDirectory + "/";
         }
         return commonPath;
     }
 
     private List<JcrItemAdapter> resolveJcrItemsToPublish(Item resourceItem) {
         JcrNodeAdapter jcrItemAdapter = ResourceUtils.getJcrNodeAdapterFor(context, resourceItem);
 
         List<JcrItemAdapter> items = Lists.newLinkedList();
         try {
             if (!StringUtils.equals(definition.getCommand(), "deactivate") || !definition.isRecursive()) {
                 int depth = jcrItemAdapter.getJcrItem().getDepth();
                 for (int i = 1; i < depth + 1; i++) {
                     Node ancestor = (Node) jcrItemAdapter.getJcrItem().getAncestor(i);
                     if (!definition.isDeletionActivation() && isNodeNotActivated(ancestor)) {
                         items.add(new JcrNodeAdapter(ancestor));
                     } else if (definition.isDeletionActivation() && isNodeDeleted(ancestor)) {
                         items.add(new JcrNodeAdapter(ancestor));
                     }
                 }
             }
         } catch (RepositoryException e) {
             log.error("Resource cannot be resolved", e);
         }
 
         // This block used for simple activation operation, as well as recursive activation and deactivate requests.
         if (items.isEmpty()) {
             items.add(new JcrNodeAdapter(jcrItemAdapter.getJcrItem()));
         }
 
         return items;
     }
 
     /**
      * Returns {@code true}, If node is deleted.
      */
     private boolean isNodeDeleted(Node ancestor) {
         try {
             return NodeUtil.hasMixin(ancestor, NodeTypes.Deleted.NAME);
         } catch (RepositoryException e) {
             log.error("Node is not being found.", e);
             return false;
         }
     }
 
     /**
      * Returns {@code true}, If node is not activated.
      */
     private boolean isNodeNotActivated(Node node) {
         try {
             return !NodeTypes.Activatable.isActivated(node);
         } catch (RepositoryException e) {
             log.error("Node is not being found.", e);
             return false;
         }
     }
 
     @Override
     protected List<JcrItemAdapter> getSortedItems(Comparator<JcrItemAdapter> comparator) {
         return Ordering.from(comparator).sortedCopy(getItems());
     }
 
     // Refreshing the resources container after activation action.
     // Since this action might activate deletion as well, thus, in that case we should be activating the parent node for reflecting changes to UI.
     @Override
     protected void onPostExecute() throws Exception {
         super.onPostExecute();
 
         String sanitizedPath;
         // If the given path is not root path ,then, we should be sanitizing it.
         if (StringUtils.equals(closestAffectedAncestor, ResourcesContainer.ROOT_DIRECTORY)) {
             sanitizedPath = closestAffectedAncestor;
         } else if (definition.isDeletionActivation()) {
             String removedLastSlash = StringUtils.removeEnd(closestAffectedAncestor, "/");
             sanitizedPath = StringUtils.substringBeforeLast(removedLastSlash, "/");
             if (StringUtils.equals(sanitizedPath, "")) {
                 sanitizedPath = ResourcesContainer.ROOT_DIRECTORY;
             }
         } else {
             sanitizedPath = StringUtils.removeEnd(closestAffectedAncestor, "/");
         }
 
         eventBus.fireEvent(new ContentChangedEvent(sanitizedPath));
     }
 }