/*
 *  Copyright 2011 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.purge;

import java.util.ArrayList;
import java.util.LinkedHashSet;
import java.util.List;
import java.util.ListIterator;
import java.util.Set;

import javax.jcr.Node;
import javax.jcr.RepositoryException;
import javax.jcr.nodetype.NodeType;
import javax.jcr.version.Version;
import javax.jcr.version.VersionHistory;
import javax.jcr.version.VersionIterator;
import javax.jcr.version.VersionManager;

import org.apache.avalon.framework.component.Component;
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.joda.time.DateTime;

import org.ametys.cms.repository.WorkflowAwareContent;
import org.ametys.cms.repository.WorkflowAwareContentHelper;
import org.ametys.plugins.repository.AmetysRepositoryException;
import org.ametys.plugins.repository.RepositoryConstants;
import org.ametys.runtime.config.Config;

/**
 * Component which purges content old versions.
 */
public class PurgeVersionsManager extends AbstractLogEnabled implements Component, Serviceable
{
    
    /** The avalon component role. */
    public static final String ROLE = PurgeVersionsManager.class.getName();
    
    /** The current step ID property. */
    private static final String __CURRENT_STEP_ID_PROPERTY = RepositoryConstants.NAMESPACE_PREFIX_INTERNAL + ':' + WorkflowAwareContentHelper.METADATA_CURRENT_STEP_ID;
    
    @Override
    public void service(ServiceManager manager) throws ServiceException
    {
        // Ignore.
    }
    
    /**
     * Purge a content.
     * @param content the content to purge.
     * @param validationStepId the ID of the validation step for this content.
     * @param firstVersionsToKeep the count of first versions to keep.
     * @return the count of removed versions.
     */
    public int purgeContent(WorkflowAwareContent content, long validationStepId, int firstVersionsToKeep)
    {
        try
        {
            Node node = content.getNode();
            
            if (node.isNodeType(NodeType.MIX_VERSIONABLE))
            {
                // Retrieve the version history and base version of the content.
                VersionManager versionManager = node.getSession().getWorkspace().getVersionManager();
                VersionHistory versionHistory = versionManager.getVersionHistory(node.getPath());
                Version baseVersion = versionManager.getBaseVersion(node.getPath());
                
                return purgeContent(content, versionHistory, baseVersion, validationStepId, firstVersionsToKeep);
            }
            
            return 0;
        }
        catch (RepositoryException e)
        {
            throw new AmetysRepositoryException("Error purging the content " + content.getId(), e);
        }
    }
    
    /**
     * Purge a content version history.
     * @param content the content.
     * @param versionHistory the version history to purge.
     * @param baseVersion the content base version, must be kept.
     * @param validationStepId the ID of the validation step for this content.
     * @param firstVersionsToKeep the count of first versions to keep.
     * @return the count of removed versions.
     * @throws RepositoryException if an error occurs.
     */
    protected int purgeContent(WorkflowAwareContent content, VersionHistory versionHistory, Version baseVersion, long validationStepId, int firstVersionsToKeep) throws RepositoryException
    {
        int validatedVersionsToKeep = Config.getInstance().getValueAsLong("purge.keep.validated.versions").intValue();
        int daysToKeep = Config.getInstance().getValueAsLong("purge.before.days").intValue();
        
        Set<String> versionsToRemove = new LinkedHashSet<>();
        
        DateTime limit = new DateTime().minusDays(daysToKeep);
        
        // Get all the versions.
        List<VersionInfo> allVersions = getAllVersions(versionHistory);
        
        ListIterator<VersionInfo> versionIt = allVersions.listIterator(allVersions.size());
        
        int validatedVersions = 0;
        try
        {
            if (content.getCurrentStepId() == validationStepId)
            {
                validatedVersions++;
            }
        }
        catch (AmetysRepositoryException e)
        {
            validatedVersions = 0;
        }
        
        while (versionIt.hasPrevious())
        {
            VersionInfo info = versionIt.previous();
            
            if (validatedVersions >= validatedVersionsToKeep && info.getCreated().isBefore(limit) && versionIt.previousIndex() >= firstVersionsToKeep - 1)
            {
                // Do not remove the base version.
                if (!info.getName().equals(baseVersion.getName()))
                {
                    versionsToRemove.add(info.getName());
                }
            }
            
            if (info.getStepId() != null && info.getStepId() == validationStepId)
            {
                validatedVersions++;
            }
        }
        
        for (String version : versionsToRemove)
        {
            versionHistory.removeVersion(version);
        }
        
        return versionsToRemove.size();
    }

    /**
     * Get all versions of a version history.
     * @param versionHistory the version history to purge.
     * @return all the version infos.
     * @throws RepositoryException if an error occurs.
     */
    protected List<VersionInfo> getAllVersions(VersionHistory versionHistory) throws RepositoryException
    {
        List<VersionInfo> allVersions = new ArrayList<>();
        
        VersionIterator versions = versionHistory.getAllVersions();
        
        while (versions.hasNext())
        {
            Version version = versions.nextVersion();
            
            Node node = version.getFrozenNode();
            
            VersionInfo info = new VersionInfo();
            
            info.setName(version.getName());
            info.setCreated(version.getCreated().getTimeInMillis());
            
            if (node.hasProperty(__CURRENT_STEP_ID_PROPERTY))
            {
                long stepId = node.getProperty(__CURRENT_STEP_ID_PROPERTY).getLong();
                info.setStepId(stepId);
            }
            
            allVersions.add(info);
        }
        
        return allVersions;
    }
    
    /**
     * Version information.
     */
    protected class VersionInfo
    {
        
        /** The version name. */
        protected String _name;
        
        /** The version creation date. */
        protected DateTime _created;
        
        /** The version step ID. */
        protected Long _stepId;
        
        /**
         * Get the name.
         * @return the name
         */
        public String getName()
        {
            return _name;
        }
        
        /**
         * Set the name.
         * @param name the name to set
         */
        public void setName(String name)
        {
            this._name = name;
        }
        
        /**
         * Get the created.
         * @return the created
         */
        public DateTime getCreated()
        {
            return _created;
        }
        
        /**
         * Set the created.
         * @param created the created to set
         */
        public void setCreated(long created)
        {
            this._created = new DateTime(created);
        }
        
        /**
         * Get the stepId.
         * @return the stepId
         */
        public Long getStepId()
        {
            return _stepId;
        }
        
        /**
         * Set the stepId.
         * @param stepId the stepId to set
         */
        public void setStepId(Long stepId)
        {
            this._stepId = stepId;
        }
        
        @Override
        public String toString()
        {
            return _name;
        }
        
    }

}