/*
 *  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.TrashElement;
import org.ametys.plugins.repository.trash.TrashElementTypeExtensionPoint;
import org.ametys.plugins.repository.trash.TrashableAmetysObject;
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
     * @return a report of the operation
     * @throws UnknownParentException if its not possible to obtains a parent to restore into
     */
    public RestorationReport restore(String trashElementId) throws UnknownParentException
    {
        TrashElement trashElement = resolve(trashElementId);
        
        // Restore the object and all its linked objects
        Map<String, TrashableAmetysObject> result = _restore(trashElement);
        
        // 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
     */
    private Map<String, TrashableAmetysObject> _restore(TrashElement trashElement) throws UnknownParentException
    {
        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);
        
        for (TrashElement linkedElement: linkedElements)
        {
            try
            {
                result.putAll(_restore(linkedElement));
            }
            catch (UnknownParentException e)
            {
                // Do not prevent restoring the original element because
                // a linked element failed
                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();
        
        result.put(trashElementId, restoredAO);
        
        // 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;
        }
    }
}