/*
 *  Copyright 2025 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.trash.element;

import java.time.ZonedDateTime;
import java.util.Arrays;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Optional;
import java.util.Set;
import java.util.function.Function;
import java.util.stream.Collectors;

import javax.jcr.Repository;
import javax.jcr.RepositoryException;
import javax.jcr.Session;

import org.apache.avalon.framework.component.Component;
import org.apache.avalon.framework.service.ServiceException;
import org.apache.avalon.framework.service.ServiceManager;
import org.apache.avalon.framework.service.Serviceable;
import org.apache.jackrabbit.util.ISO9075;

import org.ametys.cms.ObservationConstants;
import org.ametys.cms.trash.TrashConstants;
import org.ametys.cms.trash.model.TrashElementModel;
import org.ametys.core.observation.Event;
import org.ametys.core.observation.ObservationManager;
import org.ametys.core.user.CurrentUserProvider;
import org.ametys.core.util.DateUtils;
import org.ametys.plugins.repository.AmetysObject;
import org.ametys.plugins.repository.AmetysObjectIterable;
import org.ametys.plugins.repository.AmetysObjectResolver;
import org.ametys.plugins.repository.AmetysRepositoryException;
import org.ametys.plugins.repository.ModifiableTraversableAmetysObject;
import org.ametys.plugins.repository.RemovableAmetysObject;
import org.ametys.plugins.repository.collection.AmetysObjectCollection;
import org.ametys.plugins.repository.collection.AmetysObjectCollectionFactory;
import org.ametys.plugins.repository.jcr.JCRAmetysObject;
import org.ametys.plugins.repository.jcr.NameHelper;
import org.ametys.plugins.repository.jcr.NameHelper.NameComputationMode;
import org.ametys.plugins.repository.provider.AbstractRepository;
import org.ametys.plugins.repository.query.QueryHelper;
import org.ametys.plugins.repository.query.expression.AndExpression;
import org.ametys.plugins.repository.query.expression.BooleanExpression;
import org.ametys.plugins.repository.query.expression.DateExpression;
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.repository.trash.ConflictingNameException;
import org.ametys.plugins.repository.trash.TrashElement;
import org.ametys.plugins.repository.trash.TrashElementTypeExtensionPoint;
import org.ametys.plugins.repository.trash.TrashableAmetysObject;
import org.ametys.plugins.repository.trash.TrashableAmetysObject.MergeComputationMode;
import org.ametys.plugins.repository.trash.UnknownParentException;
import org.ametys.runtime.plugin.component.AbstractLogEnabled;

/**
 * {@link TrashElementDAO} to manage {@link TrashElement}s.
 */
public class TrashElementDAO extends AbstractLogEnabled implements org.ametys.plugins.repository.trash.TrashElementDAO, Serviceable, Component
{
    /** The name of the trash root node */
    protected static final String __TRASH_ROOT_NODE_NAME = "ametys-internal:trash";

    /** the Ametys object resolver */
    protected AmetysObjectResolver _resolver;

    private Repository _repository;
    private ObservationManager _observationManager;
    private CurrentUserProvider _currentUserProvider;

    private TrashElementTypeExtensionPoint _trashTypeEP;
    
    public void service(ServiceManager serviceManager) throws ServiceException
    {
        _repository = (Repository) serviceManager.lookup(AbstractRepository.ROLE);
        _resolver = (AmetysObjectResolver) serviceManager.lookup(AmetysObjectResolver.ROLE);
        _observationManager = (ObservationManager) serviceManager.lookup(ObservationManager.ROLE);
        _currentUserProvider = (CurrentUserProvider) serviceManager.lookup(CurrentUserProvider.ROLE);
        _trashTypeEP = (TrashElementTypeExtensionPoint) serviceManager.lookup(TrashElementTypeExtensionPoint.ROLE);
    }
    
    /**
     * Resolve the {@link AmetysObject} into the trash workspace.
     * @param <A> The type of the returned {@link AmetysObject}.
     * @param ametysObjectId The identifier
     * @return the resolved Ametys object, can be null if not found
     */
    public <A extends AmetysObject> A resolve(String ametysObjectId)
    {
        return executeInTrashSession(session -> _resolveSilently(ametysObjectId, session));
    }
    
    private <A extends AmetysObject> A _resolveSilently(String ametysObjectId, Session session)
    {
        try
        {
            return _resolver.resolveById(ametysObjectId, session);
        }
        catch (RepositoryException e)
        {
            throw new AmetysRepositoryException(e);
        }
    }
    
    /**
     * Find a trash element linked to a trashed ametys object.
     * @param ametysObjectId The ametys object id
     * @return the {@link TrashElement}, can be null if not found
     */
    public TrashElement find(String ametysObjectId)
    {
        return executeInTrashSession(
            session ->
            {
                try
                {
                    Expression expression = new StringExpression(TrashElementModel.DELETED_OBJECT, Operator.EQ, ametysObjectId);
                    String xPathQuery = QueryHelper.getXPathQuery(null, TrashElementFactory.TRASH_ELEMENT_NODETYPE, expression);
                    return _resolver.<TrashElement>query(xPathQuery, session).stream().findFirst().orElse(null);
                }
                catch (RepositoryException e)
                {
                    throw new AmetysRepositoryException(e);
                }
            }
        );
    }
    
    /**
     * Empty the trash.
     * @param filter indicates how to filter element
     * @throws AmetysRepositoryException if an error occurs
     */
    public void empty(TrashElementFilter filter) throws AmetysRepositoryException
    {
        empty(Optional.empty(), filter.getMinimumAge());
    }
    
    /**
     * Remove trash elements.
     * @param rootPath an optional JCR path to filter element to remove
     * @param lifetime Number of days before the trash has to be emptied. 0 or less empty all elements.
     */
    protected void empty(Optional<String> rootPath, long lifetime)
    {
        executeInTrashSession(
            session ->
            {
                Expression expression = lifetime > 0
                    ? new AndExpression(
                        // Only delete visible trash elements. Hidden trash elements will be deleted by cascading if needed
                        new BooleanExpression(TrashElementModel.HIDDEN, false),
                        new DateExpression(TrashElementModel.DATE, Operator.LT, DateUtils.asDate(ZonedDateTime.now().minusDays(lifetime)))
                    )
                    // If lifetime is not set, we want to delete all contents in the trash
                    : null;
                
                String xPathQuery = QueryHelper.getXPathQuery(null, TrashElementFactory.TRASH_ELEMENT_NODETYPE, expression);
                
                if (rootPath.isPresent())
                {
                    xPathQuery = rootPath.get() + xPathQuery;
                }
                try (AmetysObjectIterable<TrashElement> trashElements = _resolver.query(xPathQuery, session))
                {
                    for (TrashElement trashElement : trashElements)
                    {
                        _remove(trashElement, lifetime > 0);
                    }
                }
                catch (RepositoryException e)
                {
                    throw new AmetysRepositoryException(e);
                }
                finally
                {
                    session.logout();
                }
                
                return null;
            }
        );
    }
    
    /**
     * Compute the JCR path of the object and encode it to be used in XPath query
     * @param object the JCR Ametys object
     * @return the path
     * @throws RepositoryException if an error occurs
     */
    protected String getEncodedJCRPath(JCRAmetysObject object) throws RepositoryException
    {
        String path = object.getNode().getPath();
        
        return "/jcr:root" + Arrays.stream(path.split("/"))
            .map(ISO9075::encode)
            .collect(Collectors.joining("/"));
    }
    
    /**
     * Trash the {@link AmetysObject}.
     * @param ametysObject The Ametys object
     * @return the {@link TrashElement} created while moving the object to the trash
     */
    public TrashElement trash(TrashableAmetysObject ametysObject)
    {
        return trash(ametysObject, false, null);
    }
    
    /**
     * Trash the {@link AmetysObject}.
     * @param ametysObject The Ametys object
     * @param hidden <code>true</code> if it is an object trashed by another one
     * @param linkedObjects The list of linked objects to the current object to trash. Linked objects can be also trashed, but it is not mandatory.
     * @return the {@link TrashElement} created while moving the object to the trash
     */
    public TrashElement trash(TrashableAmetysObject ametysObject, boolean hidden, String[] linkedObjects)
    {
        String ametysObjectId = ametysObject.getId();
        
        // Move the trashed node under the trash element
        JCRAmetysObject originalParent = ametysObject.getParent();
        TrashElement trashElement = ametysObject.moveToTrash();
        trashElement.setHidden(hidden);
        trashElement.addLinkedObjects(linkedObjects);
        
        // Save changes to trash first. That way if the save fails, the original node is not destroyed
        trashElement.saveChanges();
        originalParent.saveChanges();
        
        // Notify observers
        Map<String, Object> eventParams = new HashMap<>();
        eventParams.put(ObservationConstants.ARGS_TRASH_ELEMENT_ID, trashElement.getId());
        eventParams.put(ObservationConstants.ARGS_AMETYS_OBJECT_ID, ametysObjectId);
        _observationManager.notify(new Event(ObservationConstants.EVENT_TRASH_ADDED, _currentUserProvider.getUser(), eventParams));
        
        return trashElement;
    }
    
    @Override
    public TrashElement createTrashElement(TrashableAmetysObject ametysObject, String title)
    {
        ModifiableTraversableAmetysObject trash = getOrCreateRoot(ametysObject);
        
        // Create the trash element
        String nodeName = NameHelper.getUniqueAmetysObjectName(trash, "trash", NameComputationMode.GENERATED_KEY, false);
        TrashElement trashElement = trash.createChild(nodeName, TrashElementFactory.TRASH_ELEMENT_NODETYPE);
        trashElement.setValue(TrashElementModel.TITLE, title);
        trashElement.setValue(TrashElementModel.AUTHOR, _currentUserProvider.getUser());
        trashElement.setValue(TrashElementModel.DATE, ZonedDateTime.now());
        trashElement.setValue(TrashElementModel.DELETED_OBJECT, ametysObject.getId());
        trashElement.setValue(TrashElementModel.PARENT_PATH, ametysObject.getParentPath());
        trashElement.setValue(TrashElementModel.HIDDEN, false);
        _trashTypeEP.getFirstSupportingExtension(ametysObject)
            .ifPresentOrElse(
                type -> trashElement.setValue(TrashElementModel.TRASH_TYPE, type.getId()),
                () -> {
                    // remove the node to prevent the presence of inconsistent data
                    trashElement.remove();
                    throw new IllegalStateException("No supporting type for trashable '" + ametysObject.getId() + "'.");
                }
            );
        
        return trashElement;
    }
    
    /**
     * Remove the {@link TrashElement} and its linked objects.
     * @param trashElementId The trash element identifier to remove
     */
    public void remove(String trashElementId)
    {
        _remove(resolve(trashElementId), true);
    }
    
    private void _remove(TrashElement trashElement, boolean removeLinkedElement)
    {
        // Get event param before deletion
        Map<String, Object> eventParams = new HashMap<>();
        eventParams.put(ObservationConstants.ARGS_TRASH_ELEMENT_ID, trashElement.getId());
        eventParams.put(ObservationConstants.ARGS_AMETYS_OBJECT_ID, trashElement.getAmetysObjectId());
        
        if (removeLinkedElement)
        {
            // Remove linked objects
            trashElement.getLinkedElements(true).forEach(e -> _remove(e, true));
        }
        
        // Remove the trash element itself
        _removeSingleObject(trashElement);
        
        // Notify observers
        _observationManager.notify(new Event(ObservationConstants.EVENT_TRASH_DELETED, _currentUserProvider.getUser(), eventParams));
    }
    
    private void _removeSingleObject(RemovableAmetysObject ametysObject)
    {
        JCRAmetysObject parent = ametysObject.getParent();
        ametysObject.remove();
        parent.saveChanges();
    }

    /**
     * Restore the {@link TrashElement} and its linked objects.
     * @param trashElementId The trash element identifier to restore
     * @param mergeComputationMode the merge computation mode, used to know how to behave when restoring an existing element. May be null, as all implementations may not use it.
     * @return a report of the operation
     * @throws UnknownParentException if its not possible to obtains a parent to restore into
     * @throws ConflictingNameException if there is a conflict between restored element or on of child element with existing element
     */
    public RestorationReport restore(String trashElementId, MergeComputationMode mergeComputationMode) throws UnknownParentException, ConflictingNameException
    {
        TrashElement trashElement = resolve(trashElementId);
        
        // Restore the object and all its linked objects
        Map<String, TrashableAmetysObject> result = _restore(trashElement, mergeComputationMode);
        
        // Perform additional action now that all object are restored
        for (TrashableAmetysObject restoredObject : result.values())
        {
            _trashTypeEP.getFirstSupportingExtension(restoredObject)
                .ifPresent(type -> type.additionnalRestoreAction(restoredObject));
        }
        
        // Then notify after all the restoration to unsure that all reference between restored elements are valid
        Set<TrashableAmetysObject> restoredLinkedObject = new HashSet<>();
        for (Entry<String, TrashableAmetysObject> entry : result.entrySet())
        {
            String elementId = entry.getKey();
            TrashableAmetysObject restoredObject = entry.getValue();
            
            // Notify observers
            Map<String, Object> eventParams = new HashMap<>();
            eventParams.put(ObservationConstants.ARGS_TRASH_ELEMENT_ID, elementId);
            eventParams.put(ObservationConstants.ARGS_AMETYS_OBJECT_ID, restoredObject.getId());
            _observationManager.notify(new Event(ObservationConstants.EVENT_TRASH_RESTORED, _currentUserProvider.getUser(), eventParams));
            
            // add to the linked object set if its not the original
            if (!elementId.equals(trashElementId))
            {
                restoredLinkedObject.add(restoredObject);
            }
        }
        
        return new RestorationReport(result.get(trashElementId), restoredLinkedObject);
    }
    
    /**
     * Restore a trash element, and its hidden linked element (if available) recursively
     * @param trashElement the trash element to restore
     * @return a map with the ids of the restored trash element as key and the restored trashables as value
     * @throws ConflictingNameException if there is a conflict between restored element (or on of his children element) with existing element
     */
    private Map<String, TrashableAmetysObject> _restore(TrashElement trashElement, MergeComputationMode mergeComputationMode) throws UnknownParentException, ConflictingNameException
    {
        Map<String, TrashableAmetysObject> result = new HashMap<>();
        
        String trashElementId = trashElement.getId();
        String trashableAOId = trashElement.getAmetysObjectId();
        TrashableAmetysObject trashableAO = resolve(trashableAOId);
        
        // We first restored linked object because the page implementation has a physical reference to its contents.
        // So if we restored the page before the contents, we have an exception from the repository.
        // It seems to be unavoidable.
        
        Set<TrashElement> linkedElements = trashElement.getLinkedElements(true);
        
        Set<TrashElement> failedLinkedElements = new HashSet<>();
        
        for (TrashElement linkedElement: linkedElements)
        {
            try
            {
                result.putAll(_restore(linkedElement, mergeComputationMode));
            }
            catch (UnknownParentException | ConflictingNameException e)
            {
                // Do not prevent restoring the original element because
                // a linked element failed, however we want to store them in order to make them visible in trash if original element is restored
                failedLinkedElements.add(linkedElement);
                getLogger().warn("An error prevented to restore the element '{}' that is linked to the restoration of '{}'", linkedElement.getId(), trashableAO.getId());
            }
        }
        
        // Restore the current trash element
        TrashableAmetysObject restoredAO = trashableAO.restoreFromTrash(mergeComputationMode);
        
        result.put(trashElementId, restoredAO);
        
        // If some linked element failed to be restored, we need to update them to be visible in the trash, as they are still linked to the original element that is now restored
        failedLinkedElements.stream().forEach(failedLinkedElement -> {
            try
            {
                failedLinkedElement.setHidden(false);
                failedLinkedElement.saveChanges();
            }
            catch (Exception e)
            {
                getLogger().error("Error while changing visibility of linked element '" + failedLinkedElement.getId() + "'.", e);
            }
        });
        
        // Remove the trash element
        _removeSingleObject(trashElement);
        
        return result;
    }
    
    /**
     * Get or create the trash root
     * @param ametysObject the object that need to be trashed
     * @return the trash where the ametys will be trashed
     */
    protected ModifiableTraversableAmetysObject getOrCreateRoot(TrashableAmetysObject ametysObject)
    {
        return executeInTrashSession(
            session ->
            {
                ModifiableTraversableAmetysObject root = _resolver.resolveByPath("/", session);
                return getOrCreateCollection(root, __TRASH_ROOT_NODE_NAME);
            }
        );
    }
    
    /**
     * Get or create an Ametys object collection on the given parent
     * @param parent The parent
     * @param collectionName The collection name
     * @return The {@link AmetysObjectCollection}
     */
    protected ModifiableTraversableAmetysObject getOrCreateCollection(ModifiableTraversableAmetysObject parent, String collectionName)
    {
        if (parent.hasChild(collectionName))
        {
            return parent.getChild(collectionName);
        }
        else
        {
            ModifiableTraversableAmetysObject child = parent.createChild(collectionName, AmetysObjectCollectionFactory.COLLECTION_NODETYPE);
            parent.saveChanges();
            return child;
        }
    }
    
    
    /**
     * Execute a function into the trash workspace.
     * 
     * This method only handles the creation of the session.
     * The caller is responsible for logging out (either in the function itself or by using the returned value).
     * 
     * @param <A> The returned type, can be anything. If it is {@link Void}, the function should return <code>null</code>
     * @param functionToExecute The function to execute, it takes a {@link Session} as parameter
     * @return The result of the function
     */
    protected <A> A executeInTrashSession(Function<Session, A> functionToExecute)
    {
        Session trashSession = null;
        try
        {
            // Login the trash workspace
            trashSession = _repository.login(TrashConstants.TRASH_WORKSPACE);
            
            // Execute the function with the trash session
            return functionToExecute.apply(trashSession);
        }
        catch (RepositoryException e)
        {
            throw new AmetysRepositoryException(e);
        }
    }

    /**
     * Describe the result of a restore operation.
     * The report contains :
     * <ul>
     * <li>the restored object
     * <li>a list of all the object restored with it
     * </ul>
     * @param restoredObject the restored object
     * @param restoredLinkedObject the object restored along the {@code restoredObject}
     */
    public record RestorationReport(TrashableAmetysObject restoredObject, Set<TrashableAmetysObject> restoredLinkedObject) { }
    
    /**
     * Information related to filtering trash element targeted by a mass operation
     */
    public static class TrashElementFilter
    {
        private long _age;
        
        /**
         * Information related to filtering trash element targeted by a mass operation
         * @param age Minimum age (in days) of the element. 0 or less means no filtering.
         */
        public TrashElementFilter(long age)
        {
            _age = age;
        }
        
        /**
         * Get the minimum age of an element
         * @return the age in days
         */
        public long getMinimumAge()
        {
            return _age;
        }
    }
}