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

import java.io.IOException;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.Future;
import java.util.stream.Collectors;

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.lang3.ArrayUtils;
import org.apache.commons.lang3.StringUtils;
import org.apache.commons.lang3.tuple.Pair;
import org.apache.solr.client.solrj.SolrServerException;

import org.ametys.cms.ObservationConstants;
import org.ametys.cms.clientsideelement.content.SmartContentClientSideElementHelper;
import org.ametys.cms.content.ContentHelper;
import org.ametys.cms.content.external.ExternalizableMetadataHelper;
import org.ametys.cms.content.indexing.solr.SolrIndexer;
import org.ametys.cms.data.ContentDataHelper;
import org.ametys.cms.repository.Content;
import org.ametys.cms.repository.WorkflowAwareContent;
import org.ametys.cms.workflow.ContentWorkflowHelper;
import org.ametys.core.observation.Event;
import org.ametys.core.observation.ObservationManager;
import org.ametys.core.right.RightManager;
import org.ametys.core.right.RightManager.RightResult;
import org.ametys.core.user.CurrentUserProvider;
import org.ametys.odf.ODFHelper;
import org.ametys.odf.ProgramItem;
import org.ametys.odf.course.Course;
import org.ametys.odf.course.ShareableCourseConstants;
import org.ametys.odf.courselist.CourseList;
import org.ametys.odf.orgunit.OrgUnit;
import org.ametys.odf.person.Person;
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.AmetysObjectResolver;
import org.ametys.plugins.repository.AmetysRepositoryException;
import org.ametys.plugins.repository.ModifiableAmetysObject;
import org.ametys.plugins.repository.RemovableAmetysObject;
import org.ametys.plugins.repository.lock.LockableAmetysObject;
import org.ametys.runtime.plugin.component.AbstractLogEnabled;

import com.opensymphony.workflow.WorkflowException;

/**
 * Helper to delete an ODF content.
 */
public class DeleteODFContentHelper extends AbstractLogEnabled implements Component, Serviceable
{
    /** Avalon role. */
    public static final String ROLE = DeleteODFContentHelper.class.getName();
    
    /** Ametys object resolver */
    private AmetysObjectResolver _resolver;
    
    /** The ODF helper */
    private ODFHelper _odfHelper;
    
    /** Observer manager. */
    private ObservationManager _observationManager;
    
    /** The Solr indexer. */
    private SolrIndexer _solrIndexer;

    /** The Content workflow helper */
    private ContentWorkflowHelper _contentWorkflowHelper;
    
    /** The current user provider */
    private CurrentUserProvider _currentUserProvider;
    
    /** The rights manager */
    private RightManager _rightManager;

    /** The content helper */
    private ContentHelper _contentHelper;
    
    /** Helper for smart content client elements */
    private SmartContentClientSideElementHelper _smartHelper;
    
    public void service(ServiceManager manager) throws ServiceException
    {
        _resolver = (AmetysObjectResolver) manager.lookup(AmetysObjectResolver.ROLE);
        _odfHelper = (ODFHelper) manager.lookup(ODFHelper.ROLE);
        _observationManager = (ObservationManager) manager.lookup(ObservationManager.ROLE);
        _solrIndexer = (SolrIndexer) manager.lookup(SolrIndexer.ROLE);
        _contentWorkflowHelper = (ContentWorkflowHelper) manager.lookup(ContentWorkflowHelper.ROLE);
        _currentUserProvider = (CurrentUserProvider) manager.lookup(CurrentUserProvider.ROLE);
        _rightManager = (RightManager) manager.lookup(RightManager.ROLE);
        _smartHelper = (SmartContentClientSideElementHelper) manager.lookup(SmartContentClientSideElementHelper.ROLE);
        _contentHelper = (ContentHelper) manager.lookup(ContentHelper.ROLE);
    }
    
    /**
     * Enumeration for the mode of deletion
     *
     */
    public enum DeleteMode
    {
        /** Delete the content only */
        SINGLE,
        /** Delete the content and its structure */
        STRUCTURE_ONLY,
        /** Delete the content and its structure and its courses */
        FULL
    }
    
    /**
     * Delete ODF contents
     * @param contentsId The ids of contents to delete
     * @param modeParam The mode of deletion
     * @return the deleted and undeleted contents
     */
    public Map<String, Object> deleteContents(List<String> contentsId, String modeParam)
    {
        return deleteContents(contentsId, modeParam, false);
    }
    
    /**
     * Delete ODF contents
     * @param contentsId The ids of contents to delete
     * @param modeParam The mode of deletion
     * @param ignoreRights If true, bypass the rights check during the deletion
     * @return the deleted and undeleted contents
     */
    public Map<String, Object> deleteContents(List<String> contentsId, String modeParam, boolean ignoreRights)
    {
        Map<String, Object> results = new HashMap<>();
        
        List<String> alreadyDeletedContentIds = new ArrayList<>();
        for (String contentId : contentsId)
        {
            Map<String, Object> result = new HashMap<>();
            result.put("deleted-contents", new HashSet<>());
            result.put("undeleted-contents", new HashSet<>());
            result.put("referenced-contents", new HashSet<>());
            result.put("unauthorized-contents", new HashSet<>());
            result.put("locked-contents", new HashSet<>());

            if (!alreadyDeletedContentIds.contains(contentId))
            {
                Content content = _resolver.resolveById(contentId);
                
                result.put("initial-content", content.getId());
                
                DeleteMode deleteMode = StringUtils.isNotBlank(modeParam) ? DeleteMode.valueOf(modeParam.toUpperCase()) : DeleteMode.SINGLE;
                
                boolean referenced = isContentReferenced(content);
                if (referenced || !_checkBeforeDeletion(content, deleteMode, ignoreRights, result))
                {
                    if (referenced)
                    {
                        // Indicate that the content is referenced.
                        @SuppressWarnings("unchecked")
                        Set<Content> referencedContents = (Set<Content>) result.get("referenced-contents");
                        referencedContents.add(content);
                    }
                    result.put("check-before-deletion-failed", true);
                }
                else
                {
                    // Process deletion
                    _deleteContent(content, deleteMode, ignoreRights, result);
                    
                    @SuppressWarnings("unchecked")
                    Set<String> deletedContents = (Set<String>) result.get("deleted-contents");
                    if (deletedContents != null)
                    {
                        alreadyDeletedContentIds.addAll(deletedContents);
                    }
                }
            }
            
            results.put(contentId, result);
        }

        return results;
    }
    
    /**
     * Delete ODF contents
     * @param contentsId The ids of contents to delete
     * @param modeParam The mode of deletion
     * @return the deleted and undeleted contents
     */
    public Map<String, Object> deleteContentsWithLog(List<String> contentsId, String modeParam)
    {
        return deleteContentsWithLog(contentsId, modeParam, false);
    }
    
    /**
     * Delete ODF contents
     * @param contentsId The ids of contents to delete
     * @param modeParam The mode of deletion
     * @param ignoreRights If true, bypass the rights check during the deletion
     * @return the deleted and undeleted contents
     */
    @SuppressWarnings("unchecked")
    public Map<String, Object> deleteContentsWithLog(List<String> contentsId, String modeParam, boolean ignoreRights)
    {
        Map<String, Object> results = deleteContents(contentsId, modeParam, ignoreRights);
        for (String contentId : contentsId)
        {
            Map<String, Object> result = (Map<String, Object>) results.get(contentId);
            
            Set<Content> referencedContents = (Set<Content>) result.get("referenced-contents");
            if (referencedContents.size() > 0)
            {
                getLogger().info("The following contents cannot be deleted because they are referenced: {}", referencedContents.stream().map(m -> m.getId()).collect(Collectors.toList()));
            }
            
            Set<Content> lockedContents = (Set<Content>) result.get("locked-contents");
            if (lockedContents.size() > 0)
            {
                getLogger().info("The following contents cannot be deleted because they are locked: {}", lockedContents.stream().map(m -> m.getId()).collect(Collectors.toList()));
            }
            
            Set<Content> unauthorizedContents = (Set<Content>) result.get("unauthorized-contents");
            if (unauthorizedContents.size() > 0)
            {
                getLogger().info("The following contents cannot be deleted because they are no authorization: {}", unauthorizedContents.stream().map(m -> m.getId()).collect(Collectors.toList()));
            }
            
            Set<Content> undeletedContents = (Set<Content>) result.get("undeleted-contents");
            if (undeletedContents.size() > 0)
            {
                getLogger().info("{} contents were not deleted. See previous logs for more information.", undeletedContents.size());
            }
        }
        
        return results;
    }
    
    /**
     * Delete one content
     * @param content the content to delete
     * @param deleteMode The deletion mode
     * @param ignoreRights If true, bypass the rights check during the deletion
     * @param results the results map
     */
    private void _deleteContent(Content content, DeleteMode deleteMode, boolean ignoreRights, Map<String, Object> results)
    {
        if (content instanceof OrgUnit)
        {
            // 1- First delete relation to parent
            OrgUnit parentOrgUnit = ((OrgUnit) content).getParentOrgUnit();
            boolean success = true;
            if (parentOrgUnit != null)
            {
                success = _removeRelation(parentOrgUnit, content, OrgUnit.CHILD_ORGUNITS, 22, results);
            }
            
            // 2 - If succeed, process to deletion
            if (success)
            {
                _deleteOrgUnit((OrgUnit) content, ignoreRights, results);
            }
            else
            {
                @SuppressWarnings("unchecked")
                Set<Content> undeletedContents = (Set<Content>) results.get("undeleted-contents");
                undeletedContents.add(content);
            }
        }
        else if (content instanceof Course)
        {
            // 1 - First delete relation to parents
            List<CourseList> courseLists = ((Course) content).getParentCourseLists();
            
            boolean success = _removeRelations(courseLists, content, CourseList.CHILD_COURSES, 22, results);
            
            // 2 - If succeed, process to deletion
            if (success)
            {
                _deleteProgramItem((Course) content, deleteMode, ignoreRights, results);
            }
            else
            {
                @SuppressWarnings("unchecked")
                Set<Content> undeletedContents = (Set<Content>) results.get("undeleted-contents");
                undeletedContents.add(content);
            }
        }
        else if (content instanceof CourseList)
        {
            // 1 - First delete relation to parents
            List<ProgramPart> parentProgramItems = ((CourseList) content).getProgramPartParents();
            List<WorkflowAwareContent> parentContents = parentProgramItems.stream().map(p -> (WorkflowAwareContent) p).collect(Collectors.toList());
            
            boolean success = _removeRelations(parentContents, content, TraversableProgramPart.CHILD_PROGRAM_PARTS, 22, results);
            if (success)
            {
                List<Course> parentCourses = ((CourseList) content).getParentCourses();
                parentContents = parentCourses.stream().map(p -> (WorkflowAwareContent) p).collect(Collectors.toList());
                
                success = _removeRelations(parentCourses, content, Course.CHILD_COURSE_LISTS, 22, results);
            }
            
            // 2 - If succeed, process to deletion
            if (success)
            {
                _deleteProgramItem((CourseList) content, deleteMode, ignoreRights, results);
            }
            else
            {
                @SuppressWarnings("unchecked")
                Set<Content> undeletedContents = (Set<Content>) results.get("undeleted-contents");
                undeletedContents.add(content);
            }
        }
        else if (content instanceof TraversableProgramPart)
        {
            // 1 - First delete relation to parents
            List<ProgramItem> parentProgramItems = _odfHelper.getParentProgramItems((ProgramPart) content);
            List<WorkflowAwareContent> parentContents = parentProgramItems.stream().map(p -> (WorkflowAwareContent) p).collect(Collectors.toList());
            
            boolean success = _removeRelations(parentContents, content, TraversableProgramPart.CHILD_PROGRAM_PARTS, 22, results);
            
            // 2 - If succeed, process to deletion
            if (success)
            {
                _deleteProgramItem((ProgramPart) content, deleteMode, ignoreRights, results);
            }
            else
            {
                @SuppressWarnings("unchecked")
                Set<Content> undeletedContents = (Set<Content>) results.get("undeleted-contents");
                undeletedContents.add(content);
            }
        }
        else if (content instanceof Person)
        {
            // 1 - Process to deletion
            _finalizeDeleteContents(Collections.singleton(content.getId()), content.getParent(), results);
        }
        else
        {
            throw new IllegalArgumentException("The content [" + content.getId() + "] is not of the expected type, it can't be deleted.");
        }
    }

    /**
     * Test if content is still referenced before removing it
     * @param content The content to remove
     * @return true if content is still referenced
     */
    public boolean isContentReferenced(Content content)
    {
        return _isContentReferenced(content, null);
    }
    
    /**
     * Test if content is still referenced before removing it.
     * @param content The content to remove
     * @param rootContent the initial content to delete (can be null if checkRoot is false)
     * @return true if content is still referenced
     */
    private boolean _isContentReferenced(Content content, Content rootContent)
    {
        if (content instanceof OrgUnit)
        {
            return _isReferencedOrgUnit((OrgUnit) content);
        }
        else if (content instanceof ProgramItem)
        {
            if (rootContent != null)
            {
                return _isReferencedContentCheckingRoot((ProgramItem) content, rootContent);
            }
            else
            {
                List<ProgramItem> ignoredRefContent = _odfHelper.getChildProgramItems((ProgramItem) content);
                if (!(content instanceof Program)) // TODO remove content instanceof Course
                {
                    ignoredRefContent.addAll(_odfHelper.getParentProgramItems((ProgramItem) content));
                }
                
                for (Pair<String, Content> refPair : _contentHelper.getReferencingContents(content))
                {
                    Content refContent = refPair.getValue();
                    String path = refPair.getKey();
                    
                    // Ignoring reference from shareable field
                    if (!(refContent instanceof Course && path.equals(ShareableCourseConstants.PROGRAMS_FIELD_ATTRIBUTE_NAME)))
                    {
                        // The ref content is not ignored
                        if (refContent instanceof ProgramItem && !ignoredRefContent.contains((ProgramItem) refContent))
                        {
                            return true;
                        }
                    }
                }

                return false;
            }
        }
        
        return content.hasReferencingContents();
    }
    
    /**
     * True if the orgUnit is referenced
     * @param orgUnit the orgUnit
     * @return true if the orgUnit is referenced
     */
    private boolean _isReferencedOrgUnit(OrgUnit orgUnit)
    {
        OrgUnit parentOrgUnit = orgUnit.getParentOrgUnit();

        List<String> relatedOrgUnit = orgUnit.getSubOrgUnits();
        if (parentOrgUnit != null)
        {
            relatedOrgUnit.add(parentOrgUnit.getId());
        }
        
        for (Pair<String, Content> refPair : _contentHelper.getReferencingContents(orgUnit))
        {
            Content refContent = refPair.getValue();
            String path = refPair.getKey();
            
            // Ignoring reference from shareable field
            if (!(refContent instanceof Course && path.equals(ShareableCourseConstants.ORGUNITS_FIELD_ATTRIBUTE_NAME)))
            {
                if (!relatedOrgUnit.contains(refContent.getId()))
                {
                    return true;
                }
            }
        }
        
        return false;
    }

    /**
     * Check that deletion can be performed without blocking errors
     * @param content The initial content to delete
     * @param mode The deletion mode
     * @param ignoreRights If true, bypass the rights check during the deletion
     * @param results The results
     * @return true if the deletion can be performed
     */
    private boolean _checkBeforeDeletion(Content content, DeleteMode mode, boolean ignoreRights, Map<String, Object> results)
    {
        // Check right and lock on content it self
        boolean allRight = _canDeleteContent(content, ignoreRights, results);
        
        // Check lock on parent contents
        allRight = _checkParentsBeforeDeletion(content, results) && allRight;
        
        // Check right and lock on children to be deleted or modified
        allRight = _checkChildrenBeforeDeletion(content, content, mode, ignoreRights, results) && allRight;
        
        return allRight;
    }
    
    private boolean _checkParentsBeforeDeletion(Content content,  Map<String, Object> results)
    {
        boolean allRight = true;
        
        // Check if parents are not locked
        List< ? extends WorkflowAwareContent> parents = _getParents(content);
        for (WorkflowAwareContent parent : parents)
        {
            if (_smartHelper.isLocked(parent))
            {
                @SuppressWarnings("unchecked")
                Set<Content> lockedContents = (Set<Content>) results.get("locked-contents");
                lockedContents.add(content);
                
                allRight = false;
            }
        }
        
        return allRight;
    }
    
    /**
     * Browse children to check if deletion could succeed
     * @param rootContentToDelete The initial content to delete
     * @param contentToCheck The current content to check
     * @param mode The deletion mode
     * @param ignoreRights If true, bypass the rights check during the deletion
     * @param results The result
     * @return true if the deletion can be processed
     */
    private boolean _checkChildrenBeforeDeletion(Content rootContentToDelete, Content contentToCheck, DeleteMode mode, boolean ignoreRights, Map<String, Object> results)
    {
        boolean allRight = true;
        
        if (contentToCheck instanceof ProgramItem)
        {
            allRight = _checkChildrenBeforeDeletionOfProgramItem(rootContentToDelete, contentToCheck, mode, ignoreRights, results);
        }
        else if (contentToCheck instanceof OrgUnit)
        {
            allRight = _checkChildrenBeforeDeletionOfOrgUnit(rootContentToDelete, contentToCheck, mode, ignoreRights, results);
        }
        
        return allRight;
    }
    
    private boolean _checkChildrenBeforeDeletionOfProgramItem(Content rootContentToDelete, Content contentToCheck, DeleteMode mode,  boolean ignoreRights, Map<String, Object> results)
    {
        boolean allRight = true;

        List<ProgramItem> childProgramItems = _odfHelper.getChildProgramItems((ProgramItem) contentToCheck);
        for (ProgramItem childProgramItem : childProgramItems)
        {
            Content childContent = (Content) childProgramItem;
            if (_smartHelper.isLocked(childContent))
            {
                // Lock should be checked for all children
                @SuppressWarnings("unchecked")
                Set<Content> lockedContents = (Set<Content>) results.get("locked-contents");
                lockedContents.add(childContent);
                
                allRight = false;
            }

            // If content is not referenced it should be deleted, so check right
            if ((mode == DeleteMode.FULL || (mode == DeleteMode.STRUCTURE_ONLY && !(childProgramItem instanceof Course))) && !_isContentReferenced(childContent, rootContentToDelete) && !ignoreRights && !hasRight(childContent))
            {
                // User has no sufficient right
                @SuppressWarnings("unchecked")
                Set<Content> norightContents = (Set<Content>) results.get("unauthorized-contents");
                norightContents.add(childContent);
                
                allRight = false;
            }
            
            if (mode != DeleteMode.SINGLE && !(mode == DeleteMode.STRUCTURE_ONLY && childProgramItem instanceof Course))
            {
                // Browse children recursively
                allRight = _checkChildrenBeforeDeletion(rootContentToDelete, childContent, mode, ignoreRights, results) && allRight;
            }
        }
        
        return allRight;
    }
    
    private boolean _checkChildrenBeforeDeletionOfOrgUnit(Content rootContentToDelete, Content contentToCheck, DeleteMode mode, boolean ignoreRights, Map<String, Object> results)
    {
        boolean allRight = true;

        List<String> childOrgUnits = ((OrgUnit) contentToCheck).getSubOrgUnits();
        for (String childOrgUnitId : childOrgUnits)
        {
            OrgUnit childOrgUnit = _resolver.resolveById(childOrgUnitId);
            if (!_canDeleteContent(childOrgUnit, ignoreRights, results))
            {
                allRight = false;
            }
            else if (_isReferencedOrgUnit(childOrgUnit))
            {
                @SuppressWarnings("unchecked")
                Set<Content> referencedContents = (Set<Content>) results.get("referenced-contents");
                referencedContents.add(childOrgUnit);
                
                allRight = false;
            }
            else
            {
                // Browse children recursively
                allRight = _checkChildrenBeforeDeletion(rootContentToDelete, childOrgUnit, mode, ignoreRights, results) && allRight;
            }
        }
        
        return allRight;
    }

    /**
     * Remove the relations between the content and its contents list
     * @param contentsToEdit the contents to edit
     * @param refContentToRemove The referenced content to be removed from contents
     * @param metadataName The name of metadata holding the relationship
     * @param actionId The id of workflow action to edit the relation
     * @param results the results map
     * @return true if remove relation successfully
     */
    private boolean _removeRelations(List<? extends WorkflowAwareContent> contentsToEdit, Content refContentToRemove, String metadataName, int actionId, Map<String, Object> results)
    {
        boolean success = true;
        
        for (Content contentToEdit : contentsToEdit)
        {
            success = _removeRelation((WorkflowAwareContent) contentToEdit, refContentToRemove, metadataName, actionId, results) && success;
        }
        
        return success;
    }
    
    /**
     * Remove the relation parent-child relation on content. 
     * @param contentToEdit The content to modified
     * @param refContentToRemove The referenced content to be removed from content
     * @param metadataName The name of metadata holding the child or parent relationship
     * @param actionId The id of workflow action to edit the relation
     * @param results the results map
     * @return boolean true if remove relation successfully
     */
    private boolean _removeRelation(WorkflowAwareContent contentToEdit, Content refContentToRemove, String metadataName, int actionId, Map<String, Object> results)
    {
        try
        {
            String[] values = ContentDataHelper.getContentIdsArrayFromMultipleContentData(contentToEdit, metadataName);
            
            if (ArrayUtils.contains(values, refContentToRemove.getId()))
            {
                String[] newValues = ArrayUtils.removeElement(values, refContentToRemove.getId());
                
                List<Content> newContents = Arrays.asList(newValues).stream()
                        .map(id -> (Content) _resolver.resolveById(id))
                        .collect(Collectors.toList());
                
                // Set Jcr content reference if we pass contents in arguments
                ExternalizableMetadataHelper.setMetadata(contentToEdit.getMetadataHolder(), metadataName, newContents.toArray(new Content[newContents.size()]));
                _applyChanges(contentToEdit, actionId);
            }
            
            return true;
        }
        catch (WorkflowException | AmetysRepositoryException e)
        {
            getLogger().error("Unable to remove relationship to content {} ({}) on content {} ({}) for metadata {}", refContentToRemove.getTitle(), refContentToRemove.getId(), contentToEdit.getTitle(), contentToEdit.getId(), metadataName, e);
            return false;
        }
    }
    
    /**
     * Delete a program item
     * @param item The program item to delete
     * @param mode The deletion mode
     * @param ignoreRights If true, bypass the rights check during the deletion
     * @param results The results
     */
    private void _deleteProgramItem(ProgramItem item, DeleteMode mode, boolean ignoreRights, Map<String, Object> results)
    {
        if (mode == DeleteMode.SINGLE)
        {
            if (_canDeleteContent((Content) item, ignoreRights, results))
            {
                // 1 - First remove relations with children
                String parentMetadataName;
                if (item instanceof Course)
                {
                    parentMetadataName = CourseList.PARENT_COURSES;
                }
                else if (item instanceof CourseList)
                {
                    parentMetadataName = Course.PARENT_COURSE_LISTS;
                }
                else
                {
                    parentMetadataName = ProgramPart.PARENT_PROGRAM_PARTS;
                }
                
                List<ProgramItem> childProgramItems = _odfHelper.getChildProgramItems(item);
                List<WorkflowAwareContent> childContents = childProgramItems.stream().map(p -> (WorkflowAwareContent) p).collect(Collectors.toList());
                
                boolean success = _removeRelations(childContents, (Content) item, parentMetadataName, 22, results);
                if (success)
                {
                    // If success delete course
                    _finalizeDeleteContents(Collections.singleton(item.getId()), item.getParent(), results);
                }
            }
        }
        else
        {
            Set<String> toDelete = _getChildrenIdToDelete(item, item, results, mode, ignoreRights);
            _finalizeDeleteContents(toDelete, item.getParent(), results);
        }
    }
    
   
    /**
     * Delete one orgUnit
     * @param orgUnit the orgUnit to delete
     * @param ignoreRights If true, bypass the rights check during the deletion
     * @param results the results map
     */
    @SuppressWarnings("unchecked")
    private void _deleteOrgUnit(OrgUnit orgUnit, boolean ignoreRights, Map<String, Object> results)
    {
        Set<String> toDelete = _getChildrenIdToDelete(orgUnit, ignoreRights, results);
        
        Set<Content> referencedContents = (Set<Content>) results.get("referenced-contents");
        Set<Content> lockedContents = (Set<Content>) results.get("locked-contents");
        Set<Content> unauthorizedContents = (Set<Content>) results.get("unauthorized-contents");
        
        if (referencedContents.size() == 0 && lockedContents.size() == 0 && unauthorizedContents.size() == 0)
        {
            _finalizeDeleteContents(toDelete, orgUnit.getParent(), results);
        }
    }

    /**
     * Finalize the deletion of contents. Call observers and remove contents
     * @param contentIdsToDelete the list of content id to delete
     * @param parent the jcr parent for saving changes
     * @param results the results map
     */
    private void _finalizeDeleteContents(Set<String> contentIdsToDelete, ModifiableAmetysObject parent, Map<String, Object> results)
    {
        @SuppressWarnings("unchecked")
        Set<Content> unauthorizedContents = (Set<Content>) results.get("unauthorized-contents");
        @SuppressWarnings("unchecked")
        Set<Content> lockedContents = (Set<Content>) results.get("locked-contents");
        
        if (!unauthorizedContents.isEmpty() || !lockedContents.isEmpty())
        {
            //Do Nothing
            return;
        }
        
        try
        {
            _observationManager.addArgumentForEvents(new String[] {ObservationConstants.EVENT_CONTENT_DELETED}, ObservationConstants.ARGS_CONTENT_COMMIT, false);
            
            Map<String, Map<String, Object>> eventParams = new HashMap<>();
            for (String id : contentIdsToDelete)
            {
                Content content = _resolver.resolveById(id);
                Map<String, Object> eventParam = _getEventParametersForDeletion(content);
                
                eventParams.put(id, eventParam);
                
                _observationManager.notify(new Event(ObservationConstants.EVENT_CONTENT_DELETING, _currentUserProvider.getUser(), eventParam));
                
                // Remove the content.
                LockableAmetysObject lockedContent = (LockableAmetysObject) content;
                if (lockedContent.isLocked())
                {
                    lockedContent.unlock();
                }
                
                ((RemovableAmetysObject) content).remove();
            }
            
            
            parent.saveChanges();
            
            for (String id : contentIdsToDelete)
            {
                _observationManager.notify(new Event(ObservationConstants.EVENT_CONTENT_DELETED, _currentUserProvider.getUser(), eventParams.get(id)));
                
                @SuppressWarnings("unchecked")
                Set<String> deletedContents = (Set<String>) results.get("deleted-contents");
                deletedContents.add(id);
            }
        }
        finally 
        {
            _observationManager.removeArgumentForEvents(new String[] {ObservationConstants.EVENT_CONTENT_DELETED}, ObservationConstants.ARGS_CONTENT_COMMIT);
            _commitAllChanges();
        }
    }
    
    /**
     * Commit all changes in solr
     */
    private void _commitAllChanges()
    {
        // Before trying to commit, be sure all the async observers of the current request are finished
        for (Future future : _observationManager.getFuturesForRequest())
        {
            try
            {
                future.get();
            }
            catch (ExecutionException | InterruptedException e)
            {
                getLogger().info("An exception occured when calling #get() on Future result of an observer." , e);
            }
        }
        
        // Commit all uncommited changes
        try
        {
            _solrIndexer.commit();
            
            getLogger().debug("Deleted contents are now committed into Solr.");
        }
        catch (IOException | SolrServerException e)
        {
            getLogger().error("Impossible to commit changes", e);
        }
    }
    
    /**
     * True if we can delete the content (check if removable, rights and if locked)
     * @param content the content
     * @param ignoreRights If true, bypass the rights check during the deletion
     * @param results the results map
     * @return true if we can delete the content
     */
    private boolean _canDeleteContent(Content content, boolean ignoreRights, Map<String, Object> results)
    {
        if (!(content instanceof RemovableAmetysObject))
        {
            throw new IllegalArgumentException("The content [" + content.getId() + "] is not a RemovableAmetysObject, it can't be deleted.");
        }
        
        if (!ignoreRights && !hasRight(content))
        {
            // User has no sufficient right
            @SuppressWarnings("unchecked")
            Set<Content> norightContents = (Set<Content>) results.get("unauthorized-contents");
            norightContents.add(content);
            
            return false;
        }
        else if (_smartHelper.isLocked(content))
        {
            @SuppressWarnings("unchecked")
            Set<Content> lockedContents = (Set<Content>) results.get("locked-contents");
            lockedContents.add(content);
            
            return false;
        }
        
        return true;
    }
    
    private void _applyChanges(WorkflowAwareContent content, int actionId) throws WorkflowException
    {
        // Notify listeners
        Map<String, Object> eventParams = new HashMap<>();
        eventParams.put(ObservationConstants.ARGS_CONTENT, content);
        eventParams.put(ObservationConstants.ARGS_CONTENT_ID, content.getId());
        _observationManager.notify(new Event(ObservationConstants.EVENT_CONTENT_MODIFIED, _currentUserProvider.getUser(), eventParams));
       
        _contentWorkflowHelper.doAction(content, actionId);
    }
    
    /**
     * Get parameters for content deleted {@link Event}
     * @param content the removed content
     * @return the event's parameters
     */
    private Map<String, Object> _getEventParametersForDeletion (Content content)
    {
        Map<String, Object> eventParams = new HashMap<>();
        eventParams.put(ObservationConstants.ARGS_CONTENT, content);
        eventParams.put(ObservationConstants.ARGS_CONTENT_NAME, content.getName());
        eventParams.put(ObservationConstants.ARGS_CONTENT_ID, content.getId());
        return eventParams;
    }
    
    private List<? extends WorkflowAwareContent> _getParents(Content content)
    {
        if (content instanceof OrgUnit)
        {
            return Collections.singletonList(((OrgUnit) content).getParentOrgUnit());
        }
        else if (content instanceof Course)
        {
            return ((Course) content).getParentCourseLists();
        }
        else if (content instanceof CourseList)
        {
            List<ProgramPart> parentProgramItems = ((CourseList) content).getProgramPartParents();
            List<WorkflowAwareContent> parents = parentProgramItems.stream().map(p -> (WorkflowAwareContent) p).collect(Collectors.toList());
            
            List<Course> parentCourses = ((CourseList) content).getParentCourses();
            parents.addAll(parentCourses.stream().map(p -> (WorkflowAwareContent) p).collect(Collectors.toList()));
            
            return parents;
        }
        else if (content instanceof ProgramPart)
        {
            List<ProgramItem> parentProgramItems = _odfHelper.getParentProgramItems((ProgramPart) content);
            return parentProgramItems.stream().map(p -> (WorkflowAwareContent) p).collect(Collectors.toList());
        }
        
        return Collections.EMPTY_LIST;
    }
    
    /**
     * Get the id of children to be deleted. 
     * All children shared with other contents which are not part of deletion, will be not deleted.
     * @param orgUnit The orgunit to delete
     * @param ignoreRights If true, bypass the rights check during the deletion
     * @param results The results
     * @return The id of contents to be deleted
     */
    private Set<String> _getChildrenIdToDelete (OrgUnit orgUnit, boolean ignoreRights, Map<String, Object> results)
    {
        Set<String> toDelete = new HashSet<>();
        
        if (_canDeleteContent(orgUnit, ignoreRights, results))
        {
            toDelete.add(orgUnit.getId());
            
            for (String childId : orgUnit.getSubOrgUnits())
            {
                OrgUnit childOrgUnit = _resolver.resolveById(childId);
                
                if (!_isReferencedOrgUnit(orgUnit))
                {
                    toDelete.addAll(_getChildrenIdToDelete(childOrgUnit, ignoreRights, results));
                }
                else
                {
                    // The child program item can not be deleted, remove the relation to the parent and stop iteration
                    @SuppressWarnings("unchecked")
                    Set<Content> referencedContents = (Set<Content>) results.get("referenced-contents");
                    referencedContents.add(childOrgUnit);
                }
            }
        }
        
        return toDelete;
    }
    
    /**
     * Get the id of children to be deleted. 
     * All children shared with other contents which are not part of deletion, will be not deleted.
     * @param contentToDelete The content to delete in the tree of initial content to delete
     * @param initialContentToDelete The initial content to delete
     * @param results The results
     * @param mode The deletion mode
     * @param ignoreRights If true, bypass the rights check during the deletion
     * @return The id of contents to be deleted
     */
    private Set<String> _getChildrenIdToDelete (ProgramItem contentToDelete, ProgramItem initialContentToDelete, Map<String, Object> results, DeleteMode mode, boolean ignoreRights)
    {
        Set<String> toDelete = new HashSet<>();
        
        if (_canDeleteContent((Content) contentToDelete, ignoreRights, results))
        {
            toDelete.add(contentToDelete.getId());
            
            List<ProgramItem> childProgramItems;
            if (mode == DeleteMode.STRUCTURE_ONLY && contentToDelete instanceof TraversableProgramPart)
            {
                // Get subprogram, container and course list children only
                childProgramItems = ((TraversableProgramPart) contentToDelete).getProgramPartChildren().stream().map(c -> (ProgramItem) c).collect(Collectors.toList());
            }
            else 
            {
                childProgramItems = _odfHelper.getChildProgramItems(contentToDelete);
            }
            
            for (ProgramItem childProgramItem : childProgramItems)
            {
                if (!_isContentReferenced((Content) childProgramItem, (Content) initialContentToDelete))
                {
                    // If all references of this program item is part of the initial content to delete, it can be deleted
                    if (mode == DeleteMode.STRUCTURE_ONLY && childProgramItem instanceof CourseList)
                    {
                        // Remove the relations to the course list to be deleted on all child courses
                        _removeRelations(((CourseList) childProgramItem).getCourses(), (Content) childProgramItem, Course.PARENT_COURSE_LISTS, 22, results);
                        toDelete.add(childProgramItem.getId());
                    }
                    else
                    {
                        // Browse children recursively
                        toDelete.addAll(_getChildrenIdToDelete(childProgramItem, initialContentToDelete, results, mode, ignoreRights));
                    }
                }
                else
                {
                    // The child program item can not be deleted, remove the relation to the parent and stop iteration
                    String parentMetadataName;
                    if (childProgramItem instanceof CourseList)
                    {
                        parentMetadataName = contentToDelete instanceof Course ? CourseList.PARENT_COURSES : ProgramPart.PARENT_PROGRAM_PARTS;
                    }
                    else if (childProgramItem instanceof Course)
                    {
                        parentMetadataName = Course.PARENT_COURSE_LISTS;
                    }
                    else
                    {
                        parentMetadataName = ProgramPart.PARENT_PROGRAM_PARTS;
                    }
                    
                    _removeRelation((WorkflowAwareContent) childProgramItem, (Content) contentToDelete, parentMetadataName, 22, results);
                    
                    @SuppressWarnings("unchecked")
                    Set<Content> referencedContents = (Set<Content>) results.get("referenced-contents");
                    referencedContents.add((Content) childProgramItem);
                }
            }
        }
        
        return toDelete;
    }

    /**
     * Determines if the user has sufficient right for the given content
     * @param content the content
     * @return true if user has sufficient right
     */
    public boolean hasRight(Content content)
    {
        String rightId = _getRightId(content);
        return _rightManager.hasRight(_currentUserProvider.getUser(), rightId, content) == RightResult.RIGHT_ALLOW;
    }
    
    private String _getRightId (Content content)
    {
        if (content instanceof Course)
        {
            return "ODF_Rights_Course_Delete";
        }
        else if (content instanceof SubProgram)
        {
            return "ODF_Rights_SubProgram_Delete";
        }
        else if (content instanceof Container)
        {
            return "ODF_Rights_Container_Delete";
        }
        else if (content instanceof Program)
        {
            return "ODF_Rights_Program_Delete";
        }
        else if (content instanceof Person)
        {
            return "ODF_Rights_Person_Delete";
        }
        else if (content instanceof OrgUnit)
        {
            return "ODF_Rights_OrgUnit_Delete";
        }
        else if (content instanceof CourseList)
        {
            return "ODF_Rights_CourseList_Delete";
        }
        return "Workflow_Rights_Delete";
    }
    
    /**
     * True if the content is referenced (we are ignoring parent references if they have same root)
     * @param programItem the program item
     * @param initialContentToDelete the initial content to delete
     * @return true if the content is referenced
     */
    private boolean _isReferencedContentCheckingRoot(ProgramItem programItem, Content initialContentToDelete)
    {
        if (programItem.getId().equals(initialContentToDelete.getId()))
        {
            return false;
        }

        List<ProgramItem> parentProgramItems = _odfHelper.getParentProgramItems(programItem);
        if (parentProgramItems.isEmpty())
        {
            return true;
        }
        
        for (ProgramItem parentProgramItem : parentProgramItems)
        {
            if (_isReferencedContentCheckingRoot(parentProgramItem, initialContentToDelete))
            {
                return true;
            }
        }
        
        return false;
    }
}