/*
 *  Copyright 2016 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.plugins.explorer.resources;

import java.io.IOException;
import java.io.InputStream;

import org.apache.commons.lang3.StringUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import org.ametys.plugins.explorer.cmis.CMISRootResourcesCollection;
import org.ametys.plugins.explorer.resources.actions.ExplorerResourcesDAO;
import org.ametys.plugins.explorer.resources.jcr.JCRResource;
import org.ametys.plugins.explorer.resources.jcr.JCRResourcesCollection;
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.TraversableAmetysObject;
import org.ametys.plugins.repository.UnknownAmetysObjectException;
import org.ametys.plugins.repository.jcr.NameHelper;
import org.ametys.plugins.repository.jcr.NameHelper.NameComputationMode;
import org.ametys.plugins.repository.jcr.NodeHelper;
import org.ametys.plugins.repository.trash.ConflictingNameException;
import org.ametys.plugins.repository.trash.TrashableAmetysObject.MergeComputationMode;

/**
 * Helper class that provides utility methods to work with resources.
 */

public final class ResourceHelper
{
    private static final Logger __LOGGER = LoggerFactory.getLogger(ResourceHelper.class);
    
    private ResourceHelper()
    {
        // Hide the default constructor.
    }
    
    /**
     * Get the resource root of a resource.
     * @param resource The resource.
     * @return The resource root.
     */
    public static TraversableAmetysObject getResourceRoot(Resource resource)
    {
        return _getResourceRoot(resource);
    }
    
    /**
     * Get the resource root of a resource collection.
     * @param collection The resource collection.
     * @return The resource root.
     */
    public static TraversableAmetysObject getResourceRoot(ResourceCollection collection)
    {
        return _getResourceRoot(collection);
    }
    
    /**
     * Get the resource root of an ametys object.
     * @param object The object.
     * @return The resource root of the ametys object.
     */
    private static TraversableAmetysObject _getResourceRoot(AmetysObject object)
    {
        AmetysObject current = object;
        TraversableAmetysObject parent = object.getParent();
        
        while (parent != null && parent instanceof ResourceCollection)
        {
            current = parent;
            parent = current.getParent();
        }
        
        return current instanceof TraversableAmetysObject ? (TraversableAmetysObject) current : null;
    }


    /**
     * Get or create resources collections by path.
     * Try to retrieve a resources collection with his path. If resources collections are missing, create them.
     * @param ametysObjectResolver the ametys object resolver
     * @param path the parent path
     * @return the resources collection related to the path or null if the path cannot be created
     */
    public static JCRResourcesCollection getOrCreateResourcesCollection(AmetysObjectResolver ametysObjectResolver, String path)
    {
        try
        {
            AmetysObject object = ametysObjectResolver.resolveByPath(path);
            if (object instanceof JCRResourcesCollection resourcesCollection)
            {
                return resourcesCollection;
            }
            // If the parent is not a JCRResourcesCollection, it means that the path corresponds to an object of another type or that we are no longer under root, so we cannot create the path
            else
            {
                return null;
            }
        }
        // The path does not exists, we try to check if the parent exists
        catch (UnknownAmetysObjectException e)
        {
            // Try to create path by creating missing resourcesCollections
            String parentPath = StringUtils.substringBeforeLast(path, "/");
            String resourcesCollectionName = StringUtils.substringAfterLast(path, "/");
            
            // Recursively get or create the parent resourcesCollection
            JCRResourcesCollection parentOfParent = ResourceHelper.getOrCreateResourcesCollection(ametysObjectResolver, parentPath);
            if (parentOfParent == null)
            {
                // The parent path cannot be created, so we cannot create the path
                return null;
            }
            
            // Create the missing resourcesCollection
            JCRResourcesCollection newResourcesCollection = (JCRResourcesCollection) parentOfParent.createChild(resourcesCollectionName, parentOfParent.getCollectionType());
            parentOfParent.saveChanges();
            return newResourcesCollection;
        }
        // The path is not a TraversableObject, so we are under a resource, abort resources collection creation
        catch (AmetysRepositoryException e)
        {
            return null;
        }
    }
    
    /**
     * Clone or merge the resource collection to the given parent node keeping the identifiers.
     * To be able to do that, parent resource collection should be in another workspace than the resource collection to restore.
     * This method does not save the parent node.
     * @param resourcesCollectionToRestore The resource collection to restore
     * @param parentResourceCollection The parent resource collection where the element will be restored
     * @param mergeComputationMode The merge computation mode (ERROR, RENAME or UPDATE)
     * @param resourcesDAO The resources DAO
     * @return the created or merged resource collection
     * @throws ConflictingNameException if a conflicting name is found and mode is ERROR or null
     * @throws AmetysRepositoryException if a repository error occurs
     */
    public static JCRResourcesCollection restoreResourcesCollection(JCRResourcesCollection resourcesCollectionToRestore, JCRResourcesCollection parentResourceCollection, MergeComputationMode mergeComputationMode, ExplorerResourcesDAO resourcesDAO) throws ConflictingNameException, AmetysRepositoryException
    {
        if (!parentResourceCollection.hasChild(resourcesCollectionToRestore.getName()))
        {
            // Simple case: clone the node
            NodeHelper.cloneNode(resourcesCollectionToRestore.getNode(), parentResourceCollection.getNode(), resourcesCollectionToRestore.getName());
            return (JCRResourcesCollection) parentResourceCollection.getChild(resourcesCollectionToRestore.getName());
        }
        
        // Merge case: the node already exists
        AmetysObject aoChild = parentResourceCollection.getChild(resourcesCollectionToRestore.getName());
        if (!(aoChild instanceof JCRResourcesCollection existingCollection))
        {
            throw new ConflictingNameException("The object at path " + aoChild.getPath() + " already exists.");
        }
        
        // Iterate over all children of trashElementToCopy and merge them
        try (AmetysObjectIterable<AmetysObject> children = resourcesCollectionToRestore.getChildren())
        {
            for (AmetysObject child : children)
            {
                if (child instanceof JCRResourcesCollection collection)
                {
                    restoreResourcesCollection(collection, existingCollection, mergeComputationMode, resourcesDAO);
                }
                else if (child instanceof JCRResource resource)
                {
                    // We do not want to call to directly call resource.restoreFromTrash(mergeComputationMode) as we do not want to do any save until all operation is done
                    restoreResource(resource, existingCollection, mergeComputationMode, resourcesDAO);
                }
                else if (child instanceof CMISRootResourcesCollection collection)
                {
                    restoreCMISCollection(collection, existingCollection, mergeComputationMode);
                }
                else
                {
                    // For other types of AmetysObject, we can not/do not want to merge them, but we can at least log some basic info about it
                    __LOGGER.info("Cannot restore child with name {} and type {} under path {} because this type is not supported for merging. It will be ignored during the restore process.", child.getName(), child.getClass().getName(), existingCollection.getPath());
                }
            }
        }
        
        return existingCollection;
    }

    /**
     * Restore a CMIS root resources collection.
     * @param cmisResourcesCollectionToRestore The CMIS resources collection to restore
     * @param parentResourcesCollection The parent resource collection where the element will be restored
     * @param mergeComputationMode The merge computation mode (ERROR, RENAME or UPDATE)
     * @return the restored CMIS resource collection
     * @throws ConflictingNameException if a conflicting name is found and mode is ERROR or null
     * @throws AmetysRepositoryException if a repository error occurs
     */
    public static CMISRootResourcesCollection restoreCMISCollection(CMISRootResourcesCollection cmisResourcesCollectionToRestore, JCRResourcesCollection parentResourcesCollection, MergeComputationMode mergeComputationMode) throws ConflictingNameException, AmetysRepositoryException
    {
        if (!parentResourcesCollection.hasChild(cmisResourcesCollectionToRestore.getName()))
        {
            NodeHelper.cloneNode(cmisResourcesCollectionToRestore.getNode(), parentResourcesCollection.getNode(), cmisResourcesCollectionToRestore.getName());
            return (CMISRootResourcesCollection) parentResourcesCollection.getChild(cmisResourcesCollectionToRestore.getName());
        }
        
        if (MergeComputationMode.RENAME.equals(mergeComputationMode))
        {
            String resourceName = NameHelper.getUniqueAmetysObjectName(parentResourcesCollection, cmisResourcesCollectionToRestore.getName(), NameComputationMode.USER_FRIENDLY, true);
            NodeHelper.cloneNode(cmisResourcesCollectionToRestore.getNode(), parentResourcesCollection.getNode(), resourceName);
            return (CMISRootResourcesCollection) parentResourcesCollection.getChild(resourceName);
        }
        else if (MergeComputationMode.UPDATE.equals(mergeComputationMode))
        {
            // Having an existing object with the same name is not a problem for RENAME mode as the new resource will be renamed,
            // but for UPDATE mode, it means that we want to update the existing object with the content of the object to restore, so we need to check that they share the same type
            if (!(parentResourcesCollection.getChild(cmisResourcesCollectionToRestore.getName()) instanceof CMISRootResourcesCollection existingCollection))
            {
                throw new ConflictingNameException("The object at path " + cmisResourcesCollectionToRestore.getPath() + " is not a CMISRootResourcesCollection.");
            }
            existingCollection.setMountPoint(cmisResourcesCollectionToRestore.getMountPoint());
            existingCollection.setPassword(cmisResourcesCollectionToRestore.getPassword());
            existingCollection.setRepositoryId(cmisResourcesCollectionToRestore.getRepositoryId());
            existingCollection.setRepositoryUrl(cmisResourcesCollectionToRestore.getRepositoryUrl());
            existingCollection.setUser(cmisResourcesCollectionToRestore.getUser());
            return existingCollection;
        }
        // If mode is ERROR or null, we throw an exception as we cannot restore the CMIS collection because a resource collection with the same name already exists
        else
        {
            throw new ConflictingNameException("The object at path " + cmisResourcesCollectionToRestore.getPath() + " already exists.");
        }
        
    }

    /**
     * Restore a resource from the trash into a resource collection.
     * @param resourceToRestore The resource from the trash to restore
     * @param parentResourcesCollection The target resource collection to restore into
     * @param mergeComputationMode The merge computation mode (ERROR, RENAME or UPDATE)
     * @param resourcesDAO The resources DAO
     * @return the restored resource
     * @throws ConflictingNameException if a conflicting name is found and mode is ERROR or null
     * @throws AmetysRepositoryException if a repository error occurs
     */
    public static JCRResource restoreResource(JCRResource resourceToRestore, JCRResourcesCollection parentResourcesCollection, MergeComputationMode mergeComputationMode, ExplorerResourcesDAO resourcesDAO) throws ConflictingNameException, AmetysRepositoryException
    {
        String resourceName = resourceToRestore.getName();
        if (parentResourcesCollection.hasChild(resourceName))
        {
            if (MergeComputationMode.RENAME.equals(mergeComputationMode))
            {
                String nameWithoutExtension = StringUtils.substringBeforeLast(resourceName, ".");
                String extension = StringUtils.substringAfterLast(resourceName, ".");
                // Get the new node name
                resourceName = NameHelper.getUniqueAmetysObjectName(parentResourcesCollection, nameWithoutExtension, NameComputationMode.USER_FRIENDLY, true, StringUtils.isEmpty(extension) ? StringUtils.EMPTY : "." + extension);
                NodeHelper.cloneNode(resourceToRestore.getNode(), parentResourcesCollection.getNode(), resourceName);
                return (JCRResource) parentResourcesCollection.getChild(resourceName);
            }
            else if (MergeComputationMode.UPDATE.equals(mergeComputationMode))
            {
                // Having an existing object with the same name is not a problem for RENAME mode as the new resource will be renamed,
                // but for UPDATE mode, it means that we want to update the existing object with the content of the object to restore, so we need to check that they share the same type
                if (!(parentResourcesCollection.getChild(resourceName) instanceof JCRResource existingResource))
                {
                    // If existing object is not also a resource, we cannot merge them so we throw an exception
                    throw new ConflictingNameException("The object at path " + resourceToRestore.getPath() + " is not a JCRResource.");
                }
                // use try to open/close is
                try (InputStream is = resourceToRestore.getInputStream())
                {
                    resourcesDAO.updateResource(existingResource, is, resourceName);
                }
                catch (IOException e)
                {
                    __LOGGER.warn("An error occurred while closing the ressource " + resourceToRestore.getId(), e);
                }
                return existingResource;
            }
            // If mode is ERROR or null, we throw an exception as we cannot restore the resource because a resource with the same name already exists
            else
            {
                throw new ConflictingNameException("The object at path " + resourceToRestore.getPath() + " already exists.");
            }
        }
        else
        {
            // Clone the ametys object from the trash session to default session
            NodeHelper.cloneNode(resourceToRestore.getNode(), parentResourcesCollection.getNode(), resourceName);
            return (JCRResource) parentResourcesCollection.getChild(resourceName);
        }
    }
    
}