/**
    * This file Copyright (c) 2016-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.security.app.tools.permission;
  
  import info.magnolia.cms.security.AccessDeniedException;
  import info.magnolia.cms.security.Group;
  import info.magnolia.cms.security.Permission;
  import info.magnolia.cms.security.Role;
  import info.magnolia.cms.security.SecuritySupport;
  import info.magnolia.cms.security.User;
  import info.magnolia.cms.security.auth.ACL;
  import info.magnolia.i18nsystem.SimpleTranslator;
  import info.magnolia.security.app.tools.AbstractSecurityToolPresenter;
  import info.magnolia.security.app.tools.SecurityToolView;
  import info.magnolia.ui.api.context.UiContext;
  import info.magnolia.ui.dialog.formdialog.FormBuilder;
  import info.magnolia.ui.framework.tools.FormToolActionExecutor;
  
  import java.util.Arrays;
  import java.util.Collections;
  import java.util.Iterator;
  import java.util.List;
  
  import javax.inject.Inject;
  
  import org.apache.commons.lang3.StringEscapeUtils;
  
  import com.google.common.collect.HashBasedTable;
  import com.google.common.collect.Table;
  import com.vaadin.v7.data.Container;
  import com.vaadin.v7.data.Item;
  import com.vaadin.v7.data.util.BeanItem;
  import com.vaadin.v7.data.util.HierarchicalContainer;
  
  /**
   * The security tools help verifying the system's security setup and ACLs.
   */
  public class PermissionToolPresenter extends AbstractSecurityToolPresenter {
  
      private final SecuritySupport securitySupport;
      private final SimpleTranslator i18n;
      private PermissionViewOption viewOption;
  
      @Inject
      public PermissionToolPresenter(SecurityToolView view, FormBuilder formBuilder, FormToolActionExecutor actionExecutor,
                                     UiContext uiContext, SecuritySupport securitySupport, SimpleTranslator i18n) {
          super(view, formBuilder, actionExecutor, uiContext);
          this.securitySupport = securitySupport;
          this.i18n = i18n;
      }
  
      @Override
      protected Item getItem() {
          viewOption = new PermissionViewOption();
          return new BeanItem<>(viewOption);
      }
  
      @Override
      protected Container.Hierarchical buildContainer() throws AccessDeniedException {
          container = new HierarchicalContainer();
          container.addContainerProperty(VALUE_ID, String.class, "");
  
          Iterator<String> iterGroups = Collections.emptyIterator();
          Iterator<String> iterRoles = Collections.emptyIterator();
          switch (viewOption.getType()) {
          case GROUP:
              Group group = securitySupport.getGroupManager().getGroup(viewOption.getName());
              if (group == null) {
                 return null;
             }
             iterGroups = group.getGroups().iterator();
             iterRoles = group.getRoles().iterator();
             break;
         case USER:
             User user = securitySupport.getUserManager().getUser(viewOption.getName());
             if (user == null) {
                 return null;
             }
             iterGroups = user.getGroups().iterator();
             iterRoles = user.getRoles().iterator();
             break;
         default:
             break;
         }
 
         boolean withPermissions = DumpMode.WITH_PERMISSIONS.equals(viewOption.getDumpMode());
         getGroupRole(iterGroups, withPermissions, null);
         getRole(iterRoles, withPermissions, null);
 
         // Resolve parent tree node
         for (Object itemId : container.getItemIds()) {
             container.setChildrenAllowed(itemId, container.getChildren(itemId) != null && container.getChildren(itemId).size() > 0);
         }
 
         return container;
     }
 
     @Override
     protected String getErrorMessage() {
         String errorKey = String.format("security.permissionsTab.%s.error", viewOption.getType().name().toLowerCase());
         return i18n.translate(errorKey, StringEscapeUtils.escapeHtml4(viewOption.getName()));
     }
 
     /**
      * Finding and adding subgroups to container.
      */
     private void getGroupRole(Iterator<String> iterGroup, boolean withPermissions, Object parentId) throws AccessDeniedException {
         while (iterGroup.hasNext()) {
             String groupName = iterGroup.next();
             Group group = securitySupport.getGroupManager().getGroup(groupName);
             if (group != null) {
                 Object itemId = addContainerItem(VALUE_ID, getGroupRepresentation(group.getName()), parentId);
 
                 getGroupRole(group.getGroups().iterator(), withPermissions, itemId);
                 getRole(group.getRoles().iterator(), withPermissions, itemId);
             } else {
                 addContainerItem(VALUE_ID, getGroupRepresentation(groupName), parentId);
             }
         }
     }
 
     /**
      * Finding and adding roles to container.
      */
     private void getRole(Iterator<String> iterRoles, boolean withPermissions, Object parentId) {
         while (iterRoles.hasNext()) {
             Role role = securitySupport.getRoleManager().getRole(iterRoles.next());
             Object itemId = addContainerItem(VALUE_ID, getRoleRepresentation(role), parentId);
             if (withPermissions) {
                 getPermission(role.getName(), itemId);
             }
         }
     }
 
     /**
      * Finding and adding permissions to container.
      */
     private void getPermission(String role, Object parentId) {
         Iterator<ACL> iterPermission = securitySupport.getRoleManager().getACLs(role).values().iterator();
         while (iterPermission.hasNext()) {
             ACL acl = iterPermission.next();
             for (Permission permission : acl.getList()) {
                 addContainerItem(VALUE_ID, getPermissionRepresentation(permission, acl.getName()), parentId);
             }
         }
     }
 
     private String getGroupRepresentation(String groupName) {
         return i18n.translate("security.tools.results.group", groupName);
     }
 
     private String getRoleRepresentation(Role role) {
         return i18n.translate("security.tools.results.role", role.getName());
     }
 
     private String getPermissionRepresentation(Permission permission, String repoName) {
         return i18n.translate("security.tools.results.permission", new String[] { getPermissionAsName(repoName, permission), repoName, permission.getPattern().getPatternString() });
     }
 
     /**
      * Mapping permission to name.
      */
     private String getPermissionAsName(String repoName, Permission permission) {
         String messageKeyName;
 
         if (!REPO_NAMES.contains(repoName)) {
             repoName = "";
         }
         messageKeyName = PERMISSION_MESSAGES.get(repoName, permission.getPermissions());
 
         if (messageKeyName == null) {
             return ("(" + permission.getPermissions() + ") unknown ");
         }
 
         return i18n.translate(messageKeyName);
     }
 
 
     private static final List<String> REPO_NAMES = Arrays.asList("uri", "forum");
     private static final Table<String, Long, String> PERMISSION_MESSAGES = HashBasedTable.create();
 
     static {
         PERMISSION_MESSAGES.put("uri", 0L, "roles.permission.deny");
         PERMISSION_MESSAGES.put("uri", Permission.READ, "roles.permission.get");
         PERMISSION_MESSAGES.put("uri", Permission.ALL, "roles.permission.getAndPost");
 
         PERMISSION_MESSAGES.put("forum", 0L, "roles.permission.deny");
         PERMISSION_MESSAGES.put("forum", Permission.READ, "roles.permission.readOnly");
         PERMISSION_MESSAGES.put("forum", Permission.WRITE, "roles.permission.post");
         PERMISSION_MESSAGES.put("forum", 75L, "roles.permission.moderate");
         PERMISSION_MESSAGES.put("forum", 79L, "roles.permission.moderateAndDelete");
         PERMISSION_MESSAGES.put("forum", 111L, "roles.permission.admin");
 
         PERMISSION_MESSAGES.put("", 0L, "roles.permission.deny");
         PERMISSION_MESSAGES.put("", Permission.READ, "roles.permission.readOnly");
         PERMISSION_MESSAGES.put("", Permission.ALL, "roles.permission.readWrite");
     }
 
     /**
      * Options for permission tools.
      */
     public static class PermissionViewOption extends AbstractSecurityToolPresenter.ViewOption {
         private DumpType type;
         private DumpMode dumpMode;
 
         public DumpType getType() {
             return type;
         }
 
         public void setType(DumpType type) {
             this.type = type;
         }
 
         public DumpMode getDumpMode() {
             return dumpMode;
         }
 
         public void setDumpMode(DumpMode dumpMode) {
             this.dumpMode = dumpMode;
         }
     }
 
     /**
      * Type is used to query permissions for.
      */
     public enum DumpType {
         USER, GROUP
     }
 
     /**
      * Mode of querying permissions.
      */
     public enum DumpMode {
         WITH_PERMISSIONS, WITHOUT_PERMISSIONS
     }
 
 }