/*
    * Copyright (C) 2003-2007 eXo Platform SAS.
    *
    * This program is free software; you can redistribute it and/or
    * modify it under the terms of the GNU Affero General Public License
    * as published by the Free Software Foundation; either version 3
    * of the License, or (at your option) any later version.
    *
    * This program is distributed in the hope that it will be useful,
   * but WITHOUT ANY WARRANTY; without even the implied warranty of
   * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   * GNU General Public License for more details.
   *
   * You should have received a copy of the GNU General Public License
   * along with this program; if not, see<http://www.gnu.org/licenses/>.
   */
  package org.exoplatform.ecm.webui.component.explorer;
  
  import java.util.ArrayList;
  import java.util.Collections;
  import java.util.HashMap;
  import java.util.List;
  import java.util.Map;
  import java.util.regex.Pattern;
  
  import javax.jcr.ItemNotFoundException;
  import javax.jcr.Node;
  import javax.jcr.PathNotFoundException;
  import javax.jcr.RepositoryException;
  import javax.jcr.Session;
  import javax.jcr.Value;
  
  import org.apache.commons.lang.StringUtils;
  import org.exoplatform.ecm.webui.component.explorer.control.UIActionBar;
  import org.exoplatform.ecm.webui.component.explorer.popup.actions.UIDocumentFormController;
  import org.exoplatform.ecm.webui.component.explorer.popup.actions.UISelectDocumentForm;
  import org.exoplatform.ecm.webui.component.explorer.rightclick.manager.RestoreFromTrashManageComponent;
  import org.exoplatform.ecm.webui.component.explorer.sidebar.UISideBar;
  import org.exoplatform.ecm.webui.component.explorer.sidebar.UITreeExplorer;
  import org.exoplatform.ecm.webui.utils.Utils;
  import org.exoplatform.services.cms.actions.ActionServiceContainer;
  import org.exoplatform.services.cms.link.NodeFinder;
  import org.exoplatform.services.cms.link.NodeLinkAware;
  import org.exoplatform.services.jcr.RepositoryService;
  import org.exoplatform.services.jcr.core.ManageableRepository;
  import org.exoplatform.services.log.ExoLogger;
  import org.exoplatform.services.log.Log;
  import org.exoplatform.services.security.Identity;
  import org.exoplatform.services.security.IdentityConstants;
  import org.exoplatform.services.security.IdentityRegistry;
  import org.exoplatform.services.security.MembershipEntry;
  import org.exoplatform.services.wcm.utils.WCMCoreUtils;
  import org.exoplatform.webui.application.WebuiRequestContext;
  import org.exoplatform.webui.config.annotation.ComponentConfig;
  import org.exoplatform.webui.config.annotation.ComponentConfigs;
  import org.exoplatform.webui.config.annotation.EventConfig;
  import org.exoplatform.webui.core.UIApplication;
  import org.exoplatform.webui.core.UIComponent;
  import org.exoplatform.webui.core.UIContainer;
  import org.exoplatform.webui.core.UIRightClickPopupMenu;
  import org.exoplatform.webui.event.Event;
  import org.exoplatform.webui.event.EventListener;
  import org.exoplatform.webui.ext.UIExtension;
  import org.exoplatform.webui.ext.UIExtensionManager;
  import org.exoplatform.webui.ext.manager.UIAbstractManagerComponent;
  
  
  /**
   * Created by The eXo Platform SARL Author : Tran The Trong trongtt@gmail.com
   * July 3, 2006 10:07:15 AM
   */
  @ComponentConfigs( {
    @ComponentConfig(template = "app:/groovy/webui/component/explorer/UIWorkingArea.gtmpl",
        events = {@EventConfig(listeners = UIWorkingArea.RefreshActionListener.class)}),
        @ComponentConfig(
                         type = UIRightClickPopupMenu.class,
                         id = "ECMContextMenu",
                         template = "app:/groovy/webui/component/explorer/UIRightClickPopupMenu.gtmpl"
            )
  })
  public class UIWorkingArea extends UIContainer {
  
    /**
     * Logger.
     */
    private static final Log                 LOG                      = ExoLogger.getLogger(UIWorkingArea.class.getName());
  
    public static final Pattern              FILE_EXPLORER_URL_SYNTAX = Pattern.compile("([^:/]+):(/.*)");
  
    public static final String               WS_NAME                  = "workspaceName";
  
    public static final String               EXTENSION_TYPE           = "org.exoplatform.ecm.dms.UIWorkingArea";
  
    public static final String               ITEM_CONTEXT_MENU        = "ItemContextMenu";
  
    public static final String               MULTI_ITEM_CONTEXT_MENU  = "MultiItemContextMenu";
  
    public static final String               GROUND_CONTEXT_MENU      = "GroundContextMenu";
  
   public static final String               ITEM_GROUND_CONTEXT_MENU = "ItemGroundContextMenu";
 
   public static final String               MOVE_NODE                = "MoveNode";
 
   public static final String               CREATE_LINK              = "CreateLink";
 
   public static final String               CUSTOM_ACTIONS           = "CustomActions";
 
   public static final String               PERMLINK                 = "PermlinkContextMenu";
   public static final String               PERM_LINK_ACTION         = "Permlink";
 
   private String nodePathDelete = "";
   private String deleteNotice = "";
   private String wcmNotice = "";
 
   public void setNodePathDelete(String nodePathDelete) {
     this.nodePathDelete = nodePathDelete;
   }
 
   public String getNodePathDelete() {
     return nodePathDelete;
   }
 
   public String getWCMNotice() {
     return wcmNotice;
   }
 
   public void setWCMNotice(String wcmNotice) {
     this.wcmNotice = wcmNotice;
   }
 
   public void setDeleteNotice(String deleteNotice) {
     this.deleteNotice = deleteNotice;
   }
 
   public String getDeleteNotice() {
     return this.deleteNotice;
   }
 
   public static final String               REFRESH_ACTION           = "Refresh";
 
   public static final String               RENAME_ACTION           = "Rename";
 
 
   private List<UIAbstractManagerComponent> managers                 =
       Collections.synchronizedList(new ArrayList<UIAbstractManagerComponent>());
 
   public UIWorkingArea() throws Exception {
     addChild(UIRightClickPopupMenu.class, "ECMContextMenu", null);
     addChild(UISideBar.class, null, null);
     addChild(UIActionBar.class, null, null) ;
     addChild(UISelectDocumentTemplateTitle.class, null, null);
     addChild(UIDocumentWorkspace.class, null, null);
     addChild(UIDrivesArea.class, null, null).setRendered(false);
   }
 
   private List<UIExtension> getUIExtensionList() {
     UIExtensionManager manager = getApplicationComponent(UIExtensionManager.class);
     return manager.getUIExtensions(EXTENSION_TYPE);
   }
 
   public synchronized UITreeExplorer getTreeExplorer() {
     UISideBar uiSideBar = getChild(UISideBar.class);
     return uiSideBar.getChild(UITreeExplorer.class);
   }
 
   public void initialize() throws Exception {
     List<UIExtension> extensions = getUIExtensionList();
     if (extensions == null) {
       return;
     }
     managers.clear();
     for (UIExtension extension : extensions) {
       UIComponent component = addUIExtension(extension, null);
       if (component !=null && !managers.contains(component))
         managers.add((UIAbstractManagerComponent)component);
     }
   }
 
   private UIComponent addUIExtension(UIExtension extension, Map<String, Object> context) throws Exception {
     UIExtensionManager manager = getApplicationComponent(UIExtensionManager.class);
     UIComponent component = manager.addUIExtension(extension, context, this);
     if(component == null) return null;
     synchronized(component) {
       if (component instanceof UIAbstractManagerComponent) {
         // You can access to the given extension and the extension is valid
         UIAbstractManagerComponent uiAbstractManagerComponent = (UIAbstractManagerComponent) component;
         uiAbstractManagerComponent.setUIExtensionName(extension.getName());
         uiAbstractManagerComponent.setUIExtensionCategory(extension.getCategory());
         return component;
       } else if (component != null) {
         // You can access to the given extension but the extension is not valid
         if (LOG.isWarnEnabled()) {
           LOG.warn("All the extension '" + extension.getName() + "' of type '" + EXTENSION_TYPE
                    + "' must be associated to a component of type " + UIAbstractManagerComponent.class);
         }
         removeChild(component.getClass());
       }
     }
     return null;
   }
 
   public RestoreFromTrashManageComponent getThrashManageComponent(){
     for(UIAbstractManagerComponent c : getManagers()){
       if(c instanceof RestoreFromTrashManageComponent){
         return (RestoreFromTrashManageComponent)c;
       }
     }
     return null;
   }
   public List<UIAbstractManagerComponent> getManagers() {
     List<UIAbstractManagerComponent> managers = new ArrayList<UIAbstractManagerComponent>();
     managers.addAll(this.managers);
     return managers;
   }
 
   public void unregister(UIAbstractManagerComponent component) {
     managers.remove(component);
   }
 
   //Should use this method to check for when execute Actions in Working Area instead in UIEditingTagsForm (line 120)
   public boolean isShowSideBar() throws Exception {
     UIJCRExplorer jcrExplorer = getParent();
     return jcrExplorer.getPreference().isShowSideBar() && getAncestorOfType(UIJCRExplorerPortlet.class).isShowSideBar();
   }
 
   public void setShowSideBar(boolean b) throws Exception {
     UIJCRExplorer jcrExplorer = getParent();
     jcrExplorer.getPreference().setShowSideBar(b);
   }
 
   public Node getNodeByUUID(String uuid) throws Exception {
     ManageableRepository repo = getApplicationComponent(RepositoryService.class).getCurrentRepository();
     String workspace = repo.getConfiguration().getDefaultWorkspaceName();
     return getNodeByUUID(uuid, workspace);
   }
 
   public Node getNodeByUUID(String uuid, String workspaceName) throws Exception {
     ManageableRepository repo = getApplicationComponent(RepositoryService.class).getCurrentRepository();
     Session session = WCMCoreUtils.getSystemSessionProvider().getSession(workspaceName, repo);
     return session.getNodeByUUID(uuid);
   }
 
   public boolean isPreferenceNode(Node node) {
     return getAncestorOfType(UIJCRExplorer.class).isPreferenceNode(node);
   }
 
   public String getVersionNumber(Node node) throws RepositoryException {
     if (!Utils.isVersionable(node))
       return "-";
     return node.getBaseVersion().getName();
   }
 
   public boolean isJcrViewEnable() throws Exception {
     UIJCRExplorer uiExplorer = getAncestorOfType(UIJCRExplorer.class);
     return uiExplorer.getPreference().isJcrEnable();
   }
 
   private Map<String, Object> createContext(Node currentNode) throws Exception {
     Map<String, Object> context = new HashMap<String, Object>();
     WebuiRequestContext requestContext =  WebuiRequestContext.getCurrentInstance() ;
     UIJCRExplorer uiExplorer = getAncestorOfType(UIJCRExplorer.class);
     UIApplication uiApp = getAncestorOfType(UIApplication.class);
     context.put(Node.class.getName(), currentNode);
     context.put(UIWorkingArea.class.getName(), this);
     context.put(UIApplication.class.getName(), uiApp);
     context.put(UIJCRExplorer.class.getName(), uiExplorer);
     context.put(WebuiRequestContext.class.getName(), requestContext);
     return context;
   }
 
   List<UIComponent> getGroundActionsExtensionList() throws Exception {
     List<UIComponent> uiGroundActionList = new ArrayList<UIComponent>();
     List<UIExtension> uiExtensionList = getUIExtensionList();
     UIJCRExplorer uiExplorer = getAncestorOfType(UIJCRExplorer.class);
     Node currentNode = uiExplorer.getCurrentNode();
     UIComponent uiAddedActionManage;
     for (UIExtension uiextension : uiExtensionList) {
       if (GROUND_CONTEXT_MENU.equals(uiextension.getCategory())
           || ITEM_GROUND_CONTEXT_MENU.equals(uiextension.getCategory())) {
         uiAddedActionManage = addUIExtension(uiextension, createContext(currentNode));
         if (uiAddedActionManage != null) {
           if (!uiGroundActionList.contains(uiAddedActionManage))
             uiGroundActionList.add(uiAddedActionManage);
         }
       }
     }
     return uiGroundActionList;
   }
 
   List<UIComponent> getMultiActionsExtensionList() throws Exception {
     List<UIComponent> uiActionList = new ArrayList<UIComponent>();
     List<UIExtension> uiExtensionList = getUIExtensionList();
     UIComponent uiAddedActionManage;
     for (UIExtension uiextension : uiExtensionList) {
       if (ITEM_CONTEXT_MENU.equals(uiextension.getCategory())
           || ITEM_GROUND_CONTEXT_MENU.equals(uiextension.getCategory())
           || MULTI_ITEM_CONTEXT_MENU.equals(uiextension.getCategory())) {
         uiAddedActionManage = addUIExtension(uiextension, null);
         if (uiAddedActionManage != null) {
           if (!uiActionList.contains(uiAddedActionManage))
             uiActionList.add(uiAddedActionManage);
         }
       }
     }
     return uiActionList;
   }
 
   public String getActionsExtensionList(Node node) throws Exception {
     StringBuffer actionsList = new StringBuffer(1024);
     List<UIExtension> uiExtensionList = getUIExtensionList();
     UIComponent uiAddedActionManage;
     try {
       NodeFinder nodeFinder = getApplicationComponent(NodeFinder.class);
       nodeFinder.getItem(getAncestorOfType(UIJCRExplorer.class).getSession(), node.getPath());
     } catch(PathNotFoundException pne) {
       return "";
     }
     for (UIExtension uiextension : uiExtensionList) {
       if (uiextension.getCategory().startsWith(ITEM_CONTEXT_MENU)
           || ITEM_GROUND_CONTEXT_MENU.equals(uiextension.getCategory())) {
         uiAddedActionManage = addUIExtension(uiextension, createContext(node));
         if (uiAddedActionManage != null) {
           actionsList.append(uiextension.getName()).append(",");
         }
       }
     }
     if (actionsList.length() > 0) {
       return actionsList.substring(0, actionsList.length() - 1);
     }
     return actionsList.toString();
   }
 
   public UIComponent getJCRMoveAction() throws Exception {
     UIExtensionManager manager = getApplicationComponent(UIExtensionManager.class);
     UIExtension extension = manager.getUIExtension(EXTENSION_TYPE, MOVE_NODE);
     return addUIExtension(extension, null);
   }
 
   public UIComponent getCreateLinkAction() throws Exception {
     UIExtensionManager manager = getApplicationComponent(UIExtensionManager.class);
     UIExtension extension = manager.getUIExtension(EXTENSION_TYPE, CREATE_LINK);
     return addUIExtension(extension, null);
   }
 
   public UIComponent getPermlink(Node node) throws Exception {
     UIComponent uicomponent = null;
     List<UIExtension> uiExtensionList = getUIExtensionList();
     for (UIExtension uiextension : uiExtensionList) {
       if (PERMLINK.equals(uiextension.getCategory())) {
         uicomponent = addUIExtension(uiextension, createContext(node));
       }
     }
     return uicomponent;
   }
 
   public UIComponent getCustomAction() throws Exception {
     UIComponent uicomponent = null;
     List<UIExtension> uiExtensionList = getUIExtensionList();
     for (UIExtension uiextension : uiExtensionList) {
       if (CUSTOM_ACTIONS.equals(uiextension.getCategory())) {
         uicomponent = addUIExtension(uiextension, null);
       }
     }
     return uicomponent;
   }
 
   private boolean hasPermission(String userName, Value[] roles) throws Exception {
     IdentityRegistry identityRegistry = getApplicationComponent(IdentityRegistry.class);
     if (IdentityConstants.SYSTEM.equalsIgnoreCase(userName)) {
       return true;
     }
     Identity identity = identityRegistry.getIdentity(userName);
     if (identity == null) {
       return false;
     }
     for (int i = 0; i < roles.length; i++) {
       String role = roles[i].getString();
       if ("*".equalsIgnoreCase(role))
         return true;
       MembershipEntry membershipEntry = MembershipEntry.parse(role);
       if (membershipEntry == null)
         return false;
       if (identity.isMemberOf(membershipEntry)) {
         return true;
       }
     }
     return false;
   }
 
   public List<Node> getCustomActions(Node node) throws Exception {
     if (node instanceof NodeLinkAware) {
       NodeLinkAware nodeLA = (NodeLinkAware) node;
       try {
         node = nodeLA.getTargetNode().getRealNode();
       } catch (Exception e) {
         // The target of the link is not reachable
       }
     }
     List<Node> safeActions = new ArrayList<Node>();
     WebuiRequestContext context = WebuiRequestContext.getCurrentInstance();
     String userName = context.getRemoteUser();
     ActionServiceContainer actionContainer = getApplicationComponent(ActionServiceContainer.class);
     List<Node> unsafeActions = actionContainer.getCustomActionsNode(node, "read");
     if (unsafeActions == null)
       return new ArrayList<Node>();
     for (Node actionNode : unsafeActions) {
       Value[] roles = actionNode.getProperty(Utils.EXO_ROLES).getValues();
       if (hasPermission(userName, roles))
         safeActions.add(actionNode);
     }
     return safeActions;
   }
 
   /**
    * Gets the title.
    *
    * @param node the node
    *
    * @return the title
    *
    * @throws Exception the exception
    */
   public String getTitle(Node node) throws Exception {
     return Utils.getTitle(node);
   }
 
   public void processRender(WebuiRequestContext context) throws Exception {
     UIJCRExplorerPortlet uiPortlet = getAncestorOfType(UIJCRExplorerPortlet.class);
     UIActionBar uiActionBar = findFirstComponentOfType(UIActionBar.class);
     uiActionBar.setRendered(uiPortlet.isShowActionBar());
     UISelectDocumentTemplateTitle uiTemplateTitle = findFirstComponentOfType(UISelectDocumentTemplateTitle.class);
     boolean isUITemplateTitleRendered = isUISelectDocumentTemplateTitleRendered();
     uiTemplateTitle.setRendered(isUITemplateTitleRendered);
     if(!context.useAjax()) {
       if (isShowSideBar()) {
         UITreeExplorer uiTreeExplorer = this.findFirstComponentOfType(UITreeExplorer.class);
         if (uiTreeExplorer != null) uiTreeExplorer.buildTree();
       }
     }
     super.processRender(context);
   }
 
   public boolean isUISelectDocumentTemplateTitleRendered()  {
     UIDocumentFormController uiDocumentController = findFirstComponentOfType(UIDocumentFormController.class);
     boolean isUITemplateTitleRendered = 
         (uiDocumentController != null
         && uiDocumentController.isRendered()
         && uiDocumentController.getChild(UISelectDocumentForm.class).isRendered());
     return isUITemplateTitleRendered;
   }
 
   /**
    * Refresh UIWorkingArea after renaming.UIPresentationContainer
    */
   public static class RefreshActionListener extends EventListener<UIWorkingArea> {
     public void execute(Event<UIWorkingArea> event) throws Exception {
       UIJCRExplorer uiExplorer = event.getSource().getAncestorOfType(UIJCRExplorer.class);
 
       // Get path before renaming
       String pathBeforeRename = event.getRequestContext().getRequestParameter("oldPath");
 
       // Get path after renaming
       String renamedNodeUUID = event.getRequestContext().getRequestParameter("uuid");
       String pathAfterRename = null;
       Node renamedNode = null;
       try {
         renamedNode = uiExplorer.getSession().getNodeByUUID(renamedNodeUUID);
       } catch (ItemNotFoundException e) {
         // Try to find node in other workspaces
         String[] workspaceNames = uiExplorer.getRepository().getWorkspaceNames();
         String currentWorkSpaceName = uiExplorer.getWorkspaceName();
         for (String workspaceName : workspaceNames) {
           if (!workspaceName.equals(currentWorkSpaceName)) {
             try {
               renamedNode = uiExplorer.getSessionByWorkspace(workspaceName).getNodeByUUID(renamedNodeUUID);
               break;
             } catch (ItemNotFoundException infE) {
               renamedNode = null;
             }
           }
         }
       }
       if (renamedNode != null) {
         pathAfterRename = renamedNode.getPath();
       } else {
         LOG.warn("Can not find renamed node with old path: [%s]", pathBeforeRename);
         return;
       }
 
       // Update content explorer
       String currentPath = uiExplorer.getCurrentPath();
       if (currentPath.equals(pathBeforeRename)) {
         uiExplorer.setCurrentPath(pathAfterRename) ;
       } else if(currentPath.startsWith(pathBeforeRename)) {
         uiExplorer.setCurrentPath(pathAfterRename + currentPath.replace(pathBeforeRename, StringUtils.EMPTY));
       }
       uiExplorer.updateAjax(event);
     }
   }
 }