/*
 *  Copyright 2015 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.cart;

import java.util.ArrayList;
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 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.StringUtils;
import org.slf4j.LoggerFactory;

import org.ametys.cms.FilterNameHelper;
import org.ametys.core.group.GroupIdentity;
import org.ametys.core.ui.Callable;
import org.ametys.core.user.CurrentUserProvider;
import org.ametys.core.user.UserIdentity;
import org.ametys.core.user.UserManager;
import org.ametys.plugins.cart.Cart.CartElementType;
import org.ametys.plugins.cart.Cart.CartProfile;
import org.ametys.plugins.cart.Cart.Visibility;
import org.ametys.plugins.core.user.UserHelper;
import org.ametys.plugins.repository.AmetysObjectResolver;
import org.ametys.plugins.repository.AmetysRepositoryException;
import org.ametys.plugins.repository.ModifiableTraversableAmetysObject;
import org.ametys.plugins.repository.UnknownAmetysObjectException;

/**
 * DAO for manipulating carts
 */
public class CartsDAO implements Serviceable, Component
{
    /** The Avalon role */
    public static final String ROLE = CartsDAO.class.getName();
    
    /** The user manager */
    protected UserManager _userManager;
    
    /** The current user provider */
    private CurrentUserProvider _userProvider;
    
    /** The Ametys object resolver */
    private AmetysObjectResolver _resolver;

    private UserHelper _userHelper;
    
    @Override
    public void service(ServiceManager serviceManager) throws ServiceException
    {
        _userProvider = (CurrentUserProvider) serviceManager.lookup(CurrentUserProvider.ROLE);
        _resolver = (AmetysObjectResolver) serviceManager.lookup(AmetysObjectResolver.ROLE);
        _userManager = (UserManager) serviceManager.lookup(UserManager.ROLE);
        _userHelper = (UserHelper) serviceManager.lookup(UserHelper.ROLE);
    }
    
    /**
     * Gets carts information.
     * @param cartIds The ids of the carts to retrieve.
     * @return The carts information
     */
    @Callable
    public Map<String, Object> getCartsInformation (List<String> cartIds)
    {
        Map<String, Object> result = new HashMap<>();
        
        List<Map<String, Object>> carts = new LinkedList<>();
        List<Map<String, Object>> notAllowedCarts = new LinkedList<>();
        Set<String> unknownCarts = new HashSet<>();
        
        for (String id : cartIds)
        {
            Cart cart = getCart(id);
            
            if (cart != null && _hasRight(cart))
            {
                if (_hasRight(cart))
                {
                    carts.add(getCartProperties(cart));
                }
                else
                {
                    notAllowedCarts.add(getCartProperties(cart));
                }
                
            }
            else
            {
                unknownCarts.add(id);
            }
        }
        
        result.put("carts", carts);
        result.put("unknownCarts", unknownCarts);
        result.put("notAllowedCarts", unknownCarts);
        
        return result;
    }
    
    /**
     * Creates a cart.
     * @param title The title
     * @param description The description
     * @return The id of the created cart
     */
    @Callable
    public Map<String, String> createCart (String title, String description)
    {
        Map<String, String> result = new HashMap<>();
        
        ModifiableTraversableAmetysObject cartsNode = CartHelper.getCartsNode(_resolver);
        
        String name = FilterNameHelper.filterName(title);
        
        // Find unique name
        int index = 1;
        String originalName = name;
        while (cartsNode.hasChild(name))
        {
            name = originalName + "_" + (++index);
        }
        
        // title might be modified to handle project with same title.
        String realTitle = title + (index > 1 ? " (" + index + ")" : "");
        
        Cart cart = cartsNode.createChild(name, CartFactory.CART_NODETYPE);
        cart.setTitle(realTitle);
        cart.setDescription(description);
        cart.setAuthor(_userProvider.getUser());
        
        cart.setVisibility(Visibility.PRIVATE);
        
        cartsNode.saveChanges();
        
        result.put("id", cart.getId());
        
        return result;
    }
    
    /**
     * Updates a cart.
     * @param id The id of the cart to update
     * @param title The title
     * @param description The description
     * @return The id of the updated cart
     */
    @Callable
    public Map<String, String> updateCart (String id, String title, String description)
    {
        Map<String, String> result = new HashMap<>();
        
        Cart cart = _resolver.resolveById(id);
        UserIdentity author = cart.getAuthor();
        
        if (author != null && author.equals(_userProvider.getUser()))
        {
            cart.setTitle(title);
            cart.setDescription(description);
            cart.saveChanges();
        }
        else
        {
            result.put("message", "not-allowed");
        }
        
        result.put("id", cart.getId());
        
        return result;
    }
    
    /**
     * Deletes some carts.
     * @param ids The ids of the carts to delete
     * @return The ids of the deleted carts
     */
    @Callable
    public Map<String, Object> deleteCarts (List<String> ids)
    {
        Map<String, Object> result = new HashMap<>();
        
        List<String> deletedCarts = new ArrayList<>();
        List<String> unknownCarts = new ArrayList<>();
        List<String> notallowedCarts = new ArrayList<>();
        
        for (String id : ids)
        {
            try
            {
                Cart cart = _resolver.resolveById(id);
                if (cart.getAuthor().equals(_userProvider.getUser()))
                {
                    cart.remove();
                    cart.saveChanges();
                    deletedCarts.add(id);
                }
                else
                {
                    notallowedCarts.add(cart.getTitle());
                }
            }
            catch (UnknownAmetysObjectException e)
            {
                unknownCarts.add(id);
                LoggerFactory.getLogger(getClass()).error("Unable to delete cart. The cart of id '" + id + " doesn't exist", e);
            }
        }
        
        result.put("deletedCarts", deletedCarts);
        result.put("notallowedCarts", notallowedCarts);
        result.put("unknownCarts", unknownCarts);
        
        return result;
    }
    
    /**
     * Add elements to a cart.
     * @param cartId The cart id.
     * @param type The type of element.
     * @param elementParams The parameters of the element.
     * @return The id of the cart or an error
     */
    @Callable
    public Map<String, Object> addElements (String cartId, String type, Map<String, Object> elementParams)
    {
        Map<String, Object> result = new HashMap<>();
        
        UserIdentity user = _userProvider.getUser();
        
        Cart cart = _resolver.resolveById(cartId);
        
        if (!cart.canWrite(user))
        {
            LoggerFactory.getLogger(getClass()).error("User '{}' try to add elements to a cart without convenient privileges", user);
            result.put("msg", "not-allowed");
            return result;
        }
        
        switch (CartElementType.valueOf(type.toUpperCase()))
        {
            case CONTENT:
                @SuppressWarnings("unchecked")
                List<String> contentIds = (List<String>) elementParams.get("ids");
                for (String contentId : contentIds)
                {
                    cart.addContent(contentId);
                }
                break;

            case RESOURCE:
                @SuppressWarnings("unchecked")
                List<String> resourceIds = (List<String>) elementParams.get("ids");
                for (String resourceId : resourceIds)
                {
                    cart.addResource(resourceId);
                }
                break;
                
            case CARTQUERY:
                String title = (String) elementParams.get("title");
                String description = (String) elementParams.get("description");
                
                cart.addQuery(user, title, description);
                break;
                
            default:
                throw new IllegalArgumentException("Unknown cart element type");
        }
        
        cart.saveChanges();
        
        result.put("id", cart.getId());
        
        return result;
    }
    
    /**
     * Deletes elements of a cart.
     * @param cartId The cart id.
     * @param cartElements The elements to delete.
     * @return The id of the cart or an error
     */
    @Callable
    public Map<String, Object> deleteElements (String cartId, List<Map<String, String>> cartElements)
    {
        Map<String, Object> result = new HashMap<>();
        
        Cart cart = _resolver.resolveById(cartId);
        
        UserIdentity user = _userProvider.getUser();
        
        if (!cart.canWrite(user))
        {
            LoggerFactory.getLogger(getClass()).error("User '{}' try to add elements to a cart without convenient privileges", user);
            result.put("msg", "not-allowed");
            return result;
        }
        
        for (Map<String, String> cartElement : cartElements)
        {
            CartElementType type = CartElementType.valueOf(cartElement.get("type").toUpperCase());
            cart.removeElement(cartElement.get("id"), type);
        }
        
        cart.saveChanges();
       
        result.put("id", cartId);
        
        return result;
    }
    
    /**
     * Changes the visibility of a cart.
     * @param cartId The cart id.
     * @param visibilityStr The visibility to set.
     * @return An empty map, or an error message.
     */
    @Callable
    public Map<String, Object> changeVisibility (String cartId, String visibilityStr)
    {
        Map<String, Object> result = new HashMap<>();
        
        // Parameter checks.
        Cart cart = null;
        if (StringUtils.isNotEmpty(cartId))
        {
            cart = _resolver.resolveById(cartId);
        }
        else
        {
            throw new IllegalArgumentException("Mandatory cart id parameter is missing.");
        }
        
        Visibility visibility = Visibility.valueOf(visibilityStr.toUpperCase());
        
        UserIdentity author = cart.getAuthor();
        if (author != null && author.equals(_userProvider.getUser()))
        {
            cart.setVisibility(visibility);
            cart.saveChanges();
        }
        else
        {
            result.put("message", "not-allowed");
        }
        
        return result;
    }
    
    /**
     * Adds users or groups to a cart profile.
     * @param cartId The cart id.
     * @param profileId The profile id.
     * @param entries The users (or groups) entries.
     * @param type The type of the entries to add: 'users' or 'groups'
     * @return An empty map, or an error.
     */
    @Callable
    public Map<String, Object> assignRights (String cartId, String profileId, List<Map<String, String>> entries, String type)
    {
        Map<String, Object> result = new HashMap<>();
        
        // Parameter checks.
        Cart cart = null;
        if (StringUtils.isNotEmpty(cartId))
        {
            cart = _resolver.resolveById(cartId);
        }
        else
        {
            throw new IllegalArgumentException("Mandatory cart 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 = cart.getAuthor();
        if (author != null && author.equals(_userProvider.getUser()))
        {
            CartProfile profile = CartProfile.valueOf(profileId.toUpperCase());
            
            // Add the entries to the profile
            
            
            // Set new values
            if ("users".equals(type))
            {
                Set<UserIdentity> allEntries = cart.getGrantedUsers(profile);
                
                for (Map<String, String> user : entries)
                {
                    UserIdentity identity = new UserIdentity(user.get("login"), user.get("populationId"));
                    if (!allEntries.contains(identity))
                    {
                        allEntries.add(identity);
                    }
                }
                cart.setGrantedUsers(profile, allEntries);
            }
            else
            {
                Set<GroupIdentity> allEntries = cart.getGrantedGroups(profile);
                
                for (Map<String, String> group : entries)
                {
                    GroupIdentity identity = new GroupIdentity(group.get("id"), group.get("groupDirectory"));
                    if (!allEntries.contains(identity))
                    {
                        allEntries.add(identity);
                    }
                }
                cart.setGrantedGroups(profile, allEntries);
            }
            
            // Save
            cart.saveChanges();
        }
        else
        {
            result.put("message", "not-allowed");
        }
        
        return result;
    }
    
    /**
     * Deletes users or groups to a cart profile.
     * @param cartId The cart id.
     * @param profileId The profile id.
     * @param users The users to delete.
     * @param groups The groups to delete;
     * @return An empty map, or an error.
     */
    @Callable
    public Map<String, Object> removeAssignment (String cartId, String profileId, List<Map<String, String>> users, List<Map<String, String>> groups)
    {
        Map<String, Object> result = new HashMap<>();
        
        // Parameter checks.
        Cart cart = null;
        if (StringUtils.isNotEmpty(cartId))
        {
            cart = _resolver.resolveById(cartId);
        }
        else
        {
            throw new IllegalArgumentException("Mandatory cart id parameter is missing.");
        }
        
        if (!"read_access".equals(profileId) && !"write_access".equals(profileId))
        {
            throw new IllegalArgumentException("Unexpected profile identifier : " + profileId);
        }
        
        UserIdentity author = cart.getAuthor();
        if (author != null && author.equals(_userProvider.getUser()))
        {
            CartProfile profile = CartProfile.valueOf(profileId.toUpperCase());
            
            if (!users.isEmpty())
            {
                Set<UserIdentity> grantedUsers = cart.getGrantedUsers(profile);
                grantedUsers.removeAll(users.stream().map(userAsMap -> new UserIdentity(userAsMap.get("login"), userAsMap.get("populationId"))).collect(Collectors.toList()));
                
                cart.setGrantedUsers(profile, grantedUsers);
            }
            
            if (!groups.isEmpty())
            {
                Set<GroupIdentity> grantedGroups = cart.getGrantedGroups(profile);
                grantedGroups.removeAll(groups.stream().map(groupAsMap -> new GroupIdentity(groupAsMap.get("id"), groupAsMap.get("groupDirectory"))).collect(Collectors.toList()));
                
                cart.setGrantedGroups(profile, grantedGroups);
            }
            
            // Save
            cart.saveChanges();
        }
        else
        {
            result.put("message", "not-allowed");
        }
        
        return result;
    }
    
    /**
     * Get the cart with given id
     * @param cartId The cart id
     * @return The retrieved cart or null.
     */
    protected Cart getCart(String cartId)
    {
        try
        {
            return _resolver.resolveById(cartId);
        }
        catch (AmetysRepositoryException e)
        {
            if (LoggerFactory.getLogger(getClass()).isWarnEnabled())
            {
                LoggerFactory.getLogger(getClass()).warn("Failed to retrieves the cart with id : " +  cartId, e);
            }
            
            return null;
        }
    }
    
    /**
     * Get the cart type properties
     * @param cart The cart
     * @return The cart type properties
     */
    public Map<String, Object> getCartProperties (Cart cart)
    {
        Map<String, Object> infos = new HashMap<>();
        
        infos.put("id", cart.getId());
        infos.put("title", cart.getTitle());
        infos.put("description", cart.getDescription());
        infos.put("author", _userHelper.user2json(cart.getAuthor()));
        infos.put("visibility", cart.getVisibility().toString());
        
        UserIdentity currentUser = _userProvider.getUser();
        infos.put("canRead", cart.canRead(currentUser));
        infos.put("canWrite", cart.canWrite(currentUser));
        
        return infos;
    }
    
    /**
     * Test if the current user has the right needed by the content type to view this cart.
     * @param cart The cart
     * @return true if the user has the right needed, false otherwise.
     */
    protected boolean _hasRight(Cart cart)
    {
        UserIdentity user = _userProvider.getUser();
        return cart.canRead(user) || cart.canWrite(user);
    }

}