/*
 *  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.content.consistency;

import java.time.ZonedDateTime;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Optional;
import java.util.concurrent.Callable;
import java.util.concurrent.CancellationException;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.Executor;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
import java.util.concurrent.ThreadFactory;
import java.util.concurrent.atomic.AtomicLong;

import javax.jcr.RepositoryException;

import org.apache.avalon.framework.activity.Initializable;
import org.apache.avalon.framework.component.Component;
import org.apache.avalon.framework.context.ContextException;
import org.apache.avalon.framework.context.Contextualizable;
import org.apache.avalon.framework.logger.Logger;
import org.apache.avalon.framework.service.ServiceException;
import org.apache.avalon.framework.service.ServiceManager;
import org.apache.avalon.framework.service.Serviceable;
import org.apache.cocoon.Constants;
import org.apache.cocoon.environment.Context;
import org.apache.cocoon.util.log.SLF4JLoggerAdapter;

import org.ametys.cms.content.references.OutgoingReferences;
import org.ametys.cms.repository.Content;
import org.ametys.cms.repository.ContentQueryHelper;
import org.ametys.cms.repository.DefaultContent;
import org.ametys.cms.repository.WorkflowAwareContent;
import org.ametys.cms.transformation.ConsistencyChecker;
import org.ametys.cms.transformation.ConsistencyChecker.CHECK;
import org.ametys.core.engine.BackgroundEngineHelper;
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.ModifiableAmetysObject;
import org.ametys.plugins.repository.ModifiableTraversableAmetysObject;
import org.ametys.plugins.repository.RepositoryConstants;
import org.ametys.plugins.repository.query.QueryHelper;
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.StringExpression;
import org.ametys.plugins.repositoryapp.RepositoryProvider;
import org.ametys.runtime.plugin.component.AbstractLogEnabled;

/**
 * Manage all operation related to checking the consistency of a content
 */
public class ContentConsistencyManager extends AbstractLogEnabled implements Initializable, Contextualizable, Serviceable, Component
{

    /** The avalon role */
    public static final String ROLE = ContentConsistencyManager.class.getName();
    
    private static ExecutorService __PARALLEL_THREAD_EXECUTOR;
    private static final int __THREAD_POOL_SIZE_MULTIPLIER = 4;
    
    /** The ametys object resolver. */
    protected AmetysObjectResolver _resolver;
    
    /** The consistency checker */
    protected ConsistencyChecker _consistencyChecker;
    
    private Context _cocoonContext;
    private RepositoryProvider _repositoryProvider;
    private ServiceManager _manager;

    public void contextualize(org.apache.avalon.framework.context.Context context) throws ContextException
    {
        _cocoonContext = (Context) context.get(Constants.CONTEXT_ENVIRONMENT_CONTEXT);
    }
    
    public void service(ServiceManager manager) throws ServiceException
    {
        _manager = manager;
        _consistencyChecker = (ConsistencyChecker) manager.lookup(ConsistencyChecker.ROLE);
        _resolver = (AmetysObjectResolver) manager.lookup(AmetysObjectResolver.ROLE);
        _repositoryProvider = (RepositoryProvider) manager.lookup(RepositoryProvider.ROLE);
    }

    public void initialize() throws Exception
    {
        AsyncConsistencyCheckerThreadFactory threadFactory = new AsyncConsistencyCheckerThreadFactory();
        // The thread are doing a lot of heavy IO operations, it's worth going over the number of available processors
        __PARALLEL_THREAD_EXECUTOR = Executors.newFixedThreadPool(Runtime.getRuntime().availableProcessors() * __THREAD_POOL_SIZE_MULTIPLIER, threadFactory);
    }
    
    /**
     * Thread factory for async checker.
     * Set the thread name format and marks the thread as daemon. 
     */
    static class AsyncConsistencyCheckerThreadFactory implements ThreadFactory
    {
        private static ThreadFactory _defaultThreadFactory;
        private static String _nameFormat;
        private static AtomicLong _count;
        
        public AsyncConsistencyCheckerThreadFactory()
        {
            _defaultThreadFactory = Executors.defaultThreadFactory();
            _nameFormat = "ametys-async-consistency-checker-%d";
            _count = new AtomicLong(0);
        }
        
        public Thread newThread(Runnable r)
        {
            Thread thread = _defaultThreadFactory.newThread(r);
            thread.setName(String.format(_nameFormat, _count.getAndIncrement()));
            // make the threads low priority daemon to avoid slowing user thread
            thread.setDaemon(true);
            thread.setPriority(3);
            
            return thread;
        }
    }
    
    /**
     * Getter to provide synthetic access to the manager
     */
    private ServiceManager getManager()
    {
        return _manager;
    }
    
    /**
     * Runnable to be used for asynchronous calls 
     */
    class AsyncConsistencyChecker implements Callable<String>
    {
        /** event to observe */
        protected final Logger _logger;
        private final Content _content;
        
        public AsyncConsistencyChecker(Content content, org.slf4j.Logger logger)
        {
            this._logger = new SLF4JLoggerAdapter(logger);
            this._content = content;
        }
        
        @Override
        public String call()
        {
            Map<String, Object> environmentInformation = null;
            try
            {
                // Create the environment.
                environmentInformation = BackgroundEngineHelper.createAndEnterEngineEnvironment(getManager(), _cocoonContext, _logger);
                
                return _checkConsistency(_content);
            }
            catch (Exception e)
            {
                throw new RuntimeException("Content consistency check for content " + _content.getId() + " failed", e);
            }
            finally
            {
                BackgroundEngineHelper.leaveEngineEnvironment(environmentInformation);
            }
        }
    }
    
    /**
     * Check all contents to see if there references are consistent.
     * All result will also be stored in the consistency result database table for later access.
     * @return record describing the results of the checks
     */
    public ConsistenciesReport checkAllContents() 
    {
        // Get the start date to remove outdated results later
        ZonedDateTime startDate = ZonedDateTime.now();
        try (AmetysObjectIterable<Content> contents = _getContents(null))
        {
            ConsistenciesReport checkReport = _checkContents(contents);
            // the checkContents only remove possible outdated results for the set of content provided as arguments.
            // We need to remove all the other result : deleted content, deleted link, etc…
            removeOutdatedResult(startDate, null);
            return checkReport;
        }
    }
    
    /**
     * Remove results older than a given date
     * @param date the threshold
     * @param filterExpression an expression to filter the content to consider, null to consider all contents
     */
    protected void removeOutdatedResult(ZonedDateTime date, Expression filterExpression)
    {
        String xPathQuery = QueryHelper.getXPathQuery(null, "ametys:consistencyResult", filterExpression);
        xPathQuery += "[@ametys:" + ContentConsistencyResult.DATE + " < xs:dateTime('" + DateUtils.zonedDateTimeToString(date) + "')]";
        try (AmetysObjectIterable<ContentConsistencyResult> outdatedResults = _resolver.query(xPathQuery))
        {
            for (ContentConsistencyResult outdatedResult : outdatedResults)
            {
                try
                {
                    outdatedResult.remove();
                    outdatedResult.saveChanges();
                }
                catch (AmetysRepositoryException e)
                {
                    getLogger().warn("Failed to remove outdated result '{}' due to repository error", outdatedResult.getId(), e);
                }
            }
        }
    }

    /**
     * Record holding the results of a consistency checks on multiple contents
     * @param results a list of {@link ContentConsistencyResult} for every contents that were checked
     * @param unchecked a list of content id for every content check that were interrupted, cancelled or failed during execution
     */
    public record ConsistenciesReport(List<String> results, List<String> unchecked) { /* Record */ }

    /**
     * Check all the content provided by the iterable for broken links.
     * This method will actually provide {@link Callable} to an {@link Executor} that parallelize the checks.
     * @param contents an iterable of contents to check
     * @return record describing the results of the checks
     */
    protected ConsistenciesReport _checkContents(AmetysObjectIterable<Content> contents)
    {
        try 
        {
            List<AsyncConsistencyChecker> checkers = contents.stream()
                .map(content -> new AsyncConsistencyChecker(content, getLogger()))
                .toList();
            
            // execute all checker and wait for their completion (either success or failure)
            List<Future<String>> futures = __PARALLEL_THREAD_EXECUTOR.invokeAll(checkers);
            
            // Refresh the session to retrieve the repository modification from the threads
            _repositoryProvider.getSession("default").refresh(true);
            
            Iterator<Future<String>> fIterarot = futures.iterator();
            Iterator<Content> cIterator = contents.iterator();
            
            List<String> done = new ArrayList<>();
            List<String> failed = new ArrayList<>();
            
            // both iterator should have the same size as the future iterator was mapped from the content iterator
            while (fIterarot.hasNext() && cIterator.hasNext())
            {
                Future<String> future = fIterarot.next();
                Content content = cIterator.next();
                
                try
                {
                    String result = future.get();
                    if (result != null)
                    {
                        done.add(result);
                    }
                }
                catch (CancellationException | InterruptedException | ExecutionException e)
                {
                    String contentId = content.getId();
                    getLogger().error("Failed to retrieve result from content consistency checker thread for content {}", contentId, e);
                    failed.add(contentId);
                }
            }
            return new ConsistenciesReport(done, failed);
        }
        catch (InterruptedException e)
        {
            getLogger().error("Content consistency check was interrupted", e);
            return null;
        }
        catch (RepositoryException e1)
        {
            getLogger().error("Failed to refresh the session");
            return null;
        }
    }
    
    private String _checkConsistency(Content content)
    {
        int successCount = 0;
        int unknownCount = 0;
        int unauthorizedCount = 0;
        int notFoundCount = 0;
        int serverErrorCount = 0;
        
        Map<String, OutgoingReferences> referencesByPath = content.getOutgoingReferences();
        
        for (String dataPath : referencesByPath.keySet())
        {
            OutgoingReferences references = referencesByPath.get(dataPath);
            for (String referenceType : references.keySet())
            {
                for (String referenceValue : references.get(referenceType))
                {
                    CHECK check;
                    try
                    {
                        check = _consistencyChecker.checkConsistency(referenceType, referenceValue, content.getId(), dataPath, false).status();
                    }
                    catch (Exception e)
                    {
                        check = CHECK.SERVER_ERROR;
                        getLogger().debug("An exception occurred while checking reference value {} at dataPath {} for content {}", referenceType + "#" + referenceValue, dataPath, content.getId(), e);
                    }
                    
                    switch (check)
                    {
                        case SUCCESS:
                            successCount++;
                            break;
                        case UNKNOWN:
                            unknownCount++;
                            break;
                        case UNAUTHORIZED:
                            unauthorizedCount++;
                            break;
                        case NOT_FOUND:
                            notFoundCount++;
                            break;
                        case SERVER_ERROR:
                        default:
                            serverErrorCount++;
                            break;
                    }
                }
            }
        }
        
        // Store the result
        ContentConsistencyResult result = storeResult((WorkflowAwareContent) content, successCount, unknownCount, unauthorizedCount, notFoundCount, serverErrorCount);
        
        return result != null ? result.getId() : null;
    }

    /**
     * Store the result of the consistency check done on the content
     * @param content the content checked
     * @param successCount the number of success
     * @param unknownCount the number of unknown
     * @param unauthorizedCount the number of unauthorized
     * @param notFoundCount the number of not found
     * @param serverErrorCount the number of server error
     * @return the result
     */
    protected ContentConsistencyResult storeResult(WorkflowAwareContent content, int successCount, int unknownCount, int unauthorizedCount, int notFoundCount, int serverErrorCount)
    {
        // Retrieve a pre existing result for the content or create an new one
        Optional<ContentConsistencyResult> previousResult = _getExistingResultForContent(content.getId());
        if (unknownCount > 0 || unauthorizedCount > 0 || serverErrorCount > 0 || notFoundCount > 0)
        {
            ContentConsistencyResult result = previousResult.orElseGet(() -> _getResultsCollection().createChild("consistency-" + content.getName(), "ametys:consistencyResult"));
            
            Map<String, Object> values = new HashMap<>(12);
            values.put(ContentConsistencyResult.CONTENT_ID, content.getId());
            values.put(ContentConsistencyResult.TITLE, content.getTitle());
            values.put(ContentConsistencyResult.CONTENT_TYPES, content.getTypes());
            values.put(ContentConsistencyResult.LAST_CONTRIBUTOR, content.getLastContributor());
            values.put(ContentConsistencyResult.WORKFLOW_STEP, content.getCurrentStepId());
            values.put(ContentConsistencyResult.DATE, ZonedDateTime.now());
            values.put(ContentConsistencyResult.NOT_FOUND, notFoundCount);
            values.put(ContentConsistencyResult.SERVER_ERROR, serverErrorCount);
            values.put(ContentConsistencyResult.SUCCESS, successCount);
            values.put(ContentConsistencyResult.UNAUTHORIZED, unauthorizedCount);
            values.put(ContentConsistencyResult.UNKNOWN, unknownCount);
            
            result.synchronizeValues(values);
            
            result.saveChanges();
            return result;
        }
        // Remove old result if there is no error any more
        else if (previousResult.isPresent())
        {
            ContentConsistencyResult result = previousResult.get();
            ModifiableAmetysObject parent = result.getParent();
            result.remove();
            parent.saveChanges();
        }
        return null;
    }

    private Optional<ContentConsistencyResult> _getExistingResultForContent(String id)
    {
        String xPathQuery = QueryHelper.getXPathQuery(null, "ametys:consistencyResult", new StringExpression(ContentConsistencyResult.CONTENT_ID, Operator.EQ, id));
        try (AmetysObjectIterable<ContentConsistencyResult> query = _resolver.query(xPathQuery))
        {
            return query.stream().findFirst();
        }
    }

    private ModifiableTraversableAmetysObject _getResultsCollection()
    {
        ModifiableTraversableAmetysObject pluginsRoot = _resolver.resolveByPath("/ametys:plugins");
        
        ModifiableTraversableAmetysObject cmsNode = null;
        if (pluginsRoot.hasChild("cms"))
        {
            cmsNode = (ModifiableTraversableAmetysObject) pluginsRoot.getChild("cms");
        }
        else
        {
            cmsNode = (ModifiableTraversableAmetysObject) pluginsRoot.createChild("cms", "ametys:unstructured");
        }
        
        ModifiableTraversableAmetysObject resultsCollection = null;
        if (cmsNode.hasChild("consistencyResults"))
        {
            resultsCollection = (ModifiableTraversableAmetysObject) cmsNode.getChild("consistencyResults");
        }
        else
        {
            resultsCollection = (ModifiableTraversableAmetysObject) cmsNode.createChild("consistencyResults", "ametys:collection");
        }
        
        return resultsCollection;
    }
    
    /**
     * Get the contents with inconsistency information.
     * @param filterExpression an expression to filter content to check, or null to check all contents
     * @return an iterator on contents.
     */
    protected AmetysObjectIterable<Content> _getContents(Expression filterExpression)
    {
        String query = ContentQueryHelper.getContentXPathQuery(filterExpression != null ? new AndExpression(new ConsistencyExpression(), filterExpression) : new ConsistencyExpression());
        return _resolver.query(query);
    }

    /**
     * Expression which tests if contents have consistency informations.
     */
    public static class ConsistencyExpression implements Expression
    {
        public String build()
        {
            return new StringBuilder()
            .append(RepositoryConstants.NAMESPACE_PREFIX_INTERNAL).append(':').append(DefaultContent.METADATA_ROOT_OUTGOING_REFERENCES)
            .append('/').append(RepositoryConstants.NAMESPACE_PREFIX_INTERNAL).append(':').append(DefaultContent.METADATA_OUTGOING_REFERENCES)
            .append("/*")
            .append("/@").append(RepositoryConstants.NAMESPACE_PREFIX).append(':').append(DefaultContent.METADATA_OUTGOING_REFERENCE_PROPERTY)
            .toString();
        }
    }
}