/*
 *  Copyright 2012 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.web.usermanagement;

import java.util.Arrays;
import java.util.Collection;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Map;
import java.util.Set;

import org.apache.avalon.framework.parameters.Parameters;
import org.apache.avalon.framework.service.ServiceException;
import org.apache.avalon.framework.service.ServiceManager;
import org.apache.cocoon.acting.ServiceableAction;
import org.apache.cocoon.environment.ObjectModelHelper;
import org.apache.cocoon.environment.Redirector;
import org.apache.cocoon.environment.Request;
import org.apache.cocoon.environment.SourceResolver;
import org.apache.commons.lang.StringUtils;

import org.ametys.core.captcha.CaptchaHelper;
import org.ametys.core.user.UserManager;
import org.ametys.core.user.directory.ModifiableUserDirectory;
import org.ametys.core.user.directory.UserDirectory;
import org.ametys.core.user.population.UserPopulation;
import org.ametys.core.user.population.UserPopulationDAO;
import org.ametys.plugins.repository.AmetysObjectResolver;
import org.ametys.runtime.i18n.I18nizableText;
import org.ametys.runtime.model.ModelItem;
import org.ametys.runtime.parameter.Errors;
import org.ametys.web.URIPrefixHandler;
import org.ametys.web.WebConstants;
import org.ametys.web.cache.PageHelper;
import org.ametys.web.renderingcontext.RenderingContextHandler;
import org.ametys.web.repository.page.Page;
import org.ametys.web.repository.page.ZoneItem;
import org.ametys.web.site.SiteConfigurationExtensionPoint;
import org.ametys.web.usermanagement.UserManagementException.StatusError;

import com.google.common.collect.ArrayListMultimap;
import com.google.common.collect.Multimap;

/**
 * Handle the user sign-up actions.
 */
public class UserSignupAction extends ServiceableAction
{
    /** The UsersManager standard fields. */
    public static final Set<String> STANDARD_FIELDS = new HashSet<>(Arrays.asList("login", "firstname", "lastname", "email", "address", "password"));
    
    /** The user signup manager. */
    protected UserSignupManager _userSignupManager;
    
    /** The user manager. */
    protected UserManager _userManager;
    
    /** The DAO for user populations */
    protected UserPopulationDAO _userPopulationDAO;
    /** The site configuration EP. */
    protected SiteConfigurationExtensionPoint _siteConfiguration;
    
    /** The Ametys Resolver */
    protected AmetysObjectResolver _resolver;
    
    /** Page helper */
    protected PageHelper _pageHelper;
    /** The rendering context */
    protected RenderingContextHandler _renderingContextHandler;
    /** The URI prefix handler */
    protected URIPrefixHandler _prefixHandler;

    @Override
    public void service(ServiceManager serviceManager) throws ServiceException
    {
        super.service(serviceManager);
        _userSignupManager = (UserSignupManager) serviceManager.lookup(UserSignupManager.ROLE);
        _userManager = (UserManager) serviceManager.lookup(UserManager.ROLE);
        _userPopulationDAO = (UserPopulationDAO) serviceManager.lookup(UserPopulationDAO.ROLE);
        _siteConfiguration = (SiteConfigurationExtensionPoint) serviceManager.lookup(SiteConfigurationExtensionPoint.ROLE);
        _resolver = (AmetysObjectResolver) serviceManager.lookup(AmetysObjectResolver.ROLE);
        _pageHelper = (PageHelper) serviceManager.lookup(PageHelper.ROLE);
        _renderingContextHandler = (RenderingContextHandler) serviceManager.lookup(RenderingContextHandler.ROLE);
        _prefixHandler = (URIPrefixHandler) manager.lookup(URIPrefixHandler.ROLE);
    }
    
    @Override
    public Map act(Redirector redirector, SourceResolver resolver, Map objectModel, String source, Parameters parameters) throws Exception
    {
        Request request = ObjectModelHelper.getRequest(objectModel);
        String siteName = (String) request.getAttribute(WebConstants.REQUEST_ATTR_SITE_NAME);
        String language = (String) request.getAttribute(WebConstants.REQUEST_ATTR_SITEMAP_NAME);
        
        Map<String, String> results = new HashMap<>();
        
        String signup = request.getParameter("signup");
        String submitPassword = request.getParameter("pwd-submit");
        String mode = request.getParameter("mode");
        String email = request.getParameter("email");
        String firstname = request.getParameter("firstname");
        String lastname = request.getParameter("lastname");
        String token = request.getParameter("token");
        
        Multimap<String, I18nizableText> errors = ArrayListMultimap.create();
        
        ZoneItem zoneItem = (ZoneItem) request.getAttribute(WebConstants.REQUEST_ATTR_ZONEITEM);
        
        try
        {
            UserDirectory userDirectory = _userSignupManager.getUserDirectory(zoneItem);
            String populationId = userDirectory.getPopulationId();
            String userDirectoryId = userDirectory.getId();
            
            if ("new-token".equals(mode))
            {
                // Action which requests a new token.
                results.put("step", "new-token");
                resetTempSignup(request, siteName, language, populationId, userDirectoryId, errors);
                if (errors.isEmpty())
                {
                    results.put("status", "success");
                }
            }
            else if ("true".equals(submitPassword))
            {
                // If the password has been entered, signup the user.
                results.put("step", "signup");
                doSignup(request, parameters, siteName, language, firstname, lastname, email, token, populationId, userDirectoryId, errors);
                if (errors.isEmpty())
                {
                    results.put("status", "success");
                }
                else 
                {
                    results.put("step", "password");
                }
            }
            else if (StringUtils.isNotEmpty(token) && StringUtils.isNotEmpty(email))
            {
                // If a token is provided, check it.
                results.put("step", "password");
                checkToken(request, siteName, email, token, populationId, userDirectoryId, errors);
                if (errors.isEmpty())
                {
                    results.put("status", "success");
                }
            }
            else if ("true".equals(signup))
            {
                // A signup request has been made.
                results.put("step", "temp-signup");
                temporarySignup(request, parameters, siteName, language, populationId, userDirectoryId, errors);
                if (errors.isEmpty())
                {
                    results.put("status", "success");
                }
            }
            else if (!_userSignupManager.isPublicSignupAllowed(siteName))
            {
                // Can not access to signup form (first step) if public signup is unauthorized 
                errors.put("global", new I18nizableText("error-unauthorized"));
            }
        }
        catch (Exception e)
        {
            errors.put("global", new I18nizableText("general-error"));
            
            getLogger().error("An error occurred signing a user up.", e);
        }
        
        request.setAttribute("errors", errors);
        
        return results;
    }
    
    /**
     * Store a user's sign-up request.
     * @param request the user request.
     * @param parameters the action parameters.
     * @param siteName the site name.
     * @param language the language.
     * @param populationId The id of the population
     * @param userDirectoryId The id of the user directory of the population
     * @param errors the Map to fill with errors to display to the user.
     * @throws UserManagementException if an error occurs.
     */
    protected void temporarySignup(Request request, Parameters parameters, String siteName, String language, String populationId, String userDirectoryId, Multimap<String, I18nizableText> errors) throws UserManagementException
    {
        String email = request.getParameter("email");
        
        Page page = _resolver.resolveById(request.getParameter("page-id"));
        
        UserPopulation userPopulation = _userPopulationDAO.getUserPopulation(populationId);
        if (userPopulation == null)
        {
            throw new IllegalStateException("The signup service in page '" + page.getTitle() + " (" + page.getId() + ")' is configured with the unexisting '" + populationId + "' user population identifier. Please reconfigure the service.");
        }
        ModifiableUserDirectory userDirectory = (ModifiableUserDirectory) userPopulation.getUserDirectory(userDirectoryId);
        if (userDirectory == null)
        {
            throw new IllegalStateException("The signup service in page '" + page.getTitle() + " (" + page.getId() + ")' is configured with the unexisting '" + userDirectoryId + "' user directory identifier. Please reconfigure the service.");
        }
        
        Map<String, String> additionalFields = getAdditionalValues(request, userDirectory);
        
        if (_pageHelper.isCaptchaRequired(page))
        {   
            String captchaValue = request.getParameter("captcha");
            String captchaKey = request.getParameter("captcha-key");

            // Validate the input
            if (!CaptchaHelper.checkAndInvalidate(captchaKey, captchaValue))
            {
                errors.put("captcha", new I18nizableText("plugin.web", "PLUGINS_WEB_USER_SIGNUP_FORM_ERROR_INVALID_CAPTCHA"));
            }
        }
        
        
        Map<String, Errors> inputErrors = _userSignupManager.validate(siteName, email, additionalFields);
        
        for (String field : inputErrors.keySet())
        {
            errors.putAll(field, inputErrors.get(field).getErrors());
        }
        
        if (errors.isEmpty())
        {
            try
            {
                _userSignupManager.temporarySignup(siteName, language, email, populationId, userDirectoryId);
            }
            catch (UserManagementException e)
            {
                switch (e.getStatusError())
                {
                    case USER_ALREADY_EXISTS:
                        errors.put("global", new I18nizableText("user-email-already-exists"));
                        break;
                    case TEMP_USER_ALREADY_EXISTS:
                        errors.put("global", new I18nizableText("temp-email-already-exists"));
                        break;
                    default:
                        throw e;
                }
                        
            }
        }
    }
    
    /**
     * Reset a user's sign-up request.
     * @param request the user request.
     * @param siteName the site name.
     * @param language the language.
     * @param populationId The id of the population
     * @param userDirectoryId The id of the user directory of the population
     * @param errors the Map to fill with errors to display to the user.
     * @throws UserManagementException if an error occurs.
     */
    protected void resetTempSignup(Request request, String siteName, String language, String populationId, String userDirectoryId, Multimap<String, I18nizableText> errors) throws UserManagementException
    {
        String email = request.getParameter("email");
        
        try
        {
            _userSignupManager.resetTempSignup(siteName, language, email, populationId, userDirectoryId);
        }
        catch (UserManagementException e)
        {
            switch (e.getStatusError())
            {
                case UNKNOWN_EMAIL:
                    errors.put("global", new I18nizableText("temp-email-unknown"));
                    break;
                default:
                    throw e;
            }
        }
    }
    
    /**
     * Check that a token is valid.
     * @param request the user request.
     * @param siteName the site name.
     * @param email the user e-mail.
     * @param token the sign-up token that was sent to the user. 
     * @param populationId The id of the population
     * @param userDirectoryId The id of the user directory of the population
     * @param errors the Map to fill with errors to display to the user.
     * @throws UserManagementException if an error occurs.
     */
    protected void checkToken(Request request, String siteName, String email, String token, String populationId, String userDirectoryId, Multimap<String, I18nizableText> errors) throws UserManagementException
    {
        try
        {
            _userSignupManager.checkToken(siteName, email, token, populationId, userDirectoryId);
        }
        catch (UserManagementException e)
        {
            switch (e.getStatusError())
            {
                case TOKEN_UNKNOWN:
                    errors.put("global", new I18nizableText("error-token-unknown"));
                    break;
                case TOKEN_EXPIRED:
                    errors.put("global", new I18nizableText("error-token-expired"));
                    break;
                default:
                    throw e;
            }
        }
    }
    
    /**
     * Sign-up the user: create a real user from his temporary information.
     * @param request the user request.
     * @param parameters the action parameters.
     * @param siteName the site name.
     * @param language the current language.
     * @param firstname the user firstname.
     * @param lastname the user lastname.
     * @param email the user e-mail.
     * @param token the sign-up token that was sent to the user. 
     * @param populationId The id of the population
     * @param userDirectoryId The id of the user directory of the population
     * @param errors the Map to fill with errors to display to the user.
     * @throws UserManagementException if an error occurs.
     */
    protected void doSignup(Request request, Parameters parameters, String siteName, String language, String firstname, String lastname, String email, String token, String populationId, String userDirectoryId, Multimap<String, I18nizableText> errors) throws UserManagementException
    {
        String password = request.getParameter("password");
        String passwordConfirmation = request.getParameter("password-confirmation");
        String tos = request.getParameter("tos");
        String tosMode = parameters.getParameter("tos-mode", "");
        
        if (StringUtils.isBlank(password))
        {
            errors.put("password", new I18nizableText("plugin.web", "PLUGINS_WEB_USER_SIGNUP_ERROR_PASSWORD_EMPTY"));
        }
        else if (!password.equals(passwordConfirmation))
        {
            errors.put("password", new I18nizableText("plugin.web", "PLUGINS_WEB_USER_SIGNUP_ERROR_PASSWORD_CONFIRMATION_DOESNT_MATCH"));
        }
        
        if (StringUtils.isBlank(firstname))
        {
            errors.put("firstname", new I18nizableText("plugin.web", "PLUGINS_WEB_USER_SIGNUP_ERROR_FIRSTNAME_EMPTY"));
        }
        
        if (StringUtils.isBlank(lastname))
        {
            errors.put("lastname", new I18nizableText("plugin.web", "PLUGINS_WEB_USER_SIGNUP_ERROR_LASTNAME_EMPTY"));
        }
        
        if (!"NONE".equals(tosMode) && !"true".equals(tos))
        {
            errors.put("tos", new I18nizableText("plugin.web", "PLUGINS_WEB_USER_SIGNUP_FORM_ERROR_TOS_NOT_CHECKED"));
        }
        
        UserDirectory userDirectory = _userPopulationDAO.getUserPopulation(populationId).getUserDirectory(userDirectoryId);
        if (!(userDirectory instanceof ModifiableUserDirectory))
        {
            throw new UserManagementException("The user subscription feature can't be used, as the UserDirectory is not modifiable.", StatusError.UNMODIFIABLE_USER_DIRECTORY);
        }
        
        // Standard info for user.
        Map<String, String> userInfos = new HashMap<>();
        userInfos.put("email", email);
        userInfos.put("firstname", firstname);
        userInfos.put("lastname", lastname);
        userInfos.put("password", password);
        
        Map<String, Errors> inputErrors = ((ModifiableUserDirectory) userDirectory).validate(userInfos);
        inputErrors.remove("login"); // ignore errors on login (user do not have login yet)
        for (String field : inputErrors.keySet())
        {
            errors.putAll(field, inputErrors.get(field).getErrors());
        }
        
        if (errors.isEmpty())
        {
            try
            {
                _userSignupManager.signup(siteName, language, firstname, lastname, email, token, password, populationId, userDirectoryId, errors);
            }
            catch (UserManagementException e)
            {
                switch (e.getStatusError())               
                {
                    case TOKEN_UNKNOWN:
                        errors.put("global", new I18nizableText("error-token-unknown"));
                        break;
                    case TOKEN_EXPIRED:
                        errors.put("global", new I18nizableText("error-token-expired"));
                        break;
                    default:
                        throw e;
                }
            }
        }
    }
       
    /**
     * Get FO user manager's custom field values.
     * @param request the request.
     * @param userDirectory the user directory
     * @return the custom field values.
     * @throws UserManagementException if an error occurs.
     */
    protected Map<String, String> getAdditionalValues(Request request, ModifiableUserDirectory userDirectory) throws UserManagementException
    {
        Map<String, String> additionalFields = new HashMap<>();
        
        Collection< ? extends ModelItem> fields = userDirectory.getModelItems();
        
        for (ModelItem field : fields)
        {
            String fieldId = field.getName();
            if (!STANDARD_FIELDS.contains(fieldId))
            {
                String value = request.getParameter(fieldId);
                
                additionalFields.put(fieldId, value);
            }
        }
        
        return additionalFields;
    }
}