/*
 *  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.io.IOException;
import java.time.ZoneId;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.Date;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Set;

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

import org.apache.avalon.framework.service.ServiceException;
import org.apache.avalon.framework.service.ServiceManager;
import org.apache.cocoon.ProcessingException;
import org.apache.cocoon.environment.ObjectModelHelper;
import org.apache.cocoon.environment.Request;
import org.apache.cocoon.generation.Generator;
import org.apache.cocoon.generation.ServiceableGenerator;
import org.apache.cocoon.xml.AttributesImpl;
import org.apache.cocoon.xml.XMLUtils;
import org.apache.commons.lang.StringUtils;
import org.xml.sax.SAXException;

import org.ametys.cms.repository.Content;
import org.ametys.cms.repository.WorkflowAwareContent;
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.AmetysObjectResolver;
import org.ametys.plugins.repository.version.VersionAwareAmetysObject;
import org.ametys.plugins.workflow.store.AbstractJackrabbitWorkflowStore;
import org.ametys.plugins.workflow.store.AmetysStep;
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.ActionDescriptor;
import com.opensymphony.workflow.loader.StepDescriptor;
import com.opensymphony.workflow.loader.WorkflowDescriptor;
import com.opensymphony.workflow.spi.SimpleStep;
import com.opensymphony.workflow.spi.Step;

/**
 * {@link Generator} for exposing content history and content versions.
 */
public class HistoryGenerator extends ServiceableGenerator
{
    
    private static final I18nizableText __MESSAGE_NO_STEP = new I18nizableText("plugin.cms", "WORKFLOW_UNKNOWN_STEP");
    
    private static final I18nizableText __MESSAGE_NO_ACTION = new I18nizableText("plugin.cms", "WORKFLOW_UNKNOWN_ACTION");
    
    private Map<UserIdentity, String> _identityToFullNameCache;
    private WorkflowProvider _workflowProvider;
    private UserManager _userManager;
    private AmetysObjectResolver _resolver;
    
    @Override
    public void service(ServiceManager serviceManager) throws ServiceException
    {
        super.service(serviceManager);
        _workflowProvider = (WorkflowProvider) serviceManager.lookup(WorkflowProvider.ROLE);
        _userManager = (UserManager) serviceManager.lookup(UserManager.ROLE);
        _resolver = (AmetysObjectResolver) serviceManager.lookup(AmetysObjectResolver.ROLE);
    }
    
    @Override
    public void generate() throws IOException, SAXException, ProcessingException
    {
        _identityToFullNameCache = new HashMap<>();
        
        Request request = ObjectModelHelper.getRequest(objectModel);
        
        String id = request.getParameter("contentId");
        Content content = _resolver.resolveById(id);
        
        assert content instanceof VersionAwareAmetysObject;
        
        contentHandler.startDocument();
        XMLUtils.startElement(contentHandler, "History");
        
        try
        {
            List<VersionInformation> versionsInformation = _resolveVersionInformations((VersionAwareAmetysObject) content);
            
            _saxVersionInformation(versionsInformation);
            
            AttributesImpl attrs = new AttributesImpl();
            attrs.addCDATAAttribute("contentIsWorkflowAware", Boolean.toString(content instanceof WorkflowAwareContent));
            
            XMLUtils.startElement(contentHandler, "Workflow", attrs);
            _saxContentWorkflowHistory(content, versionsInformation);
            XMLUtils.endElement(contentHandler, "Workflow");
        }
        catch (RepositoryException e)
        {
            throw new ProcessingException("Unable to access version history", e);
        }
        
        XMLUtils.endElement(contentHandler, "History");
        contentHandler.endDocument();
    }
    
    private List<VersionInformation> _resolveVersionInformations(VersionAwareAmetysObject content) throws RepositoryException
    {
        List<VersionInformation> versionsInformation = new ArrayList<>();
        
        for (String revision : content.getAllRevisions())
        {
            VersionInformation versionInformation = new VersionInformation(revision, content.getRevisionTimestamp(revision));
            
            for (String label : content.getLabels(revision))
            {
                versionInformation.addLabel(label);
            }
            
            versionsInformation.add(versionInformation);
        }
        
        // Sort by date descendant
        Collections.sort(versionsInformation, new Comparator<VersionInformation>()
        {
            public int compare(VersionInformation o1, VersionInformation o2)
            {
                try
                {
                    return -o1.getCreatedAt().compareTo(o2.getCreatedAt());
                }
                catch (RepositoryException e)
                {
                    throw new RuntimeException("Unable to retrieve a creation date", e);
                }
            }
        });
        
        // Set the version name
        int count = versionsInformation.size();
        for (VersionInformation versionInformation : versionsInformation)
        {
            versionInformation.setVersionName(String.valueOf(count--));
        }
        
        return versionsInformation;
    }
    
    private void _saxVersionInformation(List<VersionInformation> versionsInformation) throws SAXException, RepositoryException
    {
        XMLUtils.startElement(contentHandler, "Versions");
        
        for (VersionInformation info : versionsInformation)
        {
            AttributesImpl atts = new AttributesImpl();
            
            if (info.getVersionRawName() != null)
            {
                atts.addCDATAAttribute("rawName", info.getVersionRawName());
            }
            
            if (info.getVersionName() != null)
            {
                atts.addCDATAAttribute("name", info.getVersionName());
            }
            
            if (info.getCreatedAt() != null)
            {
                atts.addCDATAAttribute("createdAt", DateUtils.getISODateTimeFormatter().format(info.getCreatedAt().toInstant().atZone(ZoneId.systemDefault())));
            }
            
            XMLUtils.createElement(contentHandler, "Version", atts);
        }
        
        XMLUtils.endElement(contentHandler, "Versions");
    }
    
    @SuppressWarnings("unchecked")
    private void _saxContentWorkflowHistory(Content content, List<VersionInformation> versionsInformation) throws SAXException, ProcessingException, RepositoryException
    {
        if (content instanceof WorkflowAwareContent)
        {
            WorkflowAwareContent workflowAwareContent = (WorkflowAwareContent) content;
            
            long workflowId = workflowAwareContent.getWorkflowId();
            AmetysObjectWorkflow workflow = _workflowProvider.getAmetysObjectWorkflow(workflowAwareContent);
            
            String workflowName = workflow.getWorkflowName(workflowId);
            
            if (workflowName == null)
            {
                throw new ProcessingException("Unknown workflow name for workflow instance id: " + workflowId);
            }
            
            WorkflowDescriptor workflowDescriptor = workflow.getWorkflowDescriptor(workflowName);
            
            if (workflowDescriptor == null)
            {
                throw new ProcessingException("No workflow description for workflow name: " + workflowName);
            }
            
            List<Step> allSteps = new ArrayList(workflow.getCurrentSteps(workflowId));
            allSteps.addAll(workflow.getHistorySteps(workflowId));
            
            // Sort by start date descendant (only relevant when there is no split and nor join!)
            Collections.sort(allSteps, new Comparator<Step>()
            {
                public int compare(Step s1, Step s2)
                {
                    return -s1.getStartDate().compareTo(s2.getStartDate());
                }
            });
            
            Date startDate = null;
            
            if (!allSteps.isEmpty())
            {
                // Use start date of the first step for the start date
                // of the unstored "real first step"
                startDate = allSteps.get(allSteps.size() - 1).getStartDate();
            }
            
            // Use a custom step for the unstored "real first step"
            int initialActionId = (int) _getInitialActionId(workflow, workflowAwareContent);
            allSteps.add(new SimpleStep(0, 0, 0, initialActionId, null, content.getCreationDate(), startDate, null, "", new long[0], UserIdentity.userIdentityToString(content.getCreator())));
            
            Iterator<Step> itStep = allSteps.iterator();
            // We got at least one
            Step step = itStep.next();
            
            do
            {
                Step previousStep = null;
                
                if (itStep.hasNext())
                {
                    previousStep = itStep.next();
                }
                
                _saxStep(workflowDescriptor, versionsInformation, step, previousStep);
                
                step = previousStep;
            } while (itStep.hasNext());
        }
    }

    private long _getInitialActionId(AmetysObjectWorkflow workflow, WorkflowAwareContent waContent)
    {
        try
        {
            Session session = waContent.getNode().getSession();
            AbstractJackrabbitWorkflowStore workflowStore = (AbstractJackrabbitWorkflowStore) workflow.getConfiguration().getWorkflowStore();
            Node workflowEntryNode = workflowStore.getEntryNode(session, waContent.getWorkflowId());
            return workflowEntryNode.getProperty("ametys-internal:initialActionId").getLong();
        }
        catch (Exception e)
        {
            getLogger().error("Unable to retrieves initial action id for workflow aware content : " + waContent.getId(), e);
            return 0;
        }
    }

    private void _saxStep(WorkflowDescriptor workflowDescriptor, List<VersionInformation> versionsInformation, Step step, Step previousStep) throws SAXException, RepositoryException
    {
        AttributesImpl stepAttrs = new AttributesImpl();
        
        // We want the caller of the action responsible for being in the step
        String caller = previousStep != null ? previousStep.getCaller() : null;
        int stepId = step.getStepId();
        // We want the id of the action responsible for being in the step
        int actionId = previousStep != null ? previousStep.getActionId() : 0;
        
        // Get the action start and finish dates (here, it acts as a marker to distinguish
        // old and new workflow step structure).
        Date actionStartDate = null;
        Date actionFinishDate = null;
        if (step instanceof AmetysStep)
        {
            actionStartDate = (Date) ((AmetysStep) step).getProperty("actionStartDate");
            actionFinishDate = (Date) ((AmetysStep) step).getProperty("actionFinishDate");
        }
        
        Date startDate = null;
        Date finishDate = null;
        if (actionFinishDate != null)
        {
            // New format
            startDate = step.getStartDate() != null ? step.getStartDate() : null;
            finishDate = step.getFinishDate() != null ? step.getFinishDate() : null;
        }
        else
        {
            startDate = previousStep != null ? previousStep.getFinishDate() : null;
            finishDate = step.getStartDate();
        }
        
        if (stepId != 0)
        {
            stepAttrs.addCDATAAttribute("id", String.valueOf(stepId));
        }
        
        if (step.getFinishDate() == null)
        {
            stepAttrs.addCDATAAttribute("current", Boolean.TRUE.toString());
        }
        
        XMLUtils.startElement(contentHandler, "Step", stepAttrs);
        
        _saxStepDescription(workflowDescriptor, stepId);
        
        _saxCaller(UserIdentity.stringToUserIdentity(caller));
        
        _saxAction(actionId, workflowDescriptor);
        
        _saxComments(previousStep);
        
        _saxValidation(step, startDate, finishDate, actionStartDate, actionFinishDate);
        
        List<VersionInformation> versionsInsideStep = _computeVersionsBetween(versionsInformation, startDate, finishDate);
        
        for (VersionInformation versionInformation : versionsInsideStep)
        {
            AttributesImpl versionAttrs = new AttributesImpl();
            
            for (String label : versionInformation.getLabels())
            {
                versionAttrs.addCDATAAttribute(label, label);
            }
            if (StringUtils.isNotEmpty(versionInformation.getVersionRawName()))
            {
                versionAttrs.addCDATAAttribute("name", versionInformation.getVersionRawName());
            }
            XMLUtils.createElement(contentHandler, "Version", versionAttrs, versionInformation.getVersionName());
        }
        
        XMLUtils.endElement(contentHandler, "Step");
    }
    
    private void _saxStepDescription(WorkflowDescriptor workflowDescriptor, int stepId) throws SAXException
    {
        if (stepId != 0)
        {
            StepDescriptor stepDescriptor = workflowDescriptor.getStep(stepId);
            
            I18nizableText workflowStepName = stepDescriptor == null ? __MESSAGE_NO_STEP : new I18nizableText("application", stepDescriptor.getName());
            
            workflowStepName.toSAX(contentHandler, "StepName");
            
            String[] icons = new String[]{"-small", "-medium", "-large"};
            for (String icon : icons)
            {
                if ("application".equals(workflowStepName.getCatalogue()))
                {
                    XMLUtils.createElement(contentHandler, "StepIcon" + icon, "/plugins/cms/resources_workflow/" + workflowStepName.getKey() + icon + ".png");
                }
                else
                {
                    String pluginName = workflowStepName.getCatalogue().substring("plugin.".length());
                    XMLUtils.createElement(contentHandler, "StepIcon" + icon, "/plugins/" + pluginName + "/resources/img/workflow/" + workflowStepName.getKey() + icon + ".png");
                }
            }
        }
        else
        {
            XMLUtils.createElement(contentHandler, "StepName", "?");
            XMLUtils.createElement(contentHandler, "StepIcon-small", "/plugins/cms/resources/img/history/workflow/step_0_16.png");
            XMLUtils.createElement(contentHandler, "StepIcon-medium", "/plugins/cms/resources/img/history/workflow/step_0_32.png");
            XMLUtils.createElement(contentHandler, "StepIcon-large", "/plugins/cms/resources/img/history/workflow/step_0_48.png");
        }
    }
    
    private void _saxCaller(UserIdentity caller) throws SAXException
    {
        if (caller != null)
        {
            AttributesImpl authorAttrs = new AttributesImpl();
            authorAttrs.addCDATAAttribute("login", caller.getLogin());
            authorAttrs.addCDATAAttribute("population", caller.getPopulationId());
            XMLUtils.createElement(contentHandler, "Author", authorAttrs,  _resolveFullName(caller));
        }
    }
    
    private void _saxAction(int actionId, WorkflowDescriptor workflowDescriptor) throws SAXException
    {
        if (actionId != 0)
        {
            ActionDescriptor actionDescriptor = workflowDescriptor.getAction(actionId);
            
            I18nizableText actionLabel = actionDescriptor == null ? __MESSAGE_NO_ACTION : new I18nizableText("application", actionDescriptor.getName());
            
            XMLUtils.createElement(contentHandler, "ActionId", String.valueOf(actionId));
            actionLabel.toSAX(contentHandler, "ActionName");
        }
        else
        {
            new I18nizableText("plugin.cms", "WORKFLOW_ACTION_CREATE").toSAX(contentHandler, "ActionName");
        }
    }
    
    private void _saxComments(Step previousStep) throws SAXException
    {
        if (previousStep != null && previousStep instanceof AmetysStep)
        {
            String comments = (String) ((AmetysStep) previousStep).getProperty("comment");
            if (comments != null)
            {
                XMLUtils.createElement(contentHandler, "Comment", comments.replaceAll("\r?\n", "<br/>"));
            }
        }
    }
    
    private void _saxValidation(Step step, Date startDate, Date finishDate, Date actionStartDate, Date actionFinishDate) throws SAXException
    {
        Boolean validation = false;
        if (step instanceof AmetysStep)
        {
            validation = (Boolean) ((AmetysStep) step).getProperty("validation");
        }
        boolean valid = validation == null ? false : validation;
        XMLUtils.createElement(contentHandler, "Validation", String.valueOf(valid));
        
        if (startDate != null)
        {
            XMLUtils.createElement(contentHandler, "Start", DateUtils.dateToString(startDate));
        }
        
        if (finishDate != null)
        {
            XMLUtils.createElement(contentHandler, "Finish", DateUtils.dateToString(finishDate));
        }

        if (actionStartDate != null)
        {
            XMLUtils.createElement(contentHandler, "NewActionStart", DateUtils.dateToString(actionStartDate));
        }
        
        if (actionFinishDate != null)
        {
            XMLUtils.createElement(contentHandler, "OldActionFinish", DateUtils.dateToString(actionFinishDate));
        }
        
    }

    private List<VersionInformation> _computeVersionsBetween(List<VersionInformation> versionsInformation, Date startDate, Date finishDate) throws RepositoryException
    {
        List<VersionInformation> versionsInsideStep = new ArrayList<>();
        
        for (VersionInformation versionInformation : versionsInformation)
        {
            Date versionCreationDate = versionInformation.getCreatedAt();
            
            if (startDate != null)
            {
                if (versionCreationDate.after(startDate))
                {
                    if (finishDate == null || versionCreationDate.before(finishDate))
                    {
                        versionsInsideStep.add(versionInformation);
                    }
                }
            }
            else
            {
                if (finishDate == null || versionCreationDate.before(finishDate))
                {
                    versionsInsideStep.add(versionInformation);
                }
            }
        }
        
        // If there is no version created inside the step,
        // retrieve the last one just before the step 
        if (versionsInsideStep.isEmpty())
        {
            VersionInformation lastVersionBeforeStep = null;
            
            for (VersionInformation versionInformation : versionsInformation)
            {
                Date versionCreationDate = versionInformation.getCreatedAt();
                
                if (startDate != null && versionCreationDate.before(startDate))
                {
                    lastVersionBeforeStep = versionInformation;
                    break;
                }
                else if (startDate == null)
                {
                    // Use the first version
                    lastVersionBeforeStep = versionInformation;
                }
            }
            
            if (lastVersionBeforeStep != null)
            {
                versionsInsideStep.add(lastVersionBeforeStep);
            }
        }
        
        // if there is still no version for this step, then it is version 1 (case of migrations)
        if (versionsInsideStep.isEmpty())
        {
            versionsInsideStep.add(new VersionInformation("1"));
        }
        
        return versionsInsideStep;
    }

    private String _resolveFullName(UserIdentity userIdentity)
    {
        String fullName = _identityToFullNameCache.get(userIdentity);
        
        if (fullName == null)
        {
            User user = _userManager.getUser(userIdentity.getLogin(), userIdentity.getPopulationId());
            
            if (user != null)
            {
                fullName = user.getFullName();
                // Cache result
                _identityToFullNameCache.put(userIdentity, fullName);
            }
        }
        
        if (fullName == null)
        {
            // Not found
            return "";
        }
        else
        {
            return fullName;
        }
    }

    @Override
    public void recycle()
    {
        super.recycle();
        _identityToFullNameCache = null;
    }
    
    private static class VersionInformation
    {
        private String _rawName;
        private String _name;
        private Date _creationDate;
        private Set<String> _labels = new HashSet<>();
        
        /**
         * Creates a {@link VersionInformation}.
         * @param rawName the revision name.
         * @param creationDate the revision creation date.
         * @throws RepositoryException if an error occurs.
         */
        public VersionInformation(String rawName, Date creationDate)throws RepositoryException
        {
            _creationDate = creationDate;
            _rawName = rawName;
        }

        /**
         * Creates a named {@link VersionInformation}.
         * @param name the name to use.
         */
        public VersionInformation(String name)
        {
            _name = name;
        }

        /**
         * Set the version name
         * @param name The name
         */
        public void setVersionName (String name)
        {
            _name = name;
        }
        
        /**
         * Retrieves the version name.
         * @return the version name.
         */
        public String getVersionName()
        {
            return _name;
        }
        
        /**
         * Retrieves the version raw name.
         * @return the version raw name.
         */
        public String getVersionRawName()
        {
            return _rawName;
        }
        
        /**
         * Retrieves the creation date.
         * @return the creation date.
         * @throws RepositoryException if an error occurs.
         */
        public Date getCreatedAt() throws RepositoryException
        {
            return _creationDate;
        }
        
        /**
         * Retrieves the labels associated with this version.
         * @return the labels.
         */
        public Set<String> getLabels()
        {
            return _labels;
        }
        
        /**
         * Add a label to this version.
         * @param label the label.
         */
        public void addLabel(String label)
        {
            _labels.add(label);
        }
    }
}