/*
 *  Copyright 2021 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.pegase.scc;

import java.io.IOException;
import java.math.BigDecimal;
import java.util.ArrayList;
import java.util.Collection;
import java.util.HashMap;
import java.util.HashSet;
import java.util.LinkedHashMap;
import java.util.LinkedHashSet;
import java.util.List;
import java.util.Map;
import java.util.Optional;
import java.util.Set;
import java.util.function.Predicate;
import java.util.stream.Collectors;
import java.util.stream.Stream;

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.ametys.cms.data.ContentValue;
import org.ametys.cms.repository.Content;
import org.ametys.cms.repository.ContentQueryHelper;
import org.ametys.cms.repository.LanguageExpression;
import org.ametys.cms.repository.ModifiableContent;
import org.ametys.cms.repository.WorkflowAwareContent;
import org.ametys.core.util.JSONUtils;
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.courselist.CourseList;
import org.ametys.odf.courselist.CourseListFactory;
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.workflow.AbstractCreateODFContentFunction;
import org.ametys.plugins.contentio.synchronize.AbstractSimpleSynchronizableContentsCollection;
import org.ametys.plugins.odfsync.pegase.ws.PegaseApiManager;
import org.ametys.plugins.odfsync.utils.ContentWorkflowDescription;
import org.ametys.plugins.repository.AmetysObjectIterable;
import org.ametys.plugins.repository.jcr.NameHelper;
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 org.ametys.runtime.i18n.I18nizableText;
import org.ametys.runtime.model.View;

import com.opensymphony.workflow.WorkflowException;

import fr.pcscol.pegase.cof.ApiException;
import fr.pcscol.pegase.cof.api.ArbresApi;
import fr.pcscol.pegase.cof.api.ObjetsMaquetteApi;
import fr.pcscol.pegase.cof.model.Arbre;
import fr.pcscol.pegase.cof.model.Enfant;
import fr.pcscol.pegase.cof.model.ObjetLibelle;
import fr.pcscol.pegase.cof.model.ObjetMaquette;
import fr.pcscol.pegase.cof.model.ObjetMaquetteDetails;
import fr.pcscol.pegase.cof.model.ObjetMaquetteFormation;
import fr.pcscol.pegase.cof.model.ObjetMaquetteFormationTypeFormation;
import fr.pcscol.pegase.cof.model.ObjetMaquetteGroupement;
import fr.pcscol.pegase.cof.model.Pageable;
import fr.pcscol.pegase.cof.model.PagedObjetMaquette;
import fr.pcscol.pegase.cof.model.Ref;

/**
 * SCC for Pegase (COF).
 */
public class PegaseSynchronizableContentsCollection extends AbstractSimpleSynchronizableContentsCollection
{
    private static final String __INSERTED_GROUPEMENT_SUFFIX = "-LIST";
    private static final int __PEGASE_SYNC_CODE_MAX_LENGTH = 25;
    
    /** The JSON utils */
    protected JSONUtils _jsonUtils;
    
    /** The catalogs manager */
    protected CatalogsManager _catalogsManager;
    
    /** The Pégase API manager */
    protected PegaseApiManager _pegaseApiManager;
    
    /** Mapping between metadata and columns */
    protected Map<String, Map<String, List<String>>> _mappingByContentType;
    
    /** Search fields to display */
    protected Set<String> _searchFields;

    /** List of imported contents */
    protected Map<String, Integer> _importedContents;
    
    /** List of synchronized contents having differences */
    protected Set<String> _synchronizedContents;
    
    /** List of updated contents by relation */
    protected Set<String> _updatedRelationContents;
    
    /** Map to link contents to its children at the end of the process */
    protected Map<String, Set<String>> _contentsChildren;
    
    /** Default language configured for ODF */
    protected String _odfLang;
    
    /** The structure code for Pégase */
    protected String _structureCode;
    
    @Override
    public void service(ServiceManager manager) throws ServiceException
    {
        super.service(manager);
        _jsonUtils = (JSONUtils) manager.lookup(JSONUtils.ROLE);
        _catalogsManager = (CatalogsManager) manager.lookup(CatalogsManager.ROLE);
        _pegaseApiManager = (PegaseApiManager) manager.lookup(PegaseApiManager.ROLE);
    }
    
    @Override
    public String getIdField()
    {
        return "pegaseSyncCode";
    }

    /**
     * Get the identifier JSON field.
     * @return the column id
     */
    protected String getIdColumn()
    {
        return "id";
    }

    @SuppressWarnings("unchecked")
    @Override
    public Set<String> getLocalAndExternalFields(Map<String, Object> additionalParameters)
    {
        return Optional.ofNullable(additionalParameters)
            .map(params -> params.get("contentTypes"))
            .filter(List.class::isInstance)
            .map(cTypes -> (List<String>) cTypes)
            .filter(Predicate.not(List::isEmpty))
            .map(l -> l.get(0))
            .map(_mappingByContentType::get)
            .map(Map::keySet)
            .orElse(Set.of());
    }

    @Override
    protected Map<String, Object> putIdParameter(String idValue)
    {
        Map<String, Object> parameters = new HashMap<>();
        parameters.put(getIdColumn(), List.of(idValue));
        return parameters;
    }
    
    @SuppressWarnings("unchecked")
    @Override
    protected Map<String, Map<String, Object>> internalSearch(Map<String, Object> parameters, int offset, int limit, List<Object> sort, Logger logger)
    {
        Map<String, Map<String, Object>> results = new LinkedHashMap<>();
        
        try
        {
            ObjetsMaquetteApi objetsMaquetteApi = _pegaseApiManager.getObjetsMaquetteApi();
            ArbresApi arbresApi = _pegaseApiManager.getArbresApi();
            
            boolean importMode = (boolean) parameters.getOrDefault("import", false);
            List<String> pegaseSyncCodeValues = (List<String>) parameters.getOrDefault(getIdColumn(), new ArrayList<>());
            
            if (importMode)
            {
                Map<String, String> idValues = new HashMap<>();
                if (!pegaseSyncCodeValues.isEmpty())
                {
                    for (String pegaseSyncCode : pegaseSyncCodeValues)
                    {
                        // Get details for each requested programs by objetsMaquetteApi
                        ObjetMaquette programDetails = _getProgramDetails(pegaseSyncCode, objetsMaquetteApi);
                        idValues.put(programDetails.getId(), programDetails.getCode());
                    }
                }
                else
                {
                    // Get details for all requested programs by objetsMaquetteApi
                    PagedObjetMaquette pagedPrograms = _getPagedProgramsDetails(parameters, offset, limit, sort, objetsMaquetteApi);
                    for (ObjetMaquette programDetails : pagedPrograms.getItems())
                    {
                        idValues.put(programDetails.getId(), programDetails.getCode());
                    }
                }
                
                results.putAll(_getObjectDetailsForImport(idValues, objetsMaquetteApi, arbresApi, logger));
            }
            else if (pegaseSyncCodeValues.isEmpty())
            {
                // Get details for all requested programs by objetsMaquetteApi
                PagedObjetMaquette pagedPrograms = _getPagedProgramsDetails(parameters, offset, limit, sort, objetsMaquetteApi);
                for (ObjetMaquette programDetails : pagedPrograms.getItems())
                {
                    String pegaseSyncCode = _createPegaseSyncCode(programDetails);
                    
                    // If not an import, fill the results with Pégase synchronization code
                    Map<String, Object> result = results.computeIfAbsent(pegaseSyncCode, __ -> new HashMap<>());
                    Map<String, String> fields = _getFields(programDetails);

                    for (String keptField : _searchFields)
                    {
                        String field = fields.get(keptField);
                        result.put(keptField, field);
                    }    

                    result.put(SCC_UNIQUE_ID, pegaseSyncCode);
                }
            }
        }
        catch (ApiException | IOException e)
        {
            throw new RuntimeException("Error while getting remote values", e);
        }
        
        return results;
    }
    
    private ObjetMaquette _getProgramDetails(String pegaseSyncCode, ObjetsMaquetteApi objetsMaquetteApi) throws ApiException
    {
        String[] split = pegaseSyncCode.split("/");
        
        if (split.length != 2)
        {
            // If the given code is not well formatted, throw an exception
            throw new ApiException("Le code de synchronisation n'est pas valide, il doit être de la forme [code]/[version] mais il a comme valeur : " + pegaseSyncCode);
        }
        
        String code = split[0];
        BigDecimal version = new BigDecimal(split[1]);
        
        PagedObjetMaquette pagedObjectDetails = objetsMaquetteApi.lireListeObjetsMaquette(_structureCode, "FORMATION", null, null, code, null, null, null, null, null, null, version, null, null, null, null, null, null, null);
        
        if (pagedObjectDetails != null)
        {
            List<ObjetMaquette> items = pagedObjectDetails.getItems();
            if (items != null && !items.isEmpty())
            {
                // Retrieve first found formation
                return items.get(0);
            }
        }
        
        // If no formation has been found with the given code, throw an exception
        throw new ApiException("Aucune formation n'a été trouvée avec le code de synchronisation " + pegaseSyncCode);
    }
    
    @SuppressWarnings("unchecked")
    private Map<String, Map<String, Object>> _getObjectDetailsForImport(Map<String, String> idValues, ObjetsMaquetteApi objetsMaquetteApi, ArbresApi arbresApi, Logger logger) throws ApiException
    {
        Map<String, Map<String, Object>> results = new LinkedHashMap<>();
        Set<String> handledObjects = new HashSet<>();

        for (String idValue : idValues.keySet())
        {
            // Get the program tree structure from the idValue
            Arbre tree = arbresApi.lireArbre(_structureCode, idValue);
            
            // Get the program's details from the tree structure
            String code = idValues.get(idValue);
            ObjetMaquette programDetails = tree.getObjetsMaquette().get(code);
            
            if (programDetails != null)
            {
                List<ObjetMaquette> children = new ArrayList<>();
                children.add(programDetails);
                while (!children.isEmpty())
                {
                    ObjetMaquette child = children.remove(0);
    
                    String childCode = _createPegaseSyncCode(child);
                    if (handledObjects.add(childCode))
                    {
                        // Get the current child's children
                        Collection<Enfant> grandChildren = child.getEnfants().values();
                        if (!grandChildren.isEmpty())
                        {
                            try 
                            {
                                // Children must be read from objets-maquette API because they do not keep the right order in the tree
                                // Call the objets-maquette API only if the object has children (detected in the tree)
                                grandChildren = objetsMaquetteApi.lireEnfants(_structureCode, child.getId());
                            }
                            catch (Exception e) 
                            {
                                // If the request doesn't work, the ObjetMaquette is a GROUPEMENT that we created
                                // Do nothing to keep children that have been added in the right order
                            }
                        }
                        
                        Map<String, Collection<? extends Object>> childResult = _objectDetailsToMap(child, grandChildren, tree, logger);
                        children.addAll((List<ObjetMaquette>) childResult.remove("childrenToSend"));
    
                        // Add mapped object to the results
                        results.put((String) childResult.remove(getIdField()).iterator().next(), (Map<String, Object>) (Object) childResult);
                    }
                }
            }
        }
        
        return results;
    }
    
    private String _createPegaseSyncCode(ObjetMaquette objectDetails) 
    {
        String code = objectDetails.getCode();
        
        if ("FORMATION".equals(objectDetails.getType().getLibelle()))
        {
            String version = objectDetails.getDetail().getFormation().getVersion().toString();
            
            code += "/" + version;
        }
        
        return code;
    }
    
    @Override
    public List<ModifiableContent> importContent(String idValue, Map<String, Object> importParams, Logger logger) throws Exception
    {
        Map<String, Object> parameters = putIdParameter(idValue);
        return _importOrSynchronizeContents(parameters, true, logger);
    }
    
    @Override
    public void synchronizeContent(ModifiableContent content, Logger logger) throws Exception
    {
        String idValue = content.getValue(getIdField());
        Map<String, Object> parameters = putIdParameter(idValue);
        _importOrSynchronizeContents(parameters, true, logger);
    }
    
    @Override
    protected List<ModifiableContent> _importOrSynchronizeContents(Map<String, Object> searchParams, boolean forceImport, Logger logger)
    {
        _importedContents = new HashMap<>();
        _synchronizedContents = new HashSet<>();
        _updatedRelationContents = new HashSet<>();
        _contentsChildren = new HashMap<>();
        
        List<ModifiableContent> contents =  super._importOrSynchronizeContents(searchParams, forceImport, logger);
        _updateRelations(logger);
        _updateWorkflowStatus(logger);
        
        _importedContents = null;
        _synchronizedContents = null;
        _updatedRelationContents = null;
        _contentsChildren = null;
        
        return contents;
    }
    
    private void _updateRelations(Logger logger)
    {
        for (String contentId : _contentsChildren.keySet())
        {
            WorkflowAwareContent content = _resolver.resolveById(contentId);
            Set<String> childrenCodes = _contentsChildren.get(contentId);
            String contentLanguage = content.getLanguage();
            String contentCatalog = content.getValue("catalog");
            Map<String, Set<String>> childrenByAttributeName = new HashMap<>();
            
            for (String childCode : childrenCodes)
            {
                Expression expression = new AndExpression(
                    _sccHelper.getCollectionExpression(getId()),
                    new StringExpression(getIdField(), Operator.EQ, childCode),
                    new StringExpression("catalog", Operator.EQ, contentCatalog),
                    new LanguageExpression(Operator.EQ, contentLanguage)
                );
                
                ModifiableContent childContent = _resolver.<ModifiableContent>query(ContentQueryHelper.getContentXPathQuery(expression))
                    .stream()
                    .findFirst()
                    .orElse(null);
                
                if (childContent == null)
                {
                    logger.warn("Content with code '{}' in {} on catalog '{}' was not found in the repository to update relations with content [{}] '{}' ({}).", childCode, contentLanguage, contentCatalog, content.getValue(getIdField()), content.getTitle(), contentCatalog);
                }
                else
                {
                    String attributesName = _getChildAttributeName(content, childContent);
                    if (attributesName != null)
                    {
                        Set<String> children = childrenByAttributeName.computeIfAbsent(attributesName, __ -> new LinkedHashSet<>());
                        children.add(childContent.getId());
                    }
                    else
                    {
                        logger.warn("The child content [{}] '{}' of type '{}' is not compatible with parent content [{}] '{}' of type '{}'.", childCode, childContent.getTitle(), childContent.getTypes()[0], content.getValue(getIdField()), content.getTitle(), content.getTypes()[0]);
                    }
                }
            }
            _updateRelations(content, childrenByAttributeName, logger);
        }
    }
    
    private String _getChildAttributeName(Content parentContent, Content childContent)
    {
        if (childContent instanceof Course && parentContent instanceof CourseList)
        {
            return CourseList.CHILD_COURSES;
        }
        
        if (parentContent instanceof Course && childContent instanceof CourseList)
        {
            return Course.CHILD_COURSE_LISTS;
        }
        
        if (parentContent instanceof TraversableProgramPart && childContent instanceof ProgramPart)
        {
            return TraversableProgramPart.CHILD_PROGRAM_PARTS;
        }
        
        return null;
    }
    
    private void _updateRelations(WorkflowAwareContent content, Map<String, Set<String>> contentRelationsByAttribute, Logger logger)
    {
        // Compute the view
        View view = View.of(content.getModel(), contentRelationsByAttribute.keySet().toArray(new String[contentRelationsByAttribute.size()]));
        
        // Compute values
        Map<String, Object> values = new HashMap<>();
        for (String attributeName : contentRelationsByAttribute.keySet())
        {
            // Add the content relations to the existing ones
            List<String> attributeValue = _getContentAttributeValue(content, attributeName);
            contentRelationsByAttribute.get(attributeName)
                .stream()
                .filter(id -> !attributeValue.contains(id))
                .forEach(attributeValue::add);
            
            values.put(attributeName, attributeValue.toArray(new String[attributeValue.size()]));
        }
        
        // Compute not synchronized contents
        Set<String> notSynchronizedContentIds = contentRelationsByAttribute.values()
                .stream()
                .flatMap(Collection::stream)
                .filter(id -> !_synchronizedContents.contains(id))
                .collect(Collectors.toSet());
        
        try
        {
            _editContent(content, Optional.of(view), values, Map.of(), false, notSynchronizedContentIds, logger);
        }
        catch (WorkflowException e)
        {
            _nbError++;
            logger.error("The content '{}' cannot be links edited (workflow action)", content, e);
        }
    }
    
    private List<String> _getContentAttributeValue(Content content, String attributeName)
    {
        return Optional.of(attributeName)
            .map(content::<ContentValue[]>getValue)
            .map(Stream::of)
            .orElseGet(Stream::empty)
            .map(ContentValue::getContentId)
            .collect(Collectors.toList());
    }
    
    private void _updateWorkflowStatus(Logger logger)
    {
        // Validate contents -> only on newly imported contents
        if (validateAfterImport())
        {
            for (String contentId : _importedContents.keySet())
            {
                WorkflowAwareContent content = _resolver.resolveById(contentId);
                Integer validationActionId = _importedContents.get(contentId);
                if (validationActionId > 0)
                {
                    validateContent(content, validationActionId, logger);
                }
            }
        }
    }
    
    /**
     * Get the workflow description for the given category.
     * @param category The category
     * @return the matching workflow description
     * @throws IllegalArgumentException if the given categorie does not match any content workflow
     */
    protected ContentWorkflowDescription _mapWorkflowDescription(String category) throws IllegalArgumentException
    {
        switch (category)
        {
            case "formation":
                return ContentWorkflowDescription.PROGRAM_WF_DESCRIPTION;
            case "OO":
                return ContentWorkflowDescription.SUBPROGRAM_WF_DESCRIPTION;
            case "OTT":
                return ContentWorkflowDescription.CONTAINER_WF_DESCRIPTION;
            case "GROUPEMENT":
                return ContentWorkflowDescription.COURSELIST_WF_DESCRIPTION;
            case "OP":
                return ContentWorkflowDescription.COURSE_WF_DESCRIPTION;
            default:
                throw new IllegalArgumentException("The category '" + category + "' cannot be converted to an Ametys content type.");
        }
    }

    @SuppressWarnings("unchecked")
    @Override
    protected Map<String, Map<String, List<Object>>> getRemoteValues(Map<String, Object> parameters, Logger logger)
    {
        return (Map<String, Map<String, List<Object>>>) (Object) internalSearch(parameters, 0, Integer.MAX_VALUE, null, logger);
    }

    @Override
    protected void configureDataSource(Configuration configuration) throws ConfigurationException
    {
        _odfLang = Config.getInstance().getValue("odf.programs.lang");
        _searchFields = new HashSet<>();
        _mappingByContentType = new HashMap<>();
        
        if (Config.getInstance().getValue("pegase.activate", true, false))
        {
            _structureCode = Config.getInstance().getValue("pegase.structure.code");
    
            // Champs affichés dans la recherche
            _searchFields.add("code");
            _searchFields.add("libelleCourt");
            _searchFields.add("libelleLong");
            _searchFields.add("version");
            _searchFields.add("id");
            _searchFields.add("codeTypeDiplome");
            _searchFields.add("codeNiveauFormation");
            _searchFields.add("codeDomaineFormation");
            _searchFields.add("codeNatureDiplome");
            _searchFields.add("codeNiveauDiplome");
            _searchFields.add("codeMention");
            _searchFields.add("codeChampFormation");
            _searchFields.add("ects");
            
            
            // Program
            Map<String, List<String>> contentTypeMapping = new HashMap<>();
            contentTypeMapping.put("title", List.of("libelleLong", "libelleCourt"));
            contentTypeMapping.put("ects", List.of("ects"));
            contentTypeMapping.put("educationKind", List.of("codeNatureDiplomeCode"));
            contentTypeMapping.put("presentation", List.of("description"));
            contentTypeMapping.put("mention", List.of("codeMention"));
            contentTypeMapping.put("domain", List.of("codeDomaineFormation"));
            contentTypeMapping.put("programField", List.of("codeChampFormation"));
            contentTypeMapping.put("educationLevel", List.of("codeNiveauFormation"));
            contentTypeMapping.put("rncpLevel", List.of("codeNiveauDiplome"));
            contentTypeMapping.put("degree", List.of("codeTypeDiplome"));
            _mappingByContentType.put(ProgramFactory.PROGRAM_CONTENT_TYPE, contentTypeMapping);
            
            // SubProgram
            contentTypeMapping = new HashMap<>();
            contentTypeMapping.put("title", List.of("libelleLong", "libelleCourt"));
            contentTypeMapping.put("ects", List.of("ects"));
            contentTypeMapping.put("presentation", List.of("description"));
            _mappingByContentType.put(SubProgramFactory.SUBPROGRAM_CONTENT_TYPE, contentTypeMapping);
    
            // Container
            contentTypeMapping = new HashMap<>();
            contentTypeMapping.put("title", List.of("libelleLong", "libelleCourt"));
            contentTypeMapping.put("ects", List.of("ects"));
            contentTypeMapping.put("description", List.of("description"));
            contentTypeMapping.put("nature", List.of("type"));
            _mappingByContentType.put(ContainerFactory.CONTAINER_CONTENT_TYPE, contentTypeMapping);
            
            // CourseList
            contentTypeMapping = new HashMap<>();
            contentTypeMapping.put("title", List.of("libelleLong", "libelleCourt"));
            contentTypeMapping.put("plageDeChoix", List.of("plageDeChoix"));
            contentTypeMapping.put("obligatoire", List.of("obligatoire"));
            contentTypeMapping.put("min", List.of("plageMin"));
            contentTypeMapping.put("max", List.of("plageMax"));
            _mappingByContentType.put(CourseListFactory.COURSE_LIST_CONTENT_TYPE, contentTypeMapping);
    
            // Course
            contentTypeMapping = new HashMap<>();
            contentTypeMapping.put("title", List.of("libelleLong", "libelleCourt"));
            contentTypeMapping.put("ects", List.of("ects"));
            contentTypeMapping.put("description", List.of("description"));
            contentTypeMapping.put("courseType", List.of("type"));
            _mappingByContentType.put(CourseFactory.COURSE_CONTENT_TYPE, contentTypeMapping);
        }
    }

    @Override
    protected void configureSearchModel()
    {
        List<String> sortableColumns = List.of("code", "libelleCourt", "version");

        _searchModelConfiguration.addCriterion("libelle", new I18nizableText("plugin.odf-sync", "PLUGINS_ODF_SYNC_PEGASE_CRITERION_LIBELLE"), "string");
        _searchModelConfiguration.addCriterion("code", new I18nizableText("plugin.odf-sync", "PLUGINS_ODF_SYNC_PEGASE_CRITERION_CODE"), "string");
        _searchModelConfiguration.addCriterion("version", new I18nizableText("plugin.odf-sync", "PLUGINS_ODF_SYNC_PEGASE_CRITERION_VERSION"), "string");
        _searchModelConfiguration.addCriterion("validee", new I18nizableText("plugin.odf-sync", "PLUGINS_ODF_SYNC_PEGASE_CRITERION_VALIDEE"), "boolean", "edition.boolean-combobox");

        for (String keptField : _searchFields)
        {
            if (sortableColumns.contains(keptField))
            {
                _searchModelConfiguration.addColumn(keptField, new I18nizableText(keptField), true);
            }
            else
            {
                _searchModelConfiguration.addColumn(keptField, new I18nizableText(keptField), false);
            }
        }
    }

    /**
     * Get the catalog for import.
     * @return the catalog
     */
    protected String getCatalog()
    {
        return Optional.of(getParameterValues())
                   .map(params -> params.get("catalog"))
                   .map(String.class::cast)
                   .filter(StringUtils::isNotBlank)
                   .orElseGet(() -> _catalogsManager.getDefaultCatalogName());
    }
    
    /**
     * Get or create the content defined by the given parameters.
     * @param lang The content language
     * @param idValue The synchronization code
     * @param remoteValues The remote values
     * @param forceImport <code>true</code> to force import (only on single import or unlimited global synchronization)
     * @param logger The logger
     * @return the content
     * @throws Exception if an error occurs
     */
    protected ModifiableContent _getOrCreateContent(String lang, String idValue, Map<String, List<Object>> remoteValues, boolean forceImport, Logger logger) throws Exception
    {
        ContentWorkflowDescription wfDescription = (ContentWorkflowDescription) remoteValues.get("workflowDescription").get(0);
        ModifiableContent content = _getContent(lang, idValue, wfDescription.getContentType());
        if (content == null && (forceImport || !synchronizeExistingContentsOnly()))
        {
            // Calculate contentTitle
            String contentTitle = Optional.of(remoteValues)
                .map(v -> v.get("title"))
                .map(List::stream)
                .orElseGet(Stream::empty)
                .filter(String.class::isInstance)
                .map(String.class::cast)
                .filter(StringUtils::isNotEmpty)
                .findFirst()
                .orElse(idValue);
            
            String contentName = NameHelper.filterName(_contentPrefix + "-" + contentTitle + "-" + lang);
            
            Map<String, Object> inputs = new HashMap<>();
            String catalog = getCatalog();
            if (catalog != null)
            {
                inputs.put(AbstractCreateODFContentFunction.CONTENT_CATALOG_KEY, catalog);
            }
            
            Map<String, Object> resultMap = _contentWorkflowHelper.createContent(
                    wfDescription.getWorkflowName(),
                    wfDescription.getInitialActionId(),
                    contentName,
                    contentTitle,
                    new String[] {wfDescription.getContentType()},
                    null,
                    lang,
                    null,
                    null,
                    inputs);
            
            if ((boolean) resultMap.getOrDefault("error", false))
            {
                _nbError++;
            }
            
            content = (ModifiableContent) resultMap.get(Content.class.getName());

            if (content != null)
            {
                _sccHelper.updateSCCProperty(content, getId());
                
                // Set sync code
                content.setValue(getIdField(), idValue);
                
                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 syncCode The synchronization code
     * @param contentType The content type
     * @return the retrieved content
     */
    protected ModifiableContent _getContent(String lang, String syncCode, String contentType)
    {
        List<Expression> expList = _getExpressionsList(lang, syncCode, contentType);
        AndExpression andExp = new AndExpression(expList.toArray(new Expression[expList.size()]));
        String xPathQuery = ContentQueryHelper.getContentXPathQuery(andExp);

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

        if (contents.getSize() > 0)
        {
            return contents.iterator().next();
        }
        
        return null;
    }
    
    @Override
    protected Optional<ModifiableContent> _importOrSynchronizeContent(String idValue, String lang, Map<String, List<Object>> remoteValues, boolean forceImport, Logger logger)
    {
        try
        {
            ModifiableContent content = _getOrCreateContent(lang, idValue, remoteValues, forceImport, logger);
            if (content != null)
            {
                return Optional.of(_synchronizeContent(content, remoteValues, logger));
            }
        }
        catch (Exception e)
        {
            _nbError++;
            logger.error("An error occurred while importing or synchronizing content", e);
        }
        
        return Optional.empty();
    }
    
    @SuppressWarnings("unchecked")
    @Override
    protected ModifiableContent _synchronizeContent(ModifiableContent content, Map<String, List<Object>> remoteValues, Logger logger) throws Exception
    {
        super._synchronizeContent(content, remoteValues, logger);
        // Add children to the list to handle later to add relations
        if (remoteValues.containsKey("children"))
        {
            Set<String> children = _contentsChildren.computeIfAbsent(content.getId(), __ -> new LinkedHashSet<>());
            children.addAll((List<String>) (Object) remoteValues.get("children"));
        }
        return content;
    }
    
    @Override
    protected boolean _fillContent(Map<String, List<Object>> remoteValues, ModifiableContent content, Map<String, Object> additionalParameters, boolean create, Logger logger) throws Exception
    {
        _synchronizedContents.add(content.getId());
        return super._fillContent(remoteValues, content, additionalParameters, create, logger);
    }
    
    @Override
    public List<String> getLanguages()
    {
        return List.of(_odfLang);
    }

    @Override
    protected List<Expression> _getExpressionsList(String lang, String idValue, String contentType)
    {
        List<Expression> expList = super._getExpressionsList(lang, idValue, contentType);
        String catalog = getCatalog();
        if (catalog != null)
        {
            expList.add(new StringExpression(ProgramItem.CATALOG, Operator.EQ, catalog));
        }
        return expList;
    }
    
    @Override
    protected Map<String, Map<String, List<Object>>> getTransformedRemoteValues(Map<String, Object> searchParameters, Logger logger)
    {
        searchParameters.put("import", true);
        return super.getTransformedRemoteValues(searchParameters, logger);
    }
    
    @Override
    protected Map<String, Object> _transformRemoteValuesCardinality(Map<String, List<Object>> remoteValues, String obsoleteContentTypeId)
    {
        String realContentTypeId = Optional.of(remoteValues)
                .map(v -> v.get("workflowDescription"))
                .map(l -> l.get(0))
                .map(ContentWorkflowDescription.class::cast)
                .map(ContentWorkflowDescription::getContentType)
                .orElse(null);
        return super._transformRemoteValuesCardinality(remoteValues, realContentTypeId);
    }
    
    private PagedObjetMaquette _getPagedProgramsDetails(Map<String, Object> parameters, int offset, int limit, List<Object> sort, ObjetsMaquetteApi objetsMaquetteApi) throws ApiException
    {
        PagedObjetMaquette pagedPrograms = null;
        Pageable pageable = new Pageable();  
        int pageNumber = offset / 50;
        pageable.setPage(pageNumber);
        pageable.setTaille(limit);
        
        if (sort == null)
        {
            pageable.setTri(List.of());
        }
        else 
        {
            // Convert the sort parameter from Object to JSON
            String jsonSortParameters = _jsonUtils.convertObjectToJson(sort.get(0));
            // Convert the sort parameter from JSON to Map<String, Object>
            Map<String, Object> sortParameters = _jsonUtils.convertJsonToMap(jsonSortParameters);
            // Create the list containing the sort result; it is going to be of the form : ["field,direction"]
            List<String> sortParametersArray = new ArrayList<>();
            // Create the sort parameter that is going to be sent in the list; it is going to be of the form : "field,direction"
            StringBuilder stringBuilder = new StringBuilder();
            // Get the parameter "property" which is the column on which the sorting is meant to be made
            String property = (String) sortParameters.get("property");
            
            if (!"code".equals(property) & !"libelle".equals(property) & !"version".equals(property))
            {
                if ("libelleCourt".equals(property))
                {
                    stringBuilder.append("libelle,").append((String) sortParameters.get("direction"));
                    sortParametersArray.add(stringBuilder.toString());
                }
            }
            else 
            {
                stringBuilder.append(property).append(",").append((String) sortParameters.get("direction"));
                sortParametersArray.add(stringBuilder.toString());
            }
            
            pageable.setTri(sortParametersArray);
        }
        
        // Get the PagedObjetsMaquette : paged program with potential search parameters
        Object versionO = parameters.get("version");
        BigDecimal version = null;
        
        if (versionO != null)
        {
            version = new BigDecimal(versionO.toString());
        }
        
        String status = null;
        Object value = parameters.get("validee");
        if (value != null)
        {
            status = (boolean) parameters.get("validee") ? "VALIDE" : "EN-CONSTRUCTION";
        }
        
        pagedPrograms = objetsMaquetteApi.lireListeObjetsMaquette(_structureCode, "FORMATION", null, null, _getParametersInRegularExp("code", parameters), _getParametersInRegularExp("libelle", parameters), null, null, null, null, null, version, status, null, null, null, null, null, pageable);
        return pagedPrograms;
    }
    
    private String _getParametersInRegularExp(String field, Map<String, Object> parameters)
    {
        Object value = parameters.get(field);
        if (value != null)
        {
            StringBuilder criteria = new StringBuilder();
            criteria.append("*").append(value.toString()).append("*");
            return criteria.toString();
        }
        
        return null;
    }
    
    private Map<String, List<? extends Object>> _getObjectFields(ObjetMaquette objectDetails, String categorie)
    {
        Map<String, List<? extends Object>> result = new HashMap<>();

        ContentWorkflowDescription wfDescription = _mapWorkflowDescription(categorie);
        result.put("workflowDescription", List.of(wfDescription));
        
        String contentTypeId = wfDescription.getContentType();
        Map<String, List<String>> contentTypeMapping = _mappingByContentType.get(contentTypeId);
        
        Map<String, String> fields = _getFields(objectDetails);
        
        for (String attribute : contentTypeMapping.keySet())
        {
            List<String> jsonKeys = contentTypeMapping.get(attribute);
            List<Object> values = new ArrayList<>();
            
            for (String key : jsonKeys)
            {
                String value = fields.get(key);
                
                if (value != null && !value.isEmpty() && !value.isBlank())
                {
                    values.add(value);
                }
                
            }
            
            result.put(attribute, values); // Add the retrieved metadata values list to the contentResult
        }
        
        // Add the ID field
        String syncCode = _createPegaseSyncCode(objectDetails); 
        if (syncCode != null)
        {
            result.put(getIdField(), List.of(syncCode));
        }
        
        return result;
    }
    
    private Map<String, Collection<? extends Object>> _objectDetailsToMap(ObjetMaquette objectDetails, Collection<Enfant> children, Arbre tree, Logger logger) 
    {
        Map<String, Collection<? extends Object>> result = new HashMap<>();

        // Compute category depending on child - to create a Container if a GROUPEMENT has no child of type OP
        String category = _getObjectCategory(objectDetails, children, tree);
        
        // Fill map with fields of the current object
        result.putAll(_getObjectFields(objectDetails, category));
        
        // Compute children depending the current object
        Collection<ObjetMaquette> childrenDetails = "GROUPEMENT".equals(category)
                ? _filterGroupChildren(objectDetails, children, tree, logger) // Keep only OP under GROUPEMENT - ignore other objects
                : _getObjectChildren(objectDetails, children, tree);          // Insert a GROUPEMENT if there are OP
        
        // Fill map with computed children
        result.put("childrenToSend", childrenDetails);
        result.put("children", childrenDetails.stream()
                                             .map(ObjetMaquette::getCode)
                                             .collect(Collectors.toList()));
        
        return result;
    }
    
    private String _getObjectCategory(ObjetMaquette objectDetails, Collection<Enfant> children, Arbre tree)
    {
        String category = objectDetails.getCategorie();
        if ("GROUPEMENT".equals(category) && children.stream()
                                                     .map(child -> _getChildObjectDetails(child, tree))
                                                     .map(ObjetMaquette::getCategorie)
                                                     .noneMatch("OP"::equals))
        {
            // If there is no OP under the GROUPEMENT, we create a container (OTT) rather than a courseList (GROUPEMENT)
            category = "OTT";
        }
        
        return category;
    }
    
    private Collection<ObjetMaquette> _filterGroupChildren(ObjetMaquette group, Collection<Enfant> children, Arbre tree, Logger logger)
    {
        Collection<ObjetMaquette> filteredChildren = new ArrayList<>();
        
        for (Enfant child : children)
        {
            ObjetMaquette childDetails = _getChildObjectDetails(child, tree);
            if ("OP".equals(childDetails.getCategorie()))
            {
                filteredChildren.add(childDetails); 
            }
            else
            {
                // A GROUPEMENT can only have OP children to match courseList content type with courses children
                ContentWorkflowDescription childWorkflowDescription = _mapWorkflowDescription(childDetails.getCategorie());
                String childType = childWorkflowDescription.getContentType();
                String courseListType = CourseListFactory.COURSE_LIST_CONTENT_TYPE;
                logger.warn("The child content '{}' of type '{}' is not compatible with parent content '{}' of type '{}'.", childDetails.getCode(), childType, group.getCode(), courseListType);
            }
        }
        
        return filteredChildren;
    }
    
    private Collection<ObjetMaquette> _getObjectChildren(ObjetMaquette objetDetails, Collection<Enfant> children, Arbre tree)
    {
        Collection<ObjetMaquette> childrenDetails = new ArrayList<>();
        Map<String, Enfant> courses = new LinkedHashMap<>();
        for (Enfant child : children)
        {
            ObjetMaquette childDetails = _getChildObjectDetails(child, tree);
            if ("OP".equals(childDetails.getCategorie()))
            {
                // Put OP aside to add them as children of the inserted GROUPEMENT
                courses.put(childDetails.getCode(), child);
            }
            else
            {
                // Keep other children
                childrenDetails.add(childDetails);
            }
        }
        
        if (!courses.isEmpty())
        {
            // Create a GROUPEMENT Object
            ObjetMaquette childGroup = new ObjetMaquette();
            
            String code = _generateInsertedGroupementUniqueCode(objetDetails);
            childGroup.setCode(code);
            childGroup.setLibelle(code);
            childGroup.setLibelleLong(code);
            childGroup.setId(code);
            
            ObjetLibelle type = new ObjetLibelle();
            type.setCode("GROUPEMENT");
            
            childGroup.setType(type);
            childGroup.setCategorie("GROUPEMENT");
            
            // Add courses that has been put aside as children of the new GROUPEMENT
            childGroup.setEnfants(courses);
            
            // Add the GROUPEMENT to the current object children
            childrenDetails.add(childGroup);
        }
        
        return childrenDetails;
    }
    
    private String _generateInsertedGroupementUniqueCode(ObjetMaquette parent)
    {
        int maxPrefixWidth = __PEGASE_SYNC_CODE_MAX_LENGTH - __INSERTED_GROUPEMENT_SUFFIX.length();
        String codePrefix = parent.getCode();

        if (codePrefix.length() > maxPrefixWidth)
        {
            // Create a hashCode of the prefix. Hash code is an integer that will take less than 20 characters
            int parentHashedCode = codePrefix.hashCode();
            codePrefix = Integer.toHexString(parentHashedCode).toUpperCase();
        }

        return codePrefix + __INSERTED_GROUPEMENT_SUFFIX;
    }
    
    private ObjetMaquette _getChildObjectDetails(Enfant child, Arbre tree)
    {
        Ref enfantRef = child.getRef();
        String code = enfantRef.getCode();
        return tree.getObjetsMaquette().get(code);
    }
    
    private Map<String, String> _getFields(ObjetMaquette objectDetails)
    {
        ObjetMaquetteDetails detail = objectDetails.getDetail();
        Map<String, String> basicFields = Map.of(
                "id", StringUtils.defaultString(objectDetails.getId()),
                "code",  StringUtils.defaultString(objectDetails.getCode()),
                "libelleCourt", StringUtils.defaultString(objectDetails.getLibelle()),
                "libelleLong", StringUtils.defaultString(objectDetails.getLibelleLong()),
                "description", StringUtils.defaultString(objectDetails.getDescription()),
                "ects", Optional.ofNullable(objectDetails.getEcts())
                                            .map(value -> value.toString())
                                            .orElse(StringUtils.EMPTY),
                "type", Optional.ofNullable(objectDetails.getType())         // Get the ObjetLibelle nature
                        .map(objLibelleNature -> objLibelleNature.getCode()) // If the ObjetLibelle is not null, get the code
                        .orElse(StringUtils.EMPTY)                           // Else empty string
                );
        
        Map<String, String> allFields = new HashMap<>(basicFields);
        
        if (detail != null) 
        {
            String choices = Optional.ofNullable(objectDetails.getPlageDeChoix())
                                     .map(Object::toString)
                                     .orElse(StringUtils.EMPTY);

            ObjetMaquetteGroupement group = detail.getGroupement();
            if (group != null && choices.isEmpty())
            {
                choices = Optional.ofNullable(group.getPlageDeChoix())
                                  .map(Object::toString)
                                  .orElse(StringUtils.EMPTY);
            }
            
            allFields.put("plageDeChoix", choices);
            
            ObjetMaquetteFormation program = detail.getFormation();
            if (program != null)
            {
                Map<String, String> programFields = Map.of(
                        "codeTypeDiplome", StringUtils.defaultString(program.getTypeDiplome()),
                        "codeNiveauFormation", StringUtils.defaultString(program.getNiveauFormation()),
                        "codeDomaineFormation", StringUtils.defaultString(program.getDomaineFormation()),
                        "codeNiveauDiplome", StringUtils.defaultString(program.getNiveauDiplome()),
                        "codeMention", StringUtils.defaultString(program.getMention()),
                        "codeChampFormation", StringUtils.defaultString(program.getChampFormation()),
                        "version", Optional.ofNullable(program.getVersion())
                                           .map(Object::toString)
                                           .orElse(StringUtils.EMPTY),
                        "codeNatureDiplome", Optional.ofNullable(program.getTypeFormation())
                                                     .map(ObjetMaquetteFormationTypeFormation::getLibelle)
                                                     .orElse(StringUtils.EMPTY),
                        "codeNatureDiplomeCode", Optional.ofNullable(program.getTypeFormation())
                                                         .map(ObjetMaquetteFormationTypeFormation::getCode)
                                                         .orElse(StringUtils.EMPTY)
                        );
                
                allFields.putAll(programFields);
            }
        }
        
        return allFields;
    }
}