/*
 *  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;

import java.io.ByteArrayInputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.net.URL;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Date;
import java.util.HashMap;
import java.util.HashSet;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.Objects;
import java.util.Set;

import javax.jcr.RepositoryException;
import javax.xml.transform.TransformerException;

import org.apache.avalon.framework.activity.Initializable;
import org.apache.avalon.framework.component.Component;
import org.apache.avalon.framework.configuration.Configurable;
import org.apache.avalon.framework.configuration.Configuration;
import org.apache.avalon.framework.configuration.ConfigurationException;
import org.apache.avalon.framework.configuration.DefaultConfigurationBuilder;
import org.apache.avalon.framework.context.ContextException;
import org.apache.avalon.framework.context.Contextualizable;
import org.apache.avalon.framework.service.ServiceException;
import org.apache.avalon.framework.service.ServiceManager;
import org.apache.avalon.framework.service.Serviceable;
import org.apache.cocoon.Constants;
import org.apache.cocoon.ProcessingException;
import org.apache.cocoon.environment.Context;
import org.apache.commons.collections4.CollectionUtils;
import org.apache.commons.io.IOUtils;
import org.apache.commons.lang3.StringUtils;
import org.apache.excalibur.xml.dom.DOMParser;
import org.apache.excalibur.xml.xpath.PrefixResolver;
import org.apache.excalibur.xml.xpath.XPathProcessor;
import org.slf4j.Logger;
import org.w3c.dom.Document;
import org.w3c.dom.Element;
import org.w3c.dom.NamedNodeMap;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;
import org.xml.sax.InputSource;
import org.xml.sax.SAXException;

import org.ametys.cms.ObservationConstants;
import org.ametys.cms.content.external.ExternalizableMetadataHelper;
import org.ametys.cms.content.external.ExternalizableMetadataProvider.ExternalizableMetadataStatus;
import org.ametys.cms.contenttype.ContentType;
import org.ametys.cms.contenttype.ContentTypeExtensionPoint;
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.ModifiableContent;
import org.ametys.cms.repository.ModifiableDefaultContent;
import org.ametys.cms.repository.comment.CommentsDAO;
import org.ametys.core.observation.Event;
import org.ametys.core.observation.ObservationManager;
import org.ametys.core.user.CurrentUserProvider;
import org.ametys.core.user.population.UserPopulationDAO;
import org.ametys.core.util.URIUtils;
import org.ametys.odf.ProgramItem;
import org.ametys.odf.catalog.CatalogsManager;
import org.ametys.odf.course.Course;
import org.ametys.odf.course.CourseFactory;
import org.ametys.odf.course.ShareableCourseHelper;
import org.ametys.odf.courselist.CourseList;
import org.ametys.odf.courselist.CourseListFactory;
import org.ametys.odf.coursepart.CoursePart;
import org.ametys.odf.coursepart.CoursePartFactory;
import org.ametys.odf.enumeration.OdfReferenceTableEntry;
import org.ametys.odf.enumeration.OdfReferenceTableHelper;
import org.ametys.odf.observation.OdfObservationConstants;
import org.ametys.odf.orgunit.OrgUnit;
import org.ametys.odf.orgunit.OrgUnitFactory;
import org.ametys.odf.orgunit.RootOrgUnitProvider;
import org.ametys.odf.person.PersonFactory;
import org.ametys.odf.program.ContainerFactory;
import org.ametys.odf.program.ProgramFactory;
import org.ametys.odf.program.ProgramPart;
import org.ametys.odf.program.SubProgramFactory;
import org.ametys.odf.program.TraversableProgramPart;
import org.ametys.odf.translation.TranslationHelper;
import org.ametys.plugins.contentio.ContentImporterHelper;
import org.ametys.plugins.contentio.synchronize.BaseSynchroComponent;
import org.ametys.plugins.odfsync.cdmfr.CDMFrSyncExtensionPoint;
import org.ametys.plugins.odfsync.cdmfr.transformers.CDMFrSyncTransformer;
import org.ametys.plugins.repository.AmetysObjectIterable;
import org.ametys.plugins.repository.AmetysObjectResolver;
import org.ametys.plugins.repository.AmetysRepositoryException;
import org.ametys.plugins.repository.metadata.CompositeMetadata;
import org.ametys.plugins.repository.metadata.ModifiableBinaryMetadata;
import org.ametys.plugins.repository.metadata.ModifiableCompositeMetadata;
import org.ametys.plugins.repository.metadata.ModifiableFile;
import org.ametys.plugins.repository.metadata.ModifiableResource;
import org.ametys.plugins.repository.metadata.ModifiableRichText;
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.OrExpression;
import org.ametys.plugins.repository.query.expression.StringExpression;
import org.ametys.runtime.config.Config;

/**
 * Abstract class of a component to import a CDM-fr input stream.
 */
public abstract class AbstractImportCDMFrComponent implements ImportCDMFrComponent, Serviceable, Initializable, Contextualizable, Configurable, Component
{
    /** Tag to identify a program */
    protected static final String _TAG_PROGRAM = "program";

    /** Tag to identify a subprogram */
    protected static final String _TAG_SUBPROGRAM = "subProgram";
    
    /** Tag to identify a container */
    protected static final String _TAG_CONTAINER = "container";
    
    /** Tag to identify a courseList */
    protected static final String _TAG_COURSELIST = "coursesReferences";
    
    /** Tag to identify a coursePart */
    protected static final String _TAG_COURSEPART = "coursePart";

    /** The synchronize workflow action id */
    private static final int SYNCHRONIZE_WORKFLOW_ACTION_ID = 800;
    
    private static final ContentWorkflowDescription _PROGRAM_WF_DESCRIPTION = new ContentWorkflowDescription(ProgramFactory.PROGRAM_CONTENT_TYPE, "program", 1, 4);
    private static final ContentWorkflowDescription _SUBPROGRAM_WF_DESCRIPTION = new ContentWorkflowDescription(SubProgramFactory.SUBPROGRAM_CONTENT_TYPE, "subprogram", 1, 4);
    private static final ContentWorkflowDescription _CONTAINER_WF_DESCRIPTION = new ContentWorkflowDescription(ContainerFactory.CONTAINER_CONTENT_TYPE, "container", 1, 4);
    private static final ContentWorkflowDescription _COURSELIST_WF_DESCRIPTION = new ContentWorkflowDescription(CourseListFactory.COURSE_LIST_CONTENT_TYPE, "courselist", 1, 4);
    private static final ContentWorkflowDescription _COURSE_WF_DESCRIPTION = new ContentWorkflowDescription(CourseFactory.COURSE_CONTENT_TYPE, "course", 1, 4);
    private static final ContentWorkflowDescription _COURSEPART_WF_DESCRIPTION = new ContentWorkflowDescription(CoursePartFactory.COURSE_PART_CONTENT_TYPE, "course-part", 1, -1);
    private static final ContentWorkflowDescription _ORGUNIT_WF_DESCRIPTION = new ContentWorkflowDescription(OrgUnitFactory.ORGUNIT_CONTENT_TYPE, "orgunit", 1, 4);
    private static final ContentWorkflowDescription _PERSON_WF_DESCRIPTION = new ContentWorkflowDescription(PersonFactory.PERSON_CONTENT_TYPE, "person", 1, 4);

    private static final PrefixResolver _PREFIX_RESOLVER = new DocbookPrefixResolver();
    
    /** The Cocoon context */
    protected Context _cocoonContext;
    
    /** The DOM parser */
    protected DOMParser _domParser;

    /** The XPath processor */
    protected XPathProcessor _xPathProcessor;

    /** Extension point to transform CDM-fr */
    protected CDMFrSyncExtensionPoint _cdmFrSyncExtensionPoint;

    /** Default language configured for ODF */
    protected String _odfLang;
    
    /** The catalog manager */
    protected CatalogsManager _catalogsManager;

    /** The ametys object resolver */
    protected AmetysObjectResolver _resolver;

    /** The ODF TableRef Helper */
    protected OdfReferenceTableHelper _odfRefTableHelper;

    /** The content type extension point */
    protected ContentTypeExtensionPoint _contentTypeEP;

    /** The current user provider */
    protected CurrentUserProvider _currentUserProvider;

    /** The observation manager */
    protected ObservationManager _observationManager;
    
    /** The root orgunit provider */
    protected RootOrgUnitProvider _rootOUProvider;

    /** The base SCC component */
    protected BaseSynchroComponent _synchroComponent;
    
    /** The shareable course helper */
    protected ShareableCourseHelper _shareableCourseHelper;
    
    /** List of synchronized contents */
    protected Map<String, Integer> _importedContents;
    
    /** List of synchronized contents having differences */
    protected Set<String> _synchronizedContents;
    
    /** List of synchronized contents (to avoid a treatment twice or more) */
    protected Set<String> _updatedContents;

    /** Number of errors encountered */
    protected int _nbError;
    /** Number of created contents */
    protected int _nbCreatedContents;
    /** Number of synchronized contents */
    protected int _nbSynchronizedContents;
    /** Number of unchanged contents */
    protected int _nbNotChangedContents;
    /** The prefix of the contents */
    protected String _contentPrefix;
    /** Synchronized fields by content type */
    protected Map<String, Set<String>> _syncFieldsByContentType;

    public void initialize() throws Exception
    {
        _odfLang = Config.getInstance().getValue("odf.programs.lang");
    }

    @Override
    public void contextualize(org.apache.avalon.framework.context.Context context) throws ContextException
    {
        _cocoonContext = (Context) context.get(Constants.CONTEXT_ENVIRONMENT_CONTEXT);
    }

    public void configure(Configuration configuration) throws ConfigurationException
    {
        _parseSynchronizedFields();
    }
    
    @Override
    public void service(ServiceManager manager) throws ServiceException
    {
        _resolver = (AmetysObjectResolver) manager.lookup(AmetysObjectResolver.ROLE);
        _domParser = (DOMParser) manager.lookup(DOMParser.ROLE);
        _xPathProcessor = (XPathProcessor) manager.lookup(XPathProcessor.ROLE);
        _cdmFrSyncExtensionPoint = (CDMFrSyncExtensionPoint) manager.lookup(CDMFrSyncExtensionPoint.ROLE);
        _catalogsManager = (CatalogsManager) manager.lookup(CatalogsManager.ROLE);
        _odfRefTableHelper = (OdfReferenceTableHelper) manager.lookup(OdfReferenceTableHelper.ROLE);
        _contentTypeEP = (ContentTypeExtensionPoint) manager.lookup(ContentTypeExtensionPoint.ROLE);
        _currentUserProvider = (CurrentUserProvider) manager.lookup(CurrentUserProvider.ROLE);
        _observationManager = (ObservationManager) manager.lookup(ObservationManager.ROLE);
        _rootOUProvider = (RootOrgUnitProvider) manager.lookup(RootOrgUnitProvider.ROLE);
        _synchroComponent = (BaseSynchroComponent) manager.lookup(BaseSynchroComponent.ROLE);
        _shareableCourseHelper = (ShareableCourseHelper) manager.lookup(ShareableCourseHelper.ROLE);
    }

    @Override
    public String getIdField()
    {
        return "cdmfrSyncCode";
    }

    /**
     * Get the synchronized metadata from the configuration file
     * @throws ConfigurationException if the configuration is not valid.
     */
    private void _parseSynchronizedFields() throws ConfigurationException
    {
        _syncFieldsByContentType = new HashMap<>();
        
        @SuppressWarnings("resource")
        InputStream is = null;
        try
        {
            File apogeeMapping = new File(_cocoonContext.getRealPath("/WEB-INF/param/odf-synchro.xml"));
            if (!apogeeMapping.isFile())
            {
                is = getClass().getResourceAsStream("/org/ametys/plugins/odfsync/cdmfr/odf-synchro.xml");
            }
            else
            {
                is = new FileInputStream(apogeeMapping);
            }
            Configuration cfg = new DefaultConfigurationBuilder().build(is);

            Configuration[] cTypesConf = cfg.getChildren("content-type");
            for (Configuration cTypeConf : cTypesConf)
            {
                String contentType = cTypeConf.getAttribute("id");
                Set<String> syncMetadata = _configureSynchronizedFields(cTypeConf, "");
                _syncFieldsByContentType.put(contentType, syncMetadata);
            }
        }
        catch (Exception e)
        {
            throw new ConfigurationException("Error while parsing odf-synchro.xml", e);
        }
        finally
        {
            IOUtils.closeQuietly(is);
        }
    }

    private Set<String> _configureSynchronizedFields(Configuration configuration, String prefix) throws ConfigurationException
    {
        Set<String> syncMetadata = new HashSet<>();
        Configuration[] metaConf = configuration.getChildren("metadata");
        
        if (metaConf.length > 0)
        {
            for (Configuration metadata : metaConf)
            {
                if (metadata.getChildren("metadata").length > 0)
                {
                    // composite
                    syncMetadata.addAll(_configureSynchronizedFields(metadata, prefix + metadata.getAttribute("name") + "/"));
                }
                else
                {
                    syncMetadata.add(prefix + metadata.getAttribute("name"));
                }
            }
        }
        else if (configuration.getAttribute("name", null) != null)
        {
            syncMetadata.add(prefix + configuration.getAttribute("name"));
        }
        
        return syncMetadata;
    }
    
    @Override
    @SuppressWarnings("unchecked")
    public synchronized Map<String, Object> handleInputStream(InputStream input, Map<String, Object> parameters, Logger logger) throws ProcessingException
    {
        List<ModifiableDefaultContent> importedPrograms = new ArrayList<>();
        
        _importedContents = new HashMap<>();
        _synchronizedContents = new HashSet<>();
        _updatedContents = (Set<String>) parameters.getOrDefault("updatedContents", new HashSet<>());
        _nbCreatedContents = (int) parameters.getOrDefault("nbCreatedContents", 0);
        _nbSynchronizedContents = (int) parameters.getOrDefault("nbSynchronizedContents", 0);
        _nbNotChangedContents = (int) parameters.getOrDefault("nbNotChangedContents", 0);
        _nbError = (int) parameters.getOrDefault("nbError", 0);
        _contentPrefix = (String) parameters.getOrDefault("contentPrefix", "cdmfr-");
        additionalParameters(parameters);

        Map<String, Object> resultMap = new HashMap<>();
        
        try
        {
            Document doc = _domParser.parseDocument(new InputSource(input));
            doc = transformDocument(doc, new HashMap<String, Object>(), logger);

            if (doc != null)
            {
                String defaultLang = _getXPathString(doc, "CDM/@language", _odfLang);
                
                NodeList nodes = doc.getElementsByTagName(_TAG_PROGRAM);
                
                for (int i = 0; i < nodes.getLength(); i++)
                {
                    Node contentNode = nodes.item(i);
                    String syncCode = _xPathProcessor.evaluateAsString(contentNode, "@CDMid");
                    String contentLang = _getXPathString(contentNode, "@language", defaultLang);
                    contentLang = StringUtils.substring(contentLang, 0, 2).toLowerCase(); // on keep the language from the locale
                    
                    String catalog = getCatalogName(contentNode);

                    importedPrograms.add(_importOrSynchronizeContent(doc, contentNode, getProgramWfDescription(), syncCode, contentLang, catalog, syncCode, logger));
                }
                
                // Apply changes (synchronize action) -> only on newly synchronized contents
                boolean ignoreRights = ignoreRights();
                for (String contentId : _synchronizedContents)
                {
                    ModifiableDefaultContent content = _resolver.resolveById(contentId);
                    _synchroComponent.applyChanges(content, SYNCHRONIZE_WORKFLOW_ACTION_ID, org.ametys.plugins.contentio.synchronize.observation.ObservationConstants.EVENT_CONTENT_SYNCHRONIZED, ignoreRights, logger);
                }
                
                // Validate contents -> only on newly imported contents
                if (validateAfterImport())
                {
                    for (String contentId : _importedContents.keySet())
                    {
                        ModifiableDefaultContent content = _resolver.resolveById(contentId);
                        Integer validationActionId = _importedContents.get(contentId);
                        if (validationActionId > 0)
                        {
                            _synchroComponent.validateContent(content, validationActionId, ignoreRights, logger);
                        }
                    }
                }
            }
        }
        catch (IOException | ProcessingException e)
        {
            throw new ProcessingException("An error occured while transforming the stream.", e);
        }
        catch (SAXException e)
        {
            throw new ProcessingException("An error occured while parsing the stream.", e);
        }
        catch (RepositoryException e)
        {
            throw new ProcessingException("An error occured while applying changes on contents.", e);
        }

        resultMap.put("importedContents", _importedContents.keySet());
        resultMap.put("synchronizedContents", _synchronizedContents);
        resultMap.put("updatedContents", _updatedContents);
        resultMap.put("nbCreatedContents", _nbCreatedContents);
        resultMap.put("nbSynchronizedContents", _nbSynchronizedContents);
        resultMap.put("nbNotChangedContents", _nbNotChangedContents);
        resultMap.put("nbError", _nbError);
        resultMap.put("importedPrograms", importedPrograms);

        return resultMap;
    }

    /**
     * True to validate the contents after import
     * @return True to validate the contents after import
     */
    protected abstract boolean validateAfterImport();

    /**
     * When returns true, a content created by a previous synchro will be removed if it does not exist anymore during the current synchro.
     * @return true if a content created by a previous synchro has to be removed if it does not exist anymore during the current synchro.
     */
    protected abstract boolean removalSync();
    
    /**
     * Transform the document depending of it structure.
     * @param document Document to transform.
     * @param parameters Optional parameters for transformation
     * @param logger The logger
     * @return The transformed document.
     * @throws IOException if an error occurs.
     * @throws SAXException if an error occurs.
     * @throws ProcessingException if an error occurs.
     */
    protected Document transformDocument(Document document, Map<String, Object> parameters, Logger logger) throws IOException, SAXException, ProcessingException
    {
        CDMFrSyncTransformer transformer = _cdmFrSyncExtensionPoint.getTransformer(document);
        if (transformer == null)
        {
            logger.error("Cannot match a CDM-fr transformer to this file structure.");
            return null;
        }
        
        return transformer.transform(document, parameters);
    }

    /**
     * Get the name of catalog to use for import
     * @param contentNode The node of program
     * @return The catalog to used
     */
    protected String getCatalogName(Node contentNode)
    {
        String defaultCatalog = _catalogsManager.getDefaultCatalogName();
        
        String contentCatalog = _getXPathString(contentNode, "catalog", defaultCatalog);
        if (_catalogsManager.getCatalog(contentCatalog) == null)
        {
            // Catalog is empty or do not exist, use the default catalog
            return defaultCatalog;
        }
        
        return contentCatalog;
    }
    
    /**
     * Get or create the content from the synchronization code, the lang, the catalog and the content type.
     * @param title The title
     * @param lang The lang
     * @param catalog The catalog
     * @param syncCode The synchronization code
     * @param wfDescription The workflow description
     * @param logger The logger
     * @return the retrieved or created content
     * @throws RepositoryException if an error occurs
     */
    protected ModifiableDefaultContent _getOrCreateContent(String title, String lang, String catalog, String syncCode, ContentWorkflowDescription wfDescription, Logger logger) throws RepositoryException
    {
        ModifiableDefaultContent receivedContent = _getContent(lang, catalog, syncCode, wfDescription);
        if (receivedContent != null)
        {
            return receivedContent;
        }
        
        Map<String, Object> resultMap = _synchroComponent.createContentAction(wfDescription.getContentType(), wfDescription.getWorkflowName(), wfDescription.getInitialActionId(), lang, title, _contentPrefix, logger);
        if ((boolean) resultMap.getOrDefault("error", false))
        {
            _nbError++;
        }
        
        ModifiableDefaultContent content = (ModifiableDefaultContent) resultMap.get("content");
        
        if (content != null)
        {
            ExternalizableMetadataHelper.setMetadata(content.getMetadataHolder(), getIdField(), syncCode);
            if (catalog != null && (content instanceof ProgramItem || content instanceof CoursePart))
            {
                ExternalizableMetadataHelper.setMetadata(content.getMetadataHolder(), ProgramItem.CATALOG, catalog);
            }
            additionalOperationsBeforeSave(content, logger);
            content.saveChanges();
            _importedContents.put(content.getId(), wfDescription.getValidationActionId());
            _nbCreatedContents++;
        }
        return content;
    }

    /**
     * Get the content from the synchronization code, the lang, the catalog and the content type.
     * @param lang The lang
     * @param catalog The catalog
     * @param syncCode The synchronization code
     * @param wfDescription The workflow description
     * @return the retrieved content
     */
    protected ModifiableDefaultContent _getContent(String lang, String catalog, String syncCode, ContentWorkflowDescription wfDescription)
    {
        List<Expression> expList = getExpressionsList(lang, syncCode, wfDescription.getContentType(), catalog);
        AndExpression andExp = new AndExpression(expList.toArray(new Expression[expList.size()]));
        String xPathQuery = ContentQueryHelper.getContentXPathQuery(andExp);

        AmetysObjectIterable<ModifiableDefaultContent> contents = _resolver.query(xPathQuery);

        if (contents.getSize() > 0)
        {
            return contents.iterator().next();
        }
        
        return null;
    }
    
    /**
     * Additional parameters for specific treatments.
     * @param parameters The parameters map to get
     */
    protected abstract void additionalParameters(Map<String, Object> parameters);
    
    /**
     * Additional operation to do on the content before saving it.
     * @param content The content
     * @param logger The logger
     * @throws RepositoryException if an error occurs
     */
    protected abstract void additionalOperationsBeforeSave(ModifiableDefaultContent content, Logger logger) throws RepositoryException;
    
    /**
     * Import or synchronize the content.
     * @param doc XML document
     * @param contentNode Node of the content
     * @param wfDescription The workflow description
     * @param title The title
     * @param lang The lang
     * @param catalog The catalog
     * @param syncCode The synchronization code
     * @param logger The logger
     * @return The imported or synchronized content
     */
    protected ModifiableDefaultContent _importOrSynchronizeContent(Document doc, Node contentNode, ContentWorkflowDescription wfDescription, String title, String lang, String catalog, String syncCode, Logger logger)
    {
        ModifiableDefaultContent content = null;
        try
        {
            content = _getOrCreateContent(title, lang, catalog, syncCode, wfDescription, logger);
            if (content != null)
            {
                _synchronizeContent(doc, contentNode, content, wfDescription.getContentType(), lang, catalog, syncCode, logger);
            }
        }
        catch (RepositoryException e)
        {
            _nbError++;
            logger.error("An error occurred while importing or synchronizing content", e);
        }
        return content;
    }
    
    /**
     * Synchronize content 
     * @param doc The root document
     * @param contentNode the DOM content node
     * @param content The content to synchronize
     * @param contentTypeId The content type ID
     * @param lang Parent program language (to select the good courses in the CDM-FR file)
     * @param catalog The catalog of parent program
     * @param syncCode The synchronization code
     * @param logger The logger
     */
    protected void _synchronizeContent(Document doc, Node contentNode, ModifiableDefaultContent content, String contentTypeId, String lang, String catalog, String syncCode, Logger logger)
    {
        if (_updatedContents.add(content.getId()))
        {
            logger.info("Synchronization of the content '{}' with the content type '{}'", content.getTitle(), contentTypeId);
            
            List<ModifiableDefaultContent> children = new LinkedList<>();
            List<ModifiableDefaultContent> courseParts = new LinkedList<>();
            boolean removeOldCourseParts = false;
            
            if (content.isLocked())
            {
                logger.warn("The content '{}' ({}) is currently locked by user {}: it cannot be synchronized", content.getTitle(), content.getId(), content.getLockOwner());
            }
            else
            {
                boolean hasChanges = false;
                ContentType contentType = _contentTypeEP.getExtension(contentTypeId);
                int courseListPosition = 0;
                
                NodeList metadataNodes = contentNode.getChildNodes();
                for (int i = 0; i < metadataNodes.getLength(); i++)
                {
                    Node metadataNode = metadataNodes.item(i);
                    String metadataName = metadataNode.getLocalName();
                    
                    if (metadataName.equals(_TAG_SUBPROGRAM))
                    {
                        String subContentSyncCode = _xPathProcessor.evaluateAsString(metadataNode, "@CDMid");
                        String title = _xPathProcessor.evaluateAsString(metadataNode, "title");
                        ModifiableDefaultContent subProgram = _importOrSynchronizeContent(doc, metadataNode, getSubProgramWfDescription(), title, lang, catalog, subContentSyncCode, logger);
                        CollectionUtils.addIgnoreNull(children, subProgram);
                    }
                    else if (metadataName.equals(_TAG_CONTAINER))
                    {
                        String subContentSyncCode = _xPathProcessor.evaluateAsString(metadataNode, "@CDMid");
                        String title = _xPathProcessor.evaluateAsString(metadataNode, "title");
                        ModifiableDefaultContent container = _importOrSynchronizeContent(doc, metadataNode, getContainerWfDescription(), title, lang, catalog, subContentSyncCode, logger);
                        CollectionUtils.addIgnoreNull(children, container);
                    }
                    else if (metadataName.equals(_TAG_COURSELIST))
                    {
                        courseListPosition++;
                        // For courseList from another source than Ametys, there is no unique code, then a code is generated with the parent ID and the position in the parent : [parentId]-[position]
                        String subContentSyncCode = _getXPathString(metadataNode, "@code", syncCode + "-" + courseListPosition);
                        String title = _getXPathString(metadataNode, "@name", "Liste d'éléments pédagogiques");
                        ModifiableDefaultContent courseList = _importOrSynchronizeContent(doc, metadataNode, getCourseListWfDescription(), title, lang, catalog, subContentSyncCode, logger);
                        if (courseList != null)
                        {
                            _synchronizeCourseList(doc, metadataNode, courseList, lang, catalog, logger);
                            children.add(courseList);
                        }
                    }
                    else if (metadataName.equals(_TAG_COURSEPART))
                    {
                        String subContentSyncCode = _xPathProcessor.evaluateAsString(metadataNode, "code");
                        if (StringUtils.isEmpty(subContentSyncCode))
                        {
                            subContentSyncCode = org.ametys.core.util.StringUtils.generateKey().toUpperCase();
                            removeOldCourseParts = true;
                        }
                        String title = _xPathProcessor.evaluateAsString(metadataNode, "title");
                        ModifiableDefaultContent coursePart = _importOrSynchronizeContent(doc, metadataNode, getCoursePartWfDescription(), title, lang, catalog, subContentSyncCode, logger);
                        CollectionUtils.addIgnoreNull(courseParts, coursePart);
                    }
                    // Explicitely ignore catalog metadata which is forced at content creation
                    else if (!metadataName.equals(ProgramItem.CATALOG))
                    {
                        hasChanges = _synchronizeMetadata(doc, metadataNode, content, metadataName, metadataName, contentType, lang, catalog, logger) || hasChanges;
                    }
                }
                
                hasChanges = _setRelations(content, children, courseParts, removeOldCourseParts, logger) || hasChanges;
                
                // Create translation links
                _linkTranslationsIfExist(content, contentTypeId);
                
                _saveContentChanges(content, contentTypeId, hasChanges, logger);
            }
        }
    }

    /**
     * Synchronize a course list, it has attributes to synchronize.
     * @param doc The XML document
     * @param courseListNode The XML node of the course list
     * @param courseList The course list content
     * @param lang The lang
     * @param catalog The catalog
     * @param logger The logger
     */
    protected void _synchronizeCourseList(Document doc, Node courseListNode, ModifiableDefaultContent courseList, String lang, String catalog, Logger logger)
    {
        boolean hasChanges = false;
        
        ContentType contentType = _contentTypeEP.getExtension(getCourseListWfDescription().getContentType());
        NamedNodeMap attributes = courseListNode.getAttributes();
        for (int i = 0; i < attributes.getLength(); i++)
        {
            Node attributeNode = attributes.item(i);
            String attributeName = attributeNode.getLocalName();
            // Explicitely ignore catalog metadata which is forced at content creation
            if (!attributeName.equals(ProgramItem.CATALOG))
            {
                hasChanges = _synchronizeMetadata(doc, attributeNode, courseList, attributeName, attributeName, contentType, lang, catalog, logger) || hasChanges;
            }
        }

        List<ModifiableDefaultContent> courses = new LinkedList<>();
        NodeList itemNodes = courseListNode.getChildNodes();
        for (int i = 0; i < itemNodes.getLength(); i++)
        {
            String syncCode = itemNodes.item(i).getTextContent().trim();
            
            Node courseNode = _xPathProcessor.selectSingleNode(doc.getFirstChild(), "course[@CDMid = '" + syncCode + "' and @language = '" + lang + "']");
            if (courseNode == null)
            {
                courseNode = _xPathProcessor.selectSingleNode(doc.getFirstChild(), "course[@CDMid = '" + syncCode + "']");
            }
            
            if (courseNode != null)
            {
                String elpLang = _getXPathString(courseNode, "@language", lang);

                // Check the catalog is the same as the parent program
                String courseCatalog = getCatalogName(courseNode);
                if (courseCatalog != null && !courseCatalog.equals(catalog))
                {
                    String cdmCode = _xPathProcessor.evaluateAsString(courseNode, "cdmCode");
                    logger.error("The course '{}' belongs to a different catalog than the one from the imported/synchronized program : '{}' vs '{}'. No synchronization will be done on this course.", cdmCode, courseCatalog, catalog);
                }
                else
                {
                    String title = _xPathProcessor.evaluateAsString(courseNode, "title");
                    ModifiableDefaultContent course = _importOrSynchronizeContent(doc, courseNode, getCourseWfDescription(), title, elpLang, catalog, syncCode, logger);
                    if (course != null)
                    {
                        courses.add(course);
                        hasChanges = _shareableCourseHelper.initializeShareableFields((Course) course, (CourseList) courseList,  UserPopulationDAO.SYSTEM_USER_IDENTITY, true) || hasChanges;
                    }
                }
            }
        }
        
        if (!courses.isEmpty())
        {
            hasChanges = ExternalizableMetadataHelper.setMetadata(courseList.getMetadataHolder(), CourseList.CHILD_COURSES, courses.toArray(new ModifiableDefaultContent[courses.size()])) || hasChanges;
            for (ModifiableDefaultContent course : courses)
            {
                hasChanges = _synchroComponent.updateRelation(course.getMetadataHolder(), Course.PARENT_COURSE_LISTS, courseList, false) || hasChanges;
            }
        }
        
        _saveContentChanges(courseList, getCourseListWfDescription().getContentType(), hasChanges, logger);
    }

    private void _fetchImages(Node docbookNode, ModifiableDefaultContent content, ModifiableRichText richText, String metadataPath, Logger logger)
    {
        NodeList unfetchUrls = _xPathProcessor.selectNodeList(docbookNode, ".//docbook:mediaobject/docbook:imageobject/docbook:imagedata", _PREFIX_RESOLVER);
        
        for (int i = 0; i < unfetchUrls.getLength(); i++)
        {
            Element href = (Element) unfetchUrls.item(i);
            String imageUrl = href.getAttribute("fileref");
            
            if (CommentsDAO.URL_VALIDATOR.matcher(imageUrl).matches())
            {
                @SuppressWarnings("resource")
                InputStream is = null;
                try
                {
                    URL url = new URL(imageUrl);
                    is = url.openStream();
                    
                    String path = url.getPath();
                    String fileName = path.substring(path.lastIndexOf("/") + 1);
                    
                    ModifiableFile file = null;
                    if (richText.getAdditionalDataFolder().hasFile(fileName))
                    {
                        file = richText.getAdditionalDataFolder().getFile(fileName);
                    }
                    else
                    {
                        file = richText.getAdditionalDataFolder().addFile(fileName); 
                    }
                    
                    ModifiableResource resource = file.getResource();
                    resource.setInputStream(is);
                    resource.setLastModified(new Date());
                    
                    String mimeType = _cocoonContext.getMimeType(fileName);
                    if (mimeType == null)
                    {
                        mimeType = "application/unknown";
                    }
                    resource.setMimeType(mimeType);
                    
                    String fetchUrl = content.getId() + "@" + metadataPath + ";" + fileName;
                    href.setAttribute("fileref", fetchUrl);
                }
                catch (Exception e)
                {
                    logger.warn("Unable to retrieve remote image '{}'.", imageUrl, e);
                }
                finally
                {
                    IOUtils.closeQuietly(is);
                }
            }
        }
    }
    
    /**
     * Synchronize a metadata (can be a composite or a repeater).
     * @param doc The XML document
     * @param metadataNode The metadata node
     * @param content The content
     * @param logicalMetadataPath The logical metadata path (to retrieve the definition)
     * @param completeMetadataPath The complete metadata path (to retrieve the metadata holder)
     * @param contentType The content type
     * @param lang The lang
     * @param catalog The catalog
     * @param logger The logger
     * @return <code>true</code> if changes occurs
     */
    protected boolean _synchronizeMetadata(Document doc, Node metadataNode, ModifiableDefaultContent content, String logicalMetadataPath, String completeMetadataPath, ContentType contentType, String lang, String catalog, Logger logger)
    {
        List<String> untypedValues = null;
        MetadataDefinition metadataDef = contentType.getMetadataDefinitionByPath(logicalMetadataPath);
        Map<String, Object> params = Map.of("contentTypes", List.of(contentType.getId()));
        boolean synchronize = getLocalAndExternalFields(params).contains(logicalMetadataPath);
        if (metadataDef != null)
        {
            if (metadataDef instanceof RepeaterDefinition)
            {
                return _handleRepeaterMetadata(doc, metadataNode, content, logicalMetadataPath, completeMetadataPath, contentType, lang, catalog, logger);
            }
            else if (metadataDef.getType() == MetadataType.COMPOSITE)
            {
                return _handleCompositeMetadata(doc, metadataNode, content, logicalMetadataPath, completeMetadataPath, contentType, lang, catalog, logger);
            }
            else if (metadataDef.getType() == MetadataType.RICH_TEXT)
            {
                return _handleRichTextMetadata(content, logicalMetadataPath, completeMetadataPath, metadataNode, synchronize, logger);
            }
            else if (metadataDef.getType() == MetadataType.BINARY)
            {
                return _handleBinaryMetadata(metadataNode, content, completeMetadataPath, synchronize, logger);
            }
            else if (metadataDef.getType() == MetadataType.FILE)
            {
                return _handleFileMetadata(metadataNode, content, logicalMetadataPath, completeMetadataPath, synchronize, contentType, logger);
            }
            else if (metadataDef.getType() == MetadataType.GEOCODE)
            {
                return _handleGeocodeMetadata(metadataNode, content, completeMetadataPath, synchronize);
            }
            else if (metadataDef.isMultiple())
            {
                NodeList itemNodes = metadataNode.getChildNodes();
                untypedValues = new ArrayList<>();
                for (int j = 0; j < itemNodes.getLength(); j++)
                {
                    String metadataValue = itemNodes.item(j).getTextContent().trim();
                    if (StringUtils.isNotEmpty(metadataValue))
                    {
                        untypedValues.add(metadataValue);
                    }
                }
            }
            else
            {
                String metadataValue = metadataNode.getTextContent().trim();
                if (StringUtils.isNotEmpty(metadataValue))
                {
                    untypedValues = List.of(metadataValue);
                }
            }
        }

        Map<String, Boolean> resultMap = _synchroComponent.synchronizeMetadata(content, contentType, logicalMetadataPath, completeMetadataPath, _handleMetadataValues(doc, content, metadataDef, untypedValues, lang, catalog, logger), synchronize, _importedContents.containsKey(content.getId()), logger);
        if (resultMap.getOrDefault("error", Boolean.FALSE))
        {
            _nbError++;
        }
        return resultMap.getOrDefault("hasChanges", Boolean.FALSE).booleanValue();
    }
    
    /**
     * Synchronize geocode metadata
     * @param metadataNode The metadata node
     * @param content The content
     * @param completeMetadataPath The complete metadata path (to retrieve the metadata holder)
     * @param synchronize true if the data is external
     * @return true if some changes has been made
     */
    protected boolean _handleGeocodeMetadata(Node metadataNode, ModifiableDefaultContent content, String completeMetadataPath, boolean synchronize)
    {
        ModifiableCompositeMetadata metadataHolder = _synchroComponent.getMetadataHolder(content.getMetadataHolder(), completeMetadataPath);
        String[] arrayPath = completeMetadataPath.split("/");
        String metadataName = arrayPath[arrayPath.length - 1];
        
        return _handleGeocodeMetadata(metadataNode, content, metadataHolder, metadataName, synchronize);
    }
    
    /**
     * Synchronize geocode metadata
     * @param metadataNode The metadata node
     * @param content The content
     * @param metadataHolder the metadata holder
     * @param metadataName the metadata name
     * @param synchronize true if the data is external
     * @return true if some changes has been made
     */
    protected boolean _handleGeocodeMetadata(Node metadataNode, ModifiableDefaultContent content, ModifiableCompositeMetadata metadataHolder, String metadataName, boolean synchronize)
    {
        if (!metadataNode.hasChildNodes())
        {
            return _synchroComponent.removeMetadataIfExists(metadataHolder, metadataName, synchronize);
        }

        boolean hasChanges = false;
        ExternalizableMetadataStatus status = synchronize ? ExternalizableMetadataStatus.EXTERNAL : ExternalizableMetadataStatus.LOCAL;
        ModifiableCompositeMetadata geoCode = ExternalizableMetadataHelper.getCompositeMetadata(metadataHolder, metadataName, status, true);
        if (synchronize && _importedContents.containsKey(content.getId()))
        {
            hasChanges = ExternalizableMetadataHelper.updateStatus(metadataHolder, metadataName, status) || hasChanges;
        }
        
        NodeList coordinates = metadataNode.getChildNodes();
        for (int j = 0; j < coordinates.getLength(); j++)
        {
            Node coordinate = coordinates.item(j);
            Double coordinateValue = Double.valueOf(coordinate.getTextContent().trim());
            hasChanges = ExternalizableMetadataHelper.setMetadata(geoCode, coordinate.getLocalName(), coordinateValue) || hasChanges;
        }
        return hasChanges;
    }

    /**
     * Synchronize file metadata
     * @param metadataNode The metadata node
     * @param content The content
     * @param logicalMetadataPath The logical metadata path (to retrieve the definition) 
     * @param completeMetadataPath The complete metadata path (to retrieve the metadata holder)
     * @param synchronize true if the data is external
     * @param contentType the content type
     * @param logger the logger
     * @return true if some changes has been made
     */
    protected boolean _handleFileMetadata(Node metadataNode, ModifiableDefaultContent content, String logicalMetadataPath, String completeMetadataPath, boolean synchronize, ContentType contentType, Logger logger)
    {
        ModifiableCompositeMetadata metadataHolder = _synchroComponent.getMetadataHolder(content.getMetadataHolder(), completeMetadataPath);
        String[] arrayPath = completeMetadataPath.split("/");
        String metadataName = arrayPath[arrayPath.length - 1];
        
        return _handleFileMetadata(metadataNode, content, logicalMetadataPath, metadataHolder, metadataName, synchronize, contentType, logger);
    }
    
    /**
     * Synchronize file metadata
     * @param metadataNode The metadata node
     * @param content The content
     * @param logicalMetadataPath The logical metadata path (to retrieve the definition) 
     * @param metadataHolder the metadata holder
     * @param metadataName the metadata name
     * @param synchronize true if the data is external
     * @param contentType the content type
     * @param logger the logger
     * @return true if some changes has been made
     */
    protected boolean _handleFileMetadata(Node metadataNode, ModifiableDefaultContent content, String logicalMetadataPath, ModifiableCompositeMetadata metadataHolder, String metadataName, boolean synchronize, ContentType contentType, Logger logger)
    {
        boolean hasChanges = false;
        String value = metadataNode.getTextContent().trim();
        boolean metadataExists = metadataHolder.hasMetadata(metadataName);
        CompositeMetadata.MetadataType metadataType = metadataExists ? metadataHolder.getType(metadataName) : null;
        if (CommentsDAO.URL_VALIDATOR.matcher(value).matches())
        {
            if (metadataExists && metadataType != CompositeMetadata.MetadataType.BINARY)
            {
                hasChanges = _synchroComponent.removeMetadataIfExists(metadataHolder, metadataName, synchronize) || hasChanges;
            }
            hasChanges = _handleBinaryMetadata(metadataNode, content, metadataHolder, metadataName, synchronize, logger) || hasChanges;
        }
        else
        {
            if (metadataExists && metadataType != CompositeMetadata.MetadataType.STRING)
            {
                hasChanges = _synchroComponent.removeMetadataIfExists(metadataHolder, metadataName, synchronize) || hasChanges;
            }
            
            Map<String, Boolean> resultMap = _synchroComponent.synchronizeMetadata(content, contentType, logicalMetadataPath, metadataHolder, metadataName, List.of(value), synchronize, _importedContents.containsKey(content.getId()), logger);
            if (resultMap.getOrDefault("error", Boolean.FALSE))
            {
                _nbError++;
            }
            hasChanges = resultMap.getOrDefault("hasChanges", Boolean.FALSE).booleanValue() || hasChanges;
        }
        return hasChanges;
    }
    
    /**
     * Synchronize binary metadata
     * @param metadataNode The metadata node
     * @param content The content
     * @param completeMetadataPath The complete metadata path (to retrieve the metadata holder)
     * @param synchronize true if the data is external
     * @param logger the logger
     * @return true if some changes has been made
     */
    protected boolean _handleBinaryMetadata(Node metadataNode, ModifiableDefaultContent content, String completeMetadataPath, boolean synchronize, Logger logger)
    {
        ModifiableCompositeMetadata metadataHolder = _synchroComponent.getMetadataHolder(content.getMetadataHolder(), completeMetadataPath);
        String[] arrayPath = completeMetadataPath.split("/");
        String metadataName = arrayPath[arrayPath.length - 1];
        
        return _handleBinaryMetadata(metadataNode, content, metadataHolder, metadataName, synchronize, logger);
    }
    
    /**
     * Synchronize binary metadata
     * @param metadataNode The metadata node
     * @param content The content
     * @param metadataHolder the metadata holder
     * @param metadataName the metadata name
     * @param synchronize true if the data is external
     * @param logger the logger
     * @return true if some changes has been made
     */
    protected boolean _handleBinaryMetadata(Node metadataNode, ModifiableDefaultContent content, ModifiableCompositeMetadata metadataHolder, String metadataName, boolean synchronize, Logger logger)
    {
        boolean hasChanges = false;
        
        String value = metadataNode.getTextContent().trim();
        
        if (StringUtils.isEmpty(value))
        {
            return _synchroComponent.removeMetadataIfExists(metadataHolder, metadataName, synchronize);
        }
        
        try
        {
            URL url = new URL(value);
            
            byte[] bytes;
            try (InputStream is = url.openStream())
            {
                bytes = IOUtils.toByteArray(is);
            }

            ExternalizableMetadataStatus status = synchronize ? ExternalizableMetadataStatus.EXTERNAL : ExternalizableMetadataStatus.LOCAL;
            ModifiableBinaryMetadata binaryMetadata = ExternalizableMetadataHelper.getBinaryMetadata(metadataHolder, metadataName, status, true);

            byte[] oldValue = new byte[0];
            try (InputStream is = binaryMetadata.getInputStream())
            {
                oldValue = IOUtils.toByteArray(is);
            }
            catch (AmetysRepositoryException e)
            {
                logger.debug("The old value of '{}' should not be initialized on the content '{}'.", metadataName, content.getId(), e);
            }

            if (!Objects.deepEquals(bytes, oldValue))
            {
                String path = url.getPath();
                String filename = path.substring(path.lastIndexOf("/") + 1);
                String mimeType = _cocoonContext.getMimeType(filename);
                if (mimeType == null)
                {
                    mimeType = "application/unknown";
                }
                binaryMetadata.setFilename(URIUtils.decode(filename));
                binaryMetadata.setMimeType(mimeType);
                binaryMetadata.setLastModified(new Date());
                binaryMetadata.setInputStream(new ByteArrayInputStream(bytes));
    
                hasChanges = true;
            }

            if (synchronize && _importedContents.containsKey(content.getId()))
            {
                hasChanges = ExternalizableMetadataHelper.updateStatus(metadataHolder, metadataName, status) || hasChanges;
            }
        }
        catch (IOException e)
        {
            logger.error("Unable to retrieve remote file input stream", e);
        }

        return hasChanges;
    }
    
    private boolean _handleRepeaterMetadata(Document doc, Node metadataNode, ModifiableDefaultContent content, String logicalMetadataPath, String completeMetadataPath, ContentType contentType, String lang, String catalog, Logger logger)
    {
        boolean hasChanges = false;
        
        ModifiableCompositeMetadata repeater;
        if (completeMetadataPath.indexOf("/") == -1)
        {
            repeater = content.getMetadataHolder().getCompositeMetadata(completeMetadataPath, true);
        }
        else
        {
            ModifiableCompositeMetadata metadataHolder = _synchroComponent.getMetadataHolder(content.getMetadataHolder(), completeMetadataPath);
            repeater = metadataHolder.getCompositeMetadata(StringUtils.substringAfterLast(completeMetadataPath, "/"), true);
        }
        
        // Remove locale entries (unable to compare locales and remotes ...)
        String[] metadataNames = repeater.getMetadataNames();
        for (String entryName : metadataNames)
        {
            repeater.removeMetadata(entryName);
            hasChanges = 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();
                
                hasChanges = _synchronizeMetadata(doc, childNode, content, logicalMetadataPath + "/" + subMetadataName, completeMetadataPath + "/" + entryName + "/" + subMetadataName, contentType, lang, catalog, logger) || hasChanges;
            }
        }
        
        return hasChanges;
    }
    
    private boolean _handleCompositeMetadata(Document doc, Node metadataNode, ModifiableDefaultContent content, String logicalMetadataPath, String completeMetadataPath, ContentType contentType, String lang, String catalog, Logger logger)
    {
        boolean hasChanges = false;
        NodeList subMetadataNodes = metadataNode.getChildNodes();
        for (int i = 0; i < subMetadataNodes.getLength(); i++)
        {
            Node subMetadataNode = subMetadataNodes.item(i);
            hasChanges = _synchronizeMetadata(doc, subMetadataNode, content, logicalMetadataPath + "/" + subMetadataNode.getLocalName(), completeMetadataPath + "/" + subMetadataNode.getLocalName(), contentType, lang, catalog, logger) || hasChanges;
        }
        return hasChanges;
    }
    
    private boolean _handleRichTextMetadata(ModifiableDefaultContent content, String logicalMetadataPath, String completeMetadataPath, Node metadataNode, boolean synchronize, Logger logger)
    {
        ModifiableCompositeMetadata metadataHolder = _synchroComponent.getMetadataHolder(content.getMetadataHolder(), completeMetadataPath);
        String[] arrayPath = completeMetadataPath.split("/");
        String metadataName = arrayPath[arrayPath.length - 1];

        if (metadataNode.hasChildNodes())
        {
            boolean hasChanges = false;
            try
            {
                ExternalizableMetadataStatus status = synchronize ? ExternalizableMetadataStatus.EXTERNAL : ExternalizableMetadataStatus.LOCAL;
                ModifiableRichText richText = ExternalizableMetadataHelper.getRichText(metadataHolder, metadataName, status, true);
                
                _fetchImages(metadataNode.getFirstChild(), content, richText, completeMetadataPath, logger);
                
                String docbook = ContentImporterHelper.serializeNode(metadataNode.getFirstChild());
                try (ByteArrayInputStream is =  new ByteArrayInputStream(docbook.getBytes("UTF-8")))
                {
                    richText.setInputStream(is);
                    richText.setMimeType("text/xml");
                    richText.setLastModified(new Date()); 

                    if (synchronize && _importedContents.containsKey(content.getId()))
                    {
                        hasChanges = ExternalizableMetadataHelper.updateStatus(metadataHolder, metadataName, status) || hasChanges;
                    }
                    
                    hasChanges = true;
                }
                catch (IOException e)
                {
                    logger.error("An error occured while parsing the rich text '{}' of the content '{}'", logicalMetadataPath, content.getTitle(), e);
                }
            }
            catch (TransformerException e)
            {
                logger.error("Error serializing a docbook node.", e);
            }
            return hasChanges;
        }
        
        return synchronize ? ExternalizableMetadataHelper.removeExternalMetadataIfExists(metadataHolder, metadataName)
                           : ExternalizableMetadataHelper.removeLocalMetadataIfExists(metadataHolder, metadataName);
    }
    
    /**
     * Handle metadata values
     * @param doc the document
     * @param content the content
     * @param metadataDef the metadata definition
     * @param untypedValues the metadata values, untyped
     * @param lang the language
     * @param catalog the catalog
     * @param logger the logger
     * @return the list of handle value, typed
     */
    protected List<Object> _handleMetadataValues(Document doc, ModifiableDefaultContent content, MetadataDefinition metadataDef, List<String> untypedValues, String lang, String catalog, Logger logger)
    {
        if (untypedValues == null)
        {
            return null;
        }
        
        SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd");
        List<Object> typedValues = new ArrayList<>();
        
        for (String metadataValue : untypedValues)
        {
            switch (metadataDef.getType())
            {
                case DATE:
                    try
                    {
                        typedValues.add(dateFormat.parse(metadataValue));
                    }
                    catch (ParseException e)
                    {
                        logger.warn("Unable to parse the metadata '{}' of the content '{}' with the value '{}', it should respect the following format '{}'.", metadataDef.getName(), content.getId(), metadataValue, dateFormat);
                    }
                    break;
                case BOOLEAN:
                    typedValues.add(Boolean.valueOf(metadataValue));
                    break;
                case CONTENT:
                    Object value = _handleMetadataValuesAsContent(doc, metadataDef, metadataValue, lang, catalog, logger);
                    if (value != null)
                    {
                        typedValues.add(value);
                    }
                    break;
                case LONG:
                    typedValues.add(Long.valueOf(metadataValue));
                    break;
                case DOUBLE:
                    typedValues.add(Double.valueOf(metadataValue));
                    break;
                default:
                    if (content instanceof CourseList && metadataDef.getName().equals(CourseList.CHOICE_TYPE))
                    {
                        typedValues.add(metadataValue.toUpperCase());
                    }
                    else
                    {
                        typedValues.add(metadataValue);
                    }
                    break;
            }
        }
        
        return typedValues;
    }
    
    private Object _handleMetadataValuesAsContent(Document doc, MetadataDefinition metadataDef, String metadataValue, String lang, String catalog, Logger logger)
    {
        String refContentTypeId = metadataDef.getContentType();
        if (refContentTypeId != null)
        {
            ContentType refContentType = _contentTypeEP.getExtension(refContentTypeId);
            if (refContentTypeId.equals(PersonFactory.PERSON_CONTENT_TYPE))
            {
                Node personNode = _xPathProcessor.selectSingleNode(doc.getFirstChild(), "person[@CDMid ='" + metadataValue + "']");
                if (personNode != null)
                {
                    ModifiableDefaultContent person = _importOrSynchronizeContent(doc, personNode, getPersonWfDescription(), metadataValue, lang, null, metadataValue, logger);
                    if (person != null)
                    {
                        return person;
                    }
                }
                else
                {
                    logger.warn("There is no person tag corresponding to the CDM ID '{}'.", metadataValue);
                }
            }
            else if (refContentTypeId.equals(OrgUnitFactory.ORGUNIT_CONTENT_TYPE))
            {
                Node ouNode = _xPathProcessor.selectSingleNode(doc.getFirstChild(), "orgunit[@CDMid ='" + metadataValue + "']");
                if (ouNode != null)
                {
                    ModifiableDefaultContent orgUnit = _importOrSynchronizeContent(doc, ouNode, getOrgUnitWfDescription(), metadataValue, lang, null, metadataValue, logger);
                    if (orgUnit != null)
                    {
                        return orgUnit;
                    }
                }
                else
                {
                    logger.warn("There is no orgunit tag corresponding to the CDM ID '{}'.", metadataValue);
                }
            }
            else if (metadataDef.getName().equals("courseHolder"))
            {
                List<Expression> expList = getExpressionsList(lang, metadataValue, getCourseWfDescription().getContentType(), catalog);
                AndExpression andExp = new AndExpression(expList.toArray(new Expression[expList.size()]));
                String xPathQuery = ContentQueryHelper.getContentXPathQuery(andExp);
                AmetysObjectIterable<CoursePart> contents = _resolver.query(xPathQuery);
                if (contents.getSize() > 0)
                {
                    return contents.iterator().next();
                }
                else
                {
                    logger.warn("There is no course part corresponding to the CDM ID '{}'.", metadataValue);
                }
            }
            else if (refContentType.isReferenceTable() && _odfRefTableHelper.isTableReference(refContentTypeId))
            {
                String entryId = _getIdFromCDMThenCode(refContentTypeId, metadataValue);
                if (StringUtils.isNotEmpty(entryId))
                {
                    return _resolver.resolveById(entryId);
                }
                else
                {
                    logger.warn("There is no entry corresponding to the CDM-fr or Ametys code '{}' in the reference table '{}'.", metadataValue, refContentTypeId);
                }
            }
        }
        else
        {
            logger.warn("Cannot match data '{}' of content type '{}' because it is not typed.", metadataDef.getName(), metadataDef.getReferenceContentType());
        }
        
        return null;
    }

    /**
     * Search for translated contents
     * @param importedContent The imported content
     * @param contentType The content type
     */
    protected void _linkTranslationsIfExist(ModifiableContent importedContent, String contentType)
    {
        if (importedContent instanceof ProgramItem)
        {
            Expression expression = _getTranslationExpression(importedContent, contentType);
            String xPathQuery = ContentQueryHelper.getContentXPathQuery(expression);
    
            AmetysObjectIterable<ModifiableDefaultContent> contents = _resolver.query(xPathQuery);
            
            Map<String, String> translations = new HashMap<>();
            for (ModifiableDefaultContent content : contents)
            {
                translations.put(content.getLanguage(), content.getId());
            }
            
            for (ModifiableDefaultContent content : contents)
            {
                TranslationHelper.setTranslations(content, translations);
    
                Map<String, Object> eventParams = new HashMap<>();
                eventParams.put(ObservationConstants.ARGS_CONTENT, content);
                eventParams.put(ObservationConstants.ARGS_CONTENT_ID, content.getId());
                _observationManager.notify(new Event(OdfObservationConstants.ODF_CONTENT_TRANSLATED, _currentUserProvider.getUser(), eventParams));
            }
        }
    }
    
    private Expression _getTranslationExpression(ModifiableContent content, String contentType)
    {
        List<Expression> expList = new ArrayList<>();
        
        if (StringUtils.isNotBlank(contentType))
        {
            expList.add(new ContentTypeExpression(Operator.EQ, contentType));
        }
        
        String catalog = content.getValue(ProgramItem.CATALOG);
        if (StringUtils.isNotBlank(catalog))
        {
            expList.add(new StringExpression(ProgramItem.CATALOG, Operator.EQ, catalog));
        }
        
        List<Expression> codeExpressionList = new ArrayList<>();
        String syncValue = content.getMetadataHolder().getString(getIdField());
        if (StringUtils.isNotBlank(syncValue))
        {
            codeExpressionList.add(new StringExpression(getIdField(), Operator.EQ, syncValue));
        }

        String code = content.getValue(ProgramPart.CODE);
        if (StringUtils.isNotBlank(syncValue))
        {
            codeExpressionList.add(new StringExpression(ProgramPart.CODE, Operator.EQ, code));
        }
        
        if (!codeExpressionList.isEmpty())
        {
            expList.add(new OrExpression(codeExpressionList.toArray(Expression[]::new)));
        }
        
        return new AndExpression(expList.toArray(Expression[]::new));
    }

    /**
     * Save the changes of the content.
     * @param content Content to save
     * @param contentTypeId The content type (for logs)
     * @param hasChanges If there are changes to save
     * @param logger The logger
     */
    protected void _saveContentChanges(ModifiableDefaultContent content, String contentTypeId, boolean hasChanges, Logger logger)
    {
        if (hasChanges)
        {
            content.saveChanges();
            _synchronizedContents.add(content.getId());
            if (!_importedContents.containsKey(content.getId()))
            {
                _nbSynchronizedContents++;
            }
        }
        else
        {
            logger.info("No changes detected for content '{}' with the content type '{}'", content.getTitle(), contentTypeId);
            if (!_importedContents.containsKey(content.getId()))
            {
                _nbNotChangedContents++;
            }
        }
    }
    
    /**
     * Set relations for the content.
     * @param content The content to update
     * @param children Children to set
     * @param courseParts {@link List} of {@link CoursePart} to set for {@link Course} content
     * @param removeOldCourseParts If the course parts doesn't have a code, we remove all the old {@link CoursePart}s before adding the new ones
     * @param logger The logger
     * @return <code>true</code> if changes occurs
     */
    protected boolean _setRelations(ModifiableDefaultContent content, List<ModifiableDefaultContent> children, List<ModifiableDefaultContent> courseParts, boolean removeOldCourseParts, Logger logger)
    {
        boolean hasChanges = false;
        
        if (!courseParts.isEmpty() && content instanceof Course)
        {
            if (removeOldCourseParts)
            {
                hasChanges = ExternalizableMetadataHelper.removeMetadataIfExists(content.getMetadataHolder(), Course.CHILD_COURSE_PARTS) || hasChanges;
            }
            hasChanges = _updateDoubleRelation(content, courseParts, Course.CHILD_COURSE_PARTS, CoursePart.PARENT_COURSES, logger) || hasChanges;
        }
        
        if (!children.isEmpty())
        {
            hasChanges = _setChildren(content, children, logger) || hasChanges;
        }
        
        // Set the orgUnit parent (if no parent is set)
        if (content instanceof OrgUnit)
        {
            hasChanges = _setOrgUnitParent(content, logger) || hasChanges;
        }
        
        return hasChanges;
    }
    
    /**
     * Set children for the given content.
     * @param content Content to add the children
     * @param children Children to add
     * @param logger The logger
     * @return <code>true</code> if changes occurs
     */
    protected boolean _setChildren(ModifiableDefaultContent content, List<ModifiableDefaultContent> children, Logger logger)
    {
        boolean hasChanges = false;
        
        String metadataName = null;
        String invertMetadataName = null;
        if (content instanceof CourseList)
        {
            metadataName = CourseList.CHILD_COURSES;
            invertMetadataName = Course.PARENT_COURSE_LISTS;
        }
        else if (content instanceof TraversableProgramPart)
        {
            metadataName = TraversableProgramPart.CHILD_PROGRAM_PARTS;
            invertMetadataName = ProgramPart.PARENT_PROGRAM_PARTS;
        }
        else if (content instanceof Course)
        {
            metadataName = Course.CHILD_COURSE_LISTS;
            invertMetadataName = CourseList.PARENT_COURSES;
        }
        
        if (metadataName != null)
        {
            hasChanges = _updateDoubleRelation(content, children, metadataName, invertMetadataName, logger);
        }
        
        return hasChanges;
    }
    
    /**
     * Set the orgUnit parent to rootOrgUnit.
     * @param orgUnit The orgunit to link
     * @param logger The logger
     * @return <code>true</code> if changes occurs
     */
    protected boolean _setOrgUnitParent(ModifiableDefaultContent orgUnit, Logger logger)
    {
        boolean hasChanges = false;
        
        // Set the orgUnit parent (if no parent is set)
        ModifiableCompositeMetadata holder = orgUnit.getMetadataHolder();
        if (!holder.hasMetadata(OrgUnit.PARENT_ORGUNIT))
        {
            OrgUnit rootOrgUnit = _rootOUProvider.getRoot();
            
            hasChanges = ExternalizableMetadataHelper.setMetadata(holder, OrgUnit.PARENT_ORGUNIT, rootOrgUnit) || hasChanges;
            hasChanges = _synchroComponent.updateRelation(rootOrgUnit.getMetadataHolder(), OrgUnit.CHILD_ORGUNITS, orgUnit, false) || hasChanges;

            try
            {
                _synchroComponent.applyChanges(rootOrgUnit, 22, ObservationConstants.EVENT_CONTENT_MODIFIED, ignoreRights(), logger);
            }
            catch (RepositoryException e)
            {
                logger.error("An error occured during updating root org unit after synchronizing the content '{}'.", orgUnit.getId(), logger);
            }
        }
        
        return hasChanges;
    }

    /**
     * Get the content ID from the CDM code, if there is no match with the CDM code, then we search with the code.
     * If nothing is found we return null. 
     * @param tableRefId The reference table ID
     * @param cdmCode The CDM code
     * @return A content ID or <code>null</code>
     */
    protected String _getIdFromCDMThenCode(String tableRefId, String cdmCode)
    {
        OdfReferenceTableEntry entry = _odfRefTableHelper.getItemFromCDM(tableRefId, cdmCode);
        if (entry == null)
        {
            entry = _odfRefTableHelper.getItemFromCode(tableRefId, cdmCode);
        }
        return entry != null ? entry.getId() : null;
    }
    
    private boolean _updateDoubleRelation(ModifiableDefaultContent content, List<ModifiableDefaultContent> children, String metadataName, String invertMetadataName, Logger logger)
    {
        boolean hasChanges = false;
        ModifiableCompositeMetadata holder = content.getMetadataHolder();
        
        // "Normal" relation
        if (removalSync() || !holder.hasMetadata(metadataName))
        {
            hasChanges = ExternalizableMetadataHelper.setMetadata(holder, metadataName, children.toArray(new ModifiableDefaultContent[children.size()]));
        }
        else
        {
            List<String> oldValues = new ArrayList<>(Arrays.asList(holder.getStringArray(metadataName)));
            
            for (ModifiableDefaultContent child : children)
            {
                hasChanges = _synchroComponent.updateRelation(holder, metadataName, child, false) || hasChanges;
                oldValues.remove(child.getId());
            }
            
            if (logger.isWarnEnabled())
            {
                for (String oldValue : oldValues)
                {
                    // Warn the old contents
                    ModifiableDefaultContent child = _resolver.resolveById(oldValue);
                    logger.warn("The ODF content '{}' ({}) is not linked anymore to the content '{}', it should be manually removed.", child.getTitle(), oldValue, content.getTitle());
                }
            }
        }
        
        // Invert relation
        for (ModifiableDefaultContent child : children)
        {
            hasChanges = _synchroComponent.updateRelation(child.getMetadataHolder(), invertMetadataName, content, false) || hasChanges;
        }
        
        return hasChanges;
    }
    
    private String _getXPathString(Node metadataNode, String xPath, String defaultValue)
    {
        String value = _xPathProcessor.evaluateAsString(metadataNode, xPath);
        if (StringUtils.isEmpty(value))
        {
            value = defaultValue;
        }
        return value;
    }

    /**
     * If true, bypass the rights check during the import process
     * @return True if the rights check are bypassed during the import process
     */
    protected boolean ignoreRights()
    {
        return false;
    }
    
    /**
     * Get the program workflow description.
     * @return A {@link ContentWorkflowDescription} containing informations about the program workflow
     */
    protected ContentWorkflowDescription getProgramWfDescription()
    {
        return _PROGRAM_WF_DESCRIPTION;
    }

    /**
     * Get the subprogram workflow description.
     * @return A {@link ContentWorkflowDescription} containing informations about the subprogram workflow
     */
    protected ContentWorkflowDescription getSubProgramWfDescription()
    {
        return _SUBPROGRAM_WF_DESCRIPTION;
    }

    /**
     * Get the container workflow description.
     * @return A {@link ContentWorkflowDescription} containing informations about the container workflow
     */
    protected ContentWorkflowDescription getContainerWfDescription()
    {
        return _CONTAINER_WF_DESCRIPTION;
    }

    /**
     * Get the course list workflow description.
     * @return A {@link ContentWorkflowDescription} containing informations about the course list workflow
     */
    protected ContentWorkflowDescription getCourseListWfDescription()
    {
        return _COURSELIST_WF_DESCRIPTION;
    }

    /**
     * Get the course workflow description.
     * @return A {@link ContentWorkflowDescription} containing informations about the course workflow
     */
    protected ContentWorkflowDescription getCourseWfDescription()
    {
        return _COURSE_WF_DESCRIPTION;
    }

    /**
     * Get the course part workflow description.
     * @return A {@link ContentWorkflowDescription} containing informations about the course part workflow
     */
    protected ContentWorkflowDescription getCoursePartWfDescription()
    {
        return _COURSEPART_WF_DESCRIPTION;
    }

    /**
     * Get the orgunit workflow description.
     * @return A {@link ContentWorkflowDescription} containing informations about the orgunit workflow
     */
    protected ContentWorkflowDescription getOrgUnitWfDescription()
    {
        return _ORGUNIT_WF_DESCRIPTION;
    }

    /**
     * Get the person workflow description.
     * @return A {@link ContentWorkflowDescription} containing informations about the person workflow
     */
    protected ContentWorkflowDescription getPersonWfDescription()
    {
        return _PERSON_WF_DESCRIPTION;
    }
    
    /**
     * Internal object to describe content workflow elements.
     */
    protected static class ContentWorkflowDescription
    {
        private String _contentType;
        private String _workflowName;
        private int _initialActionId;
        private int _validationActionId;
        
        ContentWorkflowDescription(String contentType, String workflowName, int initialActionId, int validationActionId)
        {
            _contentType = contentType;
            _workflowName = workflowName;
            _initialActionId = initialActionId;
            _validationActionId = validationActionId;
        }
        
        /**
         * Get the content type.
         * @return the content type ID
         */
        public String getContentType()
        {
            return _contentType;
        }
        
        /**
         * Get the workflow name.
         * @return the workflow name
         */
        public String getWorkflowName()
        {
            return _workflowName;
        }
        
        /**
         * Get the initial action ID.
         * @return the initial action ID
         */
        public int getInitialActionId()
        {
            return _initialActionId;
        }
        
        /**
         * Get the validation action ID.
         * @return the validation action ID
         */
        public int getValidationActionId()
        {
            return _validationActionId;
        }
    }
    
    private static class DocbookPrefixResolver implements PrefixResolver
    {
        private Map<String, String> _ns = new HashMap<>();
        
        public DocbookPrefixResolver()
        {
            _ns.put("docbook", "http://docbook.org/ns/docbook");
        }
        
        @Override
        public String prefixToNamespace(String prefix)
        {
            return _ns.get(prefix);
        }
    }
    
    @Override
    public List<Expression> getExpressionsList(String lang, String idValue, String contentType, String catalog)
    {
        List<Expression> expList = new ArrayList<>();
        
        if (StringUtils.isNotBlank(contentType))
        {
            expList.add(new ContentTypeExpression(Operator.EQ, contentType));
        }
        
        if (StringUtils.isNotBlank(idValue))
        {
            expList.add(new StringExpression(getIdField(), Operator.EQ, idValue));
        }
        
        if (StringUtils.isNotBlank(catalog))
        {
            expList.add(new StringExpression(ProgramItem.CATALOG, Operator.EQ, catalog));
        }
        
        if (StringUtils.isNotBlank(lang))
        {
            expList.add(new LanguageExpression(Operator.EQ, lang));
        }
        
        return expList;
    }

    @Override
    public Set<String> getLocalAndExternalFields(Map<String, Object> additionalParameters)
    {
        if (additionalParameters == null || !additionalParameters.containsKey("contentTypes"))
        {
            throw new IllegalArgumentException("Content types shouldn't be null.");
        }

        @SuppressWarnings("unchecked")
        List<String> contentTypeIds = (List<String>) additionalParameters.get("contentTypes");
        Set<String> allSyncFields = new HashSet<>();
        
        for (String contentTypeId : contentTypeIds)
        {
            Set<String> syncFields = _syncFieldsByContentType.computeIfAbsent(contentTypeId, k -> new HashSet<>());
            allSyncFields.addAll(syncFields);
        }
        
        return allSyncFields;
    }
}