/*
    * 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.services.cms.link.impl;
  
  import java.security.AccessControlException;
  import java.util.ArrayList;
  import java.util.HashMap;
  import java.util.List;
  import java.util.Map;
  
  import javax.jcr.Item;
  import javax.jcr.ItemNotFoundException;
  import javax.jcr.Node;
  import javax.jcr.NodeIterator;
  import javax.jcr.PathNotFoundException;
  import javax.jcr.RepositoryException;
  import javax.jcr.Session;
  import javax.jcr.ValueFormatException;
  import javax.jcr.query.Query;
  import javax.jcr.query.QueryManager;
  import javax.jcr.query.QueryResult;
  
  import org.exoplatform.services.cms.CmsService;
  import org.exoplatform.services.cms.impl.Utils;
  import org.exoplatform.services.cms.link.LinkManager;
  import org.exoplatform.services.cms.link.NodeLinkAware;
  import org.exoplatform.services.jcr.access.AccessControlEntry;
  import org.exoplatform.services.jcr.access.PermissionType;
  import org.exoplatform.services.jcr.core.ExtendedNode;
  import org.exoplatform.services.jcr.core.ManageableRepository;
  import org.exoplatform.services.jcr.ext.app.SessionProviderService;
  import org.exoplatform.services.jcr.ext.common.SessionProvider;
  import org.exoplatform.services.listener.ListenerService;
  import org.exoplatform.services.log.ExoLogger;
  import org.exoplatform.services.log.Log;
  import org.exoplatform.services.security.IdentityConstants;
  import org.exoplatform.services.wcm.core.NodetypeConstant;
  import org.exoplatform.services.wcm.utils.WCMCoreUtils;
  
  /**
   * Created by The eXo Platform SARL
   * Author : Ly Dinh Quang
   *          quang.ly@exoplatform.com
   * Mar 13, 2009
   */
  public class LinkManagerImpl implements LinkManager {
  
    private final static String    SYMLINK       = "exo:symlink";
  
    private final static String    WORKSPACE     = "exo:workspace";
  
    private final static String    UUID          = "exo:uuid";
  
    private final static String    PRIMARY_TYPE  = "exo:primaryType";
  
    private final static String    SYMLINK_NAME  = "exo:name";
  
    private final static String    SYMLINK_TITLE = "exo:title";
  
    private final static Log       LOG  = ExoLogger.getLogger(LinkManagerImpl.class.getName());
  
    private final SessionProviderService providerService_;
  
    public LinkManagerImpl(SessionProviderService providerService) throws Exception {
      providerService_ = providerService;
    }
  
    /**
     * {@inheritDoc}
     */
    public Node createLink(Node parent, String linkType, Node target) throws RepositoryException {
      return createLink(parent, linkType, target, null);
    }
  
    /**
     * {@inheritDoc}
     */
    public Node createLink(Node parent, Node target) throws RepositoryException {
      return createLink(parent, null, target, null);
    }
  
    /**
     * {@inheritDoc}
     */  
    public Node createLink(Node parent, String linkType, Node target, String linkName) throws RepositoryException {
     return createLink(parent, linkType, target, linkName, linkName);
   }
 
   /**
    * {@inheritDoc}
    */
   public Node createLink(Node parent, String linkType, Node target, String linkName, String linkTitle)
       throws RepositoryException {
     if (!target.isNodeType(SYMLINK)) {
       boolean targetEdited = false;
       if (target.canAddMixin("mix:referenceable")) {
         target.addMixin("mix:referenceable");
         target.getSession().save();
         targetEdited = true;
       }
       if (linkType == null || linkType.trim().length() == 0)
         linkType = SYMLINK;
       if (linkName == null || linkName.trim().length() == 0)
         linkName = target.getName();
       Node linkNode = parent.addNode(linkName, linkType);
       try {
         updateAccessPermissionToLink(linkNode, target);
       } catch(Exception e) {
         if (LOG.isErrorEnabled()) {
           LOG.error("CAN NOT UPDATE ACCESS PERMISSIONS FROM TARGET NODE TO LINK NODE", e);
         }
       }
       linkNode.setProperty(WORKSPACE, target.getSession().getWorkspace().getName());
       linkNode.setProperty(PRIMARY_TYPE, target.getPrimaryNodeType().getName());
       linkNode.setProperty(UUID, target.getUUID());
       if(linkNode.canAddMixin("exo:sortable")) {
         linkNode.addMixin("exo:sortable");
       }
       linkNode.setProperty(SYMLINK_TITLE, linkTitle);
       linkNode.setProperty(SYMLINK_NAME, linkName);
       linkNode.getSession().save();
       ListenerService listenerService = WCMCoreUtils.getService(ListenerService.class);
       try {
         String remoteUser = WCMCoreUtils.getRemoteUser();
         if (remoteUser != null) {
           if (Utils.isDocument(target) && targetEdited) {
             listenerService.broadcast(CmsService.POST_EDIT_CONTENT_EVENT, null, target);
           }
         }
       } catch (Exception e) {
         if (LOG.isErrorEnabled()) {
           LOG.error("Error while broadcasting event: " + e.getMessage());
         }
       }
       return linkNode;
     }
     return null;
   }
 
   /**
    * {@inheritDoc}
    */
   public Node getTarget(Node link, boolean system) throws ItemNotFoundException,
   RepositoryException {
     String uuid = link.getProperty(UUID).getString();
     Node targetNode = getSession(link, system).getNodeByUUID(uuid);
     return targetNode;
   }
 
   private Session getSession(Node link, boolean system) throws RepositoryException {
     String workspaceTarget = link.getProperty(WORKSPACE).getString();
     return getSession((ManageableRepository) link.getSession().getRepository(), workspaceTarget,
                       system);
   }
 
   private Session getSession(ManageableRepository manageRepository, String workspaceName,
                              boolean system) throws RepositoryException {
     if (system)
       return providerService_.getSystemSessionProvider(null).getSession(workspaceName, manageRepository);
     return providerService_.getSessionProvider(null).getSession(workspaceName, manageRepository);
   }
 
   /**
    * {@inheritDoc}
    */
   public Node getTarget(Node link) throws ItemNotFoundException, RepositoryException {
     return getTarget(link, false);
   }
 
   /**
    * {@inheritDoc}
    */
   public boolean isTargetReachable(Node link) throws RepositoryException {
     return isTargetReachable(link, false);
   }
 
   /**
    * {@inheritDoc}
    */
   public boolean isTargetReachable(Node link, boolean system) throws RepositoryException {
     Session session = null;
     try {
       session = getSession(link, system);
       session.getNodeByUUID(link.getProperty(UUID).getString());
     } catch (ItemNotFoundException e) {
       return false;
     }
     return true;
   }
 
   /**
    * {@inheritDoc}
    */
   public Node updateLink(Node linkNode, Node targetNode) throws RepositoryException {
     if (targetNode.canAddMixin("mix:referenceable")) {
       targetNode.addMixin("mix:referenceable");
       targetNode.getSession().save();
     }
     try {
       updateAccessPermissionToLink(linkNode, targetNode);
     } catch(Exception e) {
       if (LOG.isErrorEnabled()) {
         LOG.error("CAN NOT UPDATE ACCESS PERMISSIONS FROM TARGET NODE TO LINK NODE", e);
       }
     }
     linkNode.setProperty(UUID, targetNode.getUUID());
     linkNode.setProperty(PRIMARY_TYPE, targetNode.getPrimaryNodeType().getName());
     linkNode.setProperty(WORKSPACE, targetNode.getSession().getWorkspace().getName());
     linkNode.getSession().save();
     return linkNode;
   }
 
   /**
    * {@inheritDoc}
    */
   public boolean isLink(Item item) throws RepositoryException {
     if (item instanceof Node) {
       Node node = (Node) item;
       if (node instanceof NodeLinkAware) {
         node = ((NodeLinkAware) node).getRealNode();
       }
       return node.isNodeType(SYMLINK);
     }
     return false;
   }
 
   /**
    * {@inheritDoc}
    */
   public String getTargetPrimaryNodeType(Node link) throws RepositoryException {
     return link.getProperty(PRIMARY_TYPE).getString();
   }
 
   /**
    * Update the permission between two given node
    * @param linkNode    The node to update permission
    * @param targetNode  The target node to get permission
    * @throws Exception
    */
   private void updateAccessPermissionToLink(Node linkNode, Node targetNode) throws Exception {
     if(canChangePermission(linkNode)) {
       if(linkNode.canAddMixin("exo:privilegeable")) {
         linkNode.addMixin("exo:privilegeable");
         ((ExtendedNode)linkNode).setPermission(getNodeOwner(linkNode),PermissionType.ALL);
       }
       removeCurrentIdentites(linkNode);
       Map<String, String[]> perMap = new HashMap<String, String[]>();
       List<String> permsList = new ArrayList<String>();
       List<String> idList = new ArrayList<String>();
       for(AccessControlEntry accessEntry : ((ExtendedNode)targetNode).getACL().getPermissionEntries()) {
         if(!idList.contains(accessEntry.getIdentity())) {
           idList.add(accessEntry.getIdentity());
           permsList = ((ExtendedNode)targetNode).getACL().getPermissions(accessEntry.getIdentity());
           perMap.put(accessEntry.getIdentity(), permsList.toArray(new String[permsList.size()]));
         }
       }
       ((ExtendedNode)linkNode).setPermissions(perMap);
     }
   }
 
   /**
    * Remove all identity of the given node
    * @param linkNode  The node to remove all identity
    * @throws AccessControlException
    * @throws RepositoryException
    */
   private void removeCurrentIdentites(Node linkNode) throws AccessControlException, RepositoryException {
     String currentUser = linkNode.getSession().getUserID();
     if (currentUser != null)
       ((ExtendedNode)linkNode).setPermission(currentUser, PermissionType.ALL);
     for(AccessControlEntry accessEntry : ((ExtendedNode)linkNode).getACL().getPermissionEntries()) {
       if(canRemovePermission(linkNode, accessEntry.getIdentity())
           && ((ExtendedNode)linkNode).getACL().getPermissions(accessEntry.getIdentity()).size() > 0
           && !accessEntry.getIdentity().equals(currentUser)) {
         ((ExtendedNode) linkNode).removePermission(accessEntry.getIdentity());
       }
     }
   }
 
   /**
    * Remove the permission from the given node
    * @param node      The node to remove permission
    * @param identity  The identity of the permission
    * @return
    * @throws ValueFormatException
    * @throws PathNotFoundException
    * @throws RepositoryException
    */
   private boolean canRemovePermission(Node node, String identity) throws ValueFormatException,
   PathNotFoundException, RepositoryException {
     String owner = getNodeOwner(node);
     if(identity.equals(IdentityConstants.SYSTEM)) return false;
     if(owner != null && owner.equals(identity)) return false;
     return true;
   }
 
   /**
    * Get the owner of the given node
    * @param node      The node to get owner
    * @return
    * @throws ValueFormatException
    * @throws PathNotFoundException
    * @throws RepositoryException
    */
   private String getNodeOwner(Node node) throws ValueFormatException, PathNotFoundException, RepositoryException {
     if(node.hasProperty("exo:owner")) {
       return node.getProperty("exo:owner").getString();
     }
     return IdentityConstants.SYSTEM;
   }
 
   /**
    * Check permission of the given node
    * @param node      The Node to check permission
    * @return
    * @throws RepositoryException
    */
   private boolean canChangePermission(Node node) throws RepositoryException {
     try {
       ((ExtendedNode)node).checkPermission(PermissionType.CHANGE_PERMISSION);
       return true;
     } catch(AccessControlException e) {
       return false;
     }
   }
 
   /**
    * {@inheritDoc}
    */
   public List<Node> getAllLinks(Node targetNode, String linkType, SessionProvider sessionProvider) {
     try {
       List<Node> result = new ArrayList<Node>();
       ManageableRepository repository  = WCMCoreUtils.getRepository();
       String[] workspaces = repository.getWorkspaceNames();
       String queryString = new StringBuilder().append("SELECT * FROM ").
           append(linkType).
           append(" WHERE exo:uuid='").
           append(targetNode.getUUID()).append("'").
           append(" AND exo:workspace='").
           append(targetNode.getSession().getWorkspace().getName()).
           append("'").toString();
 
       for (String workspace : workspaces) {
         Session session = sessionProvider.getSession(workspace, repository);
         //Continue In the case cannot access to a workspace
         if(session == null) continue;
         QueryManager queryManager = session.getWorkspace().getQueryManager();
         Query query = queryManager.createQuery(queryString, Query.SQL);
         QueryResult queryResult = query.execute();
         NodeIterator iter = queryResult.getNodes();
         while (iter.hasNext()) {
           result.add(iter.nextNode());
         }
       }
 
       return result;
     } catch (RepositoryException e) {
       // return empty node list if there are errors in execution or user has no right to access nodes
       return new ArrayList<Node>();
     }
   }
 
   /**
    * {@inheritDoc}
    */
   public List<Node> getAllLinks(Node targetNode, String linkType) {
     return getAllLinks(targetNode, linkType, WCMCoreUtils.getUserSessionProvider());
   }
 
   /**
    * {@inheritDoc}
    * @throws RepositoryException 
    */
   public void updateSymlink(Node node) throws RepositoryException {
     if (node.isNodeType(NodetypeConstant.EXO_SYMLINK)) {
       try {
         ((ExtendedNode)node).checkPermission(PermissionType.SET_PROPERTY);
       } catch(AccessControlException e) {
         SessionProvider provider = WCMCoreUtils.getSystemSessionProvider();
         node = (Node)provider.getSession(node.getSession().getWorkspace().getName(), 
                                          WCMCoreUtils.getRepository()).getItem(node.getPath());
       }
       if (node.canAddMixin(NodetypeConstant.EXO_TARGET_DATA)) {
         node.addMixin(NodetypeConstant.EXO_TARGET_DATA);
       }
       Node target = this.getTarget(node, true);
       if (!node.hasProperty(NodetypeConstant.EXO_LAST_MODIFIED_DATE) || 
           node.getProperty(NodetypeConstant.EXO_LAST_MODIFIED_DATE).getDate().compareTo( 
           target.getProperty(NodetypeConstant.EXO_LAST_MODIFIED_DATE).getDate()) < 0) {
         String[] propList = {NodetypeConstant.EXO_DATE_CREATED,
             NodetypeConstant.EXO_LAST_MODIFIED_DATE, NodetypeConstant.PUBLICATION_LIVE_DATE,
             NodetypeConstant.EXO_START_EVENT, NodetypeConstant.EXO_INDEX};
         for (String p : propList) {
           try {
             if (target.hasProperty(p)) {
               node.setProperty(p, target.getProperty(p).getValue());
               node.save();
             }
           } catch (RepositoryException e) {
             if (LOG.isErrorEnabled()) {
               LOG.error("Can not update property: " + p + " for node: " + node.getPath(), e);
             }
           }
         }
     }
     }
   }
 
 }