/*
 *  Copyright 2010 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.cms.workflow;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashSet;
import java.util.Iterator;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;

import javax.jcr.RepositoryException;

import org.apache.avalon.framework.component.Component;
import org.apache.avalon.framework.configuration.Configurable;
import org.apache.avalon.framework.configuration.Configuration;
import org.apache.avalon.framework.configuration.ConfigurationException;
import org.apache.avalon.framework.logger.AbstractLogEnabled;
import org.apache.avalon.framework.service.ServiceException;
import org.apache.avalon.framework.service.ServiceManager;
import org.apache.avalon.framework.service.Serviceable;
import org.apache.avalon.framework.thread.ThreadSafe;
import org.apache.cocoon.xml.AttributesImpl;
import org.apache.cocoon.xml.XMLUtils;
import org.apache.commons.lang.StringUtils;
import org.xml.sax.ContentHandler;
import org.xml.sax.SAXException;

import org.ametys.cms.content.ContentHelper;
import org.ametys.cms.contenttype.ContentTypeExtensionPoint;
import org.ametys.cms.contenttype.ContentTypesHelper;
import org.ametys.cms.languages.Language;
import org.ametys.cms.languages.LanguagesManager;
import org.ametys.cms.repository.Content;
import org.ametys.cms.repository.DefaultContent;
import org.ametys.cms.repository.WorkflowAwareContent;
import org.ametys.cms.repository.WorkflowStepExpression;
import org.ametys.core.right.RightManager;
import org.ametys.core.right.RightManager.RightResult;
import org.ametys.core.user.User;
import org.ametys.core.user.UserIdentity;
import org.ametys.core.user.UserManager;
import org.ametys.core.util.DateUtils;
import org.ametys.plugins.repository.AmetysObjectIterable;
import org.ametys.plugins.repository.AmetysObjectResolver;
import org.ametys.plugins.repository.AmetysRepositoryException;
import org.ametys.plugins.repository.query.SortCriteria;
import org.ametys.plugins.repository.query.expression.AndExpression;
import org.ametys.plugins.repository.query.expression.Expression;
import org.ametys.plugins.repository.query.expression.Expression.Operator;
import org.ametys.plugins.repository.query.expression.OrExpression;
import org.ametys.plugins.repository.query.expression.StringExpression;
import org.ametys.plugins.workflow.support.WorkflowProvider;
import org.ametys.plugins.workflow.support.WorkflowProvider.AmetysObjectWorkflow;
import org.ametys.runtime.i18n.I18nizableText;

import com.opensymphony.workflow.loader.StepDescriptor;
import com.opensymphony.workflow.loader.WorkflowDescriptor;
import com.opensymphony.workflow.spi.Step;

/**
 * Component for saxing tasks specific to an user.<br>
 * The algorithm is the following :
 * <ul>
 *   <li>First, we get all granted sites for the user with the right manager.
 *   <li>If there is at least one site allowed, we get all workflows 
 *       associated with the granted sites.
 *   <li>Then for each step of each task from the configuration, we get
 *       all workflows where this step is in current steps and where
 *       the workflow is contains in the previous list.
 *   <li>For each workflow matching the previous conditions we
 *       test if the user has all the rights associated with the step (from
 *       the configuration) and then we get the content from this workflow.
 *   <li>Finally, for each content, we sax its first page in order to access
 *       it directly from an URL. 
 * </ul>
 */
public class WorkflowTasksComponent extends AbstractLogEnabled implements Component, ThreadSafe, Configurable, Serviceable
{
    /** The avalon role. */
    public static final String ROLE = WorkflowTasksComponent.class.getName();
    
    /** The ametys object resolver. */
    protected AmetysObjectResolver _objectResolver;
    
    /** The rights manager. */
    protected RightManager _rightManager;
    
    /** The users manager. */
    protected UserManager _userManager;
    
    /** The content type extension point. */
    protected ContentTypeExtensionPoint _cTypeEP;
    
    /** Helper for content types */
    protected ContentTypesHelper _contentTypesHelper;
    
    /** The {@link WorkflowProvider} */
    protected WorkflowProvider _workflowProvider;
    
    /** The content helper */
    protected ContentHelper _contentHelper;
    
    /** The languages manager */
    protected LanguagesManager _languagesManager;
    
    /** The configured task map, indexed by id. */
    protected Map<String, Task> _tasks;
    
    /** Allow user querying ? */
    protected boolean _allowUserQuery;

    @Override
    public void service(ServiceManager manager) throws ServiceException
    {
        _objectResolver = (AmetysObjectResolver) manager.lookup(AmetysObjectResolver.ROLE);
        _rightManager = (RightManager) manager.lookup(RightManager.ROLE);
        _userManager = (UserManager) manager.lookup(UserManager.ROLE);
        _cTypeEP = (ContentTypeExtensionPoint) manager.lookup(ContentTypeExtensionPoint.ROLE);
        _contentTypesHelper = (ContentTypesHelper) manager.lookup(ContentTypesHelper.ROLE);
        _workflowProvider = (WorkflowProvider) manager.lookup(WorkflowProvider.ROLE);
        _languagesManager = (LanguagesManager) manager.lookup(LanguagesManager.ROLE);
        _contentHelper = (ContentHelper) manager.lookup(ContentHelper.ROLE);
    }
    
    /**
     * Configure the tasks and steps handled by this component.<br>
     * Need the following configuration:<br>
     * &lt;tasks&gt;<br>
     * &#160;&#160;&lt;task label="i18n-label"&gt;<br>
     * &#160;&#160;&#160;&#160;&lt;step id="3" rights="proposal,validation"&gt;<br>
     * &#160;&#160;&#160;&#160;&lt;step id="4" rights="validation"&gt;<br>
     * &#160;&#160;&#160;&#160;...<br>
     * &#160;&#160;&lt;/task&gt;<br>
     * &#160;&#160;...<br>
     * &lt;/tasks&gt;<br>
     * @param configuration The configuration as described above.
     * @throws ConfigurationException If the configuration is invalid.
     */
    public void configure(Configuration configuration) throws ConfigurationException
    {
        Configuration tasksConf = configuration.getChild("tasks");
        _tasks = _configureTasks(tasksConf);
        _allowUserQuery = tasksConf.getAttributeAsBoolean("allowUserQuery", false);
    }
    
    /**
     * Allow user query ?
     * @return true if allowed user querying, false otherwise.
     */
    public boolean allowUserQuery()
    {
        return _allowUserQuery;
    }
    
    /**
     * SAX the contents for given user
     * @param ch the content handler to SAX into
     * @param user the user
     * @throws SAXException If an error occurred
     */
    public void toSAX(ContentHandler ch, User user) throws SAXException
    {
        XMLUtils.startElement(ch, "tasks");
        
        long start = System.currentTimeMillis();
        
        // Get the workflow corresponding to the configuration.
        Map<Task, Collection<Content>> workflows = _getCorrespondingWorkflows(user);
        
        long wfEnd = System.currentTimeMillis();
        getLogger().info("Contents retrieved in " + (wfEnd - start) + "ms.");
        
        for (Task task : workflows.keySet())
        {
            _saxTask(ch, task, workflows.get(task));
        }
        
        long end = System.currentTimeMillis();
        
        // Display performance indicators.
        AttributesImpl attrs = new AttributesImpl();
        
        attrs.addCDATAAttribute("Total", Long.toString(end - start));
        attrs.addCDATAAttribute("WF", Long.toString(wfEnd - start));
        attrs.addCDATAAttribute("SAX", Long.toString(end - wfEnd));
        
        XMLUtils.createElement(ch, "render", attrs);
        
        XMLUtils.endElement(ch, "tasks");
    }
    
    /**
     * SAX the contents for given user and task
     * @param ch the content handler to SAX into
     * @param user the user
     * @param taskId the task id
     * @throws SAXException If an error occurred
     */
    public void toSAX(ContentHandler ch, User user, String taskId) throws SAXException
    {
        Task task = _tasks.get(taskId);
        
        Collection<Content> getTaskContents = _getTaskContents (user, task);
        _saxTask(ch, task, getTaskContents);
    }
    
    /**
     * Get the list of tasks managed by this component.
     * @return the task list.
     */
    public Map<String, Task> getTasks()
    {
        return Collections.unmodifiableMap(_tasks);
    }
    
    /**
     * Get the list of contents for a given user and task.
     * @param user the user.
     * @param taskId the task ID.
     * @param limit the maximum number of results, 0 for all.
     * @return the contents as an iterable collection of contents.
     * @throws AmetysRepositoryException If an error occurred
     */
    public Collection<Content> getContents(User user, String taskId, int limit) throws AmetysRepositoryException
    {
        if (_tasks.containsKey(taskId))
        {
            Task task = _tasks.get(taskId);
            
            return _getTaskContents(user, task, limit);
        }
        else
        {
            return Collections.emptyList();
        }
    }
    
    /**
     * SAX a task
     * @param ch the content handler to SAX into
     * @param task the task to SAX
     * @param contents the contents
     * @throws SAXException if an error occurred while SAXing
     */
    protected void _saxTask (ContentHandler ch, Task task, Collection<Content> contents) throws SAXException
    {
        AttributesImpl taskAttr = new AttributesImpl();
        taskAttr.addCDATAAttribute("id", task.getId());
        _saxAdditionalAttributes (task, taskAttr);
        
        XMLUtils.startElement(ch, "task", taskAttr);
        
        task.getLabel().toSAX(ch, "label");
        
        for (Content content : contents)
        {
            // Generate the first page on which the user has all the rights.
            try
            {
                _saxContent(ch, content);
            }
            catch (RepositoryException e)
            {
                throw new SAXException("Error trying to generate a content.", e);
            }
        }
        
        XMLUtils.endElement(ch, "task");
    }
    
    /**
     * SAX additional attributes
     * @param task the task
     * @param attrs the attributes
     * @throws SAXException If an error occurred
     */
    protected void _saxAdditionalAttributes (Task task, AttributesImpl attrs) throws SAXException
    {
        // Nothing
    }
    
    /**
     * SAX a content.
     * @param ch the content handler.
     * @param content the content to sax.
     * @throws SAXException If an error occurred
     * @throws RepositoryException If an error occurred
     */
    protected void _saxContent(ContentHandler ch, Content content) throws SAXException, RepositoryException
    {
        UserIdentity userIdentity = content.getLastContributor();
        User authorUser = _userManager.getUser(userIdentity.getPopulationId(), userIdentity.getLogin());
        
        AttributesImpl attrs = new AttributesImpl();
        attrs.addCDATAAttribute("id", content.getId());
        attrs.addCDATAAttribute("name", content.getName());
        attrs.addCDATAAttribute("title", _contentHelper.getTitle(content));
        attrs.addCDATAAttribute("lastModified", DateUtils.dateToString(content.getLastModified()));
        attrs.addCDATAAttribute("contentType", StringUtils.join(content.getTypes(), ','));
        if (content.getLanguage() != null)
        {
            attrs.addCDATAAttribute("language", content.getLanguage());
            Language language = _languagesManager.getAvailableLanguages().get(content.getLanguage());
            if (language != null)
            {
                attrs.addCDATAAttribute("language-image", language.getSmallIcon());
            }
        }
       
        if (authorUser != null)
        {
            attrs.addCDATAAttribute("author", authorUser.getFullName());
        }
        
        _saxAdditionalAttributes (content, attrs);
        
        String iconGlyph = _contentTypesHelper.getIconGlyph(content);
        if (iconGlyph != null)
        {
            attrs.addCDATAAttribute("iconGlyph", iconGlyph);
        }
        String iconDecorator = _contentTypesHelper.getIconDecorator(content);
        if (iconDecorator != null)
        {
            attrs.addCDATAAttribute("iconDecorator", iconDecorator);
        }
        attrs.addCDATAAttribute("smallIcon", _contentTypesHelper.getSmallIcon(content));
        attrs.addCDATAAttribute("mediumIcon", _contentTypesHelper.getMediumIcon(content));
        attrs.addCDATAAttribute("largeIcon", _contentTypesHelper.getLargeIcon(content));
        
        XMLUtils.startElement(ch, "content", attrs);
        if (content instanceof WorkflowAwareContent)
        {
            _saxContentCurrentState(ch, (WorkflowAwareContent) content);
        }
        XMLUtils.endElement(ch, "content");
    }
    
    /**
     * SAX additional attributes
     * @param content the content
     * @param attrs the attributes
     * @throws SAXException If an error occurred
     */
    protected void _saxAdditionalAttributes (Content content, AttributesImpl attrs) throws SAXException
    {
        // Nothing
    }
    
    /**
     * Get the workflows for a user.
     * @param user the user.
     * @return the list of contents for each task.
     */
    protected Map<Task, Collection<Content>> _getCorrespondingWorkflows(User user)
    {
        Map<Task, Collection<Content>> workflows = new LinkedHashMap<>();
        
        for (Task task : _tasks.values())
        {
            workflows.put(task, _getTaskContents(user, task));
        }
        
        return workflows;
    }

    /**
     * Get a task's contents.
     * @param user the user. 
     * @param task the task.
     * @return the content collection.
     */
    protected Collection<Content> _getTaskContents(User user, Task task)
    {
        List<Content> contents = new ArrayList<>();
        
        int length = task.getLength();
        int count = 0;
        
        for (TaskStep step : task.getSteps())
        {
            if (length != 0 && count == length)
            {
                break;
            }
            
            Set<String> rights = step.getRights();
            
            for (Content content : _getContents(step, user))
            {
                if (_testContent(content, user.getIdentity(), rights))
                {
                    if (length != 0 && count == length)
                    {
                        break;
                    }
                    
                    contents.add(content);
                    count++;
                }
            }
        }
        
        Collections.sort(contents, new LastModifiedDateComparator());
        
        return contents;
    }
    
    /**
     * Get a task's contents.
     * @param user the user. 
     * @param task the task.
     * @param limit the maximum number of contents (0 to return all).
     * @return the content collection.
     */
    protected Collection<Content> _getTaskContents(User user, Task task, int limit)
    {
        List<Content> contents = new ArrayList<>();
        for (TaskStep step : task.getSteps())
        {
            Set<String> rights = step.getRights();
            
            Iterator<Content> contentIt = _getContents(step, user).iterator();
            int stepContents = 0;
            while (contentIt.hasNext() && (limit < 1 || stepContents < limit))
            {
                Content content = contentIt.next();
                if (_testContent(content, user.getIdentity(), rights) && !contents.contains(content))
                {
                    contents.add(content);
                    stepContents++;
                }
            }
        }
        
        Collections.sort(contents, new LastModifiedDateComparator());
        
        if (limit > 0 && contents.size() > limit)
        {
            contents = contents.subList(0, limit);
        }
        
        return contents;
    }
    
    /**
     * Get the contents for a step.
     * @param step the step.
     * @param user the user.
     * @return an iterable collection of contents.
     */
    protected AmetysObjectIterable<Content> _getContents(TaskStep step, User user)
    {
        Expression expr = null;
        Set<Integer> stepIds = step.getStepIds();
        for (Integer stepId : stepIds)
        {
            Expression stepExpr = new WorkflowStepExpression(Operator.EQ, stepId);
            expr = expr == null ? stepExpr : new OrExpression(expr, stepExpr);
        }
        
        Expression contentExpr = null;
        if (step.getUserContentsOnly())
        {
            contentExpr = new StringExpression(DefaultContent.METADATA_CONTRIBUTOR, Operator.EQ, user.getIdentity().getLogin());
            expr = new AndExpression(expr, contentExpr);
        }
        
        SortCriteria sort = new SortCriteria();
        sort.addCriterion(DefaultContent.METADATA_MODIFIED, false, false);
        String xpathQuery = org.ametys.plugins.repository.query.QueryHelper.getXPathQuery(null, "ametys:content", expr, sort);

        return _objectResolver.query(xpathQuery);
    }
    
    /**
     * Test if the content is valid.
     * @param content the content to test.
     * @param user the user.
     * @param rights the rights to test.
     * @return true/false.
     */
    protected boolean _testContent(Content content, UserIdentity user, Set<String> rights)
    {
        // Supposer que nous avons tous les droits
        boolean hasAllRights = true;
        
        Iterator<String> itRights = rights.iterator();
        
        // Vérifier que nous avons tous les droits
        while (itRights.hasNext() && hasAllRights)
        {
            String right = itRights.next();
            
            hasAllRights &= _rightManager.hasRight(user, right, content) == RightResult.RIGHT_ALLOW;
        }
        
        return hasAllRights;
    }   
    
    /**
     * Configure the tasks.
     * @param tasksConf the tasks root configuration.
     * @return the task list.
     * @throws ConfigurationException if a configuration error occurs.
     */
    protected Map<String, Task> _configureTasks(Configuration tasksConf) throws ConfigurationException
    {
        Map<String, Task> tasks = new LinkedHashMap<>();
        for (Configuration taskConf : tasksConf.getChildren("task"))
        {
            Task task = new Task();
            
            String taskId = taskConf.getAttribute("id", "").trim();
            
            task.setId(taskId);
            task.setLabel(new I18nizableText(null, taskConf.getAttribute("label", "").trim()));
            
            int length = taskConf.getAttributeAsInteger("length", 0);
            task.setLength(length);
            
            List<TaskStep> steps = new ArrayList<>();
            for (Configuration stepConf : taskConf.getChildren("step"))
            {
                TaskStep step = new TaskStep();
                
                String[] rightArray = StringUtils.split(stepConf.getAttribute("rights", ""), ", ");
                step.setStepIds(_configureStepIds(stepConf));
                step.setUserContents(stepConf.getAttributeAsBoolean("userContents", false));
                step.setRights(new HashSet<>(Arrays.asList(rightArray)));
                
                steps.add(step);
            }
            
            task.setSteps(steps);
            
            tasks.put(taskId, task);
        }
        return tasks;
    }

    /**
     * Configure the step IDs.
     * @param stepConf the step configuration.
     * @return the step IDs as a Set of Integer.
     * @throws ConfigurationException If an error occurred
     */
    protected Set<Integer> _configureStepIds(Configuration stepConf) throws ConfigurationException
    {
        String[] stepIdArray = StringUtils.split(stepConf.getAttribute("id", ""), ", ");
        Set<Integer> stepIds = new HashSet<>(stepIdArray.length);
        for (String stepId : stepIdArray)
        {
            try
            {
                stepIds.add(new Integer(stepId));
            }
            catch (NumberFormatException e)
            {
                // Ignore.
            }
        }
        return stepIds;
    }
    
    /**
     * SAX workflow current step of a {@link Content}
     * @param ch the content handler.
     * @param content The content
     * @throws SAXException if an error occurs while SAXing
     * @throws RepositoryException if an error occurs while retrieving current step
     */
    protected void _saxContentCurrentState(ContentHandler ch, WorkflowAwareContent content) throws SAXException, RepositoryException
    {
        int currentStepId = 0;
        
        AmetysObjectWorkflow workflow = _workflowProvider.getAmetysObjectWorkflow(content);
        long workflowId = content.getWorkflowId();
        
        List<Step> steps = workflow.getCurrentSteps(workflowId);
        if (!steps.isEmpty())
        {
            currentStepId = steps.get(steps.size() - 1).getStepId();
        }
        
        String workflowName = workflow.getWorkflowName(workflowId);
        WorkflowDescriptor workflowDescriptor = workflow.getWorkflowDescriptor(workflowName);
        StepDescriptor stepDescriptor = workflowDescriptor.getStep(currentStepId);
        
        I18nizableText workflowStepName = new I18nizableText("application", stepDescriptor.getName());
        
        AttributesImpl attr = new AttributesImpl();
        attr.addCDATAAttribute("id", Integer.toString(currentStepId));
        
        XMLUtils.startElement(ch, "workflow-step", attr);
        workflowStepName.toSAX(ch);
        XMLUtils.endElement(ch, "workflow-step");
        
        String[] icons = new String[]{"-small", "-medium", "-large"};
        for (String icon : icons)
        {
            if ("application".equals(workflowStepName.getCatalogue()))
            {
                XMLUtils.createElement(ch, "workflow-icon" + icon, "/plugins/cms/resources_workflow/" + workflowStepName.getKey() + icon + ".png");
            }
            else
            {
                String pluginName = workflowStepName.getCatalogue().substring("plugin.".length());
                XMLUtils.createElement(ch, "workflow-icon" + icon, "/plugins/" + pluginName + "/resources/img/workflow/" + workflowStepName.getKey() + icon + ".png");
            }
        }
    }
    
    /**
     * Class representing a task.
     */
    public class Task
    {
        /** The task ID. */
        protected String _id;
        
        /** The task label. */
        protected I18nizableText _label;
        
        /** The task step configuration. */
        protected Collection<TaskStep> _steps;
        
        /** The max number of result */
        protected int _length;
        
        /**
         * Class representing a task.
         */
        public Task()
        {
            this(new I18nizableText(""), new ArrayList<TaskStep>());
        }
        
        /**
         * Class representing a task.
         * @param label The label of the task
         * @param steps  The steps of the task
         */
        public Task(I18nizableText label, Collection<TaskStep> steps)
        {
            _label = label;
            _steps = new ArrayList<>(steps);
        }

        /**
         * Get the id.
         * @return the id
         */
        public String getId()
        {
            return _id;
        }

        /**
         * Set the id.
         * @param id the id to set
         */
        public void setId(String id)
        {
            this._id = id;
        }
        
        /**
         * Get the length.
         * @return the length
         */
        public int getLength()
        {
            return _length;
        }

        /**
         * Set the length.
         * @param length the length to set
         */
        public void setLength(int length)
        {
            this._length = length;
        }

        /**
         * Get the label.
         * @return the label
         */
        public I18nizableText getLabel()
        {
            return _label;
        }
        
        /**
         * Set the label.
         * @param label the label to set
         */
        public void setLabel(I18nizableText label)
        {
            this._label = label;
        }
        
        /**
         * Get the steps.
         * @return the steps
         */
        public Collection<TaskStep> getSteps()
        {
            return _steps;
        }

        /**
         * Set the steps.
         * @param steps the steps to set
         */
        public void setSteps(Collection<TaskStep> steps)
        {
            this._steps = steps;
        }
    }
    
    /**
     * Class representing a task step.
     */
    public class TaskStep
    {
        
        /** The step ID. */
        protected Set<Integer> _stepIds;
        
        /** Only return user contents. */
        protected boolean _userContents;
        
        /** The rights to have. */
        protected Set<String> _rights;
        
        /**
         * Construct a TaskStep object.
         */
        public TaskStep()
        {
            this(new HashSet<Integer>(), false, new HashSet<String>());
        }

        /**
         * Construct a TaskStep object with parameters.
         * @param stepIds the step ID.
         * @param userContents the user contents.
         * @param rights the rights.
         */
        public TaskStep(Set<Integer> stepIds, boolean userContents, Set<String> rights)
        {
            super();
            _stepIds = stepIds;
            _userContents = userContents;
            _rights = new HashSet<>(rights);
        }

        /**
         * Get the stepId.
         * @return the stepId
         */
        public Set<Integer> getStepIds()
        {
            return _stepIds;
        }

        /**
         * Set the stepId.
         * @param stepIds the stepId to set
         */
        public void setStepIds(Set<Integer> stepIds)
        {
            this._stepIds = stepIds;
        }

        /**
         * Get the userContents.
         * @return the userContents
         */
        public boolean getUserContentsOnly()
        {
            return _userContents;
        }

        /**
         * Set the userContents.
         * @param userContents the userContents to set
         */
        public void setUserContents(boolean userContents)
        {
            this._userContents = userContents;
        }

        /**
         * Get the rights.
         * @return the rights
         */
        public Set<String> getRights()
        {
            return _rights;
        }

        /**
         * Set the rights.
         * @param rights the rights to set
         */
        public void setRights(Set<String> rights)
        {
            this._rights = rights;
        }
        
    }
    
    /**
     * Compares two contents on the last modified date.
     */
    public class LastModifiedDateComparator implements Comparator<Content>
    {
        @Override
        public int compare(Content c1, Content c2)
        {
            // The content is before if 
            return c2.getLastModified().compareTo(c1.getLastModified());
        }
    }
}