/*
 *  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.core.user;

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

import org.apache.avalon.framework.activity.Initializable;
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.tuple.Pair;

import org.ametys.core.cache.AbstractCacheManager;
import org.ametys.core.cache.Cache;
import org.ametys.core.cache.CacheException;
import org.ametys.core.user.directory.NotUniqueUserException;
import org.ametys.core.user.directory.StoredUser;
import org.ametys.core.user.directory.UserDirectory;
import org.ametys.core.user.population.PopulationContextHelper;
import org.ametys.core.user.population.UserPopulation;
import org.ametys.core.user.population.UserPopulationDAO;
import org.ametys.core.util.LambdaUtils;
import org.ametys.core.util.LambdaUtils.LambdaException;
import org.ametys.plugins.core.user.UserHelper;
import org.ametys.runtime.i18n.I18nizableText;
import org.ametys.runtime.plugin.component.AbstractLogEnabled;

/**
 * Component for getting user list and verify the presence of a particular user on a context or for user directory(ies).
 */
public class UserManager extends AbstractLogEnabled implements Component, Serviceable, Initializable
{
    /** Avalon Role */
    public static final String ROLE = UserManager.class.getName();

    private static final String __USER_CACHE_ID = UserHelper.class.getName() + "$userCache";
    
    private static final String __USER_CACHE_BY_EMAIL_ID = UserHelper.class.getName() + "$userByEmailCache";
    
    /** The DAO for User Population */
    protected UserPopulationDAO _userPopulationDAO;
    /** The helper for the associations population/context */
    protected PopulationContextHelper _populationContextHelper;

    private AbstractCacheManager _abstractCacheManager;
    
    @Override
    public void service(ServiceManager manager) throws ServiceException
    {
        _userPopulationDAO = (UserPopulationDAO) manager.lookup(UserPopulationDAO.ROLE);
        _populationContextHelper = (PopulationContextHelper) manager.lookup(PopulationContextHelper.ROLE);
        _abstractCacheManager = (AbstractCacheManager) manager.lookup(AbstractCacheManager.ROLE);
    }

    @Override
    public void initialize() throws Exception
    {
        _abstractCacheManager.createRequestCache(__USER_CACHE_ID,
                new I18nizableText("plugin.core", "PLUGINS_CORE_CACHE_USER_BY_USER_IDENTITY_LABEL"),
                new I18nizableText("plugin.core", "PLUGINS_CORE_CACHE_USER_BY_USER_IDENTITY_DESCRIPTION"),
                true);
        _abstractCacheManager.createRequestCache(__USER_CACHE_BY_EMAIL_ID,
                new I18nizableText("plugin.core", "PLUGINS_CORE_CACHE_USER_BY_EMAIL_LABEL"),
                new I18nizableText("plugin.core", "PLUGINS_CORE_CACHE_USER_BY_EMAIL_DESCRIPTION"),
                true);
    }
    
    /**
     * Get the list of users on some given contexts
     * @param contexts The contexts
     * @param checkRight True to check that current user belongs to one of populations on theses contexts or he's an administrator user
     * @return the collection of users
     */
    public Collection<User> getUsersByContext(Set<String> contexts, boolean checkRight)
    {
        List<UserPopulation> userPopulations = _populationContextHelper.getUserPopulationsOnContexts(contexts, false, checkRight).stream()
            .map(upId -> _userPopulationDAO.getUserPopulation(upId))
            .collect(Collectors.toList());
        
        return getUsersByPopulations(userPopulations);
    }
    
    /**
     * Get the users for given users' populations
     * @param userPopulationIds the id of population of users
     * @return the collection of users
     */
    public Collection<User> getUsersByPopulationIds(List<String> userPopulationIds)
    {
        List<User> users = new ArrayList<>();
        for (String id : userPopulationIds)
        {
            UserPopulation userPopulation = _userPopulationDAO.getUserPopulation(id);
            if (userPopulation != null)
            {
                for (User user : getUsers(userPopulation))
                {
                    if (!users.contains(user))
                    {
                        users.add(user);
                    }
                }
            }
        }
        return users;
    }
    
    /**
     * Get the users for given users' populations
     * @param userPopulations the population of users
     * @return the collection of users
     */
    public Collection<User> getUsersByPopulations(List<UserPopulation> userPopulations)
    {
        List<User> users = new ArrayList<>();
        for (UserPopulation userPopulation : userPopulations)
        {
            for (User user : getUsers(userPopulation))
            {
                if (!users.contains(user))
                {
                    users.add(user);
                }
            }
        }
        return users;
    }
    
    /**
     * Gets all the users of a {@link UserPopulation}
     * @param userPopulationId The ID of user population
     * @return list of users as Collection of {@link User}s, empty if a problem occurs.
     */
    public Collection<User> getUsers(String userPopulationId)
    {
        UserPopulation userPopulation = _userPopulationDAO.getUserPopulation(userPopulationId);
        if (userPopulation != null)
        {
            return getUsers(userPopulation);
        }
        else
        {
            return Collections.EMPTY_LIST;
        }
    }
    
    /**
     * Gets all the users of a {@link UserPopulation}
     * @param userPopulation The user population
     * @return list of users as Collection of {@link User}s, empty if a problem occurs.
     */
    public Collection<User> getUsers(UserPopulation userPopulation)
    {
        List<User> users = new ArrayList<>();
        
        for (UserDirectory ud : userPopulation.getUserDirectories())
        {
            Collection<User> usersOfUd = _storedUsers2Users(ud.getStoredUsers(), ud);
            for (User user : usersOfUd)
            {
                if (!users.contains(user))
                {
                    users.add(user);
                }
            }
        }
        
        return users;
    }
    
    /**
     * Get a list of users given the parameters
     * @param contexts The contexts
     * @param count The limit of users to retrieve
     * @param offset The number of result to ignore before starting to collect users.
     * @param parameters A map of additional parameters, see implementation.
     * @param checkRight True to check that current user belongs to one of populations on theses contexts or he's an administrator user
     * @param sort true to sort users
     * @return The list of retrieved {@link User}
     */
    public List<User> getUsersByContext(Set<String> contexts, int count, int offset, Map<String, Object> parameters, boolean checkRight, boolean sort)
    {
        List<UserPopulation> userPopulations = _populationContextHelper.getUserPopulationsOnContexts(contexts, false, checkRight).stream()
                .map(upId -> _userPopulationDAO.getUserPopulation(upId))
                .collect(Collectors.toList());
        
        return getUsers(userPopulations, count, offset, parameters, sort);
    }
    
    /**
     * Get a list of users given the parameters
     * @param userPopulations the population of users
     * @param count The limit of users to retrieve
     * @param offset The number of result to ignore before starting to collect users.
     * @param parameters A map of additional parameters, see implementation.
     * @param sort true to sort users
     * @return The list of retrieved {@link User}
     */
    public List<User> getUsers(List<UserPopulation> userPopulations, int count, int offset, Map<String, Object> parameters, boolean sort)
    {
        List<User> users = new ArrayList<>();
        for (UserPopulation userPopulation : userPopulations)
        {
            for (User user : getUsers(userPopulation, count + offset, 0, parameters, sort))
            {
                if (!users.contains(user))
                {
                    users.add(user);
                }
            }
        }
        
        int boundedCount = count >= 0 ? count : Integer.MAX_VALUE;
        int boundedOffset = offset >= 0 ? offset : 0;
        int toIndex;
        if (boundedOffset + boundedCount >= 0)
        {
            toIndex = Math.min(boundedOffset + boundedCount, users.size());
        }
        else
        {
            // particular case where count was initially negative (to say "no limit") and we set it to Integer.MAX_VALUE
            // so if the offset is strictly positive, the sum overflows
            toIndex = users.size();
        }
        return users.subList(boundedOffset, toIndex);
    }
    
    /**
     * Gets all the users of a {@link UserPopulation}
     * @param userPopulationId The ID of user population
     * @param count The limit of users to retrieve
     * @param offset The number of result to ignore before starting to collect users.
     * @param parameters A map of additional parameters, see implementation.
     * @param sort true to sort users
     * @return list of users as Collection of {@link User}s, empty if a problem occurs.
     */
    public Collection<User> getUsers(String userPopulationId, int count, int offset, Map<String, Object> parameters, boolean sort)
    {
        UserPopulation userPopulation = _userPopulationDAO.getUserPopulation(userPopulationId);
        if (userPopulation != null)
        {
            return getUsers(userPopulation, count, offset, parameters, sort);
        }
        else
        {
            return Collections.EMPTY_LIST;
        }
    }
    
    /**
     * Gets all the users of a given {@link UserPopulation} and {@link UserDirectory}
     * @param userPopulationId The ID of user population
     * @param userDirectoryId The id of the user directory
     * @param count The limit of users to retrieve
     * @param offset The number of result to ignore before starting to collect users.
     * @param parameters A map of additional parameters, see implementation.
     * @return list of users as Collection of {@link User}s, empty if a problem occurs.
     */
    public Collection<User> getUsersByDirectory(String userPopulationId, String userDirectoryId, int count, int offset, Map<String, Object> parameters)
    {
        UserPopulation userPopulation = _userPopulationDAO.getUserPopulation(userPopulationId);
        
        if (userPopulation == null)
        {
            return Collections.EMPTY_LIST;
        }
        
        UserDirectory ud = userPopulation.getUserDirectory(userDirectoryId);
        if (ud == null)
        {
            throw new IllegalArgumentException("In the population '" + userPopulationId + "' the directory '" + userDirectoryId + "' was referenced but does not exists");
        }
        return _storedUsers2Users(ud.getStoredUsers(count, offset, parameters), ud);
    }
    
    /**
     * Gets all the users of a {@link UserPopulation}
     * @param userPopulation The users population
     * @param count The limit of users to retrieve
     * @param offset The number of result to ignore before starting to collect users.
     * @param parameters A map of additional parameters, see implementation.
     * @param sort true to sort users
     * @return list of users as Collection of {@link User}s, empty if a problem occurs.
     */
    public Collection<User> getUsers(UserPopulation userPopulation, int count, int offset, Map<String, Object> parameters, boolean sort)
    {
        Set<User> users = new HashSet<>();
        
        for (UserDirectory ud : userPopulation.getUserDirectories())
        {
            users.addAll(_storedUsers2Users(ud.getStoredUsers(count + offset, 0, parameters), ud));
        }
        
        int boundedCount = count >= 0 ? count : Integer.MAX_VALUE;
        int boundedOffset = offset >= 0 ? offset : 0;
        int toIndex;
        if (boundedOffset + boundedCount >= 0)
        {
            toIndex = Math.min(boundedOffset + boundedCount, users.size());
        }
        else
        {
            // particular case where count was initially negative (to say "no limit") and we set it to Integer.MAX_VALUE
            // so if the offset is strictly positive, the sum overflows
            toIndex = users.size();
        }
        
        
        // Use isTrue as sort parameter can be null
        List<User> usersList = new ArrayList<>(users);
        if (sort)
        {
            usersList.sort(Comparator.comparing(UserManager::_getSortableNameLowerCase));
        }
        
        return usersList.subList(boundedOffset, toIndex);
    }
    
    private static String _getSortableNameLowerCase(User user)
    {
        return user.getSortableName().toLowerCase();
    }
    
    /**
     * Gets all the users of a {@link UserPopulation}
     * @param userPopulation The users population
     * @param userDirectoryId The id of the user directory
     * @param count The limit of users to retrieve
     * @param offset The number of result to ignore before starting to collect users.
     * @param parameters A map of additional parameters, see implementation.
     * @return list of users as Collection of {@link User}s, empty if a problem occurs.
     */
    public Collection<User> getUsersByDirectory(UserPopulation userPopulation, String userDirectoryId, int count, int offset, Map<String, Object> parameters)
    {
        UserDirectory ud = userPopulation.getUserDirectory(userDirectoryId);
        return _storedUsers2Users(ud.getStoredUsers(count, offset, parameters), ud);
    }
    
    /**
     * Get a user by his login on some given contexts
     * @param contexts The contexts
     * @param login Login of the user to get. Cannot be null.
     * @param checkRight True to check that current user is authorized to retrieve this user (true if he belongs to one of populations on theses contexts or he's an administrator user)
     * @return User's information as a {@link User} instance or null if the user login does not exist.
     */
    public User getUserByContext(Set<String> contexts, String login, boolean checkRight)
    {
        Set<String> upIds = _populationContextHelper.getUserPopulationsOnContexts(contexts, false, checkRight);
        for (String upId : upIds)
        {
            UserPopulation userPopulation = _userPopulationDAO.getUserPopulation(upId);
            User user = getUser(userPopulation, login);
            if (user != null)
            {
                return user;
            }
        }
        return null;
    }
    
    /**
     * Get the user from its user identity
     * @param userIdentity The user identity
     * @return The User or null if the user login does not exist.
     */
    public User getUser (UserIdentity userIdentity)
    {
        if (userIdentity == null)
        {
            return null;
        }
        
        Cache<UserIdentity, User> cache = _getUserCache();
        return cache.get(userIdentity, key ->
        {
            UserPopulation userPopulation = _userPopulationDAO.getUserPopulation(key.getPopulationId());
            if (userPopulation != null)
            {
                return getUser(userPopulation, key.getLogin());
            }
            else
            {
                return null;
            }
        });
    }
    
    /**
     * Get a particular user of the given users population by his login.
     * @param userPopulationId The ID of user population
     * @param login Login of the user to get. Cannot be null.
     * @return User's information as a {@link User} instance or null if the user login does not exist.
     */
    public User getUser(String userPopulationId, String login)
    {
        UserIdentity userIdentity = new UserIdentity(login, userPopulationId);
        return getUser(userIdentity);
    }

    private Cache<UserIdentity, User> _getUserCache()
    {
        return _abstractCacheManager.get(__USER_CACHE_ID);
    }
    
    /**
     * Get a particular user of the given users population by his email.
     * @param userPopulationIds The IDs of user population
     * @param email Email of the user to get. Cannot be null.
     * @return User's information as a {@link User} instance or null if the user login does not exist.
     * @throws NotUniqueUserException if many users match the given email
     */
    public User getUserByEmail(Set<String> userPopulationIds, String email) throws NotUniqueUserException
    {
        if (email == null)
        {
            return null;
        }
        
        User user = null;
        for (String populationId : userPopulationIds)
        {
            User u = getUserByEmail(populationId, email);
            if (u != null)
            {
                if (user == null)
                {
                    user = u;
                }
                else
                {
                    throw new NotUniqueUserException("Cannot find user in populations '" + userPopulationIds + "' by email '" + email + "' because 2 or more users match (at least " + UserIdentity.userIdentityToString(u.getIdentity()) + " and " + UserIdentity.userIdentityToString(user.getIdentity()) + ")");
                }
            }
        }
        
        return user;
    }
    
    /**
     * Get a particular user of the given users population by his email.
     * @param userPopulationId The ID of user population
     * @param email Email of the user to get. Cannot be null.
     * @return User's information as a {@link User} instance or null if the user login does not exist.
     * @throws NotUniqueUserException if many users match the given email
     */
    public User getUserByEmail(String userPopulationId, String email) throws NotUniqueUserException
    {
        if (email == null)
        {
            return null;
        }

        Cache<Pair<String, String>, User> cache = _getUserByEmailCache();
        try
        {
            return cache.get(Pair.of(userPopulationId, email), LambdaUtils.wrap(key ->
            {
                UserPopulation userPopulation = _userPopulationDAO.getUserPopulation(userPopulationId);
                if (userPopulation != null)
                {
                    return getUserByEmail(userPopulation, email);
                }
                else
                {
                    return null;
                }
            }));
        }
        catch (CacheException e)
        {
            if (e.getCause() instanceof LambdaException)
            {
                if (e.getCause().getCause() instanceof NotUniqueUserException)
                {
                    throw (NotUniqueUserException) e.getCause().getCause();
                }
                else
                {
                    throw new RuntimeException(e.getCause().getCause());
                }
            }
            throw new RuntimeException(e.getCause());
        }
    }

    private Cache<Pair<String, String>, User> _getUserByEmailCache()
    {
        return _abstractCacheManager.get(__USER_CACHE_BY_EMAIL_ID);
    }
    
    /**
     * Get a particular user of the given user population and given user directory by his login.
     * @param userPopulationId The ID of user population
     * @param userDirectoryId The id of the user directory
     * @param login Login of the user to get. Cannot be null.
     * @return User's information as a {@link User} instance or null if the user login does not exist.
     */
    public User getUserByDirectory(String userPopulationId, String userDirectoryId, String login)
    {
        UserPopulation userPopulation = _userPopulationDAO.getUserPopulation(userPopulationId);
        if (userPopulation != null)
        {
            return getUserByDirectory(userPopulation, userDirectoryId, login);
        }
        else
        {
            return null;
        }
    }
    
    /**
     * Get a particular user of the given user population by his login.
     * @param userPopulation The user population
     * @param login Login of the user to get. Cannot be null.
     * @return User's information as a {@link User} instance or null if the user login does not exist.
     */
    public User getUser(UserPopulation userPopulation, String login)
    {
        for (UserDirectory ud : userPopulation.getUserDirectories())
        {
            StoredUser storedUser = ud.getStoredUser(login);
            if (storedUser != null)
            {
                return _storedUser2User(storedUser, ud);
            }
        }
        return null;
    }
    
    /**
     * Get a particular user of the given user population by his email.
     * @param userPopulation The user population
     * @param email Email of the user to get. Cannot be null.
     * @return User's information as a {@link User} instance or null if the user login does not exist.
     * @throws NotUniqueUserException if many users match the given email
     */
    public User getUserByEmail(UserPopulation userPopulation, String email) throws NotUniqueUserException
    {
        for (UserDirectory ud : userPopulation.getUserDirectories())
        {
            StoredUser storedUser = ud.getStoredUserByEmail(email);
            if (storedUser != null)
            {
                return _storedUser2User(storedUser, ud);
            }
        }
        return null;
    }

    /**
     * Get a particular user of the given user directory by his email.
     * @param userDirectory The user directory
     * @param email Email of the user to get. Cannot be null.
     * @return User's information as a {@link User} instance or null if the user login does not exist.
     * @throws NotUniqueUserException if many users match the given email
     */
    public User getUserByUserDirectoryAndEmail(UserDirectory userDirectory, String email) throws NotUniqueUserException
    {
        StoredUser storedUser = userDirectory.getStoredUserByEmail(email);
        if (storedUser != null)
        {
            return _storedUser2User(storedUser, userDirectory);
        }
        
        return null;
    }
    
    /**
     * Get a particular user of the given user population and given user directory by his login.
     * @param userPopulation The user population
     * @param userDirectoryId The id of the user directory
     * @param login Login of the user to get. Cannot be null.
     * @return User's information as a {@link User} instance or null if the user login does not exist.
     */
    public User getUserByDirectory(UserPopulation userPopulation, String userDirectoryId, String login)
    {
        UserDirectory ud = userPopulation.getUserDirectory(userDirectoryId);
        
        StoredUser storedUser = ud.getStoredUser(login);
        if (storedUser != null)
        {
            return _storedUser2User(storedUser, ud);
        }
        
        return null;
    }
    
    /**
     * Get a particular user of the given user directory by his login.
     * @param userDirectory The user directory
     * @param login Login of the user to get. Cannot be null.
     * @return User's information as a {@link User} instance or null if the user login does not exist.
     */
    public User getUserByDirectory(UserDirectory userDirectory, String login)
    {
        StoredUser storedUser = userDirectory.getStoredUser(login);
        if (storedUser != null)
        {
            return _storedUser2User(storedUser, userDirectory);
        }
        
        return null;
    }
    
    /**
     * Get the user directory the given user belongs to
     * @param userPopulationId The id of the user population
     * @param login Login of the user to get. Cannot be null.
     * @return The user directory the user belongs to.
     */
    public UserDirectory getUserDirectory(String userPopulationId, String login)
    {
        UserPopulation userPopulation = _userPopulationDAO.getUserPopulation(userPopulationId);
        if (userPopulation == null)
        {
            return null;
        }
        
        for (UserDirectory ud : userPopulation.getUserDirectories())
        {
            StoredUser storedUser = ud.getStoredUser(login);
            if (storedUser != null)
            {
                return ud;
            }
        }
        return null;
    }
    
    /**
     * Convert a {@link StoredUser} to a {@link User}
     * @param storedUser The stored user to convert
     * @param userDirectory the user directory containing the StoredUser
     * @return A {@link User}
     */
    private User _storedUser2User(StoredUser storedUser, UserDirectory userDirectory)
    {
        return new User(userDirectory.getUserIdentity(storedUser), storedUser.getLastName(), storedUser.getFirstName(), storedUser.getEmail(), userDirectory, storedUser.getCreationDate(), storedUser.getCreationOrigin());
    }
    
    /**
     * Convert a Collection of {@link StoredUser} from the same user directory to a Collection of {@link User}
     * @param storedUsers The collection of stored user to convert
     * @param userDirectory the user directory containing the stored users
     * @return A {@link User}
     */
    private Collection<User> _storedUsers2Users(Collection<StoredUser> storedUsers, UserDirectory userDirectory)
    {
        Collection<User> users = new ArrayList<>();
        for (StoredUser storedUser : storedUsers)
        {
            users.add(_storedUser2User(storedUser, userDirectory));
        }
        
        return users;
    }
}