/*
    * 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.metadata.impl;
  
  import java.io.ByteArrayInputStream;
  import java.io.InputStream;
  import java.util.ArrayList;
  import java.util.List;
  
  import javax.jcr.Node;
  import javax.jcr.PathNotFoundException;
  import javax.jcr.Session;
  import javax.jcr.nodetype.NodeType;
  import javax.jcr.nodetype.NodeTypeIterator;
  import javax.jcr.nodetype.PropertyDefinition;
  
  import org.exoplatform.container.component.ComponentPlugin;
  import org.exoplatform.services.cms.BasePath;
  import org.exoplatform.services.cms.impl.DMSConfiguration;
  import org.exoplatform.services.cms.impl.DMSRepositoryConfiguration;
  import org.exoplatform.services.cms.metadata.MetadataService;
  import org.exoplatform.services.cms.templates.TemplateService;
  import org.exoplatform.services.cms.templates.impl.TemplatePlugin;
  import org.exoplatform.services.jcr.RepositoryService;
  import org.exoplatform.services.jcr.core.nodetype.ExtendedNodeTypeManager;
  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.utils.WCMCoreUtils;
  import org.picocontainer.Startable;
  
  /**
   * Process with meta data for system
   */
  public class MetadataServiceImpl implements MetadataService, Startable{
  
    /**
     * NodeType NT_UNSTRUCTURED
     */
    final static public String NT_UNSTRUCTURED = "nt:unstructured";
  
    /**
     * Property name INTERNAL_USE
     */
    final static public String INTERNAL_USE = "exo:internalUse";
  
    /**
     * NodeType METADATA_TYPE
     */
    final static public String METADATA_TYPE = "exo:metadata";
  
    /**
     * Node name DIALOGS
     */
    final static public String DIALOGS = "dialogs";
  
    /**
     * Node name VIEWS
     */
    final static public String VIEWS = "views";
  
    /**
     * Node name DIALOG1
     */
    final static public String DIALOG1 = "dialog1";
  
    /**
     * Node name VIEW1
     */
    final static public String VIEW1 = "view1";
  
    /**
     * RepositoryService object process with repository
     */
    private RepositoryService repositoryService_;
  
    /**
     * NodeHierarchyCreator object
     */
    private NodeHierarchyCreator nodeHierarchyCreator_;
  
    /**
     * Path to Metadata node in System workspace
     */
    private String baseMetadataPath_;
 
   /**
    * List of TemplatePlugin plugins_
    */
   private List<TemplatePlugin> plugins_ = new ArrayList<TemplatePlugin>();
 
   /**
   * DMS configuration which used to store informations
   */
   private DMSConfiguration dmsConfiguration_;
   private static final Log LOG  = ExoLogger.getLogger(MetadataServiceImpl.class.getName());
 
   private TemplateService templateService;
 
   /**
    * Constructor method
    * @param nodeHierarchyCreator  NodeHierarchyCreator object
    * @param repositoryService     RepositoryService object
    * @param dmsConfiguration DMSConfiguration object
    * @throws Exception
    */
   public MetadataServiceImpl(NodeHierarchyCreator nodeHierarchyCreator,
       RepositoryService repositoryService, DMSConfiguration dmsConfiguration) throws Exception {
     nodeHierarchyCreator_ = nodeHierarchyCreator;
     repositoryService_ = repositoryService;
     baseMetadataPath_ = nodeHierarchyCreator_.getJcrPath(BasePath.METADATA_PATH);
     dmsConfiguration_ = dmsConfiguration;
     templateService = WCMCoreUtils.getService(TemplateService.class);
   }
 
   /**
    * {@inheritDoc}
    */
   public void start() {
     try {
       init();
     } catch (Exception e) {
       if (LOG.isErrorEnabled()) {
         LOG.error("Unexpected error", e);
       }
     }
   }
 
   /**
    * {@inheritDoc}
    */
   public void stop() {}
 
   /**
    * Add TemplatePlugin
    * @param plugin
    */
   public void addPlugins(ComponentPlugin plugin) {
     if (plugin instanceof TemplatePlugin) plugins_.add((TemplatePlugin) plugin);
   }
 
   /**
    * Call all available in list of TemplatePlugin to
    * add some predefine template to all repository got
    * from configuration
    * @throws Exception
    */
   public void init() throws Exception{
     for(TemplatePlugin plugin : plugins_) {
       try {
         plugin.setBasePath(baseMetadataPath_);
         plugin.init();
       } catch(Exception e) {
         if (LOG.isErrorEnabled()) {
           LOG.error("Unexpected error", e);
         }
       }
     }
   }
  
   /**
    * {@inheritDoc}
    */
   public String addMetadata(String nodetype,
                             boolean isDialog,
                             String role,
                             String content,
                             boolean isAddNew) throws Exception {
     return addMetadata(nodetype, isDialog, role, content, nodetype, isAddNew);
   } 
   
   /**
    * {@inheritDoc}
    */
   public String addMetadata(String nodetype,
                             boolean isDialog,
                             String role,
                             String content,
                             String label,
                             boolean isAddNew) throws Exception {
     Session session = getSession();
     Node metadataHome = (Node)session.getItem(baseMetadataPath_);
     String path = null;
     if(!isAddNew) {
       if(isDialog) {
         Node dialog1 = metadataHome.getNode(nodetype).getNode(DIALOGS).getNode(DIALOG1);
         path = templateService.updateTemplate(dialog1, new ByteArrayInputStream(content.getBytes()), role.split(";"));
         metadataHome.getNode(nodetype).setProperty("label", label);
         metadataHome.save();
       } else {
         Node view1 = metadataHome.getNode(nodetype).getNode(VIEWS).getNode(VIEW1);
         path = templateService.updateTemplate(view1, new ByteArrayInputStream(content.getBytes()), role.split(";"));
         metadataHome.getNode(nodetype).setProperty("label", label);
         metadataHome.save();
       }
       return path;
     } 
     Node metadata = null;
     if(metadataHome.hasNode(nodetype)) metadata = metadataHome.getNode(nodetype);
     else metadata = metadataHome.addNode(nodetype, NT_UNSTRUCTURED);
     metadata.setProperty("label", label);
     metadataHome.save();
     addTemplate(metadata, role, new ByteArrayInputStream(content.getBytes()), isDialog);
     metadataHome.save();
     return metadata.getPath();
   }    
 
   /**
    * Add new node named nodetype
    * And child node for dialog template node or view template node
    * Set property EXO_ROLES_PROP, EXO_TEMPLATE_FILE_PROP for child node
    * @param nodetype    Node name for processing
    * @param isDialog    true for dialog template
    * @param role        permission
    * @param content     content of template
    * @throws Exception
    */
   private void addTemplate(Node nodetype, String role, InputStream content, boolean isDialog) throws Exception {
     Node templateHome = createTemplateHome(nodetype, isDialog);
     String[] arrRoles = {};
     if(role != null) arrRoles = role.split(";");
     if(isDialog) {
       templateService.createTemplate(templateHome, DIALOG1, DIALOG1, content, arrRoles);
     } else {
       templateService.createTemplate(templateHome, VIEW1, VIEW1, content, arrRoles);
     }
   }
 
   /**
    * {@inheritDoc}
    */
   public void removeMetadata(String nodetype) throws Exception {
     Session session = getSession();
     Node metadataHome = (Node)session.getItem(baseMetadataPath_);
     Node metadata = metadataHome.getNode(nodetype);
     metadata.remove();
     metadataHome.save();
   }  
   
   /**
    * {@inheritDoc}
    */
   public List<String> getMetadataList() throws Exception {
     List<String> metadataTypes = new ArrayList<String>();
     for(NodeType metadata:getAllMetadatasNodeType()) {
       metadataTypes.add(metadata.getName());
     }
     return metadataTypes;
   }
   
   /**
    * {@inheritDoc}
    */
   public List<NodeType> getAllMetadatasNodeType() throws Exception {
     List<NodeType> metadataTypes = new ArrayList<NodeType>();
     ExtendedNodeTypeManager ntManager = repositoryService_.getCurrentRepository().getNodeTypeManager();
     NodeTypeIterator ntIter = ntManager.getMixinNodeTypes();
     while(ntIter.hasNext()) {
       NodeType nt = ntIter.nextNodeType();
       if(nt.isNodeType(METADATA_TYPE) && !nt.getName().equals(METADATA_TYPE)) metadataTypes.add(nt);
     }
     return metadataTypes;
   }  
 
 
   /**
    * Create node for Dialog template or view template
    * @param nodetype    Node name for processing
    * @param isDialog    true for dialog template, false for view template
    * @return            Node for dialog template if isDialog = true
    *                    Node for dialog template if isDialog = false
    * @throws Exception
    */
   private Node createTemplateHome(Node nodetype, boolean isDialog) throws Exception{
     if(isDialog) {
       Node dialogs = null;
       if(nodetype.hasNode(DIALOGS)) dialogs = nodetype.getNode(DIALOGS);
       else dialogs = nodetype.addNode(DIALOGS, NT_UNSTRUCTURED);
       return dialogs;
     }
     Node views = null;
     if(nodetype.hasNode(VIEWS)) views = nodetype.getNode(VIEWS);
     else views = nodetype.addNode(VIEWS, NT_UNSTRUCTURED);
     return views;
   }
 
   /**
    * {@inheritDoc}
    */
   public String getMetadataTemplate(String name, boolean isDialog) throws Exception {
     Session session = getSession();
     Node metadataHome = (Node)session.getItem(baseMetadataPath_);
     Node template = null;
     if(!hasMetadata(name)) return null;
     if(isDialog) template = metadataHome.getNode(name).getNode(DIALOGS).getNode(DIALOG1);
     else template = metadataHome.getNode(name).getNode(VIEWS).getNode(VIEW1);
     String ret = templateService.getTemplate(template);
     return ret;
   }  
 
   /**
    * {@inheritDoc}
    */
   public String getMetadataPath(String name, boolean isDialog) throws Exception {
     Session session = getSession();
     Node metadataHome = (Node)session.getItem(baseMetadataPath_);
     if(!hasMetadata(name)) return null;
     Node template = null;
     if(isDialog){
       template = metadataHome.getNode(name).getNode(DIALOGS).getNode(DIALOG1);
     } else {
       template = metadataHome.getNode(name).getNode(VIEWS).getNode(VIEW1);
     }
     String ret = template.getPath();
     return ret;
   }  
 
   /**
    * {@inheritDoc}
    */
   public String getMetadataRoles(String name, boolean isDialog) throws Exception {
     Session session = getSession();
     Node metadataHome = (Node)session.getItem(baseMetadataPath_);
     Node template = null;
     if(!hasMetadata(name)) return null;
     if(isDialog){
       template = metadataHome.getNode(name).getNode(DIALOGS).getNode(DIALOG1);
     } else {
       template = metadataHome.getNode(name).getNode(VIEWS).getNode(VIEW1);
     }
     String ret = templateService.getTemplateRoles(template);
     return ret;
   }  
   
   /**
    * {@inheritDoc}
    */
   public boolean hasMetadata(String name) throws Exception {
     Session session = getSession();
     Node metadataHome = (Node)session.getItem(baseMetadataPath_);
     if(metadataHome.hasNode(name)) {
       return true;
     }
     return false;
   }  
   
   /**
    * {@inheritDoc}
    */
   public List<String> getExternalMetadataType() throws Exception {
     List<String> extenalMetaTypes = new ArrayList<String>();
     for (NodeType metadata : getAllMetadatasNodeType()) {
       for (PropertyDefinition pro : metadata.getPropertyDefinitions()) {
         if (pro.getName().equals(INTERNAL_USE)) {
           if (!pro.getDefaultValues()[0].getBoolean() && !metadata.getName().equals(METADATA_TYPE))
             extenalMetaTypes.add(metadata.getName());
           break;
         }
       }
     }
 
     return extenalMetaTypes;
   }
   
 
   @Override
   /**
    * {@inheritDoc}
    */
   public Node getMetadata(String metaName) throws Exception {
     Node metadataHome = (Node)getSession().getItem(baseMetadataPath_);
     try {
       return metadataHome.getNode(metaName);
     } catch(PathNotFoundException pne) {
       return null;
     } 
   }
 
   @Override
   /**
    * {@inheritDoc}
    */
   public String getMetadataLabel(String metaName) throws Exception {
     if(getMetadata(metaName) != null) {
       try {
         return getMetadata(metaName).getProperty("label").getString();
       } catch(PathNotFoundException pne) {
         return metaName;
       }
     }
     return null;
   }
   
   private Session getSession() throws Exception{
     DMSRepositoryConfiguration dmsRepoConfig = dmsConfiguration_.getConfig();
     return WCMCoreUtils.getSystemSessionProvider().getSession(dmsRepoConfig.getSystemWorkspace(), 
             repositoryService_.getCurrentRepository());
   }
 
 }