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

import java.util.ArrayList;
import java.util.Date;
import java.util.HashMap;
import java.util.HashSet;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.Optional;
import java.util.Set;
import java.util.function.Function;
import java.util.stream.Collectors;

import javax.jcr.Node;
import javax.jcr.RepositoryException;

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.StringUtils;
import org.apache.jackrabbit.util.Text;

import org.ametys.cms.FilterNameHelper;
import org.ametys.core.group.GroupIdentity;
import org.ametys.core.group.GroupManager;
import org.ametys.core.right.RightManager;
import org.ametys.core.right.RightManager.RightResult;
import org.ametys.core.ui.Callable;
import org.ametys.core.user.CurrentUserProvider;
import org.ametys.core.user.UserIdentity;
import org.ametys.core.util.DateUtils;
import org.ametys.core.util.LambdaUtils;
import org.ametys.plugins.core.user.UserHelper;
import org.ametys.plugins.queriesdirectory.Query.QueryProfile;
import org.ametys.plugins.queriesdirectory.Query.Visibility;
import org.ametys.plugins.repository.AmetysObject;
import org.ametys.plugins.repository.AmetysObjectIterable;
import org.ametys.plugins.repository.AmetysObjectResolver;
import org.ametys.plugins.repository.AmetysRepositoryException;
import org.ametys.plugins.repository.ModifiableTraversableAmetysObject;
import org.ametys.plugins.repository.MovableAmetysObject;
import org.ametys.plugins.repository.UnknownAmetysObjectException;
import org.ametys.runtime.plugin.component.AbstractLogEnabled;

import com.google.common.base.Predicates;
import com.google.common.collect.ImmutableMap;

/**
 * DAO for manipulating queries
 */
public class QueryDAO extends AbstractLogEnabled implements Serviceable, Component
{
    /** The Avalon role */
    public static final String ROLE = QueryDAO.class.getName();
    
    /** The alias id of the root {@link QueryContainer} */
    public static final String ROOT_QUERY_CONTAINER_ID = "root";
    
    private static final String __PLUGIN_NODE_NAME = "queriesdirectory";
    
    /** The current user provider */
    protected CurrentUserProvider _userProvider;
    /** The group manager */
    protected GroupManager _groupManager;
    
    /** The Ametys object resolver */
    private AmetysObjectResolver _resolver;

    private UserHelper _userHelper;

    private RightManager _rightManager;
    
    @Override
    public void service(ServiceManager serviceManager) throws ServiceException
    {
        _resolver = (AmetysObjectResolver) serviceManager.lookup(AmetysObjectResolver.ROLE);
        _userProvider = (CurrentUserProvider) serviceManager.lookup(CurrentUserProvider.ROLE);
        _groupManager = (GroupManager) serviceManager.lookup(GroupManager.ROLE);
        _userHelper = (UserHelper) serviceManager.lookup(UserHelper.ROLE);
        _rightManager = (RightManager) serviceManager.lookup(RightManager.ROLE);
    }
    
    /**
     * Get the root plugin storage object.
     * @return the root plugin storage object.
     * @throws AmetysRepositoryException if a repository error occurs.
     */
    public QueryContainer getQueriesRootNode() throws AmetysRepositoryException
    {
        try
        {
            return _getOrCreateRootNode();
        }
        catch (AmetysRepositoryException e)
        {
            throw new AmetysRepositoryException("Unable to get the queries root node", e);
        }
    }
    
    private QueryContainer _getOrCreateRootNode() throws AmetysRepositoryException
    {
        ModifiableTraversableAmetysObject pluginsNode = _resolver.resolveByPath("/ametys:plugins");
        
        ModifiableTraversableAmetysObject pluginNode = (ModifiableTraversableAmetysObject) _getOrCreateNode(pluginsNode, __PLUGIN_NODE_NAME, "ametys:unstructured");
        
        return (QueryContainer) _getOrCreateNode(pluginNode, "ametys:queries", QueryContainerFactory.QUERY_CONTAINER_NODETYPE);
    }
    
    private static AmetysObject _getOrCreateNode(ModifiableTraversableAmetysObject parentNode, String nodeName, String nodeType) throws AmetysRepositoryException
    {
        AmetysObject definitionsNode;
        if (parentNode.hasChild(nodeName))
        {
            definitionsNode = parentNode.getChild(nodeName);
        }
        else
        {
            definitionsNode = parentNode.createChild(nodeName, nodeType);
            parentNode.saveChanges();
        }
        return definitionsNode;
    }
    
    /**
     * Get queries' properties
     * @param queryIds The ids of queries to retrieve
     * @return The queries' properties
     */
    @Callable
    public Map<String, Object> getQueriesProperties(List<String> queryIds)
    {
        Map<String, Object> result = new HashMap<>();
        
        List<Map<String, Object>> queries = new LinkedList<>();
        List<Map<String, Object>> notAllowedQueries = new LinkedList<>();
        Set<String> unknownQueries = new HashSet<>();
        
        
        for (String id : queryIds)
        {
            try
            {
                Query query = _resolver.resolveById(id);
                
                if (_hasRight(query))
                {
                    queries.add(getQueryProperties(query));
                }
                else
                {
                    notAllowedQueries.add(getQueryProperties(query));
                }
            }
            catch (UnknownAmetysObjectException e)
            {
                unknownQueries.add(id);
            }
        }
        
        result.put("queries", queries);
        result.put("unknownQueries", unknownQueries);
        result.put("unknownQueries", unknownQueries);
        
        return result;
    }
    
    /**
     * Get the query properties
     * @param query The query
     * @return The query properties
     */
    public Map<String, Object> getQueryProperties (Query query)
    {
        Map<String, Object> infos = new HashMap<>();
        
        infos.put("isQuery", true);
        infos.put("id", query.getId());
        infos.put("title", query.getTitle());
        infos.put("type", query.getType());
        infos.put("description", query.getDescription());
        infos.put("author", _userHelper.user2json(query.getAuthor())); 
        infos.put("visibility", query.getVisibility().toString());
        infos.put("content", query.getContent());
        infos.put("lastModificationDate", DateUtils.dateToString(query.getLastModificationDate()));
        
        boolean isAdministrator = isAdministrator();
        infos.put("isAdministrator", isAdministrator);
        
        UserIdentity currentUser = _userProvider.getUser();
        infos.put("canRead", isAdministrator || query.canRead(currentUser));
        infos.put("canWrite", isAdministrator || query.canWrite(currentUser));
        
        return infos;
    }
    
    /**
     * Gets the ids of the path elements of a query or query container, i.e. the parent ids.
     * <br>For instance, if the query path is 'a/b/c', then the result list will be ["id-of-a", "id-of-b", "id-of-c"]
     * @param queryId The id of the query
     * @return the ids of the path elements of a query
     */
    @Callable
    public List<String> getIdsOfPath(String queryId)
    {
        AmetysObject queryOrQueryContainer = _resolver.resolveById(queryId);
        QueryContainer queriesRootNode = getQueriesRootNode();
        
        if (!(queryOrQueryContainer instanceof Query) && !(queryOrQueryContainer instanceof QueryContainer))
        {
            throw new IllegalArgumentException("The given id is not a query nor a query container");
        }
        
        List<String> pathElements = new ArrayList<>();
        QueryContainer current = queryOrQueryContainer.getParent();
        while (!queriesRootNode.equals(current))
        {
            pathElements.add(0, current.getId());
            current = current.getParent();
        }
        
        return pathElements;
    }
    
    /**
     * Determines if the current user has right to handle {@link QueryContainer}s
     * @return <code>true</code> if the current user has right to handle {@link QueryContainer}s
     */
    @Callable
    public boolean hasRightOnContainers()
    {
        return _rightManager.currentUserHasRight("QueriesDirectory_Rights_Containers", "/cms") == RightResult.RIGHT_ALLOW;
    }
    
    /**
     * Get the query container properties
     * @param id The query container id. Can be {@link #ROOT_QUERY_CONTAINER_ID} for the root container.
     * @return The query container properties
     */
    @Callable
    public Map<String, Object> getQueryContainerProperties(String id)
    {
        return getQueryContainerProperties(_getQueryContainer(id));
    }
    
    /**
     * Get the query container properties
     * @param queryContainer The query container
     * @return The query container properties
     */
    public Map<String, Object> getQueryContainerProperties(QueryContainer queryContainer)
    {
        Map<String, Object> infos = new HashMap<>();
        
        infos.put("isQuery", false);
        infos.put("id", queryContainer.getId());
        infos.put("title", queryContainer.getName());
        
        return infos;
    }
    
    /**
     * Creates a new {@link Query}
     * @param title The title of the query
     * @param desc The description of the query
     * @param type The type of the query
     * @param content The content of the query
     * @param parentId The id of the parent of the query. Use {@link #ROOT_QUERY_CONTAINER_ID} for the root container.
     * @return A result map
     */
    @Callable
    public Map<String, Object> createQuery(String title, String desc, String type, String content, String parentId)
    {
        Map<String, Object> results = new HashMap<>();
        
        QueryContainer queriesNode = _getQueryContainer(parentId);

        String name = FilterNameHelper.filterName(title);
        
        // Find unique name
        String uniqueName = name;
        int index = 2;
        while (queriesNode.hasChild(uniqueName))
        {
            uniqueName = name + "-" + (index++);
        }
        
        Query query = queriesNode.createChild(uniqueName, QueryFactory.QUERY_NODETYPE);
        query.setTitle(title);
        query.setDescription(desc);
        query.setAuthor(_userProvider.getUser());
        query.setType(type);
        query.setContent(content);
        query.setVisibility(Visibility.PRIVATE);
        query.setLastModificationDate(new Date());

        queriesNode.saveChanges();

        results.put("id", query.getId());
        
        return results;
    }
    
    /**
     * Creates a new {@link QueryContainer}
     * @param parentId The id of the parent. Use {@link #ROOT_QUERY_CONTAINER_ID} for the root container.
     * @param name The desired name for the new {@link QueryContainer}
     * @return A result map
     */
    @Callable(right = "QueriesDirectory_Rights_Containers", context = "/cms")
    public Map<String, Object> createQueryContainer(String parentId, String name)
    {
        Map<String, Object> results = new HashMap<>();
        
        QueryContainer parent = _getQueryContainer(parentId);
        
        int index = 2;
        String legalName = Text.escapeIllegalJcrChars(name);
        String realName = legalName;
        while (parent.hasChild(realName))
        {
            realName = legalName + " (" + index + ")";
            index++;
        }
        
        QueryContainer createdChild = parent.createChild(realName, QueryContainerFactory.QUERY_CONTAINER_NODETYPE);
        parent.saveChanges();
        
        results.put("id", createdChild.getId());
        results.put("name", realName);
        
        return results;
    }
    
    /**
     * Edits a {@link Query}
     * @param id The id of the query
     * @param title The title of the query
     * @param desc The description of the query
     * @return A result map
     */
    @Callable
    public Map<String, Object> updateQuery(String id, String title, String desc)
    {
        Map<String, Object> results = new HashMap<>();
        
        Query query = _resolver.resolveById(id);
        
        if (query.canWrite(_userProvider.getUser()))
        {
            query.setTitle(title);
            query.setDescription(desc);
            query.saveChanges();
        }
        else
        {
            results.put("message", "not-allowed");
        }
        
        results.put("id", query.getId());
        
        return results;
    }
    
    /**
     * Renames a {@link QueryContainer}
     * @param id The id of the query container
     * @param newName The new name of the container
     * @return A result map
     */
    @Callable(right = "QueriesDirectory_Rights_Containers", context = "/cms")
    public Map<String, Object> renameQueryContainer(String id, String newName)
    {
        Map<String, Object> results = new HashMap<>();
        
        QueryContainer query = _resolver.resolveById(id);
        
        String legalName = Text.escapeIllegalJcrChars(newName);
        Node node = query.getNode();
        try
        {
            node.getSession().move(node.getPath(), node.getParent().getPath() + '/' + legalName);
            node.getSession().save();
            
            results.put("id", id);
            results.put("newName", legalName);
        }
        catch (RepositoryException e)
        {
            getLogger().warn("Query container renaming failed.", e);
            results.put("message", "cannot-rename");
        }
        
        return results;
    }
    
    /**
     * Moves a {@link Query}
     * @param id The id of the query
     * @param newParentId The id of the new parent container of the query. Use {@link #ROOT_QUERY_CONTAINER_ID} for the root container.
     * @return A result map
     */
    @Callable
    public Map<String, Object> moveQuery(String id, String newParentId)
    {
        Map<String, Object> results = new HashMap<>();
        Query query = _resolver.resolveById(id);
        
        if (query.canWrite(_userProvider.getUser())
            || hasRightOnContainers())
        {
            _move(query, newParentId, results);
        }
        else
        {
            results.put("message", "not-allowed");
        }
        
        results.put("id", query.getId());
        return results;
    }
    
    /**
     * Moves a {@link QueryContainer}
     * @param id The id of the query container
     * @param newParentId The id of the new parent container of the query container. Use {@link #ROOT_QUERY_CONTAINER_ID} for the root container.
     * @return A result map
     */
    @Callable(right = "QueriesDirectory_Rights_Containers", context = "/cms")
    public Map<String, Object> moveQueryContainer(String id, String newParentId)
    {
        Map<String, Object> results = new HashMap<>();
        QueryContainer queryContainer = _resolver.resolveById(id);
        
        _move(queryContainer, newParentId, results);
        
        results.put("id", queryContainer.getId());
        results.put("name", queryContainer.getName());
        return results;
    }
    
    private void _move(MovableAmetysObject obj, String newParentId, Map<String, Object> results)
    {
        QueryContainer newParent = _getQueryContainer(newParentId);
        if (obj.canMoveTo(newParent))
        {
            try
            {
                obj.moveTo(newParent, false);
            }
            catch (AmetysRepositoryException e)
            {
                getLogger().warn("Query moving failed.", e);
                results.put("message", "cannot-move");
            }
        }
        else
        {
            results.put("message", "cannot-move");
        }
    }
    
    private QueryContainer _getQueryContainer(String id)
    {
        QueryContainer container;
        if (ROOT_QUERY_CONTAINER_ID.equals(id))
        {
            container = getQueriesRootNode();
        }
        else
        {
            container = _resolver.resolveById(id);
        }
        return container;
    }
    
    /**
     * Saves a {@link Query}
     * @param id The id of the query
     * @param type The type of the query
     * @param content The content of the query
     * @return A result map
     */
    @Callable
    public Map<String, Object> saveQuery(String id, String type, String content)
    {
        Map<String, Object> results = new HashMap<>();
        
        Query query = _resolver.resolveById(id);
        
        if (query.canWrite(_userProvider.getUser()))
        {
            query.setType(type);
            query.setContent(content);
            query.saveChanges();
        }
        else
        {
            results.put("message", "not-allowed");
        }
        
        results.put("id", query.getId());
        
        return results;
    }
    
    /**
     * Deletes {@link Query}(ies)
     * @param ids The ids of the queries to delete
     * @return A result map
     */
    @Callable
    public Map<String, Object> deleteQuery(List<String> ids)
    {
        Map<String, Object> results = new HashMap<>();
        
        List<String> deletedQueries = new ArrayList<>();
        List<String> unknownQueries = new ArrayList<>();
        List<String> notallowedQueries = new ArrayList<>();
         
        for (String id : ids)
        {
            try
            {
                Query query = _resolver.resolveById(id);
                
                UserIdentity author = query.getAuthor();
                if (author != null && author.equals(_userProvider.getUser()))
                {
                    query.remove();
                    query.saveChanges();
                    deletedQueries.add(id);
                }
                else
                {
                    notallowedQueries.add(query.getTitle());
                }
            }
            catch (UnknownAmetysObjectException e)
            {
                unknownQueries.add(id);
                getLogger().error("Unable to delete query. The query of id '" + id + " doesn't exist", e);
            }
        }
        
        results.put("deletedQueries", deletedQueries);
        results.put("notallowedQueries", notallowedQueries);
        results.put("unknownQueries", unknownQueries);
        
        return results;
    }
    
    /**
     * Can the current user delete all the {@link QueryContainer}s from the list ?
     * @param ids The {@link QueryContainer} ids
     * @return <code>true</code> if he can
     */
    protected boolean canDeleteAllQueryContainers(List<String> ids)
    {
        return canDeleteQueryContainers(ids).values()
                .stream()
                .allMatch(Boolean.TRUE::equals);
    }
    
    /**
     * Determines if the current user can delete the given {@link QueryContainer}s
     * @param ids The {@link QueryContainer} ids
     * @return A map with <code>true</code> for each id if the current user can delete the associated {@link QueryContainer}
     */
    @Callable
    public Map<String, Boolean> canDeleteQueryContainers(List<String> ids)
    {
        return ids.stream()
                .collect(Collectors.toMap(
                        Function.identity(), 
                        LambdaUtils.wrap(this::_canDeleteQueryContainer)));
    }
    
    private boolean _canDeleteQueryContainer(String id)
    {
        if (ROOT_QUERY_CONTAINER_ID.equals(id))
        {
            return false;
        }
        else
        {
            UserIdentity user = _userProvider.getUser();
            Set<GroupIdentity> userGroups = _groupManager.getUserGroups(user);
            QueryContainer container = _resolver.resolveById(id);
            
            org.ametys.plugins.queriesdirectory.QueryHelper.Visibility visibility = org.ametys.plugins.queriesdirectory.QueryHelper.Visibility.of(user, userGroups);
            AmetysObjectIterable<Query> queriesInWriteAccess = getChildQueriesInWriteAccess(container, false, visibility, Optional.empty());
            AmetysObjectIterable<Query> allQueries = getChildQueriesForAdministrator(container, false, Optional.empty());
            return allQueries.getSize() == queriesInWriteAccess.getSize(); // if different collections, then it means the current user has not the write access on at least one query
        }
    }
    
    /**
     * Determines if application must warn before deleting the given {@link QueryContainer}s
     * @param ids The {@link QueryContainer} ids
     * @return <code>true</code> if application must warn
     */
    @Callable
    public boolean mustWarnBeforeDeletion(List<String> ids)
    {
        return ids.stream()
                .anyMatch(LambdaUtils.wrapPredicate(this::_mustWarnBeforeDeletion));
    }
    
    private boolean _mustWarnBeforeDeletion(String id)
    {
        QueryContainer container = _resolver.resolveById(id);
        AmetysObjectIterable<Query> allQueries = getChildQueriesForAdministrator(container, false, Optional.empty());
        return _containsNotOwnQueries(allQueries) || _containsSharedQueries(allQueries);
    }
    
    private boolean _containsNotOwnQueries(AmetysObjectIterable<Query> allQueries)
    {
        UserIdentity currentUser = _userProvider.getUser();
        return allQueries.stream()
                .map(Query::getAuthor)
                .anyMatch(Predicates.not(currentUser::equals));
    }
    
    private boolean _containsSharedQueries(AmetysObjectIterable<Query> allQueries)
    {
        return allQueries.stream()
                .map(Query::getVisibility)
                .anyMatch(Predicates.not(Visibility.PRIVATE::equals));
    }
    
    
    /**
     * Deletes {@link QueryContainer}(s)
     * @param ids The ids of the query containers to delete
     * @return A result map
     */
    @Callable(right = "QueriesDirectory_Rights_Containers", context = "/cms")
    public Map<String, Object> deleteQueryContainer(List<String> ids)
    {
        Map<String, Object> results = new HashMap<>();
        
        List<Map<String, Object>> allDeleted = new ArrayList<>();
        List<Map<String, Object>> allUnknown = new ArrayList<>();
        
        if (!canDeleteAllQueryContainers(ids))
        {
            results.put("message", "not-allowed");
            return results;
        }
        
        for (String id : ids)
        {
            try
            {
                QueryContainer container = _resolver.resolveById(id);
                String name = container.getName();
                container.remove();
                container.saveChanges();
                Map<String, Object> deleted = ImmutableMap.of("id", id, "name", name);
                allDeleted.add(deleted);
            }
            catch (UnknownAmetysObjectException e)
            {
                Map<String, Object> unknown = ImmutableMap.of("id", id, "name", id);
                allUnknown.add(unknown);
                getLogger().error("Unable to delete query container. The container of id '" + id + " doesn't exist", e);
            }
        }
        
        results.put("deleted", allDeleted);
        results.put("unknown", allUnknown);
        
        return results;
    }
    
    /**
     * Changes the visibility of a {@link Query}
     * @param queryId The id of the query
     * @param visibilityStr The new visibility
     * @return A result map
     */
    @Callable
    public Map<String, Object> changeVisibility(String queryId, String visibilityStr)
    {
        Map<String, Object> results = new HashMap<>();
        
        // Parameter checks.
        Query query = null;
        if (StringUtils.isNotEmpty(queryId))
        {
            query = _resolver.resolveById(queryId);
        }
        else
        {
            throw new IllegalArgumentException("Mandatory query id parameter is missing.");
        }
        
        Visibility visibility = Visibility.valueOf(visibilityStr.toUpperCase());
        
        UserIdentity author = query.getAuthor();
        if (author != null && author.equals(_userProvider.getUser()))
        {
            query.setVisibility(visibility);
            query.saveChanges();
        }
        else
        {
            results.put("message", "not-allowed");
        }
        
        return results;
    }
    
    /**
     * Assign rights to the given users on the given query
     * @param queryId The query id
     * @param profileId The profile id
     * @param users The users to grant
     * @return A result map
     */
    @Callable
    public Map<String, Object> addGrantedUsers(String queryId, String profileId, List<Map<String, String>> users)
    {
        return _assignRights(queryId, profileId, "users", users, null);
    }
    
    /**
     * Assign rigths to the given groups on the given query
     * @param queryId The query id
     * @param profileId The profile id
     * @param groups The groups to grant
     * @return A result map
     */
    @Callable
    public Map<String, Object> addGrantedGroups(String queryId, String profileId, List<Map<String, String>> groups)
    {
        return _assignRights(queryId, profileId, "groups", null, groups);
    }
    
    private Map<String, Object> _assignRights(String queryId, String profileId, String type, List<Map<String, String>> users, List<Map<String, String>> groups)
    {
        HashMap<String, Object> results = new HashMap<>();
        
        // Parameter checks.
        Query query = null;
        if (StringUtils.isNotEmpty(queryId))
        {
            query = _resolver.resolveById(queryId);
        }
        else
        {
            throw new IllegalArgumentException("Mandatory query id parameter is missing.");
        }
        
        if (!"users".equals(type) && !"groups".equals(type))
        {
            throw new IllegalArgumentException("Unexpected type parameter : " + type);
        }
        
        if (!"read_access".equals(profileId) && !"write_access".equals(profileId))
        {
            throw new IllegalArgumentException("Unexpected profile identifier : " + profileId);
        }
        
        UserIdentity author = query.getAuthor();
        if (author != null && author.equals(_userProvider.getUser()))
        {
            QueryProfile profile = QueryProfile.valueOf(profileId.toUpperCase());
            
            // Set new values
            if ("users".equals(type))
            {
                Set<UserIdentity> allEntries = query.getGrantedUsers(profile);
                
                for (Map<String, String> user : users)
                {
                    UserIdentity userIdentity = new UserIdentity(user.get("login"), user.get("populationId"));
                    if (!allEntries.contains(userIdentity))
                    {
                        allEntries.add(userIdentity);
                    }
                }
                
                query.setGrantedUsers(profile, allEntries);
            }
            else
            {
                Set<GroupIdentity> allEntries = query.getGrantedGroups(profile);
                
                for (Map<String, String> group : groups)
                {
                    GroupIdentity groupIdentity = new GroupIdentity(group.get("id"), group.get("groupDirectory"));
                    if (!allEntries.contains(groupIdentity))
                    {
                        allEntries.add(groupIdentity);
                    }
                }
                
                query.setGrantedGroups(profile, allEntries);
            }
            
            // Save
            query.saveChanges();
        }
        else
        {
            results.put("message", "not-allowed");
        }
        
        return results;
    }
    
    /**
     * Remove rights to the given users on the given query
     * @param queryId The query id
     * @param profileId The profile id
     * @param users The users to remove
     * @param groups The groups to remove
     * @return A result map
     */
    @Callable
    public Map<String, Object> removeAssignment(String queryId, String profileId, List<Map<String, String>> users, List<Map<String, String>> groups)
    {
        HashMap<String, Object> results = new HashMap<>();
        
        // Parameter checks.
        Query query = null;
        if (StringUtils.isNotEmpty(queryId))
        {
            query = _resolver.resolveById(queryId);
        }
        else
        {
            throw new IllegalArgumentException("Mandatory query id parameter is missing.");
        }
        if (!"read_access".equals(profileId) && !"write_access".equals(profileId))
        {
            throw new IllegalArgumentException("Unexpected profile identifier : " + profileId);
        }
        
        UserIdentity author = query.getAuthor();
        if (author != null && author.equals(_userProvider.getUser()))
        {
            QueryProfile profile = QueryProfile.valueOf(profileId.toUpperCase());
            
            if (!users.isEmpty())
            {
                Set<UserIdentity> grantedUsers = query.getGrantedUsers(profile);
                for (Map<String, String> user : users)
                {
                    UserIdentity userIdentity = new UserIdentity(user.get("login"), user.get("populationId"));
                    grantedUsers.remove(userIdentity);
                }
                
                query.setGrantedUsers(profile, grantedUsers);
            }
            
            if (!groups.isEmpty())
            {
                Set<GroupIdentity> grantedGroups = query.getGrantedGroups(profile);
                for (Map<String, String> group : groups)
                {
                    GroupIdentity groupIdentity = new GroupIdentity(group.get("id"), group.get("groupDirectory"));
                    grantedGroups.remove(groupIdentity);
                }
                
                query.setGrantedGroups(profile, grantedGroups);
            }
            
            // Save
            query.saveChanges();
        }
        else
        {
            results.put("message", "not-allowed");
        }
        
        return results;
    }
    
    /**
     * Determines if the current user is administrator of queries
     * @return <code>true</code> if current user is administrator 
     */
    public boolean isAdministrator()
    {
        return _rightManager.hasRight(_userProvider.getUser(), "QueriesDirectory_Rights_Admin", "/cms") == RightResult.RIGHT_ALLOW;
    }
    
    /**
     * Test if the current user has the right required to access the query
     * @param query The query
     * @return true if the user has the right needed, false otherwise.
     */
    protected boolean _hasRight(Query query)
    {
        UserIdentity user = _userProvider.getUser();
        return query.canRead(user) || isAdministrator();
    }
    
    /**
     * Gets all queries for administrator for given parent
     * @param parent The {@link QueryContainer}, defining the context from which getting children
     * @param onlyDirect <code>true</code> in order to have only direct child queries from parent path, <code>false</code> otherwise to have all queries at any level underneath the parent path
     * @param type The query type
     * @return all queries for administrator for given parent
     */
    public AmetysObjectIterable<Query> getChildQueriesForAdministrator(QueryContainer parent, boolean onlyDirect, Optional<String> type)
    {
        return _resolver.query(QueryHelper.getXPathForQueriesForAdministrator(parent, onlyDirect, type));
    }
    
    /**
     * Gets all queries in READ access for given parent
     * @param parent The {@link QueryContainer}, defining the context from which getting children
     * @param onlyDirect <code>true</code> in order to have only direct child queries from parent path, <code>false</code> otherwise to have all queries at any level underneath the parent path
     * @param visibility The user and its groups for checking visibility
     * @param type The query type
     * @return all queries in READ access for given parent
     */
    public AmetysObjectIterable<Query> getChildQueriesInReadAccess(QueryContainer parent, boolean onlyDirect, QueryHelper.Visibility visibility, Optional<String> type)
    {
        return _resolver.query(QueryHelper.getXPathForQueriesInReadAccess(parent, onlyDirect, visibility, type));
    }
    
    /**
     * Gets all queries in WRITE access for given parent
     * @param parent The {@link QueryContainer}, defining the context from which getting children
     * @param onlyDirect <code>true</code> in order to have only direct child queries from parent path, <code>false</code> otherwise to have all queries at any level underneath the parent path
     * @param visibility The user and its groups for checking visibility
     * @param type The query type
     * @return all queries in WRITE access for given parent
     */
    public AmetysObjectIterable<Query> getChildQueriesInWriteAccess(QueryContainer parent, boolean onlyDirect, QueryHelper.Visibility visibility, Optional<String> type)
    {
        return _resolver.query(QueryHelper.getXPathForQueriesInWriteAccess(parent, onlyDirect, visibility, type));
    }
    
    /**
     * Gets all query containers for given parent
     * @param parent The {@link QueryContainer}, defining the context from which getting children
     * @return all query containers for given parent
     */
    public AmetysObjectIterable<QueryContainer> getChildQueryContainers(QueryContainer parent)
    {
        return _resolver.query(QueryHelper.getXPathForQueryContainers(parent));
    }
}