/*
 *  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.workspaces.tasks;

import java.io.IOException;
import java.util.Collection;
import java.util.Collections;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;

import javax.jcr.Node;
import javax.jcr.RepositoryException;
import javax.jcr.Session;
import javax.jcr.query.Query;

import org.apache.avalon.framework.context.Context;
import org.apache.avalon.framework.context.ContextException;
import org.apache.avalon.framework.context.Contextualizable;
import org.apache.avalon.framework.service.ServiceException;
import org.apache.avalon.framework.service.ServiceManager;
import org.apache.cocoon.ProcessingException;
import org.apache.cocoon.components.ContextHelper;
import org.apache.cocoon.environment.Request;
import org.apache.commons.io.IOUtils;
import org.apache.commons.lang3.StringUtils;
import org.apache.excalibur.source.Source;
import org.apache.excalibur.source.SourceResolver;

import org.ametys.core.ui.Callable;
import org.ametys.plugins.explorer.tasks.ModifiableTask;
import org.ametys.plugins.explorer.tasks.Task;
import org.ametys.plugins.explorer.tasks.TasksList;
import org.ametys.plugins.explorer.tasks.jcr.JCRTasksDAO;
import org.ametys.plugins.repository.AmetysObject;
import org.ametys.plugins.repository.AmetysRepositoryException;
import org.ametys.plugins.repository.jcr.DefaultTraversableAmetysObject;
import org.ametys.plugins.workspaces.html.HTMLTransformer;
import org.ametys.plugins.workspaces.project.ProjectManager;
import org.ametys.plugins.workspaces.project.modules.WorkspaceModuleExtensionPoint;
import org.ametys.plugins.workspaces.project.objects.Project;
import org.ametys.runtime.plugin.component.PluginAware;

/**
 * DAO for interacting with tasks of a project
 */
public class WorkspaceTaskDAO extends JCRTasksDAO implements PluginAware, Contextualizable
{
    /** The Avalon role */
    @SuppressWarnings("hiding")
    public static final String ROLE = WorkspaceTaskDAO.class.getName();
    
    private HTMLTransformer _htmlTransformer;
    
    private SourceResolver _sourceResolver;

    private ProjectManager _projectManager;

    private String _pluginName;

    private Context _context;

    private WorkspaceModuleExtensionPoint _moduleEP;

    @Override
    public void service(ServiceManager manager) throws ServiceException
    {
        super.service(manager);
        _htmlTransformer = (HTMLTransformer) manager.lookup(HTMLTransformer.ROLE);
        _sourceResolver = (SourceResolver) manager.lookup(SourceResolver.ROLE);
        _projectManager = (ProjectManager) manager.lookup(ProjectManager.ROLE);
        _moduleEP = (WorkspaceModuleExtensionPoint) manager.lookup(WorkspaceModuleExtensionPoint.ROLE);
    }

    @Override
    public void setPluginInfo(String pluginName, String featureName, String id)
    {
        _pluginName = pluginName;
    }
    
    @Override
    public void contextualize(Context context) throws ContextException
    {
        _context = context;
    }
    
    /**
     * Add a new task to the current project
     * @param parameters The task parameters
     * @return The task data
     * @throws IllegalAccessException If an error occurs
     */
    @Callable
    public Map<String, Object> addTask(Map<String, Object> parameters) throws IllegalAccessException
    {
        String projectName = (String) parameters.get("project");
        
        if (StringUtils.isEmpty(projectName))
        {
            projectName = _getProjectFromRequest();
        }
        
        Project project = _projectManager.getProject(projectName);
        
        TasksWorkspaceModule taskModule = _moduleEP.getModule(TasksWorkspaceModule.TASK_MODULE_ID);
        DefaultTraversableAmetysObject tasksRoot = taskModule.getTasksRoot(project, true);
        
        return addTask(tasksRoot.getId(), parameters);
    }
    
    /**
     * Get the list of tasks
     * @param projectNames The project that contain the tasks. Can be null to search in all project.
     * @param assignedToUser Filter only the tasks assigned to the current user
     * @param userSubscribed Filter only the tasks for which current user subscribed
     * @param offset Offset the list of results
     * @param limit  The maximum number of results to return
     * @param filter Return only tasks matching the filter
     * @param orderBy Order the list by this property. Default to the creation date
     * @param orderAsc Sort the list by order ascendant or descendant. Default to ascendant. 
     * @return The list as a {@link org.ametys.plugins.explorer.tasks.jcr.JCRTasksDAO.TaskListResult} object
     * @throws ProcessingException If an error occurred
     */
    public TaskListResult getProjectTaskList(List<String> projectNames, boolean assignedToUser, boolean userSubscribed, Integer offset, Integer limit, String filter, String orderBy, Boolean orderAsc) throws ProcessingException
    {
        List<String> parentIds = _projectToTaskList(projectNames);
        return getTaskList(parentIds, assignedToUser, userSubscribed, offset, limit, filter, orderBy, orderAsc);
    }
    
    /**
     * Get the list of tasks
     * @param projectNames The project that contain the tasks. Can be null to search in all project.
     * @param assignedToUser Filter only the tasks assigned to the current user
     * @param userSubscribed Filter only the tasks for which current user subscribed
     * @param offset Offset the list of results
     * @param limit  The maximum number of results to return
     * @param filter Return only tasks matching the filter
     * @param orderBy Order the list by this property. Default to the creation date
     * @param orderAsc Sort the list by order ascendant or descendant. Default to ascendant. 
     * @return The list of tasks
     * @throws ProcessingException If an error occurred
     */
    @Callable
    public Map<String, Object> getProjectTasks(List<String> projectNames, boolean assignedToUser, boolean userSubscribed, Integer offset, Integer limit, String filter, String orderBy, Boolean orderAsc) throws ProcessingException
    {
        List<String> parentIds = _projectToTaskList(projectNames);
        return getTasks(parentIds, assignedToUser, userSubscribed, offset, limit, filter, orderBy, orderAsc);
    }
    
    /**
     * Retrieves the list of {@link TasksList}
     * @param projectNames The project names
     * @return list of task list identifiers
     */
    private List<String> _projectToTaskList(List<String> projectNames)
    {
        Collection<String> finalProjectNames = projectNames;
        
        // All project if no project names provided
        if (finalProjectNames == null)
        {
            finalProjectNames = _projectManager.getProjectNames();
        }
        
        TasksWorkspaceModule taskModule = _moduleEP.getModule(TasksWorkspaceModule.TASK_MODULE_ID);
        
        return finalProjectNames.stream()
                                     .map(_projectManager::getProject)
                                     .map(project -> taskModule.getTasksRoot(project, true).getId())
                                     .collect(Collectors.toList());
    }
    
    /**
     * Get the tasks of the current project
     * @param assignedToUser True to filter only the tasks assigned to the current user
     * @param userSubscribed Filter only the tasks for which current user subscribed
     * @param offset Start the list of tasks at the Nth task, used for pagination
     * @param limit Only return a maximum of N tasks, used for pagination
     * @param filter Return only tasks matching the filter
     * @param orderBy Order the list by this property. Default to the creation date
     * @param orderAsc Sort the list by order ascendant or descendant. Default to ascendant.
     * @return The list of tasks
     * @throws IllegalAccessException If the user is not authorized
     * @throws ProcessingException If an error occurred
     */
    @Callable
    public Map<String, Object> getProjectTasks(boolean assignedToUser, boolean userSubscribed, Integer offset, Integer limit, String filter, String orderBy, Boolean orderAsc) throws IllegalAccessException, ProcessingException
    {
        String projectName = _getProjectFromRequest();
        Project project = _projectManager.getProject(projectName);
        
        TasksWorkspaceModule taskModule = _moduleEP.getModule(TasksWorkspaceModule.TASK_MODULE_ID);
        DefaultTraversableAmetysObject tasksRoot = taskModule.getTasksRoot(project, true);
        
        return getTasks(Collections.singletonList(tasksRoot.getId()), assignedToUser, userSubscribed, offset, limit, filter, orderBy, orderAsc);
    }
    
    @Override
    protected void setTaskDescription(ModifiableTask task, String description)
    {
        try
        {
            _htmlTransformer.transform(description, task.getDescription());
        }
        catch (IOException e)
        {
            throw new AmetysRepositoryException("Failed to transform task's description into rich text", e);
        }
    }
    
    @Override
    protected String getTaskDescription(Task task) throws AmetysRepositoryException
    {
        Source contentSource = null;
        try
        {
            Map<String, Object> parameters = new HashMap<>();
            parameters.put("source", task.getDescription().getInputStream());
            contentSource = _sourceResolver.resolveURI("cocoon://_plugins/" + _pluginName + "/convert/html2html", null, parameters);
            return IOUtils.toString(contentSource.getInputStream(), "UTF-8");
        }
        catch (IOException e)
        {
            throw new AmetysRepositoryException("Failed to transform rich text into string", e);
        }
        finally
        {
            _sourceResolver.release(contentSource);
        }
    }
    
    @Override
    protected String getTaskDescriptionForEdition(Task task) throws AmetysRepositoryException
    {
        try
        {
            if (!(task instanceof ModifiableTask))
            {
                throw new AmetysRepositoryException("Can not transform description of a non modifiable task");
            }
            
            StringBuilder sb = new StringBuilder();
            _htmlTransformer.transformForEditing(((ModifiableTask) task).getDescription(), sb);
            return sb.toString();
        }
        catch (IOException e)
        {
            throw new AmetysRepositoryException("Failed to transform rich text into string", e);
        }
    }
    
    @Override
    protected Map<String, Object> getTask(Task task, boolean isEdition)
    {
        Map<String, Object> data = super.getTask(task, isEdition);
        
        Project project = getParentProject(task);
        if (project != null)
        {
            data.put("project", _projectToJson(project));
        }
        
        return data;
    }
    
    /**
     * Get the parent project of a task
     * @param task The task
     * @return the project or <code>null</code> if not found
     */
    protected Project getParentProject(Task task)
    {
        AmetysObject parent = task.getParent();
        while (parent != null)
        {
            if (parent instanceof Project)
            {
                return (Project) parent;
            }
            parent = parent.getParent();
        }
        
        return null;
    }
    
    /**
     * Retrieve the project JSON data
     * @param project The project
     * @return The data
     */
    protected Map<String, String> _projectToJson(Project project)
    {
        Map<String, String> projectData = new HashMap<>();
        projectData.put("title", project.getTitle());
        projectData.put("name", project.getName());
        return projectData;
    }
    
    private String _getProjectFromRequest()
    {
        Request request = ContextHelper.getRequest(_context);
        return (String) request.getAttribute("projectName");
    }

    /**
     * Get the total number of tasks of the project
     * @param project The project
     * @return The number of tasks, or null if the module is not activated
     */
    public Long getTasksCount(Project project)
    {
        TasksWorkspaceModule taskModule = _moduleEP.getModule(TasksWorkspaceModule.TASK_MODULE_ID);
        DefaultTraversableAmetysObject tasksRoot = taskModule.getTasksRoot(project, true);
        
        if (tasksRoot != null)
        {
            try
            {
                Node node = tasksRoot.getNode();
                String xPathQuery = getTasksXpathQuery(node.getPath(), null, null);
                Session session = node.getSession();
                Query query = session.getWorkspace().getQueryManager().createQuery(xPathQuery, Query.XPATH);
                
                return query.execute().getNodes().getSize();
            }
            catch (RepositoryException e)
            {
                getLogger().error("Unable to retrieve the total count of tasks for the project " + project, e);
            }
        }
        return null;
    }
}