/*
 *  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.web.trash;

import java.util.Optional;

import javax.jcr.RepositoryException;

import org.ametys.cms.trash.element.TrashElementDAO;
import org.ametys.plugins.repository.AmetysObject;
import org.ametys.plugins.repository.AmetysRepositoryException;
import org.ametys.plugins.repository.ModifiableTraversableAmetysObject;
import org.ametys.plugins.repository.UnknownAmetysObjectException;
import org.ametys.plugins.repository.jcr.JCRAmetysObject;
import org.ametys.plugins.repository.trash.TrashableAmetysObject;
import org.ametys.web.repository.SiteAwareAmetysObject;
import org.ametys.web.repository.site.Site;

/**
 * Add supports for a trash by site
 */
public class WebTrashElementDAO extends TrashElementDAO
{
    private static final String __SITES_TRASH_ROOT_NODE_NAME = "ametys-internal:sites-trash";
    
    /**
     * Get the trash root for the object.
     * The root can be the root for all element shared between sites
     * or the root for the site of the element
     */
    @Override
    protected ModifiableTraversableAmetysObject getOrCreateRoot(TrashableAmetysObject ametysObject)
    {
        // If the object is site aware use it, otherwise, try to guess the site based on the path
        String siteName = ametysObject instanceof SiteAwareAmetysObject siteAO
                ? siteAO.getSiteName()
                : _getParentSiteName(ametysObject);
        
        return siteName != null
                ? _getOrCreateSiteRoot(siteName)        // get the root for the site
                : super.getOrCreateRoot(ametysObject);  // get the root for the shared object
    }

    private ModifiableTraversableAmetysObject _getOrCreateSiteRoot(String siteName)
    {
        return executeInTrashSession(
            session ->
            {
                ModifiableTraversableAmetysObject root = _resolver.resolveByPath("/", session);
                ModifiableTraversableAmetysObject sitesTrash = getOrCreateCollection(root, __SITES_TRASH_ROOT_NODE_NAME);
                return getOrCreateCollection(sitesTrash, siteName);
            }
        );
    }

    // Search the sitename on parents of the object
    private String _getParentSiteName(AmetysObject ametysObject)
    {
        if (ametysObject instanceof Site site)
        {
            return site.getName();
        }
        else if (ametysObject != null)
        {
            return _getParentSiteName(ametysObject.getParent());
        }
        else
        {
            return null;
        }
    }
    
    @Override
    public void empty(TrashElementFilter filter) throws AmetysRepositoryException
    {
        if (!(filter instanceof WebTrashElementFilter webFilter))
        {
            super.empty(filter);
            return;
        }
        
        if (webFilter.allowCommon())
        {
            Optional<String> rootPath = executeInTrashSession(session -> {
                try
                {
                    JCRAmetysObject trashRoot = _resolver.resolveByPath(__TRASH_ROOT_NODE_NAME, session);
                    return Optional.of(getEncodedJCRPath(trashRoot));
                }
                catch (UnknownAmetysObjectException e)
                {
                    return Optional.empty();
                }
                catch (RepositoryException e)
                {
                    throw new AmetysRepositoryException(e);
                }
            });
            
            // empty means that the root is not initialized
            // do not forward it to the empty method has it means no filter to it
            if (rootPath.isPresent())
            {
                empty(rootPath, webFilter.getMinimumAge());
            }
        }
        
        if (webFilter.getSitename().isPresent())
        {
            Optional<String> rootPath = executeInTrashSession(session -> {
                try
                {
                    JCRAmetysObject trashRoot = _resolver.resolveByPath(__SITES_TRASH_ROOT_NODE_NAME + "/" + webFilter.getSitename().get(), session);
                    return Optional.of(getEncodedJCRPath(trashRoot));
                }
                catch (UnknownAmetysObjectException e)
                {
                    return Optional.empty();
                }
                catch (RepositoryException e)
                {
                    throw new AmetysRepositoryException(e);
                }
            });
            
            // empty means that the root is not initialized
            // do not forward it to the empty method has it means no filter to it
            if (rootPath.isPresent())
            {
                empty(rootPath, webFilter.getMinimumAge());
            }
        }
    }
    
    /**
     * Information related to filtering trash element targeted by a mass operation
     * This implementation handle the segregation of trash by site
     */
    public static class WebTrashElementFilter extends TrashElementFilter
    {
        private Optional<String> _sitename;
        private boolean _common;

        /**
         * Information related to filtering trash element targeted by a mass operation
         * @param sitename set this to target element of a given site. if empty, no element of any site will be targeted
         * @param common if true, element of the common trash will be targeted
         * @param age Minimum age (in days) of the element. 0 or less means no filtering.
         */
        public WebTrashElementFilter(Optional<String> sitename, boolean common, long age)
        {
            super(age);
            _sitename = sitename;
            _common = common;
        }
        
        /**
         * Get the name of the site to target
         * @return the site name or empty if no site's trash element should be targeted
         */
        public Optional<String> getSitename()
        {
            return _sitename;
        }
        
        /**
         * Indicate if element from the common trash should be targeted
         * @return true if the common trash should be targeted
         */
        public boolean allowCommon()
        {
            return _common;
        }
    }
}