/*
    * Copyright (C) 2003-2008 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.wcm.extensions.publication;
  
  import java.util.ArrayList;
  import java.util.HashMap;
  import java.util.List;
  import java.util.TreeSet;
  
  import javax.jcr.Node;
  import javax.jcr.lock.Lock;
  
  import org.apache.commons.lang.StringUtils;
  import org.exoplatform.container.xml.InitParams;
  import org.exoplatform.ecm.utils.lock.LockUtil;
  import org.exoplatform.ecm.webui.utils.Utils;
  import org.exoplatform.services.ecm.publication.PublicationPlugin;
  import org.exoplatform.services.ecm.publication.PublicationService;
  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.IdentityRegistry;
  import org.exoplatform.services.wcm.core.NodeLocation;
  import org.exoplatform.services.wcm.core.NodetypeConstant;
  import org.exoplatform.services.wcm.extensions.publication.context.impl.ContextConfig.Context;
  import org.exoplatform.services.wcm.extensions.publication.impl.PublicationManagerImpl;
  import org.exoplatform.services.wcm.extensions.publication.lifecycle.authoring.AuthoringPublicationConstant;
  import org.exoplatform.services.wcm.extensions.publication.lifecycle.impl.LifecyclesConfig.Lifecycle;
  import org.exoplatform.services.wcm.extensions.publication.lifecycle.impl.LifecyclesConfig.State;
  import org.exoplatform.services.wcm.extensions.utils.ContextComparator;
  import org.exoplatform.services.wcm.publication.WebpagePublicationPlugin;
  import org.exoplatform.services.wcm.utils.WCMCoreUtils;
  
  public class WCMPublicationServiceImpl
                                        extends
                                        org.exoplatform.services.wcm.publication.WCMPublicationServiceImpl {
  
    private static final Log LOG = ExoLogger.getLogger(WCMPublicationServiceImpl.class.getName());
    
    private String publicationLocation = "collaboration:/";
    
    private String[] notAllowChildNodeEnrollInPubliction = new String[] { NodetypeConstant.EXO_WEBCONTENT };
  
    /**
     * Instantiates a new WCM publication service. This service delegate to
     * PublicationService to manage the publication
     */
    public WCMPublicationServiceImpl(InitParams initParams) {
      super();
      this.publicationService = WCMCoreUtils.getService(PublicationService.class);
      if(initParams.getValueParam("publicationLocation") != null) {
        publicationLocation = initParams.getValueParam("publicationLocation").getValue();
      }
      if(initParams.getValueParam("notAllowChildNodeEnrollInPubliction") != null) {
        if(initParams.getValueParam("notAllowChildNodeEnrollInPubliction").getValue().indexOf(";") > -1) {
          notAllowChildNodeEnrollInPubliction = 
                  initParams.getValueParam("notAllowChildNodeEnrollInPubliction").getValue().split(";");
        }
        
      }
    }
  
    /**
     * This default implementation uses "States and versions based publication" as
     * a default lifecycle for all sites and "Simple Publishing" for the root
     * user.
     */
    public void enrollNodeInLifecycle(Node node, String siteName, String remoteUser) {
      try {
        if (LOG.isInfoEnabled()) LOG.info(node.getPath() + "::" + siteName + "::"+remoteUser);
  
        PublicationManagerImpl publicationManagerImpl = WCMCoreUtils.getService(PublicationManagerImpl.class);
  
        ContextComparator comparator = new ContextComparator();
        TreeSet<Context> treeSetContext = new TreeSet<Context>(comparator);
        treeSetContext.addAll(publicationManagerImpl.getContexts());
        for (Context context : treeSetContext) {
          boolean pathVerified = true;
          boolean nodetypeVerified = true;
          boolean siteVerified = true;
          boolean membershipVerified = true;
          String path = context.getPath();
          String nodetype = context.getNodetype();
          String site = context.getSite();
         List<String> memberships = new ArrayList<String>();
         if (context.getMembership() != null) {
           memberships.add(context.getMembership());
         }
         if (context.getMemberships() != null) {
           memberships.addAll(context.getMemberships());
         }
         if (path != null) {
           String workspace = node.getSession().getWorkspace().getName();
           ManageableRepository manaRepository = (ManageableRepository) node.getSession()
                                                                            .getRepository();
           String repository = manaRepository.getConfiguration().getName();
           String[] pathTab = path.split(":");
           pathVerified = node.getPath().contains(pathTab[2]) && (repository.equals(pathTab[0]))
               && (workspace.equals(pathTab[1]));
         }
         if (nodetype != null)
           nodetypeVerified = nodetype.equals(node.getPrimaryNodeType().getName());
         if (site != null)
           siteVerified = site.equals(siteName);
         if (memberships.size() > 0) {
           for (String membership : memberships) {
             String[] membershipTab = membership.split(":");
             IdentityRegistry identityRegistry = WCMCoreUtils.getService(IdentityRegistry.class);
             Identity identity = identityRegistry.getIdentity(remoteUser);
             membershipVerified = identity.isMemberOf(membershipTab[1], membershipTab[0]);
             if (membershipVerified)
               break;
           }
         }
         if (pathVerified && nodetypeVerified && siteVerified && membershipVerified) {
           Lifecycle lifecycle = publicationManagerImpl.getLifecycle(context.getLifecycle());
           String lifecycleName = this.getWebpagePublicationPlugins()
                                      .get(lifecycle.getPublicationPlugin())
                                      .getLifecycleName();
           if (node.canAddMixin("publication:authoring")) {
             node.addMixin("publication:authoring");
             node.setProperty("publication:lastUser", remoteUser);
             node.setProperty("publication:lifecycle", lifecycle.getName());
 
           }
           enrollNodeInLifecycle(node, lifecycleName);
           setInitialState(node, lifecycle, remoteUser);
           break;
         }
       }
     } catch (Exception ex) {
       if (LOG.isErrorEnabled()) {
         LOG.error("Couldn't complete the enrollement : ", ex);
       }
     }
   }
 
   /**
    * Automatically move to initial state if 'automatic'
    *
    * @param node
    * @param lifecycle
    * @throws Exception
    */
   private void setInitialState(Node node, Lifecycle lifecycle, String remoteUser) throws Exception {
     List<State> states = lifecycle.getStates();
     if (states == null || states.size() <= 0) {
       if (LOG.isWarnEnabled()) {
         LOG.warn("could not find an initial state in lifecycle " + lifecycle.getName());
       }
     } else {
       String initialState = states.get(0).getState();
       PublicationPlugin publicationPlugin = publicationService.getPublicationPlugins()
                                                               .get(AuthoringPublicationConstant.LIFECYCLE_NAME);
       HashMap<String, String> context = new HashMap<String, String>();
 
       NodeLocation currentRevisionLocation = NodeLocation.getNodeLocationByNode(node);
 
       Node currentRevision = getCurrentRevision(currentRevisionLocation);
       if (currentRevision != null) {
         context.put(AuthoringPublicationConstant.CURRENT_REVISION_NAME, currentRevision.getName());
       }
       try {
         if (node.isLocked()) {
           Lock lock = node.getLock();
           String owner = lock.getLockOwner();
           if (LOG.isInfoEnabled())
             LOG.info("node is locked by owner, unlocking it for enrollement");
           if (node.holdsLock() && remoteUser.equals(owner)) {
             String lockToken = LockUtil.getLockToken(node);
             if (lockToken != null) {
               node.getSession().addLockToken(lockToken);
             }
             node.unlock();
             node.removeMixin(Utils.MIX_LOCKABLE);
             // remove lock from Cache
             LockUtil.removeLock(node);
           }
         }
 
         context.put(AuthoringPublicationConstant.IS_INITIAL_PHASE, "true");
         node.setProperty("publication:lastUser", remoteUser);
         publicationPlugin.changeState(node, initialState, context);         
       } catch (Exception e) {
         if (LOG.isErrorEnabled()) {
           LOG.error("Error setting staged state : ", e);
         }
       }
     }
 
   }
 
   public Node getCurrentRevision(NodeLocation currentRevisionLocation) {
     return NodeLocation.getNodeByLocation(currentRevisionLocation);
   }
 
   /**
    * This default implementation checks if the state is valid then delegates the
    * update to the node WebpagePublicationPlugin.
    */
   public void updateLifecyleOnChangeContent(Node node,
                                             String siteName,
                                             String remoteUser,
                                             String newState) throws Exception {
     if(!node.getPath().startsWith(publicationLocation.split(":")[1]) 
 			&& !publicationService.isNodeEnrolledInLifecycle(node)) return;
     if(node.getPrimaryNodeType().getName().equals(NodetypeConstant.NT_FILE)) {
       for(String nodeType : notAllowChildNodeEnrollInPubliction) {
         if(!allowEnrollInPublication(node, nodeType)) return;
       }
     }
     if (!publicationService.isNodeEnrolledInLifecycle(node)) {
       enrollNodeInLifecycle(node, siteName, remoteUser);
     }
     String lifecycleName = publicationService.getNodeLifecycleName(node);
     WebpagePublicationPlugin publicationPlugin = this.getWebpagePublicationPlugins()
                                                      .get(lifecycleName);
 
     publicationPlugin.updateLifecyleOnChangeContent(node, remoteUser, newState);
 
     listenerService.broadcast(UPDATE_EVENT, cmsService, node);
   }
   
   private boolean allowEnrollInPublication(Node node, String nodeType) throws Exception {
     String path = node.getPath();
     Node parentNode = node.getParent();
     while(!path.equals("/") && path.length() > 0) {
       parentNode = (Node)node.getSession().getItem(path);
       if(parentNode.isNodeType(nodeType)) return false;
       path = path.substring(0, path.lastIndexOf("/"));
     }
     return true;
   }
 }