/*
 *  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.Collections;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;

import org.apache.avalon.framework.component.Component;
import org.apache.avalon.framework.service.ServiceException;
import org.apache.avalon.framework.service.ServiceManager;
import org.apache.avalon.framework.service.Serviceable;
import org.apache.commons.lang.StringUtils;

import org.ametys.cms.ObservationConstants;
import org.ametys.cms.content.external.ExternalizableMetadataHelper;
import org.ametys.cms.contenttype.ContentTypeExtensionPoint;
import org.ametys.cms.form.AbstractField.MODE;
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.WorkflowAwareContent;
import org.ametys.cms.workflow.ContentWorkflowHelper;
import org.ametys.cms.workflow.EditContentFunction;
import org.ametys.core.observation.Event;
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.courselist.CourseList;
import org.ametys.odf.orgunit.OrgUnit;
import org.ametys.odf.orgunit.RootOrgUnitProvider;
import org.ametys.odf.program.AbstractProgram;
import org.ametys.odf.program.Container;
import org.ametys.odf.program.Program;
import org.ametys.odf.program.ProgramPart;
import org.ametys.odf.program.SubProgram;
import org.ametys.odf.program.TraversableProgramPart;
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.metadata.ModifiableCompositeMetadata;
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.StringExpression;
import org.ametys.plugins.workflow.AbstractWorkflowComponent;
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
{
    /** The component role. */
    public static final String ROLE = ODFHelper.class.getName();
    
    /** The default id of initial workflow action */
    protected static final int __INITIAL_WORKFLOW_ACTION_ID = 0;
    /** The default id of edit workflow action */
    protected static final int __EDIT_WORKFLOW_ACTION_ID = 2;
    
    /** 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;
    
    private String _pluginName;
    
    @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);
    }
    
    @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 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)
    {
        List<Expression> exprs = new ArrayList<>();
        
        if (StringUtils.isNotEmpty(cTypeId))
        {
            exprs.add(new ContentTypeExpression(Operator.EQ, cTypeId));
        }
        if (StringUtils.isNotEmpty(code))
        {
            exprs.add(new StringExpression(ProgramItem.METADATA_CODE, Operator.EQ, code));
        }
        if (StringUtils.isNotEmpty(catalogName))
        {
            exprs.add(new StringExpression(ProgramItem.METADATA_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 ProgramItem} of the source {@link ProgramItem} in given catalog and language 
     * @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 Content getProgramItem(ProgramItem srcProgramItem, String catalogName, String lang)
    {
        Expression langExpr = new LanguageExpression(Operator.EQ, lang);
        Expression catalogExpr = new StringExpression(ProgramItem.METADATA_CATALOG, Operator.EQ, catalogName);
        Expression codeExpr = new StringExpression(ProgramItem.METADATA_CODE, Operator.EQ, srcProgramItem.getCode());
        
        Expression expr = new AndExpression(langExpr, catalogExpr, codeExpr);
        
        String xpathQuery = ContentQueryHelper.getContentXPathQuery(expr);
        AmetysObjectIterable<Content> contents = _resolver.query(xpathQuery);
        AmetysObjectIterator<Content> 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;
    }
    
    /**
     * 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)
    {
        Set<ProgramItem> visitedProgramItems = new HashSet<>();
        visitedProgramItems.add(programItem);
        return _getParentAbstractPrograms(programItem, visitedProgramItems);
    }
    
    private Set<AbstractProgram> _getParentAbstractPrograms(ProgramItem programItem, Set<ProgramItem> visitedProgramItems)
    {
        Set<AbstractProgram> parentAbstractPrograms = new HashSet<>();
        List<ProgramItem> parents = getParentProgramItems(programItem);
        
        for (ProgramItem parent : parents)
        {
            // Only parents not already visited
            if (visitedProgramItems.add(parent))
            {
                if (parent instanceof AbstractProgram)
                {
                    parentAbstractPrograms.add((AbstractProgram) parent);
                }
                else
                {
                    parentAbstractPrograms.addAll(_getParentAbstractPrograms(parent, visitedProgramItems));
                }
            }
        }
        
        return parentAbstractPrograms;
    }
    
    /**
     * 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)
            {
                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 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<>();
        
        String title = ((Content) item).getTitle();

        List<ProgramItem> parentProgramItems = getParentProgramItems(item);
        if (parentProgramItems.isEmpty())
        {
            paths.add(title);
            return paths;
        }
        
        for (ProgramItem parentProgramItem : parentProgramItems)
        {
            for (String path : getPaths(parentProgramItem, separator))
            {
                paths.add(path + separator + title);
            }
        }
        
        return paths;
    }
    
    /**
     * 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;
    }
    
    /**
     * 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
     * @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) throws AmetysRepositoryException, WorkflowException
    {
        return copyProgramItem(srcContent, null, null, __INITIAL_WORKFLOW_ACTION_ID, __EDIT_WORKFLOW_ACTION_ID, targetCatalog, fullCopy, copiedPrograms, copiedSubPrograms, copiedContainers, copiedCourseLists, copiedCourses);
    }
    
    /**
     * 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 <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) throws AmetysRepositoryException, WorkflowException
    {
        return copyProgramItem(srcContent, targetContentName, targetContentLanguage, __INITIAL_WORKFLOW_ACTION_ID, __EDIT_WORKFLOW_ACTION_ID, targetCatalog, fullCopy, copiedPrograms, copiedSubPrograms, copiedContainers, copiedCourseLists, copiedCourses);
    }
    
    
    /**
     * 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 editWorkflowActionId The workflow action id to edit the relationship
     * @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 <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")
    public <C extends ModifiableContent> C copyProgramItem(ProgramItem srcContent, String targetContentName, String targetContentLanguage, int initWorkflowActionId, int editWorkflowActionId, String targetCatalog, boolean fullCopy, Map<String, String> copiedPrograms, Map<String, String> copiedSubPrograms, Map<String, String> copiedContainers, Map<String, String> copiedCourseLists, Map<String, String> copiedCourses) throws AmetysRepositoryException, WorkflowException
    {
        String computedTargetLanguage = targetContentLanguage;
        if (computedTargetLanguage == null)
        {
            computedTargetLanguage = ((Content) srcContent).getLanguage();
        }
        
        String computeTargetName = targetContentName;
        if (computeTargetName == null)
        {
            // Compute content name from source content and requested language
            computeTargetName = ((Content) srcContent).getName() + (targetContentLanguage != null && !targetContentLanguage.equals(((Content) srcContent).getName()) ? "-" + targetContentLanguage : "");
        }
        
        String computeTargetCatalog = targetCatalog;
        if (computeTargetCatalog == null)
        {
            computeTargetCatalog = srcContent.getCatalog();
        }
        
        if (getProgramItem(srcContent, computeTargetCatalog, computedTargetLanguage) != null)
        {
            throw new AmetysObjectExistsException("A program item already exists with same code, catalog and language [" + srcContent.getCode() + ", " + computeTargetCatalog + ", " + targetContentLanguage + "]");
        }
        
        // Copy content waiting for observers to be completed and copying ACL
        ModifiableContent createdContent = ((DefaultContent) srcContent).copyTo(getRootContent(true), computeTargetName, targetContentLanguage, initWorkflowActionId, true, true);
        String createdContentId = createdContent.getId();
        
        if (fullCopy)
        {
            _cleanContentMetadata(createdContent);
            
            if (targetCatalog != null && createdContent instanceof ProgramItem)
            {
                ((ProgramItem) createdContent).setCatalog(targetCatalog);
                createdContent.saveChanges();
                // Content is modified as we changed the value of its catalog, notify it
                Map<String, Object> eventParams = new HashMap<>();
                eventParams.put(ObservationConstants.ARGS_CONTENT, createdContent);
                eventParams.put(ObservationConstants.ARGS_CONTENT_ID, createdContentId);
                _observationManager.notify(new Event(ObservationConstants.EVENT_CONTENT_MODIFIED, _currentUserProvider.getUser(), eventParams));
            }
            
            copyProgramItemStructure(srcContent, createdContent, computedTargetLanguage, initWorkflowActionId, editWorkflowActionId, computeTargetCatalog, copiedPrograms, copiedSubPrograms, copiedContainers, copiedCourseLists, copiedCourses);
        }
        
        if (createdContent instanceof Program)
        {
            copiedPrograms.put(((Content) srcContent).getId(), createdContentId);
        }
        else if (createdContent instanceof SubProgram)
        {
            copiedSubPrograms.put(((Content) srcContent).getId(), createdContentId);
        }
        else if (createdContent instanceof Container)
        {
            copiedContainers.put(((Content) srcContent).getId(), createdContentId);
        }
        else if (createdContent instanceof CourseList)
        {
            copiedCourseLists.put(((Content) srcContent).getId(), createdContentId);
        }
        else if (createdContent instanceof Course)
        {
            copiedCourses.put(((Content) srcContent).getId(), createdContentId);
        }
        
        return (C) createdContent;
    }
    
    /**
     * 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 editWorkflowActionId The workflow action id to edit the relationship
     * @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
     * @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, int editWorkflowActionId, String targetCatalogName, Map<String, String> copiedPrograms, Map<String, String> copiedSubPrograms, Map<String, String> copiedContainers, Map<String, String> copiedCourseLists, Map<String, String> copiedCourses) throws AmetysRepositoryException, WorkflowException
    {
        List<String> refChildIds = new ArrayList<>();
        
        List<ProgramItem> srcChildContents = new ArrayList<>();
        
        String childMetadataPath = null;
        
        if (srcContent instanceof TraversableProgramPart)
        {
            childMetadataPath = TraversableProgramPart.METADATA_CHILD_PROGRAM_PARTS;
            srcChildContents.addAll(((TraversableProgramPart) srcContent).getProgramPartChildren());
        }
        else if (srcContent instanceof CourseList)
        {
            childMetadataPath = CourseList.METADATA_CHILD_COURSES;
            srcChildContents.addAll(((CourseList) srcContent).getCourses());
        }
        else if (srcContent instanceof Course)
        {
            childMetadataPath = Course.METADATA_CHILD_COURSE_LISTS;
            srcChildContents.addAll(((Course) srcContent).getCourseLists());
        }
        
        for (ProgramItem srcChildContent : srcChildContents)
        {
            Content targetChildContent = getProgramItem(srcChildContent, targetCatalogName, targetContentLanguage);
            if (targetChildContent == null)
            {
                targetChildContent = copyProgramItem(srcChildContent, null, targetContentLanguage, initWorkflowActionId, editWorkflowActionId, targetCatalogName, true, copiedPrograms, copiedSubPrograms, copiedContainers, copiedCourseLists, copiedCourses);
            }
            refChildIds.add(targetChildContent.getId());
        }
        
        _editChildRelation((WorkflowAwareContent) targetContent, refChildIds, editWorkflowActionId, childMetadataPath);
    }
    
    private void _editChildRelation(WorkflowAwareContent parentContent, List<String> refChildIds, int actionId, String childMetadataPath) throws AmetysRepositoryException, WorkflowException
    {
        if (refChildIds.size() > 0)
        {
            Map<String, Object> values = new HashMap<>();
            
            values.put(EditContentFunction.FORM_ELEMENTS_PREFIX + childMetadataPath, refChildIds);
            values.put(EditContentFunction.INTERNAL_FORM_ELEMENTS_PREFIX + childMetadataPath + ".mode", MODE.REPLACE.name());
            
            Map<String, Object> contextParameters = new HashMap<>();
            contextParameters.put("quit", true);
            contextParameters.put("values", values);
            
            Map<String, Object> inputs = new HashMap<>();
            inputs.put(AbstractWorkflowComponent.CONTEXT_PARAMETERS_KEY, contextParameters);
            
            _contentWorkflowHelper.doAction(parentContent, actionId, inputs);
        }
    }
    
    /**
     * 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.METADATA_PARENT_PROGRAM_PARTS);
        }
        
        if (createdContent instanceof TraversableProgramPart)
        {
            ExternalizableMetadataHelper.removeMetadataIfExists(metadataHolder, TraversableProgramPart.METADATA_CHILD_PROGRAM_PARTS);
        }
        
        if (createdContent instanceof CourseList)
        {
            ExternalizableMetadataHelper.removeMetadataIfExists(metadataHolder, CourseList.METADATA_CHILD_COURSES);
            ExternalizableMetadataHelper.removeMetadataIfExists(metadataHolder, CourseList.METADATA_PARENT_COURSES);
        }
        
        if (createdContent instanceof Course)
        {
            ExternalizableMetadataHelper.removeMetadataIfExists(metadataHolder, Course.METADATA_CHILD_COURSE_LISTS);
            ExternalizableMetadataHelper.removeMetadataIfExists(metadataHolder, Course.METADATA_PARENT_COURSE_LISTS);
        }
    }
}