/*
 *  Copyright 2017 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.odf;

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

import org.apache.avalon.framework.component.Component;
import org.apache.avalon.framework.context.Context;
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.components.ContextHelper;
import org.apache.cocoon.environment.Request;
import org.apache.commons.lang.StringUtils;
import org.apache.commons.lang3.ArrayUtils;
import org.apache.commons.lang3.tuple.Pair;

import org.ametys.cms.content.external.ExternalizableMetadataHelper;
import org.ametys.cms.content.external.ExternalizableMetadataProviderExtensionPoint;
import org.ametys.cms.contenttype.ContentTypeExtensionPoint;
import org.ametys.cms.data.ContentDataHelper;
import org.ametys.cms.repository.Content;
import org.ametys.cms.repository.ContentQueryHelper;
import org.ametys.cms.repository.ContentTypeExpression;
import org.ametys.cms.repository.DefaultContent;
import org.ametys.cms.repository.LanguageExpression;
import org.ametys.cms.repository.ModifiableContent;
import org.ametys.cms.repository.ModifiableWorkflowAwareContent;
import org.ametys.cms.workflow.ContentWorkflowHelper;
import org.ametys.core.observation.ObservationManager;
import org.ametys.core.ui.Callable;
import org.ametys.core.user.CurrentUserProvider;
import org.ametys.odf.course.Course;
import org.ametys.odf.course.CourseContainer;
import org.ametys.odf.course.ShareableCourseHelper;
import org.ametys.odf.courselist.CourseList;
import org.ametys.odf.courselist.CourseList.ChoiceType;
import org.ametys.odf.courselist.CourseListContainer;
import org.ametys.odf.coursepart.CoursePart;
import org.ametys.odf.coursepart.CoursePartFactory;
import org.ametys.odf.orgunit.OrgUnit;
import org.ametys.odf.orgunit.RootOrgUnitProvider;
import org.ametys.odf.program.AbstractProgram;
import org.ametys.odf.program.AbstractTraversableProgramPart;
import org.ametys.odf.program.Container;
import org.ametys.odf.program.Program;
import org.ametys.odf.program.ProgramFactory;
import org.ametys.odf.program.ProgramPart;
import org.ametys.odf.program.SubProgram;
import org.ametys.odf.program.TraversableProgramPart;
import org.ametys.odf.workflow.ValidateODFContentFunction;
import org.ametys.plugins.repository.AmetysObject;
import org.ametys.plugins.repository.AmetysObjectExistsException;
import org.ametys.plugins.repository.AmetysObjectIterable;
import org.ametys.plugins.repository.AmetysObjectIterator;
import org.ametys.plugins.repository.AmetysObjectResolver;
import org.ametys.plugins.repository.AmetysRepositoryException;
import org.ametys.plugins.repository.ModifiableTraversableAmetysObject;
import org.ametys.plugins.repository.RepositoryConstants;
import org.ametys.plugins.repository.UnknownAmetysObjectException;
import org.ametys.plugins.repository.collection.AmetysObjectCollection;
import org.ametys.plugins.repository.jcr.DefaultAmetysObject;
import org.ametys.plugins.repository.metadata.ModifiableCompositeMetadata;
import org.ametys.plugins.repository.query.QueryHelper;
import org.ametys.plugins.repository.query.SortCriteria;
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.i18n.I18nizableText;
import org.ametys.runtime.plugin.component.AbstractLogEnabled;
import org.ametys.runtime.plugin.component.PluginAware;

import com.opensymphony.workflow.WorkflowException;

/**
 * Helper for ODF contents
 *
 */
public class ODFHelper extends AbstractLogEnabled implements Component, Serviceable, PluginAware, Contextualizable
{
    /** The component role. */
    public static final String ROLE = ODFHelper.class.getName();
    
    /** Request attribute to get the "Live" version of contents */
    public static final String REQUEST_ATTRIBUTE_VALID_LABEL = "live-version";
    
    /** The default id of initial workflow action */
    protected static final int __INITIAL_WORKFLOW_ACTION_ID = 0;
    
    /** Ametys object resolver */
    protected AmetysObjectResolver _resolver;
    /** The content workflow helper */
    protected ContentWorkflowHelper _contentWorkflowHelper;
    /** The content types manager */
    protected ContentTypeExtensionPoint _cTypeEP;
    /** The observation manager */
    protected ObservationManager _observationManager;
    /** The current user provider */
    protected CurrentUserProvider _currentUserProvider;
    /** Root orgunit */
    protected RootOrgUnitProvider _ouRootProvider;
    /** Provider for externalizable metadata */
    protected ExternalizableMetadataProviderExtensionPoint _externalizableMetadataProviderEP;
    /** Helper for shareable course */
    protected ShareableCourseHelper _shareableCourseHelper;
    /** The Avalon context */
    protected Context _context;
    
    private String _pluginName;

    public void contextualize(Context context) throws ContextException
    {
        _context = context;
    }
    
    @Override
    public void service(ServiceManager manager) throws ServiceException
    {
        _resolver = (AmetysObjectResolver) manager.lookup(AmetysObjectResolver.ROLE);
        _contentWorkflowHelper = (ContentWorkflowHelper) manager.lookup(ContentWorkflowHelper.ROLE);
        _cTypeEP = (ContentTypeExtensionPoint) manager.lookup(ContentTypeExtensionPoint.ROLE);
        _observationManager = (ObservationManager) manager.lookup(ObservationManager.ROLE);
        _currentUserProvider = (CurrentUserProvider) manager.lookup(CurrentUserProvider.ROLE);
        _ouRootProvider = (RootOrgUnitProvider) manager.lookup(RootOrgUnitProvider.ROLE);
        _externalizableMetadataProviderEP = (ExternalizableMetadataProviderExtensionPoint) manager.lookup(ExternalizableMetadataProviderExtensionPoint.ROLE);
        _shareableCourseHelper = (ShareableCourseHelper) manager.lookup(ShareableCourseHelper.ROLE);
    }
    
    @Override
    public void setPluginInfo(String pluginName, String featureName, String id)
    {
        _pluginName = pluginName;
    }
    
    /**
     * Gets the root for ODF contents
     * @return the root for ODF contents
     */
    public AmetysObjectCollection getRootContent()
    {
        return getRootContent(false);
    }
    
    /**
     * Gets the root for ODF contents
     * @param create <code>true</code> to create automatically the root when missing.
     * @return the root for ODF contents
     */
    public AmetysObjectCollection getRootContent(boolean create)
    {
        ModifiableTraversableAmetysObject pluginsNode = _resolver.resolveByPath("/ametys:plugins/");
        
        boolean needSave = false;
        if (!pluginsNode.hasChild(_pluginName))
        {
            if (create)
            {
                pluginsNode.createChild(_pluginName, "ametys:unstructured");
                needSave = true;
            }
            else
            {
                throw new UnknownAmetysObjectException("Node '/ametys:plugins/" + _pluginName + "' is missing");
            }
        }
        
        ModifiableTraversableAmetysObject pluginNode = pluginsNode.getChild(_pluginName);
        if (!pluginNode.hasChild(RepositoryConstants.NAMESPACE_PREFIX + ":contents"))
        {
            if (create)
            {
                pluginNode.createChild(RepositoryConstants.NAMESPACE_PREFIX + ":contents", "ametys:collection");
                needSave = true;
            }
            else
            {
                throw new UnknownAmetysObjectException("Node '/ametys:plugins/" + _pluginName + "/ametys:contents' is missing");
            }
        }
        
        if (needSave)
        {
            pluginsNode.saveChanges();
        }
        
        return pluginNode.getChild(RepositoryConstants.NAMESPACE_PREFIX + ":contents");
    }
    
    /**
     * Get the {@link ProgramItem}s matching the given arguments
     * @param cTypeId The id of content type. Can be null to get program's items whatever their content type.
     * @param code The code. Can be null to get program's items regardless of their code
     * @param catalogName The search catalog. Can be null to get program's items regardless the catalog they belong to.
     * @param lang The search language. Can be null to get program's items regardless of their language
     * @param <C> The content return type 
     * @return The matching program items
     */
    public <C extends Content> AmetysObjectIterable<C> getProgramItems(String cTypeId, String code, String catalogName, String lang)
    {
        return getProgramItems(cTypeId, code, catalogName, lang, null, null);
    }
    
    /**
     * Get the {@link ProgramItem}s matching the given arguments
     * @param cTypeIds The id of content types. Can be empty to get program's items whatever their content type.
     * @param code The code. Can be null to get program's items regardless of their code
     * @param catalogName The search catalog. Can be null to get program's items regardless the catalog they belong to.
     * @param lang The search language. Can be null to get program's items regardless of their language
     * @param <C> The content return type 
     * @return The matching program items
     */
    public <C extends Content> AmetysObjectIterable<C> getProgramItems(Collection<String> cTypeIds, String code, String catalogName, String lang)
    {
        return getProgramItems(cTypeIds, code, catalogName, lang, null, null);
    }
    
    /**
     * Get the {@link ProgramItem}s matching the given arguments
     * @param cTypeId The id of content type. Can be null to get program's items whatever their content type.
     * @param code The code. Can be null to get program's items regardless of their code
     * @param catalogName The search catalog. Can be null to get program's items regardless the catalog they belong to.
     * @param lang The search language. Can be null to get program's items regardless of their language
     * @param additionnalExpr An additional expression for filtering result. Can be null
     * @param sortCriteria criteria for sorting results
     * @param <C> The content return type 
     * @return The matching program items
     */
    public <C extends Content> AmetysObjectIterable<C> getProgramItems(String cTypeId, String code, String catalogName, String lang, Expression additionnalExpr, SortCriteria sortCriteria)
    {
        return getProgramItems(cTypeId != null ? Collections.singletonList(cTypeId) : Collections.EMPTY_LIST, code, catalogName, lang, additionnalExpr, sortCriteria);
    }
    
    /**
     * Get the {@link ProgramItem}s matching the given arguments
     * @param cTypeIds The id of content types. Can be empty to get program's items whatever their content type.
     * @param code The code. Can be null to get program's items regardless of their code
     * @param catalogName The search catalog. Can be null to get program's items regardless the catalog they belong to.
     * @param lang The search language. Can be null to get program's items regardless of their language
     * @param additionnalExpr An additional expression for filtering result. Can be null
     * @param sortCriteria criteria for sorting results
     * @param <C> The content return type 
     * @return The matching program items
     */
    public <C extends Content> AmetysObjectIterable<C> getProgramItems(Collection<String> cTypeIds, String code, String catalogName, String lang, Expression additionnalExpr, SortCriteria sortCriteria)
    {
        List<Expression> exprs = new ArrayList<>();
        
        if (!cTypeIds.isEmpty())
        {
            exprs.add(new ContentTypeExpression(Operator.EQ, cTypeIds.toArray(new String[cTypeIds.size()])));
        }
        if (StringUtils.isNotEmpty(code))
        {
            exprs.add(new StringExpression(ProgramItem.CODE, Operator.EQ, code));
        }
        if (StringUtils.isNotEmpty(catalogName))
        {
            exprs.add(new StringExpression(ProgramItem.CATALOG, Operator.EQ, catalogName));
        }
        if (StringUtils.isNotEmpty(lang))
        {
            exprs.add(new LanguageExpression(Operator.EQ, lang));
        }
        if (additionnalExpr != null)
        {
            exprs.add(additionnalExpr);
        }
        
        Expression expr = new AndExpression(exprs.toArray(new Expression[exprs.size()]));
        
        String xpathQuery = ContentQueryHelper.getContentXPathQuery(expr, sortCriteria);
        return _resolver.query(xpathQuery);
    }
    
    /**
     * Get the equivalent {@link CoursePart} of the source {@link CoursePart} in given catalog and language 
     * @param srcCoursePart The source course part
     * @param catalogName The name of catalog to search into
     * @param lang The search language
     * @return The equivalent program item or <code>null</code> if not exists
     */
    public CoursePart getCoursePart(CoursePart srcCoursePart, String catalogName, String lang)
    {
        return getODFContent(CoursePartFactory.COURSE_PART_CONTENT_TYPE, srcCoursePart.getCode(), catalogName, lang);
    }
    
    /**
     * Get the equivalent {@link ProgramItem} of the source {@link ProgramItem} in given catalog and language 
     * @param <T> The type of returned object, it have to be a subclass of {@link ProgramItem}
     * @param srcProgramItem The source program item
     * @param catalogName The name of catalog to search into
     * @param lang The search language
     * @return The equivalent program item or <code>null</code> if not exists
     */
    public <T extends ProgramItem> T getProgramItem(T srcProgramItem, String catalogName, String lang)
    {
        return getODFContent(((Content) srcProgramItem).getTypes()[0], srcProgramItem.getCode(), catalogName, lang);
    }
    
    /**
     * Get the equivalent {@link Content} having the same code in given catalog and language 
     * @param <T> The type of returned object, it have to be a subclass of {@link AmetysObject}
     * @param contentType The content type to search for
     * @param odfContentCode The code of the ODF content
     * @param catalogName The name of catalog to search into
     * @param lang The search language
     * @return The equivalent content or <code>null</code> if not exists
     */
    public <T extends AmetysObject> T getODFContent(String contentType, String odfContentCode, String catalogName, String lang)
    {
        Expression contentTypeExpr = new ContentTypeExpression(Operator.EQ, contentType);
        Expression langExpr = new LanguageExpression(Operator.EQ, lang);
        Expression catalogExpr = new StringExpression(ProgramItem.CATALOG, Operator.EQ, catalogName);
        Expression codeExpr = new StringExpression(ProgramItem.CODE, Operator.EQ, odfContentCode);
        
        Expression expr = new AndExpression(contentTypeExpr, langExpr, catalogExpr, codeExpr);
        
        String xpathQuery = ContentQueryHelper.getContentXPathQuery(expr);
        AmetysObjectIterable<T> contents = _resolver.query(xpathQuery);
        AmetysObjectIterator<T> contentsIt = contents.iterator();
        if (contentsIt.hasNext())
        {
            return contentsIt.next();
        }
        
        return null;
    }
    
    /**
     * Get the child program items of a {@link ProgramItem}
     * @param programItem The program item
     * @return The child program items 
     */
    public List<ProgramItem> getChildProgramItems(ProgramItem programItem)
    {
        List<ProgramItem> children = new ArrayList<>();
        
        if (programItem instanceof TraversableProgramPart)
        {
            children.addAll(((TraversableProgramPart) programItem).getProgramPartChildren());
        }
        
        if (programItem instanceof CourseContainer)
        {
            children.addAll(((CourseContainer) programItem).getCourses());
        }
        
        if (programItem instanceof Course)
        {
            children.addAll(((Course) programItem).getCourseLists());
        }
        
        return children;
    }

    /**
     * Get the child subprograms of a {@link ProgramPart}
     * @param programPart The program part
     * @return The child subprograms
     */
    public Set<SubProgram> getChildSubPrograms(ProgramPart programPart)
    {
        Set<SubProgram> subPrograms = new HashSet<>();
        
        if (programPart instanceof TraversableProgramPart)
        {
            if (programPart instanceof SubProgram)
            {
                subPrograms.add((SubProgram) programPart);
            }
            ((TraversableProgramPart) programPart).getProgramPartChildren().forEach(child -> subPrograms.addAll(getChildSubPrograms(child)));
        }

        return subPrograms;
    }
    
    /**
     * Gets (recursively) parent containers of this program item.
     * @param programItem The program item
     * @return parent containers of this program item.
     */
    public Set<Container> getParentContainers(ProgramItem programItem)
    {
        return _getParentsOfType(programItem, Container.class);
    }
    
    /**
     * Gets (recursively) parent programs of this program item.
     * @param programItem The program item
     * @return parent programs of this program item.
     */
    public Set<Program> getParentPrograms(ProgramItem programItem)
    {
        return _getParentsOfType(programItem, Program.class);
    }
    
    /**
     * Gets (recursively) parent abstract programs of this program item.
     * @param programItem The program item
     * @return parent abstract programs of this program item.
     */
    public Set<AbstractProgram> getParentAbstractPrograms(ProgramItem programItem)
    {
        return _getParentsOfType(programItem, AbstractProgram.class);
    }

    private <T> Set<T> _getParentsOfType(ProgramItem programItem, Class<T> classToTest)
    {
        Set<ProgramItem> visitedProgramItems = new HashSet<>();
        visitedProgramItems.add(programItem);
        return _getParentsOfType(programItem, visitedProgramItems, classToTest);
    }
    
    @SuppressWarnings("unchecked")
    private <T> Set<T> _getParentsOfType(ProgramItem programItem, Set<ProgramItem> visitedProgramItems, Class<T> classToTest)
    {
        Set<T> parentsOfType = new HashSet<>();
        List<ProgramItem> parents = getParentProgramItems(programItem);
        
        for (ProgramItem parent : parents)
        {
            // Only parents not already visited
            if (visitedProgramItems.add(parent))
            {
                // Cast to Content if instance of Content instead of another type (for structures containing both Container and SubProgram)
                if (classToTest.isInstance(parent))
                {
                    parentsOfType.add((T) parent);
                }
                else
                {
                    parentsOfType.addAll(_getParentsOfType(parent, visitedProgramItems, classToTest));
                }
            }
        }
        
        return parentsOfType;
    }
    
    /**
     * Get the child programs of an {@link OrgUnit}
     * @param orgUnit the orgUnit
     * @param catalog the catalog
     * @param lang the lang
     * @return The child programs
     */
    public List<Program> getProgramsFromOrgUnit(OrgUnit orgUnit, String catalog, String lang)
    {
        List<Program> programs = new ArrayList<>();
        List<Expression> programExpressions = new ArrayList<>();
        programExpressions.add(new ContentTypeExpression(Operator.EQ, ProgramFactory.PROGRAM_CONTENT_TYPE));
       
        programExpressions.add(new StringExpression(ProgramItem.CATALOG, Operator.EQ, catalog));
        programExpressions.add(new LanguageExpression(Operator.EQ, lang));
        
        List<Expression> expressions = new ArrayList<>();
        for (String orgUnitId : getSubOrgUnitIds(orgUnit))
        {
            expressions.add(new StringExpression(AbstractProgram.ORG_UNITS_REFERENCES, Operator.EQ, orgUnitId));
        }
        
        programExpressions.add(new OrExpression(expressions.toArray(new Expression[0])));
        String programQuery = QueryHelper.getXPathQuery(null, ProgramFactory.PROGRAM_NODETYPE, new AndExpression(programExpressions.toArray(new Expression[0])));
        AmetysObjectIterable<Program> programsIterable = _resolver.query(programQuery);
        AmetysObjectIterator<Program> programsIterator = programsIterable.iterator();
        while (programsIterator.hasNext())
        {
            programs.add(programsIterator.next());
        }
        return programs;
    }
    
    /**
     * Get the current orgunit and its suborgunits recursively identifiers.
     * @param orgUnit The orgunit at the top
     * @return A {@link List} of {@link OrgUnit} ids
     */
    public List<String> getSubOrgUnitIds(OrgUnit orgUnit)
    {
        List<String> orgUnitIds = new ArrayList<>();
        orgUnitIds.add(orgUnit.getId());
        for (String id : orgUnit.getSubOrgUnits())
        {
            OrgUnit childOrgUnit = _resolver.resolveById(id);
            orgUnitIds.addAll(getSubOrgUnitIds(childOrgUnit));
        }
        
        return orgUnitIds;
    }
    
    /**
     * Determines if the {@link ProgramItem} has parent program items 
     * @param programItem The program item
     * @return true if has parent program items 
     */
    public boolean hasParentProgramItems(ProgramItem programItem)
    {
        boolean hasParent = false;
        
        if (programItem instanceof ProgramPart)
        {
            hasParent = !((ProgramPart) programItem).getProgramPartParents().isEmpty() || hasParent;
        }
        
        if (programItem instanceof CourseList)
        {
            hasParent = !((CourseList) programItem).getParentCourses().isEmpty() || hasParent;
        }
        
        if (programItem instanceof Course)
        {
            hasParent = !((Course) programItem).getParentCourseLists().isEmpty() || hasParent;
        }
        
        return hasParent;
    }
    
    /**
     * Get the parent program items of a {@link ProgramItem}
     * @param programItem The program item
     * @return The parent program items 
     */
    public List<ProgramItem> getParentProgramItems(ProgramItem programItem)
    {
        List<ProgramItem> parents = new ArrayList<>();
        
        if (programItem instanceof ProgramPart)
        {
            parents.addAll(((ProgramPart) programItem).getProgramPartParents());
        }
        
        if (programItem instanceof CourseList)
        {
            parents.addAll(((CourseList) programItem).getParentCourses());
        }
        
        if (programItem instanceof Course)
        {
            parents.addAll(((Course) programItem).getParentCourseLists());
        }
        
        return parents;
    }
    
    /**
     * Get the nearest program item parent into the given parent {@link AbstractProgram}
     * @param programItem The program item
     * @param parentProgram The parent program or subprogram. If null, the nearest abstract program will be returned.
     * @return The parent program item or null if not found.
     */
    public ProgramItem getParentProgramItem (ProgramItem programItem, AbstractProgram parentProgram)
    {
        if (programItem instanceof Program)
        {
            return null;
        }
        
        if (programItem instanceof ProgramPart)
        {
            List<ProgramPart> parents = ((ProgramPart) programItem).getProgramPartParents();
            
            for (ProgramPart parent : parents)
            {
                if (parent instanceof AbstractProgram && (parentProgram == null || parent.equals(parentProgram)))
                {
                    return parent;
                }
                else
                {
                    ProgramItem ancestor = getParentProgramItem(parent, parentProgram);
                    if (ancestor != null)
                    {
                        return parent;
                    }
                }
            }
        }
        
        if (programItem instanceof CourseList)
        {
            for (Course parentCourse : ((CourseList) programItem).getParentCourses())
            {
                ProgramItem ancestor = getParentProgramItem(parentCourse, parentProgram);
                if (ancestor != null)
                {
                    return parentCourse;
                }
            }
        }
        
        if (programItem instanceof Course)
        {
            for (CourseList cl : ((Course) programItem).getParentCourseLists())
            {
                ProgramItem ancestor = getParentProgramItem(cl, parentProgram);
                if (ancestor != null)
                {
                    return cl;
                }
            }
        }
        
        return null;
    }
    
    /**
     * Get information of the program item structure (type, if program has children)
     * @param programItemId the program item id
     * @return a map of information
     */
    @Callable
    public Map<String, Object> getStructureInfo(String programItemId)
    {
        Map<String, Object> results = new HashMap<>();
        
        if (StringUtils.isNotBlank(programItemId))
        {
            Content content = _resolver.resolveById(programItemId);
            if (content instanceof ProgramItem)
            {
                results.put("id", programItemId);
                results.put("title", content.getTitle());
                results.put("code", ((ProgramItem) content).getCode());
                
                List<ProgramItem> childProgramItems = getChildProgramItems((ProgramItem) content);
                results.put("hasChildren", !childProgramItems.isEmpty());
                
                List<ProgramItem> parentProgramItems = getParentProgramItems((ProgramItem) content);
                results.put("hasParent", !parentProgramItems.isEmpty());
                
                results.put("paths", getPaths((ProgramItem) content, " > "));
            }
        }
        
        return results;
    }
    
    /**
     * Get information of the program item structure (type, if program has children)
     * @param programItemIds the list of program item id
     * @return a map of information
     */
    @Callable
    public Map<String, Map<String, Object>> getStructureInfo(List<String> programItemIds)
    {
        Map<String,  Map<String, Object>> results = new HashMap<>();
        
        for (String programItemId : programItemIds)
        {
            results.put(programItemId, getStructureInfo(programItemId));
        }
        
        return results;
    }
    
    /**
     * Get all the paths of a ODF content.<br>
     * The path is construct with the contents' title
     * @param separator The path separator
     * @param item The program item
     * @return the paths in parent program items
     */
    protected List<String> getPaths(ProgramItem item, String separator)
    {
        List<String> paths = new ArrayList<>();
        
        List<List<ProgramItem>> ancestorPaths = getPathOfAncestors(item);
        for (List<ProgramItem> ancestorPath : ancestorPaths)
        {
            List<String> titles = ancestorPath.stream().map(p -> ((Content) p).getTitle() + " (" + p.getCode() + ")").collect(Collectors.toList());
            paths.add(String.join(separator, titles));
        }
        
        return paths;
    }
    
    /**
     * Get the full path to program item for highest ancestors. The path includes this final item.
     * @param item the program item
     * @return a list for each highest ancestors found. Each item of the list contains the program items to the path to this program item.
     */
    public List<List<ProgramItem>> getPathOfAncestors(ProgramItem item)
    {
        List<List<ProgramItem>> ancestors = new ArrayList<>();
        
        List<ProgramItem> parentProgramItems = getParentProgramItems(item);
        if (parentProgramItems.isEmpty())
        {
            List<ProgramItem> items = new ArrayList<>();
            items.add(item);
            ancestors.add(items);
            return ancestors;
        }
        
        for (ProgramItem parentProgramItem : parentProgramItems)
        {
            for (List<ProgramItem> ancestorPaths : getPathOfAncestors(parentProgramItem))
            {
                ancestorPaths.add(item);
                ancestors.add(ancestorPaths);
            }
        }
        
        return ancestors;
    }
    
    /**
     * Get the path of a {@link ProgramItem} into a {@link Program}<br>
     * The path is construct with the contents' names and the used separator is '/'.
     * @param programItemId The id of the program item
     * @param programId The id of program. Can not be null.
     * @return the path into the parent program or null if the item is not part of this program.
     */
    @Callable
    public String getPathInProgram (String programItemId, String programId)
    {
        ProgramItem item = _resolver.resolveById(programItemId);
        Program program = _resolver.resolveById(programId);
        
        return getPathInProgram(item, program);
    }
    
    /**
     * Get the path of a ODF content into a {@link Program}.<br>
     * The path is construct with the contents' names and the used separator is '/'.
     * @param item The program item
     * @param parentProgram The parent root (sub)program. Can not be null.
     * @return the path from the parent program
     */
    public String getPathInProgram (ProgramItem item, Program parentProgram)
    {
        if (item instanceof Program)
        {
            // The program item is already the program it self or another program
            return item.equals(parentProgram) ? "" : null;
        }
        
        List<String> paths = new ArrayList<>();
        paths.add(item.getName());
        
        ProgramItem parent = getParentProgramItem(item, parentProgram);
        while (parent != null && !(parent instanceof Program))
        {
            paths.add(parent.getName());
            parent = getParentProgramItem(parent, parentProgram);
        }
        
        if (parent != null)
        {
            paths.add(parent.getName());
            Collections.reverse(paths);
            return org.apache.commons.lang3.StringUtils.join(paths, "/");
        }
        
        return null;
    }
    
    /**
     * Get the path of a {@link Course} or a {@link CourseList} into a {@link Course}<br>
     * The path is construct with the contents' names and the used separator is '/'.
     * @param contentId The id of the content
     * @param parentCourseId The id of parent course. Can not be null.
     * @return the path into the parent course or null if the item is not part of this course.
     */
    @Callable
    public String getPathInCourse (String contentId, String parentCourseId)
    {
        Content content = _resolver.resolveById(contentId);
        Course parentCourse = _resolver.resolveById(parentCourseId);
        
        return getPathInCourse(content, parentCourse);
    }
    
    /**
     * Get the path of a {@link Course}  or a {@link CourseList} into a {@link Course}<br>
     * The path is construct with the contents' names and the used separator is '/'.
     * @param courseOrList The course or the course list
     * @param parentCourse The parent course. Can not be null.
     * @return the path into the parent course or null if the item is not part of this course.
     */
    public String getPathInCourse(Content courseOrList, Course parentCourse)
    {
        if (courseOrList.equals(parentCourse))
        {
            return "";
        }
        
        String path = _getPathInCourse(courseOrList, parentCourse);
        
        return path;
    }
    
    private String _getPathInCourse(Content content, Content parentContent)
    {
        if (content.equals(parentContent))
        {
            return content.getName();
        }

        List<? extends Content> parents;
        
        if (content instanceof Course)
        {
            parents = ((Course) content).getParentCourseLists();
        }
        else if (content instanceof CourseList)
        {
            parents = ((CourseList) content).getParentCourses();
        }
        else
        {
            throw new IllegalStateException();
        }
        
        for (Content parent : parents)
        {
            String path = _getPathInCourse(parent, parentContent);
            if (path != null)
            {
                return path + '/' + content.getName(); 
            }
        }
        return null;
    }
    
    /**
     * Get the hierarchical path of a {@link OrgUnit} from the root orgunit id.<br>
     * The path is construct with the contents' names and the used separator is '/'.
     * @param orgUnitId The id of the orgunit
     * @param rootOrgUnitId The root orgunit id
     * @return the path into the parent program or null if the item is not part of this program.
     */
    @Callable
    public String getOrgUnitPath(String orgUnitId, String rootOrgUnitId)
    {
        OrgUnit rootOU = null;
        if (StringUtils.isNotBlank(rootOrgUnitId))
        {
            rootOU = _resolver.resolveById(rootOrgUnitId);
        }
        else
        {
            rootOU = _ouRootProvider.getRoot();
        }
        
        if (orgUnitId.equals(rootOU.getId()))
        {
            // The orgunit is already the root orgunit
            return rootOU.getName();
        }
        
        OrgUnit ou = _resolver.resolveById(orgUnitId);
        
        List<String> paths = new ArrayList<>();
        paths.add(ou.getName());
        
        OrgUnit parent = ou.getParentOrgUnit();
        while (parent != null && !parent.getId().equals(rootOU.getId()))
        {
            paths.add(parent.getName());
            parent = parent.getParentOrgUnit();
        }
        
        if (parent != null)
        {
            paths.add(rootOU.getName());
            Collections.reverse(paths);
            return org.apache.commons.lang3.StringUtils.join(paths, "/");
        }
        
        return null;
    }
    
    /**
     * Get the hierarchical path of a {@link OrgUnit} from the root orgunit.<br>
     * The path is construct with the contents' names and the used separator is '/'.
     * @param orgUnitId The id of the orgunit
     * @return the path into the parent program or null if the item is not part of this program.
     */
    @Callable
    public String getOrgUnitPath(String orgUnitId)
    {
        return getOrgUnitPath(orgUnitId, null);
    }
    
    /**
     * Return true if the given {@link ProgramPart} has in its hierarchy a parent of given id
     * @param part The program part
     * @param parentId The ancestor id
     * @return true if the given {@link ProgramPart} has in its hierarchy a parent of given id
     */
    public boolean hasAncestor (ProgramPart part, String parentId)
    {
        List<ProgramPart> parents = part.getProgramPartParents();
        
        for (ProgramPart parent : parents)
        {
            if (parent.getId().equals(parentId))
            {
                return true;
            }
            else if (hasAncestor(parent, parentId))
            {
                return true;
            }
        }
        
        return false;
    }
    
    /**
     * Check if a relation can be establish between two ODF contents
     * @param srcContent The source content (copied or moved)
     * @param targetContent The target content
     * @param errors The list of error messages
     * @param contextualParameters the contextual parameters
     * @return true if the relation is valid, false otherwise
     */
    public boolean isRelationCompatible(Content srcContent, Content targetContent, List<I18nizableText> errors, Map<String, Object> contextualParameters)
    {
        boolean isCompatible = true;
        
        if (targetContent instanceof ProgramItem || targetContent instanceof OrgUnit)
        {
            if (!_isContentTypeCompatible(srcContent, targetContent))
            {
                // Invalid relations between content types
                errors.add(new I18nizableText("plugin.odf", "PLUGINS_ODF_RELATIONS_SETCONTENTATTRIBUTE_REFERENCE_ERROR_CONTENT_TYPES", _getContentParameters(srcContent, targetContent)));
                isCompatible = false;
            }
            else if (!_isCatalogCompatible(srcContent, targetContent))
            {
                // Catalog is invalid
                errors.add(new I18nizableText("plugin.odf", "PLUGINS_ODF_RELATIONS_SETCONTENTATTRIBUTE_REFERENCE_ERROR_CATALOG", _getContentParameters(srcContent, targetContent)));
                isCompatible = false;
            }
            else if (!srcContent.getLanguage().equals(targetContent.getLanguage()))
            {
                // Language is invalid
                errors.add(new I18nizableText("plugin.odf", "PLUGINS_ODF_RELATIONS_SETCONTENTATTRIBUTE_REFERENCE_ERROR_LANGUAGE", _getContentParameters(srcContent, targetContent)));
                isCompatible = false;
            }
            // We check shareable fields only if the course content is not created (or created by copy) and not moved
            else if (srcContent instanceof Course 
                    && targetContent instanceof CourseList 
                    && _shareableCourseHelper.handleShareableCourse() 
                    && !"create".equals(contextualParameters.get("mode")) 
                    && !"copy".equals(contextualParameters.get("mode"))
                    && !"move".equals(contextualParameters.get("mode"))
                    // In this case, it means that we try to change the position of the course in the courseList, so don't check shareable fields
                    && !_isCourseAlreadyBelongToCourseList((Course) srcContent, (CourseList) targetContent))
            {
                if (!_shareableCourseHelper.isShareableFieldsMatch((Course) srcContent, (CourseList) targetContent))
                {
                    // Shareable fields don't match
                    errors.add(new I18nizableText("plugin.odf", "PLUGINS_ODF_RELATIONS_SETCONTENTATTRIBUTE_REFERENCE_ERROR_SHAREABLE_COURSE", _getContentParameters(srcContent, targetContent)));
                    isCompatible = false;
                }
            }
        }
        else if (srcContent instanceof ProgramItem || srcContent instanceof OrgUnit)
        {
            // If the target isn't ODF related but the source is, the relation is not compatible.
            errors.add(new I18nizableText("plugin.odf", "PLUGINS_ODF_RELATIONS_SETCONTENTATTRIBUTE_REFERENCE_ERROR_NO_PROGRAM_ITEM", _getContentParameters(srcContent, targetContent)));
            isCompatible = false;
        }
        
        return isCompatible;
    }
    
    private boolean _isCourseAlreadyBelongToCourseList(Course course, CourseList courseList)
    {
        return courseList.getCourses().contains(course);
    }
    
    private boolean _isContentTypeCompatible(Content srcContent, Content targetContent)
    {
        if (srcContent instanceof Container || srcContent instanceof SubProgram)
        {
            return targetContent instanceof AbstractTraversableProgramPart;
        }
        else if (srcContent instanceof CourseList)
        {
            return targetContent instanceof CourseListContainer;
        }
        else if (srcContent instanceof Course)
        {
            return targetContent instanceof CourseList;
        }
        else if (srcContent instanceof OrgUnit)
        {
            return targetContent instanceof OrgUnit;
        }
        
        return false;
    }
    
    private boolean _isCatalogCompatible(Content srcContent, Content targetContent)
    {
        if (srcContent instanceof ProgramItem && targetContent instanceof ProgramItem)
        {
            return ((ProgramItem) srcContent).getCatalog().equals(((ProgramItem) targetContent).getCatalog());
        }
        return true;
    }
    
    private List<String> _getContentParameters(Content srcContent, Content targetContent)
    {
        List<String> parameters = new ArrayList<>();
        parameters.add(srcContent.getTitle());
        parameters.add(srcContent.getId());
        parameters.add(targetContent.getTitle());
        parameters.add(targetContent.getId());
        return parameters;
    }
    /**
     * Copy a {@link ProgramItem} 
     * @param srcContent The program item to copy
     * @param targetCatalog The target catalog. Can be null. The target catalog will be the catalog of the source object.
     * @param fullCopy Set to <code>true</code> to copy the sub-structure
     * @param copiedPrograms the id of initial programs with their copied content
     * @param copiedSubPrograms the id of initial subprograms with their copied content
     * @param copiedContainers the id of initial containers with their copied content
     * @param copiedCourseLists the id of initial course lists with their copied content
     * @param copiedCourses the id of initial courses with their copied content
     * @param copiedCourseParts the id of initial course parts with their copied content
     * @return The created content
     * @param <C> The modifiable content return type 
     * @throws AmetysRepositoryException If an error occurred during copy
     * @throws WorkflowException If an error occurred during copy
     */
    public <C extends ModifiableContent> C copyProgramItem(ProgramItem srcContent, String targetCatalog, boolean fullCopy, Map<String, String> copiedPrograms, Map<String, String> copiedSubPrograms, Map<String, String> copiedContainers, Map<String, String> copiedCourseLists, Map<String, String> copiedCourses, Map<String, String> copiedCourseParts) throws AmetysRepositoryException, WorkflowException
    {
        return copyProgramItem(srcContent, null, null, __INITIAL_WORKFLOW_ACTION_ID, targetCatalog, fullCopy, copiedPrograms, copiedSubPrograms, copiedContainers, copiedCourseLists, copiedCourses, copiedCourseParts);
    }
    
    /**
     * Copy a {@link ProgramItem}
     * @param srcContent The program item to copy
     * @param targetContentName The name of content to created. Can be null. If null, the new name will be get from the source object.
     * @param targetContentLanguage The name of content to created. Can be null. If null, the language of target content will be the same as source object.
     * @param targetCatalog The target catalog. Can be null. The target catalog will be the catalog of the source object.
     * @param fullCopy Set to <code>true</code> to copy the sub-structure
     * @param copiedPrograms the id of initial programs with their copied content
     * @param copiedSubPrograms the id of initial subprograms with their copied content
     * @param copiedContainers the id of initial containers with their copied content
     * @param copiedCourseLists the id of initial course lists with their copied content
     * @param copiedCourses the id of initial courses with their copied content
     * @param copiedCourseParts the id of initial course parts with their copied content
     * @param <C> The modifiable content return type 
     * @return The created content
     * @throws AmetysObjectExistsException If a program item with same code, catalog and language already exists
     * @throws AmetysRepositoryException If an error occurred
     * @throws WorkflowException If an error occurred
     */
    public <C extends ModifiableContent> C copyProgramItem(ProgramItem srcContent, String targetContentName, String targetContentLanguage, String targetCatalog, boolean fullCopy, Map<String, String> copiedPrograms, Map<String, String> copiedSubPrograms, Map<String, String> copiedContainers, Map<String, String> copiedCourseLists, Map<String, String> copiedCourses, Map<String, String> copiedCourseParts) throws AmetysRepositoryException, WorkflowException
    {
        return copyProgramItem(srcContent, targetContentName, targetContentLanguage, __INITIAL_WORKFLOW_ACTION_ID, targetCatalog, fullCopy, copiedPrograms, copiedSubPrograms, copiedContainers, copiedCourseLists, copiedCourses, copiedCourseParts);
    }
    
    /**
     * Copy a {@link CoursePart}
     * @param srcContent The course part to copy
     * @param targetContentName The name of content to created. Can be null. If null, the new name will be get from the source object.
     * @param targetContentLanguage The name of content to created. Can be null. If null, the language of target content will be the same as source object.
     * @param initWorkflowActionId The initial workflow action id
     * @param fullCopy Set to <code>true</code> to copy the sub-structure
     * @param targetCatalog The target catalog. Can be null. The target catalog will be the catalog of the source object.
     * @param copiedPrograms the id of initial programs with their copied content
     * @param copiedSubPrograms the id of initial subprograms with their copied content
     * @param copiedContainers the id of initial containers with their copied content
     * @param copiedCourseLists the id of initial course lists with their copied content
     * @param copiedCourses the id of initial courses with their copied content
     * @param copiedCourseParts the id of initial course parts with their copied content
     * @param <C> The modifiable content return type 
     * @return The created content
     * @throws AmetysObjectExistsException If a program item with same code, catalog and language already exists
     * @throws AmetysRepositoryException If an error occurred
     * @throws WorkflowException If an error occurred
     */
    public <C extends ModifiableContent> C copyCoursePart(CoursePart srcContent, String targetContentName, String targetContentLanguage, int initWorkflowActionId, String targetCatalog, boolean fullCopy, Map<String, String> copiedPrograms, Map<String, String> copiedSubPrograms, Map<String, String> copiedContainers, Map<String, String> copiedCourseLists, Map<String, String> copiedCourses, Map<String, String> copiedCourseParts) throws AmetysRepositoryException, WorkflowException
    {
        return _copyODFContent((Content) srcContent, srcContent.getCatalog(), srcContent.getCode(), targetContentName, targetContentLanguage, initWorkflowActionId, targetCatalog, fullCopy, copiedPrograms, copiedSubPrograms, copiedContainers, copiedCourseLists, copiedCourses, copiedCourseParts);
    }
    
    /**
     * Copy a {@link ProgramItem}
     * @param srcContent The program item to copy
     * @param targetContentName The name of content to created. Can be null. If null, the new name will be get from the source object.
     * @param targetContentLanguage The name of content to created. Can be null. If null, the language of target content will be the same as source object.
     * @param initWorkflowActionId The initial workflow action id
     * @param fullCopy Set to <code>true</code> to copy the sub-structure
     * @param targetCatalog The target catalog. Can be null. The target catalog will be the catalog of the source object.
     * @param copiedPrograms the id of initial programs with their copied content
     * @param copiedSubPrograms the id of initial subprograms with their copied content
     * @param copiedContainers the id of initial containers with their copied content
     * @param copiedCourseLists the id of initial course lists with their copied content
     * @param copiedCourses the id of initial courses with their copied content
     * @param copiedCourseParts the id of initial course parts with their copied content
     * @param <C> The modifiable content return type 
     * @return The created content
     * @throws AmetysObjectExistsException If a program item with same code, catalog and language already exists
     * @throws AmetysRepositoryException If an error occurred
     * @throws WorkflowException If an error occurred
     */
    public <C extends ModifiableContent> C copyProgramItem(ProgramItem srcContent, String targetContentName, String targetContentLanguage, int initWorkflowActionId, String targetCatalog, boolean fullCopy, Map<String, String> copiedPrograms, Map<String, String> copiedSubPrograms, Map<String, String> copiedContainers, Map<String, String> copiedCourseLists, Map<String, String> copiedCourses, Map<String, String> copiedCourseParts) throws AmetysRepositoryException, WorkflowException
    {
        return _copyODFContent((Content) srcContent, srcContent.getCatalog(), srcContent.getCode(), targetContentName, targetContentLanguage, initWorkflowActionId, targetCatalog, fullCopy, copiedPrograms, copiedSubPrograms, copiedContainers, copiedCourseLists, copiedCourses, copiedCourseParts);
    }
    
    /**
     * Copy a {@link ProgramItem}
     * @param srcContent The program item to copy
     * @param catalog The catalog
     * @param code The odf content code
     * @param targetContentName The name of content to created. Can be null. If null, the new name will be get from the source object.
     * @param targetContentLanguage The name of content to created. Can be null. If null, the language of target content will be the same as source object.
     * @param initWorkflowActionId The initial workflow action id
     * @param fullCopy Set to <code>true</code> to copy the sub-structure
     * @param targetCatalog The target catalog. Can be null. The target catalog will be the catalog of the source object.
     * @param copiedPrograms the id of initial programs with their copied content
     * @param copiedSubPrograms the id of initial subprograms with their copied content
     * @param copiedContainers the id of initial containers with their copied content
     * @param copiedCourseLists the id of initial course lists with their copied content
     * @param copiedCourses the id of initial courses with their copied content
     * @param copiedCourseParts the id of initial course parts with their copied content
     * @param <C> The modifiable content return type 
     * @return The created content
     * @throws AmetysObjectExistsException If a program item with same code, catalog and language already exists
     * @throws AmetysRepositoryException If an error occurred
     * @throws WorkflowException If an error occurred
     */
    @SuppressWarnings("unchecked")
    private <C extends ModifiableContent> C _copyODFContent(Content srcContent, String catalog, String code, String targetContentName, String targetContentLanguage, int initWorkflowActionId, String targetCatalog, boolean fullCopy, Map<String, String> copiedPrograms, Map<String, String> copiedSubPrograms, Map<String, String> copiedContainers, Map<String, String> copiedCourseLists, Map<String, String> copiedCourses, Map<String, String> copiedCourseParts) throws AmetysRepositoryException, WorkflowException
    {
        String computedTargetLanguage = targetContentLanguage;
        if (computedTargetLanguage == null)
        {
            computedTargetLanguage = srcContent.getLanguage();
        }
        
        String computeTargetName = targetContentName;
        if (computeTargetName == null)
        {
            // Compute content name from source content and requested language
            computeTargetName = srcContent.getName() + (targetContentLanguage != null && !targetContentLanguage.equals(srcContent.getName()) ? "-" + targetContentLanguage : "");
        }
        
        String computeTargetCatalog = targetCatalog;
        if (computeTargetCatalog == null)
        {
            computeTargetCatalog = catalog;
        }
        
        String principalContentType = srcContent.getTypes()[0];
        ModifiableContent createdContent = getODFContent(principalContentType, code, computeTargetCatalog, computedTargetLanguage);
        if (createdContent != null)
        {
            getLogger().info("A program item already exists with the same type, code, catalog and language [{}, {}, {}, {}]", principalContentType, code, computeTargetCatalog, targetContentLanguage);
        }
        else
        {
            // Copy content waiting for observers to be completed and copying ACL
            createdContent = ((DefaultContent) srcContent).copyTo(getRootContent(true), computeTargetName, targetContentLanguage, initWorkflowActionId, false, true);
            
            if (fullCopy)
            {
                _cleanContentMetadata(createdContent);
                
                if (targetCatalog != null)
                {
                    boolean hasChanges = false;
                    if (createdContent instanceof ProgramItem)
                    {
                        ((ProgramItem) createdContent).setCatalog(targetCatalog);
                        hasChanges = true;
                    }
                    else if (createdContent instanceof CoursePart)
                    {
                        ((CoursePart) createdContent).setCatalog(targetCatalog);
                        hasChanges = true;
                    }
                    
                    if (hasChanges)
                    {
                        createdContent.saveChanges();
                    }
                }
                
                if (srcContent instanceof ProgramItem)
                {
                    copyProgramItemStructure((ProgramItem) srcContent, createdContent, computedTargetLanguage, initWorkflowActionId, computeTargetCatalog, copiedPrograms, copiedSubPrograms, copiedContainers, copiedCourseLists, copiedCourses, copiedCourseParts);
                }
            }

            _putInCopiedMap(srcContent, createdContent, copiedPrograms, copiedSubPrograms, copiedContainers, copiedCourseLists, copiedCourses, copiedCourseParts);
        }
        
        return (C) createdContent;
    }
    
    private void _putInCopiedMap(Content srcContent, ModifiableContent createdContent, Map<String, String> copiedPrograms, Map<String, String> copiedSubPrograms, Map<String, String> copiedContainers, Map<String, String> copiedCourseLists, Map<String, String> copiedCourses, Map<String, String> copiedCourseParts)
    {
        if (createdContent instanceof Program)
        {
            copiedPrograms.put(srcContent.getId(), createdContent.getId());
        }
        else if (createdContent instanceof SubProgram)
        {
            copiedSubPrograms.put(srcContent.getId(), createdContent.getId());
        }
        else if (createdContent instanceof Container)
        {
            copiedContainers.put(srcContent.getId(), createdContent.getId());
        }
        else if (createdContent instanceof CourseList)
        {
            copiedCourseLists.put(srcContent.getId(), createdContent.getId());
        }
        else if (createdContent instanceof Course)
        {
            copiedCourses.put(srcContent.getId(), createdContent.getId());
        }
        else if (createdContent instanceof CoursePart)
        {
            copiedCourseParts.put(srcContent.getId(), createdContent.getId());
        }
    }
    
    /**
     * Copy the structure of a {@link ProgramItem}
     * @param srcContent the content to copy
     * @param targetContent the target content
     * @param targetContentLanguage The name of content to created. Can be null. If null, the language of target content will be the same as source object.
     * @param initWorkflowActionId The initial workflow action id
     * @param targetCatalogName The target catalog. Can be null. The target catalog will be the catalog of the source object.
     * @param copiedPrograms the id of initial programs with their copied content
     * @param copiedSubPrograms the id of initial subprograms with their copied content
     * @param copiedContainers the id of initial containers with their copied content
     * @param copiedCourseLists the id of initial course lists with their copied content
     * @param copiedCourses the id of initial courses with their copied content
     * @param copiedCourseParts the id of initial course parts with their copied content
     * @throws AmetysRepositoryException If an error occurred during copy
     * @throws WorkflowException If an error occurred during copy
     */
    protected void copyProgramItemStructure(ProgramItem srcContent, ModifiableContent targetContent, String targetContentLanguage, int initWorkflowActionId, String targetCatalogName, Map<String, String> copiedPrograms, Map<String, String> copiedSubPrograms, Map<String, String> copiedContainers, Map<String, String> copiedCourseLists, Map<String, String> copiedCourses, Map<String, String> copiedCourseParts) throws AmetysRepositoryException, WorkflowException
    {
        List<ProgramItem> srcChildContents = new ArrayList<>();
        Map<Pair<String, String>, List<String>> values = new HashMap<>();
        
        String childMetadataPath = null;
        String parentMetadataPath = null;
        
        if (srcContent instanceof TraversableProgramPart)
        {
            childMetadataPath = TraversableProgramPart.CHILD_PROGRAM_PARTS;
            parentMetadataPath = ProgramPart.PARENT_PROGRAM_PARTS;
            srcChildContents.addAll(((TraversableProgramPart) srcContent).getProgramPartChildren());
        }
        else if (srcContent instanceof CourseList)
        {
            childMetadataPath = CourseList.CHILD_COURSES;
            parentMetadataPath = Course.PARENT_COURSE_LISTS;
            srcChildContents.addAll(((CourseList) srcContent).getCourses());
        }
        else if (srcContent instanceof Course)
        {
            childMetadataPath = Course.CHILD_COURSE_LISTS;
            parentMetadataPath = CourseList.PARENT_COURSES;
            srcChildContents.addAll(((Course) srcContent).getCourseLists());

            List<String> refCoursePartIds = new ArrayList<>();
            for (CoursePart srcChildContent : ((Course) srcContent).getCourseParts())
            {
                CoursePart targetChildContent = copyCoursePart(srcChildContent, null, targetContentLanguage, initWorkflowActionId, targetCatalogName, true, copiedPrograms, copiedSubPrograms, copiedContainers, copiedCourseLists, copiedCourses, copiedCourseParts);
                refCoursePartIds.add(targetChildContent.getId());
            }
            _addFormValues(values, Course.CHILD_COURSE_PARTS, CoursePart.PARENT_COURSES, refCoursePartIds);
        }

        List<String> refChildIds = new ArrayList<>();
        for (ProgramItem srcChildContent : srcChildContents)
        {
            ProgramItem targetChildContent = copyProgramItem(srcChildContent, null, targetContentLanguage, initWorkflowActionId, targetCatalogName, true, copiedPrograms, copiedSubPrograms, copiedContainers, copiedCourseLists, copiedCourses, copiedCourseParts);
            refChildIds.add(targetChildContent.getId());
        }

        _addFormValues(values, childMetadataPath, parentMetadataPath, refChildIds);

        _editChildRelation((ModifiableWorkflowAwareContent) targetContent, values);
        
    }
    
    private void _addFormValues(Map<Pair<String, String>, List<String>> values, String childMetadataPath, String parentMetadataPath, List<String> refChildIds)
    {
        if (!refChildIds.isEmpty())
        {
            values.put(Pair.of(childMetadataPath, parentMetadataPath), refChildIds);
        }
    }
    
    private void _editChildRelation(ModifiableWorkflowAwareContent parentContent, Map<Pair<String, String>, List<String>> values) throws AmetysRepositoryException
    {
        if (!values.isEmpty())
        {
            for (Map.Entry<Pair<String, String>, List<String>> entry : values.entrySet())
            {
                String childMetadataName = entry.getKey().getLeft();
                String parentMetadataName = entry.getKey().getRight();
                List<String> childContents = entry.getValue();
                
                parentContent.setValue(childMetadataName, childContents.toArray(new String[childContents.size()]));
                
                for (String childContentId : childContents)
                {
                    ModifiableContent content = _resolver.resolveById(childContentId);
                    String[] parentContentIds = ContentDataHelper.getContentIdsArrayFromMultipleContentData(content, parentMetadataName);
                    content.setValue(parentMetadataName, ArrayUtils.add(parentContentIds, parentContent.getId()));
                }
            }
        }
    }
    
    /**
     * Clean the CONTENT metadata created after a copy but whose values reference the initial content' structure
     * @param createdContent The created content to clean
     */
    protected void _cleanContentMetadata(ModifiableContent createdContent)
    {
        ModifiableCompositeMetadata metadataHolder = createdContent.getMetadataHolder();
        if (createdContent instanceof ProgramPart)
        {
            ExternalizableMetadataHelper.removeMetadataIfExists(metadataHolder, ProgramPart.PARENT_PROGRAM_PARTS);
        }
        
        if (createdContent instanceof TraversableProgramPart)
        {
            ExternalizableMetadataHelper.removeMetadataIfExists(metadataHolder, TraversableProgramPart.CHILD_PROGRAM_PARTS);
        }
        
        if (createdContent instanceof CourseList)
        {
            ExternalizableMetadataHelper.removeMetadataIfExists(metadataHolder, CourseList.CHILD_COURSES);
            ExternalizableMetadataHelper.removeMetadataIfExists(metadataHolder, CourseList.PARENT_COURSES);
        }
        
        if (createdContent instanceof Course)
        {
            ExternalizableMetadataHelper.removeMetadataIfExists(metadataHolder, Course.CHILD_COURSE_LISTS);
            ExternalizableMetadataHelper.removeMetadataIfExists(metadataHolder, Course.PARENT_COURSE_LISTS);
            ExternalizableMetadataHelper.removeMetadataIfExists(metadataHolder, Course.CHILD_COURSE_PARTS);
        }
        
        if (createdContent instanceof CoursePart)
        {
            ExternalizableMetadataHelper.removeMetadataIfExists(metadataHolder, CoursePart.PARENT_COURSES);
        }
    }
    
    /**
     * Switch the ametys object to Live version if it has one
     * @param ao the Ametys object
     * @throws NoLiveVersionException if the content has no live version
     */
    public void switchToLiveVersion(DefaultAmetysObject ao) throws NoLiveVersionException
    {
        // Switch to the Live label if exists
        String[] allLabels = ao.getAllLabels();
        String[] currentLabels = ao.getLabels();
        
        boolean hasLiveVersion = Arrays.asList(allLabels).contains(ValidateODFContentFunction.VALID_LABEL);
        boolean currentVersionIsLive = Arrays.asList(currentLabels).contains(ValidateODFContentFunction.VALID_LABEL);
        
        if (hasLiveVersion && !currentVersionIsLive)
        {
            ao.switchToLabel(ValidateODFContentFunction.VALID_LABEL);
        }
        else if (!hasLiveVersion)
        {
            throw new NoLiveVersionException("The ametys object '" + ao.getId() + "' has no live version");
        }
    }
    
    /**
     * Switch to Live version if is required
     * @param ao the Ametys object
     * @throws NoLiveVersionException if the Live version is required but not exist
     */
    public void switchToLiveVersionIfNeeded(DefaultAmetysObject ao) throws NoLiveVersionException
    {
        Request request = _getRequest();
        if (request != null && request.getAttribute(REQUEST_ATTRIBUTE_VALID_LABEL) != null)
        {
            switchToLiveVersion(ao);
        }
    }
    
    /**
     * Count the hours accumulation in the {@link ProgramItem}
     * @param programItem The program item on which we compute the total number of hours
     * @return The hours accumulation
     */
    public Double getCumulatedHours(ProgramItem programItem)
    {
        // Ignore optional course list and avoid useless expensive calls
        if (programItem instanceof CourseList && ChoiceType.OPTIONAL.equals(((CourseList) programItem).getType()))
        {
            return 0.0;
        }

        List<ProgramItem> children = getChildProgramItems(programItem);

        Double coef = 1.0;
        Double countNbHours = 0.0;

        // If the program item is a course list, compute the coef (mandatory: 1, optional: 0, optional: min / total)
        if (programItem instanceof CourseList)
        {
            // If there is no children, compute the coef is useless
            // Also choice list can throw an exception while dividing by zero
            if (children.isEmpty())
            {
                return 0.0;
            }
            
            CourseList courseList = (CourseList) programItem;
            switch (courseList.getType())
            {
                case CHOICE:
                    // Apply the average of number of EC from children multiply by the minimum ELP to select
                    coef = ((double) courseList.getMinNumberOfCourses()) / children.size();
                    break;
                case MANDATORY:
                default:
                    // Add all ECTS from children
                    break;
            }
        }

        // If it's a course and we have a value for the number of hours
        // Then get the value
        if (programItem instanceof Course && ((Course) programItem).hasNonEmptyValue(Course.NUMBER_OF_HOURS))
        {
            countNbHours += ((Course) programItem).<Double>getValue(Course.NUMBER_OF_HOURS);
        }
        // Else if there are program item children on the item
        // Then compute on children
        else if (children.size() > 0)
        {
            for (ProgramItem child : children)
            {
                countNbHours += getCumulatedHours(child);
            }
        }
        // Else, it's a course but there is no value for the number of hours and we don't have program item children
        // Then compute on course parts
        else if (programItem instanceof Course)
        {
            countNbHours += ((Course) programItem).getCourseParts()
                .stream()
                .mapToDouble(CoursePart::getNumberOfHours)
                .sum();
        }
        
        return coef * countNbHours;
    }
    
    /**
     * Get the request
     * @return the request
     */
    protected Request _getRequest()
    {
        return ContextHelper.getRequest(_context);
    }
}