/*
 * Copyright (C) 2003-2009 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.category;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Set;

import javax.jcr.Node;
import javax.jcr.Session;
import javax.jcr.Workspace;
import javax.jcr.nodetype.NodeType;
import javax.jcr.nodetype.PropertyDefinition;

import org.apache.commons.lang3.StringUtils;
import org.exoplatform.container.configuration.ConfigurationManager;
import org.exoplatform.container.xml.InitParams;
import org.exoplatform.container.xml.ObjectParameter;
import org.exoplatform.container.xml.ValueParam;
import org.exoplatform.services.cms.BasePath;
import org.exoplatform.services.cms.JcrInputProperty;
import org.exoplatform.services.cms.actions.ActionServiceContainer;
import org.exoplatform.services.cms.actions.impl.ActionConfig;
import org.exoplatform.services.cms.actions.impl.ActionConfig.TaxonomyAction;
import org.exoplatform.services.cms.impl.DMSConfiguration;
import org.exoplatform.services.cms.impl.DMSRepositoryConfiguration;
import org.exoplatform.services.cms.impl.Utils;
import org.exoplatform.services.cms.link.LinkManager;
import org.exoplatform.services.cms.taxonomy.TaxonomyService;
import org.exoplatform.services.cms.taxonomy.impl.TaxonomyAlreadyExistsException;
import org.exoplatform.services.cms.taxonomy.impl.TaxonomyConfig;
import org.exoplatform.services.cms.taxonomy.impl.TaxonomyConfig.Permission;
import org.exoplatform.services.cms.taxonomy.impl.TaxonomyConfig.Taxonomy;
import org.exoplatform.services.jcr.RepositoryService;
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.common.SessionProvider;
import org.exoplatform.services.jcr.ext.hierarchy.NodeHierarchyCreator;
import org.exoplatform.services.log.ExoLogger;
import org.exoplatform.services.log.Log;
import org.exoplatform.services.wcm.portal.artifacts.CreatePortalPlugin;
import org.exoplatform.services.wcm.utils.WCMCoreUtils;

/**
 * Created by The eXo Platform SAS
 * Author : eXoPlatform
 * chuong_phan@exoplatform.com, phan.le.thanh.chuong@gmail.com
 * Aug 11, 2009
 */
public class CreateTaxonomyPlugin extends CreatePortalPlugin {

  private static final Log LOG = ExoLogger.getLogger(CreateTaxonomyPlugin.class.getName());

  public static final String MIX_AFFECTED_NODETYPE  = "mix:affectedNodeTypes";

  public static final String AFFECTED_NODETYPE      = "exo:affectedNodeTypeNames";

  public static final String ALL_DOCUMENT_TYPES     = "ALL_DOCUMENT_TYPES";

  /** The workspace. */
  private String                  workspace                  = "";

  /** The path. */
  private String                  path                       = "";

  /** The tree name. */
  private String                  treeName                   = "";

  /** The permissions. */
  private List<Permission>        permissions                = new ArrayList<Permission>(4);

  /** The auto create in new repository_. */
  private boolean                 autoCreateWithNewSite_ = false;

  /** The repository service_. */
  private RepositoryService       repositoryService;

  /** The taxonomy service_. */
  private TaxonomyService         taxonomyService;

  /** The link manager service_. */
  private LinkManager             linkManager;

  /** The base taxonomies storage_. */
  private String                  baseTaxonomiesStorage;

  /** The base taxonomies definition_. */
  private String                  baseTaxonomiesDefinition;

  /** The action service container_. */
  private ActionServiceContainer  actionServiceContainer;

  /** The params_. */
  private InitParams              params;

  /** The dms configuration_. */
  private DMSConfiguration        dmsConfiguration;

  /** The name. */
  private String                  name;

  private String                   portalName;

  /**
   * Instantiates a new initial taxonomy plugin.
   *
   * @param params the params
   * @param configurationManager the configuration manager
   * @param repositoryService the repository service
   * @param nodeHierarchyCreator the node hierarchy creator
   * @param taxonomyService the taxonomy service
   * @param actionServiceContainer the action service container
   * @param dmsConfiguration the dms configuration
   *
   * @throws Exception the exception
   */
  public CreateTaxonomyPlugin(InitParams params,
                               ConfigurationManager configurationManager,
                               RepositoryService repositoryService,
                               NodeHierarchyCreator nodeHierarchyCreator,
                               TaxonomyService taxonomyService,
                               ActionServiceContainer actionServiceContainer,
                               DMSConfiguration dmsConfiguration,
                               LinkManager linkManager) throws Exception {
    super(params, configurationManager, repositoryService);

    this.repositoryService = repositoryService;
    this.baseTaxonomiesStorage = nodeHierarchyCreator.getJcrPath(BasePath.TAXONOMIES_TREE_STORAGE_PATH);
    this.baseTaxonomiesDefinition = nodeHierarchyCreator.getJcrPath(BasePath.TAXONOMIES_TREE_DEFINITION_PATH);
    this.taxonomyService = taxonomyService;
    this.actionServiceContainer = actionServiceContainer;
    this.params = params;
    this.dmsConfiguration = dmsConfiguration;
    this.linkManager = linkManager;
  }

  /*
   * (non-Javadoc)
   * @see
   * org.exoplatform.services.wcm.portal.artifacts.BasePortalArtifactsPlugin
   * #deployToPortal(java.lang.String,
   * org.exoplatform.services.jcr.ext.common.SessionProvider)
   */
  public void deployToPortal(SessionProvider sessionProvider, String portalName) throws Exception {
    this.portalName = portalName;
    ValueParam autoCreated = params.getValueParam("autoCreateWithNewSite");
    ValueParam workspaceParam = params.getValueParam("workspace");
    ValueParam pathParam = params.getValueParam("path");
    ValueParam nameParam = params.getValueParam("treeName");
    if (autoCreated != null)
      autoCreateWithNewSite_ = Boolean.parseBoolean(autoCreated.getValue());
    if(!autoCreateWithNewSite_) return;
    if (pathParam == null || workspaceParam == null || workspaceParam.getValue().trim().length() == 0) {
      path = baseTaxonomiesStorage;
    } else {
      path = pathParam.getValue();
      workspace = workspaceParam.getValue();
    }
    if (nameParam != null) {
      treeName = nameParam.getValue();
    }

    if (treeName.contains("{treeName}")) {
      treeName = StringUtils.replace(treeName, "{treeName}", portalName);
    }

    path = StringUtils.replace(path, "{portalName}", portalName);

    Session session = null;
    try {
      // Get source information
      Node srcTaxonomy = taxonomyService.getTaxonomyTree(treeName);
      String srcWorkspace = srcTaxonomy.getSession().getWorkspace().getName();

      // Get destination information
      ManageableRepository repository = repositoryService.getCurrentRepository();
      session = sessionProvider.getSession(this.workspace, repository);
      Workspace destWorkspace = session.getWorkspace();
      String destPath = path + "/" + srcTaxonomy.getName();

      // If same workspace
      if (srcWorkspace.equals(destWorkspace.getName())) {
        destWorkspace.move(srcTaxonomy.getPath(), destPath);
      } else {
        // Clone taxonomy tree across workspace
        destWorkspace.clone(srcWorkspace, srcTaxonomy.getPath(), destPath, true);

        // Remove old link taxonomy tree in definition
        String dmsSystemWorkspaceName = dmsConfiguration.getConfig().getSystemWorkspace();
        Node taxonomyDefinition = (Node) sessionProvider.getSession(dmsSystemWorkspaceName,
                                                                    repository)
                                                        .getItem(baseTaxonomiesDefinition);
        Node srcLinkTaxonomy = taxonomyDefinition.getNode(srcTaxonomy.getName());
        srcLinkTaxonomy.remove();

        // Remove old taxonomy tree
        srcTaxonomy.remove();

        // Register new taxonomy tree in definition
        Node destTaxonomy = (Node) session.getItem(destPath);
        linkManager.createLink(taxonomyDefinition, destTaxonomy);
      }
      session.save();
      return;
    } catch (Exception e) {
      init();
    }
  }

  /**
   * Inits the.
   *
   * @throws Exception the exception
   */
  public void init() throws Exception {
    importPredefineTaxonomies();
  }

  /* (non-Javadoc)
   * @see org.exoplatform.services.deployment.DeploymentPlugin#getName()
   */
  public String getName() {
    return name;
  }

  /* (non-Javadoc)
   * @see org.exoplatform.services.deployment.DeploymentPlugin#setName(java.lang.String)
   */
  public void setName(String name) {
    this.name = name;
  }

  /**
   * Gets the path.
   *
   * @return the path
   */
  public String getPath() {
    return path;
  }

  /**
   * Sets the path.
   *
   * @param path the new path
   */
  public void setPath(String path) {
    this.path = path;
  }

  /**
   * Gets the permissions.
   *
   * @return the permissions
   */
  public List<Permission> getPermissions() {
    return permissions;
  }

  /**
   * Sets the permissions.
   *
   * @param permissions the new permissions
   */
  public void setPermissions(List<Permission> permissions) {
    this.permissions = permissions;
  }

  /**
   * Gets the workspace.
   *
   * @return the workspace
   */
  public String getWorkspace() {
    return workspace;
  }

  /**
   * Sets the workspace.
   *
   * @param workspace the new workspace
   */
  public void setWorkspace(String workspace) {
    this.workspace = workspace;
  }

  /**
   * Import predefine taxonomies.
   *
   * @param repository the repository
   *
   * @throws Exception the exception
   */
  @SuppressWarnings("unchecked")
  private void importPredefineTaxonomies() throws Exception {
    ManageableRepository manageableRepository = this.repositoryService.getCurrentRepository();
    DMSRepositoryConfiguration dmsRepoConfig = this.dmsConfiguration.getConfig();
    if (getWorkspace() == null) {
      setWorkspace(dmsRepoConfig.getSystemWorkspace());
    }
    Session session = manageableRepository.getSystemSession(getWorkspace());
    Node taxonomyStorageNode = (Node) session.getItem(getPath());
    if (taxonomyStorageNode.hasProperty("exo:isImportedChildren")) {
      session.logout();
      return;
    }
    taxonomyStorageNode.setProperty("exo:isImportedChildren", true);
    Iterator<ObjectParameter> it = params.getObjectParamIterator();
    Node taxonomyStorageNodeSystem = Utils.makePath(taxonomyStorageNode, treeName, "exo:taxonomy",
            null);
    taxonomyStorageNode.save();
    while (it.hasNext()) {
      ObjectParameter objectParam = it.next();
      if (objectParam.getName().equals("permission.configuration")) {
        TaxonomyConfig config = (TaxonomyConfig) objectParam.getObject();
        for (Taxonomy taxonomy : config.getTaxonomies()) {
          Map mapPermissions = getPermissions(taxonomy.getPermissions());
          if (mapPermissions != null) {
            ((ExtendedNode) taxonomyStorageNodeSystem).setPermissions(mapPermissions);
          }
          if (taxonomyStorageNodeSystem.canAddMixin("mix:referenceable")) {
            taxonomyStorageNodeSystem.addMixin("mix:referenceable");
          }
        }
      } else if (objectParam.getName().equals("taxonomy.configuration")) {
        TaxonomyConfig config = (TaxonomyConfig) objectParam.getObject();
        for (Taxonomy taxonomy : config.getTaxonomies()) {
          Node taxonomyNode = Utils.makePath(taxonomyStorageNodeSystem, taxonomy.getPath(),
              "exo:taxonomy", getPermissions(taxonomy.getPermissions()));
          if (taxonomyNode.canAddMixin("mix:referenceable")) {
            taxonomyNode.addMixin("mix:referenceable");
          }

          if (taxonomyNode.canAddMixin("exo:rss-enable")) {
            taxonomyNode.addMixin("exo:rss-enable");
          }
          if(StringUtils.isNotEmpty(taxonomy.getTitle())) {
            taxonomyNode.setProperty("exo:title", taxonomy.getTitle());
          } else {
            taxonomyNode.setProperty("exo:title", taxonomy.getName());
          }

          taxonomyNode.save();
        }
      } else if (objectParam.getName().equals("predefined.actions")) {
        ActionConfig config = (ActionConfig) objectParam.getObject();
        List actions = config.getActions();
        for (Iterator iter = actions.iterator(); iter.hasNext();) {
          TaxonomyAction action = (TaxonomyAction) iter.next();
          addAction(action, taxonomyStorageNodeSystem);
        }
      }

    }
    taxonomyStorageNode.save();
    try {
      taxonomyService.addTaxonomyTree(taxonomyStorageNodeSystem);
    } catch (TaxonomyAlreadyExistsException e) {
      if (LOG.isErrorEnabled()) LOG.error("Cannot add taxonomy tree", e);
    }
    session.logout();
  }

  /**
   * Adds the action.
   *
   * @param action the action
   * @param srcNode the src node
   * @param repository the repository
   *
   * @throws Exception the exception
   */
  private void addAction(ActionConfig.TaxonomyAction action, Node srcNode)
      throws Exception {
    Map<String, JcrInputProperty> sortedInputs = new HashMap<String, JcrInputProperty>();
    JcrInputProperty jcrInputName = new JcrInputProperty();
    jcrInputName.setJcrPath("/node/exo:name");
    jcrInputName.setValue(action.getName());
    sortedInputs.put("/node/exo:name", jcrInputName);
    JcrInputProperty jcrInputDes = new JcrInputProperty();
    jcrInputDes.setJcrPath("/node/exo:description");
    jcrInputDes.setValue(action.getDescription());
    sortedInputs.put("/node/exo:description", jcrInputDes);

    JcrInputProperty jcrInputLife = new JcrInputProperty();
    jcrInputLife.setJcrPath("/node/exo:lifecyclePhase");
    jcrInputLife.setValue(action.getLifecyclePhase().toArray(new String[0]));
    sortedInputs.put("/node/exo:lifecyclePhase", jcrInputLife);

    JcrInputProperty jcrInputHomePath = new JcrInputProperty();
    jcrInputHomePath.setJcrPath("/node/exo:storeHomePath");
    String homepath = action.getHomePath();
    homepath = StringUtils.replace(homepath, "{portalName}", portalName);
    homepath = StringUtils.replace(homepath, "{treeName}", treeName);
    jcrInputHomePath.setValue(homepath);
    sortedInputs.put("/node/exo:storeHomePath", jcrInputHomePath);

    JcrInputProperty jcrInputTargetWspace = new JcrInputProperty();
    jcrInputTargetWspace.setJcrPath("/node/exo:targetWorkspace");
    jcrInputTargetWspace.setValue(action.getTargetWspace());
    sortedInputs.put("/node/exo:targetWorkspace", jcrInputTargetWspace);

    JcrInputProperty jcrInputTargetPath = new JcrInputProperty();
    jcrInputTargetPath.setJcrPath("/node/exo:targetPath");
    String targetPath = action.getTargetPath();
    targetPath = StringUtils.replace(targetPath, "{portalName}", portalName);
    jcrInputTargetPath.setValue(targetPath);
    sortedInputs.put("/node/exo:targetPath", jcrInputTargetPath);

    JcrInputProperty rootProp = sortedInputs.get("/node");
    if (rootProp == null) {
      rootProp = new JcrInputProperty();
      rootProp.setJcrPath("/node");
      rootProp.setValue((sortedInputs.get("/node/exo:name")).getValue());
      sortedInputs.put("/node", rootProp);
    } else {
      rootProp.setValue((sortedInputs.get("/node/exo:name")).getValue());
    }
    actionServiceContainer.addAction(srcNode, action.getType(), sortedInputs);
    Node actionNode = actionServiceContainer.getAction(srcNode, action.getName());
    if (action.getRoles() != null) {
      String[] roles = StringUtils.split(action.getRoles(), ";");
      actionNode.setProperty("exo:roles", roles);
    }

    Iterator mixins = action.getMixins().iterator();
    NodeType nodeType;
    String value;
    ManageableRepository manageableRepository = WCMCoreUtils.getRepository();
    while (mixins.hasNext()) {
      ActionConfig.Mixin mixin = (ActionConfig.Mixin) mixins.next();
      actionNode.addMixin(mixin.getName());
      Map<String, String> props = mixin.getParsedProperties();
      Set keys = props.keySet();
      nodeType = manageableRepository.getNodeTypeManager().getNodeType(mixin.getName());
      for (Iterator iterator = keys.iterator(); iterator.hasNext();) {
        String key = (String) iterator.next();
        for(PropertyDefinition pro : nodeType.getPropertyDefinitions()) {
          if (pro.getName().equals(key)) {
            if (pro.isMultiple()) {
              value = props.get(key);
              if (value != null) {
                actionNode.setProperty(key, value.split(","));
              }
            } else {
              actionNode.setProperty(key, props.get(key));
            }
            break;
          }
        }
      }
    }
    actionNode.save();
  }

  /**
   * Gets the permissions.
   *
   * @param listPermissions the list permissions
   *
   * @return the permissions
   */
  private Map<String, String[]> getPermissions(List<Permission> listPermissions) {
    Map<String, String[]> permissionsMap = new HashMap<String, String[]>();
    for (Permission permission : listPermissions) {
      StringBuilder strPer = new StringBuilder();
      if ("true".equals(permission.getRead()))
        strPer.append(PermissionType.READ);
      if ("true".equals(permission.getAddNode()))
        strPer.append(",").append(PermissionType.ADD_NODE);
      if ("true".equals(permission.getSetProperty()))
        strPer.append(",").append(PermissionType.SET_PROPERTY);
      if ("true".equals(permission.getRemove()))
        strPer.append(",").append(PermissionType.REMOVE);
      permissionsMap.put(permission.getIdentity(), strPer.toString().split(","));
    }
    return permissionsMap;
  }

}
