/*
 *  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.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.lang3.StringUtils;

import org.ametys.cms.FilterNameHelper;
import org.ametys.core.group.GroupIdentity;
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.plugins.core.user.UserHelper;
import org.ametys.plugins.queriesdirectory.Query.QueryProfile;
import org.ametys.plugins.queriesdirectory.Query.Visibility;
import org.ametys.plugins.repository.AmetysObjectResolver;
import org.ametys.plugins.repository.ModifiableTraversableAmetysObject;
import org.ametys.plugins.repository.UnknownAmetysObjectException;
import org.ametys.runtime.parameter.ParameterHelper;
import org.ametys.runtime.plugin.component.AbstractLogEnabled;

/**
 * DAO for manipulating queries
 */
public class QueryDAO extends AbstractLogEnabled implements Serviceable, Component
{
    /** The Avalon role */
    public static final String ROLE = QueryDAO.class.getName();
    
    /** The current user provider */
    protected CurrentUserProvider _userProvider;
    
    /** 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);
        _userHelper = (UserHelper) serviceManager.lookup(UserHelper.ROLE);
        _rightManager = (RightManager) serviceManager.lookup(RightManager.ROLE);
    }
    
    /**
     * 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("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", ParameterHelper.valueToString(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;
    }
    
    /**
     * 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
     * @return The id of created query
     */
    @Callable
    public String createQuery(String title, String desc, String type, String content)
    {
        ModifiableTraversableAmetysObject queriesNode = QueryHelper.getQueriesRootNode(_resolver);

        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();

        return query.getId();
    }
    
    /**
     * 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;
    }
    
    /**
     * 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;
    }
    
    /**
     * 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();
    }
}