/*
 *  Copyright 2018 Anyware Services
 *
 *  Licensed under the Apache License, Version 2.0 (the "License");
 *  you may not use this file except in compliance with the License.
 *  You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 *  Unless required by applicable law or agreed to in writing, software
 *  distributed under the License is distributed on an "AS IS" BASIS,
 *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 *  See the License for the specific language governing permissions and
 *  limitations under the License.
 */
package org.ametys.plugins.odfsync.cdmfr.components.impl;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;

import javax.jcr.RepositoryException;

import org.apache.avalon.framework.configuration.Configuration;
import org.apache.avalon.framework.configuration.ConfigurationException;
import org.apache.avalon.framework.service.ServiceException;
import org.apache.avalon.framework.service.ServiceManager;
import org.apache.commons.lang3.StringUtils;
import org.slf4j.Logger;
import org.w3c.dom.Document;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;

import org.ametys.cms.content.external.ExternalizableMetadataHelper;
import org.ametys.cms.contenttype.ContentType;
import org.ametys.cms.contenttype.MetadataDefinition;
import org.ametys.cms.contenttype.MetadataType;
import org.ametys.cms.contenttype.RepeaterDefinition;
import org.ametys.cms.repository.ContentQueryHelper;
import org.ametys.cms.repository.ContentTypeExpression;
import org.ametys.cms.repository.LanguageExpression;
import org.ametys.cms.repository.ModifiableDefaultContent;
import org.ametys.odf.ProgramItem;
import org.ametys.odf.enumeration.OdfReferenceTableHelper;
import org.ametys.odf.helper.DeleteODFContentHelper;
import org.ametys.odf.helper.DeleteODFContentHelper.DeleteMode;
import org.ametys.odf.program.AbstractProgram;
import org.ametys.odf.program.Program;
import org.ametys.odf.program.ProgramFactory;
import org.ametys.odf.program.ProgramPart;
import org.ametys.odf.program.SubProgram;
import org.ametys.odf.program.SubProgramFactory;
import org.ametys.odf.program.TraversableProgramPart;
import org.ametys.plugins.odfsync.cdmfr.MergeMetadataForSharedProgramHelper;
import org.ametys.plugins.odfsync.cdmfr.RemoteCDMFrSynchronizableContentsCollection;
import org.ametys.plugins.repository.AmetysObjectIterable;
import org.ametys.plugins.repository.RepositoryConstants;
import org.ametys.plugins.repository.metadata.ModifiableCompositeMetadata;
import org.ametys.plugins.repository.query.expression.AndExpression;
import org.ametys.plugins.repository.query.expression.Expression;
import org.ametys.plugins.repository.query.expression.Expression.Operator;
import org.ametys.plugins.repository.query.expression.StringExpression;
import org.ametys.runtime.config.Config;

import com.google.common.collect.ImmutableList;
import com.google.common.collect.ImmutableMap;

/**
 * Component to import a CDM-fr input stream from a remote server with co-accredited mode.
 */
public class CoAccreditedRemoteImportCDMFrComponent extends RemoteImportCDMFrComponent
{
    /** The name of the JCR node holding the shared metadata  */
    public static final String SHARED_PROGRAMS_NODE_NAME = RepositoryConstants.NAMESPACE_PREFIX_INTERNAL + ":shared-programs";

    /** The merge metadata helper */
    protected MergeMetadataForSharedProgramHelper _mergeMetadataHelper;
    
    /** The delete ODF content helper */
    protected DeleteODFContentHelper _deleteODFContent;
    
    /** The list of metadata to copy for mention program */
    protected Set<String> _mentionMetadataPaths;
    
    /** The list of metadata to merge */
    protected Set<String> _metadataPathsToMerge;
    
    private Map<String, String> _degree2MentionMap;
    private ContentType _mentionContentType;
    private String _mentionId;
    private String _programToLinkCode;
    private String _sharedSubProgramType;
    
    /**
     * Enum to define the way to detect shared subProgram
     */
    public enum SharedWithType
    {
        /**
         * The main subProgram set the other shared program in the metadata "shared-with"
         */
        WITH_SHARED_METADATA,
       
        /**
         * All subProgram with the same title are shared. The first imported subProgram is the main subProgram.
         */
        WITH_SAME_TITLE,
        
        
        /**
         * Shared subProgram are not handled
         */
        NONE
    }
    
    @Override
    public void service(ServiceManager manager) throws ServiceException
    {
        super.service(manager);
        _mergeMetadataHelper = (MergeMetadataForSharedProgramHelper) manager.lookup(MergeMetadataForSharedProgramHelper.ROLE);
        _deleteODFContent = (DeleteODFContentHelper) manager.lookup(DeleteODFContentHelper.ROLE);
    }
    
    @Override
    public void initialize() throws Exception
    {
        super.initialize();

        _degree2MentionMap = new HashMap<>();
        _degree2MentionMap.put(Config.getInstance().getValue("odf.programs.degree.license"), OdfReferenceTableHelper.MENTION_LICENCE);
        _degree2MentionMap.put(Config.getInstance().getValue("odf.programs.degree.licensepro"), OdfReferenceTableHelper.MENTION_LICENCEPRO);
        _degree2MentionMap.put(Config.getInstance().getValue("odf.programs.degree.master"), OdfReferenceTableHelper.MENTION_MASTER);

        _mentionContentType = _contentTypeEP.getExtension(getProgramWfDescription().getContentType());
    }
    
    @Override
    public void configure(Configuration configuration) throws ConfigurationException
    {
        super.configure(configuration);

        _mentionMetadataPaths = new HashSet<>();
        _metadataPathsToMerge = new HashSet<>();
        if ("co-accredited".equals(configuration.getName()))
        {
            _configureCoAccreditedParams(configuration);
        }
        else
        {
            _configureCoAccreditedParams(configuration.getChild("co-accredited"));
        }
    }
    
    /**
     * Configure the co-accredited params
     * @param configuration the configuration
     * @throws ConfigurationException if an error occurred
     */
    protected void _configureCoAccreditedParams(Configuration configuration) throws ConfigurationException
    {
        Configuration mentionConf = configuration.getChild("mention");
        if (mentionConf != null)
        {
            Configuration metadatas = mentionConf.getChild("metadata-to-copy");
            if (metadatas != null)
            {
                for (Configuration metadataConf : metadatas.getChildren())
                {
                    String metadataPath = metadataConf.getAttribute("path");
                    _mentionMetadataPaths.add(metadataPath);
                }
            }
        }
        
        Configuration sharedWithConf = configuration.getChild("shared-with");
        if (sharedWithConf != null)
        {
            Configuration metadatas = sharedWithConf.getChild("metadata-to-merge");
            if (metadatas != null)
            {
                for (Configuration metadataConf : metadatas.getChildren())
                {
                    String metadataPath = metadataConf.getAttribute("path");
                    _metadataPathsToMerge.add(metadataPath);
                }
            }
        }
    }

    @Override
    protected void additionalParameters(Map<String, Object> parameters)
    {
        _mentionId = null;
        _sharedSubProgramType = (String) parameters.getOrDefault(RemoteCDMFrSynchronizableContentsCollection.PARAM_SHARED_WITH_TYPE, SharedWithType.NONE.name());
        
        super.additionalParameters(parameters);
    }

    @Override
    protected ModifiableDefaultContent _importOrSynchronizeContent(Document doc, Node contentNode, ContentWorkflowDescription wfDescription, String title, String lang, String catalog, String syncCode, Logger logger)
    {
        ModifiableDefaultContent content = null;
        ContentWorkflowDescription contentWfDescription = wfDescription;
        if (contentNode.getLocalName().equals(_TAG_PROGRAM))
        {
            String educationKind = _xPathProcessor.evaluateAsString(contentNode, AbstractProgram.EDUCATION_KIND);
            String mention = _xPathProcessor.evaluateAsString(contentNode, AbstractProgram.MENTION);

            // This is a co-accredited program
            if (StringUtils.isNotBlank(mention) && "parcours".equals(educationKind))
            {
                // Change the workflow description of the program to subprogram
                contentWfDescription = getSubProgramWfDescription();

                // Get or create the mention from the program
                Program mentionProgram = _getOrCreateMention(doc, contentNode, mention, lang, catalog, logger);
                _mentionId = mentionProgram.getId();
                
                // Store the content to link to the mention
                _programToLinkCode = syncCode;
                
                // Handle shared subPrograms
                if (_getSharedWithType() != SharedWithType.NONE)
                {
                    content = _importOrSynchronizeSharedSubPrograms(doc, mentionProgram, contentNode, contentWfDescription, title, syncCode, lang, catalog, logger);
                }
            }
        }

        if (content == null)
        {
            content = super._importOrSynchronizeContent(doc, contentNode, contentWfDescription, title, lang, catalog, syncCode, logger);
        }
        
        if (_mentionId != null && content instanceof SubProgram && content.getMetadataHolder().getString(getIdField()).equals(_programToLinkCode))
        {
            // Mettre les composantes de la mention à jour
            ModifiableDefaultContent mention = _resolver.resolveById(_mentionId);
            List<String> orgunits = ((SubProgram) content).getOrgUnits();
            for (String orgunit : orgunits)
            {
                _synchroComponent.updateRelation(mention.getMetadataHolder(), AbstractProgram.ORG_UNITS_REFERENCES, orgunit, false);
            }
        }
        
        return content;
    }

    
    /**
     * Import or synchronized shared subPrograms
     * @param doc the document
     * @param mentionProgram the mention program
     * @param contentNode the content node
     * @param contentWfDescription the content workflow description
     * @param title the title of the subprogram
     * @param syncCode the synchronisation code
     * @param lang the language 
     * @param catalog the catalog
     * @param logger the logger
     * @return the imported of synchronized content
     */
    protected ModifiableDefaultContent _importOrSynchronizeSharedSubPrograms(Document doc, Program mentionProgram, Node contentNode, ContentWorkflowDescription contentWfDescription, String title, String syncCode, String lang, String catalog, Logger logger)
    {
        // Is imported program already exist as a subprogram ?
        ModifiableDefaultContent subProgram = _getContent(lang, catalog, syncCode, contentWfDescription);
        if (subProgram == null)
        {
            // The imported program does not exist as subprogram, create it except if it is a shared subprogram
            if (_isSecondarySharedSubPrograms(mentionProgram, contentNode, lang, logger))
            {
                // Search if there is a main subprogram shared with it.
                SubProgram mainSubProgram = getMainSharedSubProgram(mentionProgram, contentNode, lang, logger);
                if (mainSubProgram != null)
                {
                    // The imported program is a shared subprogram, it will not be imported nor synchronized, only the main subprogram will be updated
                    try
                    {
                        // Merge shared program metadata from CDMfr
                        if (_synchronizeSharedMetadata(doc, contentNode, mainSubProgram, null, _metadataPathsToMerge, catalog, lang, logger))
                        {
                            _mergeMetadataHelper.mergeSharedMetadata(mainSubProgram, contentNode, _metadataPathsToMerge, logger);
                        }
                    }
                    catch (RepositoryException e)
                    {
                        String warnMsg = "Impossible de synchronizer les métadonnées partagées pour le parcours principal \"" + mainSubProgram.getTitle() + "\"";
                        logger.warn(warnMsg);
                    }
                    
                    return mainSubProgram;
                }
                else
                {
                    return super._importOrSynchronizeContent(doc, contentNode, contentWfDescription, title, lang, catalog, syncCode, logger);
                }
            }
            else
            {
                subProgram = super._importOrSynchronizeContent(doc, contentNode, contentWfDescription, title, lang, catalog, syncCode, logger);
                
                try
                {
                    // Synchronize the shared metadata of the main program to be merged later
                    _synchronizeSharedMetadata(doc, contentNode, (SubProgram) subProgram, null, _metadataPathsToMerge, catalog, lang, logger);
                }
                catch (RepositoryException e)
                {
                    String warnMsg = "Impossible de synchronizer les métadonnées partagées du parcours principal \"" + subProgram.getTitle() + "\"";
                    logger.warn(warnMsg);
                }
                
                // Browse existing shared subprograms to first merge them then delete them. 
                // When we shared subprograms with the title, it can't have other created shared subPrograms because the first one is the main shared subprogram 
                SharedWithType sharedWithType = _getSharedWithType();
                if (SharedWithType.WITH_SHARED_METADATA == sharedWithType)
                {
                    List<String> sharedWith = _getSharedWithAsString(contentNode, logger);
                    _synchronizeAndDeleteSharedSubPrograms(mentionProgram, (SubProgram) subProgram, sharedWith, catalog, lang, logger);
                    
                    try
                    {
                        // Then merge main subprogram
                        _mergeMetadataHelper.mergeSharedMetadata((SubProgram) subProgram, contentNode, _metadataPathsToMerge, logger);
                    }
                    catch (RepositoryException e)
                    {
                        String warnMsg = "Impossible de synchronizer les metadatas du programme principal \"" + subProgram.getTitle() + "\"";
                        logger.warn(warnMsg);
                    }
                }
                
                return subProgram;
            }
        }
        else // The imported program exists as subprogram
        {
            ModifiableDefaultContent mainSubProgram = super._importOrSynchronizeContent(doc, contentNode, contentWfDescription, title, lang, catalog, syncCode, logger);
            
            if (!_isSecondarySharedSubPrograms(mentionProgram, contentNode, lang, logger))
            {
                // When we shared subprograms with the title, it can't have other created shared subPrograms because the first one is the main shared subprogram 
                SharedWithType sharedWithType = _getSharedWithType();
                if (SharedWithType.WITH_SHARED_METADATA == sharedWithType)
                {
                    List<String> sharedWith = _getSharedWithAsString(contentNode, logger);

                    // Browse existing shared subprograms to first merge them then delete them.
                    _synchronizeAndDeleteSharedSubPrograms(mentionProgram, (SubProgram) subProgram, sharedWith, catalog, lang, logger);
                }
                
                try
                {
                    // Synchronize the shared metadata of the main program to be merged later
                    _synchronizeSharedMetadata(doc, contentNode, (SubProgram) subProgram, null, _metadataPathsToMerge, catalog, lang, logger);
                    // Then merge main subprogram
                    _mergeMetadataHelper.mergeSharedMetadata((SubProgram) subProgram, contentNode, _metadataPathsToMerge, logger);
                }
                catch (RepositoryException e)
                {
                    String warnMsg = "Impossible de synchronizer les metadatas du programme principal \"" + subProgram.getTitle() + "\"";
                    logger.warn(warnMsg);
                }
            }
            
            return mainSubProgram;
        }
    }
    
    /**
     * Get of create the mention program
     * @param doc the document
     * @param contentNode the content node
     * @param mentionCode the mention code
     * @param lang the language
     * @param catalog the catalog
     * @param logger the logger
     * @return the mention program
     */
    protected Program _getOrCreateMention(Document doc, Node contentNode, String mentionCode, String lang, String catalog, Logger logger)
    {
        String degreeCodeCDM = _xPathProcessor.evaluateAsString(contentNode, AbstractProgram.DEGREE);
        String degreeCode = _odfRefTableHelper.getItemCodeFromCDM(OdfReferenceTableHelper.DEGREE, degreeCodeCDM);
        if (degreeCode == null)
        {
            degreeCode = degreeCodeCDM;
        }
        
        String mentionType = _degree2MentionMap.get(degreeCode);
        if (mentionType != null)
        {
            String mentionId = _getIdFromCDMThenCode(mentionType, mentionCode);
            if (mentionId != null)
            {
                String degreeId = _getIdFromCDMThenCode(OdfReferenceTableHelper.DEGREE, degreeCode);
                Program mention = _getMention(mentionId, degreeId, lang, catalog);
                if (mention == null)
                {
                    mention = _createMention(doc, contentNode, mentionId, catalog, lang, logger);
                    _importedContents.put(mention.getId(), getProgramWfDescription().getValidationActionId());
                }
                
                return mention;
            }
            else
            {
                logger.error("Il n'y a pas de code associé à la mention {}. La formation n'a pas été importée.", mentionCode);
                _nbError++;
            }
        }
        else
        {
            logger.error("Il n'y a pas de type de mention (licence, licence pro, master) associée au diplôme {}. La formation n'a pas été importée.", degreeCode);
            _nbError++;
        }
        
        return null;
    }
    
    /**
     * Create the mention
     * @param doc the document
     * @param contentNode the content node
     * @param mentionId the mention id
     * @param catalog the catalog
     * @param lang the language
     * @param logger the logger
     * @return the created mention
     */
    protected Program _createMention(Document doc, Node contentNode, String mentionId, String catalog, String lang, Logger logger)
    {
        String contentTitle = _odfRefTableHelper.getItemLabel(mentionId, lang);
        ContentWorkflowDescription wfDescription = getProgramWfDescription();
        Map<String, Object> resultMap = _synchroComponent.createContentAction(wfDescription.getContentType(), wfDescription.getWorkflowName(), wfDescription.getInitialActionId(), lang, contentTitle, _contentPrefix, logger);
        if ((boolean) resultMap.getOrDefault("error", false))
        {
            _nbError++;
        }
        
        Program mention = (Program) resultMap.get("content");

        if (mention != null)
        {
            boolean hasChanges = false;
            if (catalog != null)
            {
                hasChanges = ExternalizableMetadataHelper.setMetadata(mention.getMetadataHolder(), ProgramItem.METADATA_CATALOG, catalog);
            }

            hasChanges = ExternalizableMetadataHelper.setExternalMetadata(mention.getMetadataHolder(), AbstractProgram.MENTION, mentionId, true) || hasChanges;
            hasChanges = _synchronizeMentionMetadata(doc, contentNode, mention, AbstractProgram.DEGREE, lang, catalog, logger) || hasChanges;
            hasChanges = _synchronizeMentionMetadata(doc, contentNode, mention, AbstractProgram.DOMAIN, lang, catalog, logger) || hasChanges;
            
            for (String metadataPath : _mentionMetadataPaths)
            {
                hasChanges = _synchronizeMentionMetadata(doc, contentNode, mention, metadataPath, lang, catalog, logger) || hasChanges;
            }
            
            _saveContentChanges(mention, wfDescription.getContentType(), hasChanges, logger);
        }
        
        return mention;
    }
    
    /**
     * Get the mention program
     * @param mentionId the mention content id
     * @param degreeId the degree content id
     * @param lang the language
     * @param catalog the catalog
     * @return the mention program or <code>null</code> if it doesn't exist
     */
    protected Program _getMention(String mentionId, String degreeId, String lang, String catalog)
    {
        List<Expression> expList = new ArrayList<>();
        expList.add(new ContentTypeExpression(Operator.EQ, ProgramFactory.PROGRAM_CONTENT_TYPE));
        expList.add(new LanguageExpression(Operator.EQ, lang));
        expList.add(new StringExpression(ProgramItem.METADATA_CATALOG, Operator.EQ, catalog));
        expList.add(new StringExpression(AbstractProgram.DEGREE, Operator.EQ, degreeId));
        expList.add(new StringExpression(AbstractProgram.MENTION, Operator.EQ, mentionId));

        AndExpression andExp = new AndExpression(expList.toArray(new Expression[expList.size()]));
        String xPathQuery = ContentQueryHelper.getContentXPathQuery(andExp);

        AmetysObjectIterable<Program> contents = _resolver.query(xPathQuery);
        
        if (contents.getSize() > 0)
        {
            return contents.iterator().next();
        }
        
        return null;
    }
    
    /**
     * Synchronize metadata in the mention program
     * @param doc the document
     * @param contentNode the content node
     * @param mention the mention program
     * @param metadataPath the metadata path to synchronize
     * @param lang the language
     * @param catalog the catalog
     * @param logger the logger
     * @return true if some changes were made
     */
    protected boolean _synchronizeMentionMetadata(Document doc, Node contentNode, ModifiableDefaultContent mention, String metadataPath, String lang, String catalog, Logger logger)
    {
        Node metadataNode = _xPathProcessor.selectSingleNode(contentNode, metadataPath);
        if (metadataNode != null)
        {
            return _synchronizeMetadata(doc, metadataNode, mention, metadataPath, metadataPath, _mentionContentType, lang, catalog, logger);
        }
        return false;
    }

    @Override
    protected void additionalOperationsBeforeSave(ModifiableDefaultContent content, Logger logger) throws RepositoryException
    {
        if (_mentionId != null && content instanceof SubProgram && content.getMetadataHolder().getString(getIdField()).equals(_programToLinkCode))
        {
            boolean hasChanges = false;
            
            ModifiableDefaultContent mentionContent = _resolver.resolveById(_mentionId);
            
            // Relier le programme à la mention
            hasChanges = _synchroComponent.updateRelation(mentionContent.getMetadataHolder(), TraversableProgramPart.METADATA_CHILD_PROGRAM_PARTS, content, false) || hasChanges;
            if (_synchroComponent.updateRelation(content.getMetadataHolder(), ProgramPart.METADATA_PARENT_PROGRAM_PARTS, _mentionId, false))
            {
                _saveContentChanges(content, getSubProgramWfDescription().getContentType(), true, logger);
            }

            if (hasChanges)
            {
                _saveContentChanges(mentionContent, _mentionContentType.getId(), hasChanges, logger);
            }
        }
    }
    
    /**
     * Get the defined way to detect shared program
     * @return shared with type
     */
    protected SharedWithType _getSharedWithType()
    {
        return SharedWithType.valueOf(_sharedSubProgramType);
    }
    
    /**
     * Get the main subprogram shared with the program representing by the content node
     * @param mentionProgram the root mention program
     * @param contentNode the content node
     * @param lang the content lang
     * @param logger the logger
     * @return the main subprogram if the program is a shared subprogram or <code>null</code> otherwise
     */
    protected SubProgram getMainSharedSubProgram(Program mentionProgram, Node contentNode, String lang, Logger logger)
    {
        SharedWithType sharedWithType = _getSharedWithType();
        switch (sharedWithType)
        {
            case WITH_SHARED_METADATA:
                return _getMainSharedWithSubProgram(mentionProgram, contentNode, logger);
            case WITH_SAME_TITLE:
                return _getSubProgramWithSameTitle(mentionProgram, contentNode, lang);
            default:
                return null;
        }
    }
    
    /**
     * True if the subProgram node is shared with a main subProgram.
     * False if the subProgram node is not shared or if the main subProgram is not already imported
     * @param mentionProgram the mention program
     * @param contentNode the content node
     * @param lang the lang
     * @param logger the logger
     * @return true if it's a secondary subProgram
     */
    protected boolean _isSecondarySharedSubPrograms(Program mentionProgram, Node contentNode, String lang, Logger logger)
    {
        SharedWithType sharedWithType = _getSharedWithType();
        switch (sharedWithType)
        {
            case WITH_SHARED_METADATA:
                List<String> sharedWith = _getSharedWithAsString(contentNode, logger);
                return sharedWith.isEmpty();
            case WITH_SAME_TITLE:
                return _hasSubProgramWithSameTitle(mentionProgram, contentNode, lang, logger);
            default:
                return false;
        }
    }
    
    /**
     * True if there is a subProgram with the same title of the content node
     * @param mentionProgram the mention program
     * @param contentNode the content node
     * @param lang the lang
     * @param logger the logger
     * @return true if there is a subProgram with the same title of the content node
     */
    protected boolean _hasSubProgramWithSameTitle(Program mentionProgram, Node contentNode, String lang, Logger logger)
    {
        SubProgram subProgram = _getSubProgramWithSameTitle(mentionProgram, contentNode, lang);
        return subProgram != null;
    }
    
    
    /**
     * Get the subProgram with the same title
     * @param mentionProgram the mention program
     * @param contentNode the content node
     * @param lang the lang
     * @return the subProgram with the same title. null if there are no subProgram with same title.
     */
    protected SubProgram _getSubProgramWithSameTitle(Program mentionProgram, Node contentNode, String lang)
    {
        String contentTitle = _xPathProcessor.evaluateAsString(contentNode, "title");
        
        for (ProgramPart child : mentionProgram.getProgramPartChildren())
        {
            if (child instanceof SubProgram)
            {
                SubProgram subProgram  = (SubProgram) child;
                if (subProgram.getTitle().equals(contentTitle))
                {
                    return subProgram;
                }
            }
        }
        return null;
    }
    
    /**
     * Get the list of "shared with" program from the remote document
     * @param contentNode The content node
     * @param logger the logger
     * @return The CDM code of shared program
     */
    protected List<String> _getSharedWithAsString (Node contentNode, Logger logger)
    {
        List<String> codes = new ArrayList<>();
        
        Node sharedWithNode = _xPathProcessor.selectSingleNode(contentNode, AbstractProgram.SHARED_WITH);
        
        if (sharedWithNode != null)
        {
            NodeList itemNodes = sharedWithNode.getChildNodes();
            for (int j = 0; j < itemNodes.getLength(); j++)
            {
                String code = itemNodes.item(j).getTextContent().trim();
                if (StringUtils.isNotBlank(code))
                {
                    codes.add(code);
                }
            }
        }
        
        return codes;
    }
    
    /**
     * Get the main subprogram shared with the program representing by the content node
     * @param mentionProgram the root mention program
     * @param contentNode the content node
     * @param logger the logger
     * @return the main subprogram if the program is a shared subprogram or <code>null</code> otherwise
     */
    protected SubProgram _getMainSharedWithSubProgram(Program mentionProgram, Node contentNode, Logger logger)
    {
        String programCode = _xPathProcessor.evaluateAsString(contentNode, ProgramItem.METADATA_CODE);
        
        for (ProgramPart child : mentionProgram.getProgramPartChildren())
        {
            if (child instanceof SubProgram)
            {
                SubProgram subProgram  = (SubProgram) child;
                List<String> sharedProgram = Arrays.asList(subProgram.getSharedWith());
                if (sharedProgram.contains(programCode))
                {
                    return subProgram;
                }
            }
        }
        return null;
    }
    
    /**
     * Get the shared subprogram with the given code
     * @param mentionProgram The root mention program
     * @param code The CDMfr code
     * @param logger the logger
     * @return The shared subprogram if exist or <code>null</code> if not found
     */
    protected SubProgram _getSharedSubProgram (Program mentionProgram, String code, Logger logger)
    {
        for (ProgramPart child : mentionProgram.getProgramPartChildren())
        {
            if (child instanceof SubProgram)
            {
                SubProgram subProgram  = (SubProgram) child;
                if (subProgram.getCode().equals(code))
                {
                    return subProgram;
                }
            }
        }
        return null;
    }
    
    /**
     * Delete a shared secondary subprogram.
     * This subprogram was created by a precede import before the main subprogram was imported
     * @param sharedProgram the shared program
     * @param logger the logger
     */
    protected void deleteSharedSubProgram(ModifiableDefaultContent sharedProgram, Logger logger)
    {
        String title = sharedProgram.getTitle();
        String infoMsg = "Suppression du parcours partagé secondaire \"" + title + "\"";
        logger.info(infoMsg);
        
        String contentId = sharedProgram.getId();
        List<String> contentIds = Collections.singletonList(contentId);
        
        // Delete content bypassing the rights check
        Map<String, Object> results = _deleteODFContent.deleteContentsWithLog(contentIds, DeleteMode.FULL.name(), true);
        
        @SuppressWarnings("unchecked")
        Map<String, Object> result = (Map<String, Object>) results.get(contentId);
        if (result.containsKey("check-before-deletion-failed") && (boolean) result.get("check-before-deletion-failed"))
        {
            logger.warn("Can't deleted shared content " + title + " (" + contentId + "). See previous logs for more information.");
        }
    }

    /**
     * Synchronize the shared metadata of a shared subprogram before deleting the subprogram
     * @param rootProgram The root mention
     * @param mainSubProgram The main subprogram
     * @param sharedWith The CDMfr of shared subprogram
     * @param catalog the catalog
     * @param lang the language
     * @param logger The logger
     * @return <code>true</code> if changes were made
     */
    protected boolean _synchronizeAndDeleteSharedSubPrograms (Program rootProgram, SubProgram mainSubProgram, List<String> sharedWith, String catalog, String lang, Logger logger)
    {
        boolean hasChanged = false;
        
        // Browse existing shared subprograms to first merge them then delete them.
        for (String code : sharedWith)
        {
            SubProgram sharedSubProgram = _getSharedSubProgram(rootProgram, code, logger);
            if (sharedSubProgram != null)
            {
                String infoMsg = "Fusion avec le parcours partagé \"" + sharedSubProgram.getTitle() + "\"";
                logger.info(infoMsg);
                
                try
                {
                    _synchronizeSharedMetadata(null, null, mainSubProgram, sharedSubProgram, _metadataPathsToMerge, catalog, lang, logger);
                }
                catch (RepositoryException e)
                {
                    String warnMsg = "Impossible de synchronizer les metadatas du programme partagé \"" + sharedSubProgram.getTitle() + "\" avec le programme principal \"" + mainSubProgram.getTitle() + "\"";
                    logger.warn(warnMsg);
                }
                
                // Then delete the secondary shared subprogram
                deleteSharedSubProgram(sharedSubProgram, logger);
                hasChanged = true;
            }
        }
        
        return hasChanged;
    }
    
    /**
     * Synchronize the shared program node for a main subprogram, from a secondary subprogram
     * @param doc the document. Can be null if the sharedProgram is not
     * @param sharedProgramNode the shared program node. Can be null if the sharedProgram is not
     * @param mainProgram the main program
     * @param sharedProgram the shared program. Can be null if the doc and the sharedProgramNode is not
     * @param metadataToMerge the set of metadata to merge
     * @param catalog the catalog
     * @param lang the language
     * @param logger the logger
     * @return <code>true</code> if changes were made
     * @throws RepositoryException if an error occurred
     */
    public boolean _synchronizeSharedMetadata(Document doc, Node sharedProgramNode, SubProgram mainProgram, SubProgram sharedProgram, Set<String> metadataToMerge, String catalog, String lang, Logger logger) throws RepositoryException
    {
        boolean hasChanged = false;
        
        ModifiableCompositeMetadata sharedMetadataHolder = _getSharedMetadataHolder(doc, sharedProgramNode, mainProgram, sharedProgram, logger);
        for (String metadataPath : metadataToMerge)
        {
            ContentType cType = _contentTypeEP.getExtension(SubProgramFactory.SUBPROGRAM_CONTENT_TYPE);
            
            if (_mergeMetadataHelper.isValidMetadataPath(cType, metadataPath, logger))
            {
                String[] pathSegments = StringUtils.split(metadataPath, '/');
                MetadataDefinition metadataDefinition = cType.getMetadataDefinition(pathSegments[0]);
                
                if (metadataDefinition.isMultiple())
                {
                    hasChanged = _synchronizeSharedMultipleMetadata(doc, sharedProgramNode, mainProgram, sharedProgram, metadataDefinition, sharedMetadataHolder, metadataPath, catalog, lang, logger) || hasChanged;
                }
                else
                {
                    hasChanged = _synchronizeSharedSingleMetadata(doc, sharedProgramNode, mainProgram, sharedProgram, metadataDefinition, sharedMetadataHolder, metadataPath, catalog, lang, logger) || hasChanged;
                }
            }
        }
        
        return hasChanged;
    }

    /**
     * Get the metadata composite holding shared metadata of subprograms
     * @param doc the document. Can be null if the sharedProgram is not
     * @param sharedProgramNode the shared program node. Can be null if the sharedProgram is not
     * @param mainProgram the main program
     * @param sharedProgram the shared program. Can be null if the doc and the sharedProgramNode is not
     * @param logger the logger
     * @return the shared metadata holder
     * @throws RepositoryException if an error occurred
     */
    protected ModifiableCompositeMetadata _getSharedMetadataHolder(Document doc, Node sharedProgramNode, SubProgram mainProgram, SubProgram sharedProgram, Logger logger) throws RepositoryException
    {
        // The data comes from a content
        if (doc == null)
        {
            return _mergeMetadataHelper.getSharedMetadataHolder(mainProgram, sharedProgram.getCode(), logger);
        }
        else // The data comes from the DOM
        {
            String sharedProgramCode = _xPathProcessor.evaluateAsString(sharedProgramNode, ProgramItem.METADATA_CODE);
            return _mergeMetadataHelper.getSharedMetadataHolder(mainProgram, sharedProgramCode, logger);
        }
    }
    
    /**
     * Synchronize a shared multiple metadata for shared program
     * @param doc the document. Can be null if the sharedProgram is not
     * @param sharedProgramNode the shared program node. Can be null if the sharedProgram is not
     * @param mainProgram the main program
     * @param sharedProgram the shared program. Can be null if the doc and the sharedProgramNode is not
     * @param metadataDefinition the metadata definition
     * @param sharedMetadataHolder the metadata composite holding shared metadata of subprograms
     * @param logicalMetadataPath The logical metadata path (to retrieve the definition)
     * @param catalog the catalog
     * @param lang the language
     * @param logger the logger
     * @return <code>true</code> if changes were made
     */
    protected boolean _synchronizeSharedMultipleMetadata(Document doc, Node sharedProgramNode, SubProgram mainProgram, SubProgram sharedProgram, MetadataDefinition metadataDefinition, ModifiableCompositeMetadata sharedMetadataHolder, String logicalMetadataPath, String catalog, String lang, Logger logger)
    {
        boolean hasChanged = false;
        ContentType contentType = _contentTypeEP.getExtension(SubProgramFactory.SUBPROGRAM_CONTENT_TYPE);
        Map<String, Object> params = ImmutableMap.of("contentType", contentType.getId());
        boolean synchronize = getLocalAndExternalFields(params).contains(logicalMetadataPath);
        
        MetadataType type = metadataDefinition.getType();
        
        // Data comes from a content
        List<Object> metadataValues = new ArrayList<>();
        if (doc == null)
        {
            metadataValues = _getMultipleValuesFromContent(sharedProgram, logicalMetadataPath, type, logger);
        }
        else
        {
            metadataValues = _getMultipleValuesFromDOM(doc, sharedProgramNode, mainProgram, metadataDefinition, logicalMetadataPath, type, catalog, lang, logger);
        }
        
        
        Map<String, Boolean> resultMap = _synchroComponent.synchronizeMetadata(mainProgram, contentType, logicalMetadataPath, sharedMetadataHolder, logicalMetadataPath, metadataValues, synchronize, false, logger);
        if (resultMap.getOrDefault("error", Boolean.FALSE))
        {
            _nbError++;
        }
        hasChanged = resultMap.getOrDefault("hasChanges", Boolean.FALSE).booleanValue();
        
        return hasChanged;
    }

    /**
     * Get multiple values from content 
     * @param sharedProgram the shared program
     * @param logicalMetadataPath The logical metadata path (to retrieve the definition)
     * @param type the type of the data to retrieve
     * @param logger the logger
     * @return the list of values
     */
    protected List<Object> _getMultipleValuesFromContent(SubProgram sharedProgram, String logicalMetadataPath, MetadataType type, Logger logger)
    {
        List<Object> metadataValues = new ArrayList<>();
        ModifiableCompositeMetadata metadataHolder = sharedProgram.getMetadataHolder();
        switch (type)
        {
            case STRING:
            case REFERENCE:
            case CONTENT:
                for (String value : metadataHolder.getStringArray(logicalMetadataPath, new String[0]))
                {
                    metadataValues.add(value);
                }
                break;
            case DOUBLE:
                for (double value : metadataHolder.getDoubleArray(logicalMetadataPath, new double[0]))
                {
                    metadataValues.add(value);
                }
                break;
            case LONG:
                for (long value : metadataHolder.getLongArray(logicalMetadataPath, new long[0]))
                {
                    metadataValues.add(value);
                }
                break;
            default:
                String warn = "Le type de métadonnée " + type.toString() + " n'est pas supporté pour la fusion des parcours partagées. La métadonnée '" + logicalMetadataPath + "' est ignorée.";
                logger.warn(warn);
                break;    
        }
        
        return metadataValues;
    }
    
    /**
     * Get multiple values from DOM 
     * @param doc the document
     * @param sharedProgramDOM the shared program node
     * @param mainProgram the main program
     * @param metadataDefinition the metadata definition
     * @param logicalMetadataPath The logical metadata path (to retrieve the definition)
     * @param type the type of the data to retrieve
     * @param catalog the catalog
     * @param lang the lang
     * @param logger the logger
     * @return the list of values
     */
    protected List<Object> _getMultipleValuesFromDOM (Document doc, Node sharedProgramDOM, SubProgram mainProgram, MetadataDefinition metadataDefinition, String logicalMetadataPath, MetadataType type, String catalog, String lang, Logger logger)
    {
        List<String> metadataValues = new ArrayList<>();
        
        Node metadataNode = _xPathProcessor.selectSingleNode(sharedProgramDOM, logicalMetadataPath);
        if (metadataNode != null)
        {
            switch (type)
            {
                case STRING:
                case REFERENCE:
                case CONTENT:
                    NodeList itemNodes = metadataNode.getChildNodes();
                    for (int j = 0; j < itemNodes.getLength(); j++)
                    {
                        String metadataValue = itemNodes.item(j).getTextContent().trim();
                        if (StringUtils.isNotEmpty(metadataValue))
                        {
                            metadataValues.add(metadataValue);
                        }
                    }
                    break;
                default:
                    String warn = "Le type de métadonnée " + type.toString() + " n'est pas supporté pour la fusion des parcours partagées. La métadonnée '" + logicalMetadataPath + "' est ignorée.";
                    logger.warn(warn);
            }
        }
        
        return _handleMetadataValues(doc, mainProgram, metadataDefinition, metadataValues, lang, catalog, logger);
    }
    
    /**
     * Synchronize single metadata for shared program
     * @param doc the document. Can be null if the sharedProgram is not
     * @param sharedProgramNode the shared program node. Can be null if the sharedProgram is not
     * @param mainProgram the main program
     * @param sharedProgram the shared program. Can be null if the doc and the sharedProgramNode is not
     * @param metadataDefinition the metadata definition
     * @param sharedMetadataHolder the metadata composite holding shared metadata of subprograms
     * @param logicalMetadataPath The logical metadata path (to retrieve the definition)
     * @param catalog the catalog
     * @param lang the language
     * @param logger the logger
     * @return <code>true</code> if changes were made
     */
    protected boolean _synchronizeSharedSingleMetadata(Document doc, Node sharedProgramNode, SubProgram mainProgram, SubProgram sharedProgram, MetadataDefinition metadataDefinition, ModifiableCompositeMetadata sharedMetadataHolder, String logicalMetadataPath, String catalog, String lang, Logger logger)
    {
        MetadataType type = metadataDefinition.getType();
        switch (type)
        {
            case COMPOSITE:
                if (metadataDefinition instanceof RepeaterDefinition)
                {
                    if (doc == null)
                    {
                        return synchronizeRepeaterMetadataFromContent(sharedProgram, sharedMetadataHolder, logicalMetadataPath, logger);
                    }
                    else
                    {
                        return synchronizeRepeaterMetadataFromDOM(doc, sharedProgramNode, mainProgram, metadataDefinition, sharedMetadataHolder, logicalMetadataPath, catalog, lang, logger);
                    }
                }
                else
                {
                    String warn = "Le type de métadonnée " + type.toString() + " n'est pas supporté pour la fusion des parcours partagées. La métadonnée '" + logicalMetadataPath + "' est ignorée.";
                    logger.warn(warn);
                    break;    
                }
            default:
                String warn = "Le type de métadonnée " + type.toString() + " n'est pas supporté pour la fusion des parcours partagées. La métadonnée '" + logicalMetadataPath + "' est ignorée.";
                logger.warn(warn);
                break;
        }
        return false;
    }
  
    /**
     * Synchronize repeater from content
     * @param sharedProgram the shared program
     * @param sharedMetadataHolder the metadata composite holding shared metadata of subprograms
     * @param logicalMetadataPath The logical metadata path (to retrieve the definition)
     * @param logger the logger
     * @return <code>true</code> if changes were made
     */
    protected boolean synchronizeRepeaterMetadataFromContent(SubProgram sharedProgram, ModifiableCompositeMetadata sharedMetadataHolder, String logicalMetadataPath, Logger logger)
    {
        if (sharedMetadataHolder.hasMetadata(logicalMetadataPath))
        {
            // Remove old values
            sharedMetadataHolder.removeMetadata(logicalMetadataPath);
        }
        
        if (sharedProgram.getMetadataHolder().hasMetadata(logicalMetadataPath))
        {
            ModifiableCompositeMetadata sharedRepeater = sharedMetadataHolder.getCompositeMetadata(logicalMetadataPath, true);
            ModifiableCompositeMetadata repeaterToCopy = sharedProgram.getMetadataHolder().getCompositeMetadata(logicalMetadataPath);
            repeaterToCopy.copyTo(sharedRepeater);
        }
        
        return true;
    }

    /**
     * Synchronize repeater from DOM
     * @param doc the document
     * @param sharedProgramNode the shared program node
     * @param mainProgram the main program
     * @param metadataDefinition the metadata definition
     * @param sharedMetadataHolder the metadata composite holding shared metadata of subprograms
     * @param logicalMetadataPath The logical metadata path (to retrieve the definition)
     * @param catalog the catalog
     * @param lang the language
     * @param logger the logger
     * @return <code>true</code> if changes were made
     */
    protected boolean synchronizeRepeaterMetadataFromDOM(Document doc, Node sharedProgramNode, SubProgram mainProgram, MetadataDefinition metadataDefinition, ModifiableCompositeMetadata sharedMetadataHolder, String logicalMetadataPath, String catalog, String lang, Logger logger)
    {
        boolean hasChanges = false;
        Node metadataNode = _xPathProcessor.selectSingleNode(sharedProgramNode, logicalMetadataPath);
        if (metadataNode != null)
        {
            ModifiableCompositeMetadata repeater = sharedMetadataHolder.getCompositeMetadata(logicalMetadataPath, true);
            
            // Remove locale entries (unable to compare locales and remotes ...)
            String[] metadataNames = repeater.getMetadataNames();
            for (String entryName : metadataNames)
            {
                repeater.removeMetadata(entryName);
                hasChanges = true;
            }
            
            ModifiableCompositeMetadata repeaterMetadataHolder = sharedMetadataHolder.getCompositeMetadata(logicalMetadataPath, true);

            // Create new entries from remote data
            NodeList entryNodes = metadataNode.getChildNodes();
            for (int i = 0; i < entryNodes.getLength(); i++)
            {
                Node entryNode = entryNodes.item(i);
                String entryName = entryNode.getAttributes().getNamedItem("name").getTextContent().trim();
                
                NodeList childNodes = entryNode.getChildNodes();
                for (int j = 0; j < childNodes.getLength(); j++)
                {
                    Node childNode = childNodes.item(j);
                    String subMetadataName = childNode.getLocalName();
                    
                    ModifiableCompositeMetadata entryMetadataHolder = repeaterMetadataHolder.getCompositeMetadata(entryName, true);
                    hasChanges = synchronizeSimpleMetadataFromDOM(doc, mainProgram, childNode, metadataDefinition.getMetadataDefinition(subMetadataName), logicalMetadataPath + "/" + subMetadataName, entryMetadataHolder, subMetadataName, catalog, lang, logger)  || hasChanges;
                }
            }
        }
        
        return hasChanges;
    }
    
    /**
     * Synchronize a simple metadata from DOM
     * @param doc the document
     * @param subProgram the subProgram content
     * @param metadataNode The metadata DOM node
     * @param metadataDefinition the metadata definition
     * @param logicalMetadataPath The logical metadata path (to retrieve the definition)
     * @param sharedMetadataHolder the metadata composite holding shared metadata of subprograms
     * @param metadataName the metadata name
     * @param catalog the catalog
     * @param lang the language
     * @param logger The logger
     * @return <code>true</code> if changes were made
     */
    public boolean synchronizeSimpleMetadataFromDOM (Document doc, SubProgram subProgram, Node metadataNode, MetadataDefinition metadataDefinition, String logicalMetadataPath, ModifiableCompositeMetadata sharedMetadataHolder, String metadataName, String catalog, String lang, Logger logger)
    {
        List<String> metadataValues = null;
        ContentType contentType = _contentTypeEP.getExtension(SubProgramFactory.SUBPROGRAM_CONTENT_TYPE);
        
        MetadataType type = metadataDefinition.getType();
        switch (type)
        {
            case BINARY:
                return _handleBinaryMetadata(metadataNode, subProgram, sharedMetadataHolder, metadataName, false, logger);
            case FILE:
                return _handleFileMetadata(metadataNode, subProgram, logicalMetadataPath, sharedMetadataHolder, metadataName, false, contentType, logger);
            case GEOCODE:
                return _handleGeocodeMetadata(metadataNode, subProgram, sharedMetadataHolder, metadataName, false);
            case CONTENT:
            case STRING:
            case LONG:
            case DOUBLE:
            case REFERENCE:
            case BOOLEAN:
                if (metadataDefinition.isMultiple())
                {
                    NodeList itemNodes = metadataNode.getChildNodes();
                    metadataValues = new ArrayList<>();
                    for (int j = 0; j < itemNodes.getLength(); j++)
                    {
                        String metadataValue = itemNodes.item(j).getTextContent().trim();
                        if (StringUtils.isNotEmpty(metadataValue))
                        {
                            metadataValues.add(metadataValue);
                        }
                    }
                }
                else
                {
                    String metadataValue = metadataNode.getTextContent().trim();
                    if (StringUtils.isNotEmpty(metadataValue))
                    {
                        metadataValues = ImmutableList.of(metadataValue);
                    }
                }
                break;
            default:
                String warn = "Le type de métadonnée '" + type.toString() + "' n'est pas supporté pour la fusion des entrées de repeater de parcours partagés. La métadonnée est ignorée"; 
                logger.warn(warn);
                return false;
        }
        
        List<Object> handleMetadataValues = _handleMetadataValues(doc, subProgram, metadataDefinition, metadataValues, lang, catalog, logger);
        Map<String, Boolean> resultMap = _synchroComponent.synchronizeMetadata(subProgram, contentType, logicalMetadataPath, sharedMetadataHolder, metadataName, handleMetadataValues, false, false, logger);
        if (resultMap.getOrDefault("error", Boolean.FALSE))
        {
            _nbError++;
        }
        return resultMap.getOrDefault("hasChanges", Boolean.FALSE).booleanValue();
    }
}