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

import java.util.ArrayList;
import java.util.Collection;
import java.util.HashSet;
import java.util.Map;
import java.util.Set;
import java.util.stream.Collectors;

import javax.jcr.RepositoryException;
import javax.jcr.Session;
import javax.jcr.observation.Event;
import javax.jcr.observation.ObservationManager;

import org.apache.avalon.framework.activity.Initializable;
import org.apache.avalon.framework.component.Component;
import org.apache.avalon.framework.context.Context;
import org.apache.avalon.framework.context.ContextException;
import org.apache.avalon.framework.context.Contextualizable;
import org.apache.avalon.framework.logger.AbstractLogEnabled;
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.components.ContextHelper;
import org.apache.cocoon.environment.Request;
import org.apache.commons.lang.StringUtils;

import org.ametys.core.cache.AbstractCacheManager;
import org.ametys.core.cache.AbstractCacheManager.CacheType;
import org.ametys.core.cache.Cache;
import org.ametys.core.cache.CacheException;
import org.ametys.core.right.RightManager;
import org.ametys.core.user.CurrentUserProvider;
import org.ametys.core.user.UserIdentity;
import org.ametys.core.user.population.PopulationContextHelper;
import org.ametys.plugins.core.impl.cache.AbstractCacheKey;
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.CollectionIterable;
import org.ametys.plugins.repository.ModifiableTraversableAmetysObject;
import org.ametys.plugins.repository.RepositoryConstants;
import org.ametys.plugins.repository.RepositoryIntegrityViolationException;
import org.ametys.plugins.repository.TraversableAmetysObject;
import org.ametys.plugins.repository.UnknownAmetysObjectException;
import org.ametys.plugins.repository.activities.ActivityHolder;
import org.ametys.plugins.repository.provider.AbstractRepository;
import org.ametys.plugins.repository.provider.JackrabbitRepository;
import org.ametys.plugins.repository.provider.WorkspaceSelector;
import org.ametys.runtime.i18n.I18nizableText;
import org.ametys.web.live.LiveWorkspaceListener;
import org.ametys.web.repository.page.CopySiteComponent;
import org.ametys.web.synchronization.SynchronizeComponent;

/**
 * Helper component for managing sites.
 */
public class SiteManager extends AbstractLogEnabled implements Serviceable, Component, Contextualizable, Initializable
{
    /** Avalon Role */
    public static final String ROLE = SiteManager.class.getName();

    /** Constant for the {@link Cache} id (the {@link Cache} is in {@link CacheType#REQUEST REQUEST} attribute) for the {@link Site}s objects in cache by {@link RequestSiteCacheKey} (composition of site name and workspace name). */
    public static final String REQUEST_CACHE = SiteManager.class.getName() + "$Request";
    
    /** Constant for the {@link Cache} id for the {@link Site} ids (as {@link String}s) in cache by site name (for whole application). */
    public static final String MEMORY_CACHE = SiteManager.class.getName() + "$UUID";
    
    /** sites root's JCR node name */
    public static final String ROOT_SITES = RepositoryConstants.NAMESPACE_PREFIX_INTERNAL + ":sites";
    
    /** sites root's JCR path */
    public static final String ROOT_SITES_PATH = "/" + ROOT_SITES;
    
    private static final String __IS_CACHE_FILLED = "###iscachefilled###";
        
    private AmetysObjectResolver _resolver;
    private JackrabbitRepository _repository;
    private SynchronizeComponent _synchronizeComponent;
    private CopySiteComponent _copySiteComponent;
    private WorkspaceSelector _workspaceSelector;
    private RightManager _rightManager;
    private CurrentUserProvider _currentUserProvider;
    private PopulationContextHelper _populationContextHelper;
    private AbstractCacheManager _cacheManager;
    
    private Context _context;

    @Override
    public void service(ServiceManager manager) throws ServiceException
    {
        _resolver = (AmetysObjectResolver) manager.lookup(AmetysObjectResolver.ROLE);
        _repository = (JackrabbitRepository) manager.lookup(AbstractRepository.ROLE);
        _synchronizeComponent = (SynchronizeComponent) manager.lookup(SynchronizeComponent.ROLE);
        _copySiteComponent = (CopySiteComponent) manager.lookup(CopySiteComponent.ROLE);
        _workspaceSelector = (WorkspaceSelector) manager.lookup(WorkspaceSelector.ROLE);
        _rightManager = (RightManager) manager.lookup(RightManager.ROLE);
        _currentUserProvider = (CurrentUserProvider) manager.lookup(CurrentUserProvider.ROLE);
        _populationContextHelper = (PopulationContextHelper) manager.lookup(PopulationContextHelper.ROLE);
        _cacheManager = (AbstractCacheManager) manager.lookup(AbstractCacheManager.ROLE);
    }

    @Override
    public void initialize() throws Exception
    {
        _createCaches();
    }
    
    /**
     * Creates the caches
     */
    protected void _createCaches()
    {
        _cacheManager.createMemoryCache(MEMORY_CACHE, 
                new I18nizableText("plugin.web", "PLUGINS_WEB_SITE_MANAGER_UUID_CACHE_LABEL"),
                new I18nizableText("plugin.web", "PLUGINS_WEB_SITE_MANAGER_UUID_CACHE_DESCRIPTION"),
                true,
                null);
        _cacheManager.createRequestCache(REQUEST_CACHE, 
                new I18nizableText("plugin.web", "PLUGINS_WEB_SITE_MANAGER_REQUEST_CACHE_LABEL"),
                new I18nizableText("plugin.web", "PLUGINS_WEB_SITE_MANAGER_REQUEST_CACHE_DESCRIPTION"),
                false);
    }
    
    public void contextualize(Context context) throws ContextException
    {
        _context = context;
    }

    private synchronized Map<String, String> _getUUIDCache()
    {
        if (!_getMemoryCache().hasKey(__IS_CACHE_FILLED))
        {
            Session defaultSession = null;
            try
            {
                // Force default workspace to execute query
                defaultSession = _repository.login(RepositoryConstants.DEFAULT_WORKSPACE);
                
                String jcrQuery = "//element(*, ametys:site)";
                
                AmetysObjectIterable<Site> sites = _resolver.query(jcrQuery, defaultSession);
                
                for (Site site : sites)
                {
                    _getMemoryCache().put(site.getName(), site.getId());
                }
                
                _getMemoryCache().put(__IS_CACHE_FILLED, null);
            }
            catch (RepositoryException e)
            {
                throw new AmetysRepositoryException(e);
            }
            finally
            {
                if (defaultSession != null)
                {
                    defaultSession.logout();
                }
            }
        }
        
        Map<String, String> cacheAsMap = _getMemoryCache().asMap();
        cacheAsMap.remove(__IS_CACHE_FILLED);
        return cacheAsMap;
    }
    
    private Request _getRequest ()
    {
        try 
        {
            return (Request) _context.get(ContextHelper.CONTEXT_REQUEST_OBJECT);
        } 
        catch (ContextException ce)
        {
            getLogger().info("Unable to get the request", ce);
            return null;
        }
    }
    
    /**
     * Returns the sites names.
     * @return the sites names.
     */
    public Collection<String> getRootSiteNames()
    {
        TraversableAmetysObject root = _resolver.resolveByPath(ROOT_SITES_PATH);
        AmetysObjectIterable<AmetysObject> sites = root.getChildren();
        
        ArrayList<String> result = new ArrayList<>();
        
        for (AmetysObject object : sites)
        {
            result.add(object.getName());
        }
        
        return result;
    }
    
    /**
     * Returns the sites names.
     * @return the sites names.
     */
    public Collection<String> getSiteNames()
    {
        // As cache is computed from default JCR workspace, we need to filter on sites that exist into the current JCR workspace 
        return _getUUIDCache().entrySet().stream()
                .filter(e -> _resolver.hasAmetysObjectForId(e.getValue()))
                .map(Map.Entry::getKey)
                .collect(Collectors.toList());
    }
    
    /**
     * Get the granted site names for the current user
     * @return The name of sites the current user can access
     */
    public Set<String> getGrantedSites()
    {
        return getGrantedSites(_currentUserProvider.getUser());
    }
    
    /**
     * Get the granted site names for user
     * @param user The user
     * @return The name of sites the user can access
     */
    public Set<String> getGrantedSites(UserIdentity user)
    {
        Set<String> grantedSiteNames = new HashSet<>();
        
        Request request = _getRequest();
        
        for (String siteName : getSiteNames())
        {
            if (_populationContextHelper.getUserPopulationsOnContext("/sites/" + siteName, false).contains(user.getPopulationId()))
            {
                try
                {
                    request.setAttribute("siteName", siteName); // Setting temporarily this attribute to check user rights on any object on this site
                    if (!_rightManager.getUserRights(user, "/cms").isEmpty())
                    {
                        grantedSiteNames.add(siteName);
                    }
                }
                finally
                {
                    request.setAttribute("siteName", null);
                }
            }
        }
        
        return grantedSiteNames;
    }
    
    /**
     * Determines if the user has granted access to the site 
     * @param user The user
     * @param siteName The site name
     * @return <code>true</code> if the user can access to the site
     */
    public boolean isGrantedSite (UserIdentity user, String siteName)
    {
        Object oldValue = null;
        
        Request request = _getRequest();
        try
        {
            oldValue = request.getAttribute("siteName");
            request.setAttribute("siteName", siteName); // Setting temporarily this attribute to check user rights on any object on this site
            return !_rightManager.getUserRights(user, "/cms").isEmpty();
        }
        finally
        {
            request.setAttribute("siteName", oldValue);
        }
    }
    
    /**
     * Returns the root for sites.
     * @return the root for sites.
     */
    public ModifiableTraversableAmetysObject getRoot()
    {
        return _resolver.resolveByPath(ROOT_SITES_PATH);
    }
    
    /**
     * Returns the root sites.
     * @return the root sites.
     */
    public AmetysObjectIterable<Site> getRootSites()
    {
        TraversableAmetysObject root = _resolver.resolveByPath(ROOT_SITES_PATH);
        return root.getChildren();
    }
    
    /**
     * Returns the all sites.
     * @return the all sites.
     */
    public AmetysObjectIterable<Site> getSites()
    {
        // As cache is computed from default JCR workspace, we need to filter on sites that exist into the current JCR workspace 
        Set<Site> sites = _getUUIDCache().values().stream()
                .filter(_resolver::hasAmetysObjectForId)
                .map(_resolver::<Site>resolveById)
                .collect(Collectors.toSet());
        
        return new CollectionIterable<>(sites);
    }
    
    /**
     * Creates a site with the given name.
     * @param siteName the site name.
     * @param parentId the id of the parent site. Can be null.
     * @return the newly created {@link Site}.
     * @throws RepositoryIntegrityViolationException if the named site already exists.
     */
    public Site createSite(String siteName, String parentId) throws RepositoryIntegrityViolationException
    {
        ModifiableTraversableAmetysObject root = null;
        if (parentId != null)
        {
            Site site = _resolver.resolveById(parentId);
            if (!site.hasChild(ROOT_SITES))
            {
                site.createChild(ROOT_SITES, "ametys:sites");
            }
            root = site.getChild(ROOT_SITES);
        }
        else
        {
            root = _resolver.resolveByPath(ROOT_SITES_PATH);
        }
        
        Site site = (Site) root.createChild(siteName, "ametys:site");
        String sitePath;
        try
        {
            sitePath = site.getNode().getPath();
            
            // Create the resource explorer root.
            site.getNode().addNode(RepositoryConstants.NAMESPACE_PREFIX_INTERNAL + ":resources", "ametys:resources-collection");
        }
        catch (RepositoryException ex)
        {
            throw new AmetysRepositoryException(ex);
        }
        finally
        {
            _getMemoryCache().invalidateAll();
        }

        try
        {
            Session session = _repository.getAdminSession();
            ObservationManager manager = session.getWorkspace().getObservationManager();
            
            manager.addEventListener(new LiveWorkspaceListener(_repository, _synchronizeComponent, getLogger()), 
                                     Event.NODE_ADDED
                                     | Event.NODE_REMOVED
                                     | Event.NODE_MOVED
                                     | Event.PROPERTY_ADDED
                                     | Event.PROPERTY_CHANGED
                                     | Event.PROPERTY_REMOVED, 
                                     sitePath + "/ametys-internal:plugins", true, null, null, false);
            
            manager.addEventListener(new LiveWorkspaceListener(_repository, _synchronizeComponent, getLogger()), 
                                     Event.NODE_ADDED
                                     | Event.NODE_REMOVED
                                     | Event.NODE_MOVED
                                     | Event.PROPERTY_ADDED
                                     | Event.PROPERTY_CHANGED
                                     | Event.PROPERTY_REMOVED, 
                                     sitePath + "/ametys-internal:resources", true, null, null, false);
            
            manager.addEventListener(new LiveWorkspaceListener(_repository, _synchronizeComponent, getLogger()), 
                                    Event.NODE_ADDED
                                    | Event.NODE_REMOVED
                                    | Event.NODE_MOVED
                                    | Event.PROPERTY_ADDED
                                    | Event.PROPERTY_CHANGED
                                    | Event.PROPERTY_REMOVED, 
                                    sitePath + "/" + ActivityHolder.ACTIVITIES_ROOT_NODE_NAME, true, null, null, false);
        }
        catch (RepositoryException ex)
        {
            throw new AmetysRepositoryException(ex);
        }
        finally
        {
            _getMemoryCache().invalidateAll();
        }
        
        return site;
    }
    
    /**
     * Creates a site with the given name.
     * @param siteName the site name.
     * @return the newly created {@link Site}.
     * @throws RepositoryIntegrityViolationException if the named site already exists.
     */
    public Site createSite(String siteName) throws RepositoryIntegrityViolationException
    {
        return createSite(siteName, null);
    }
    
    /**
     * Creates a site with the given name, from another site to copy 
     * @param site the site to be copied
     * @param siteName the site name
     * @return the newly created {@link Site}.
     * @throws RepositoryIntegrityViolationException if the named site already exists.
     */
    public Site copySite(Site site, String siteName) throws RepositoryIntegrityViolationException
    {
        return copySite(site, null, siteName);
    }
    
    /**
     * Creates a site with the given name, from another site to copy 
     * @param site the site to be copied
     * @param parentId the id of the parent site. Can be null.
     * @param siteName the site name
     * @return the newly created {@link Site}.
     * @throws RepositoryIntegrityViolationException if the named site already exists.
     */
    public Site copySite(Site site, String parentId, String siteName) throws RepositoryIntegrityViolationException
    {
        ModifiableTraversableAmetysObject root = null;
        if (parentId != null)
        {
            root = _resolver.resolveById(parentId);
        }
        else
        {
            root = _resolver.resolveByPath(ROOT_SITES_PATH);
        }
        
        Site cSite = site.copyTo(root, siteName);
        
        _getMemoryCache().invalidateAll();
        
        // Clear url and title
        cSite.removeValue("url");
        cSite.removeValue("title");
        
        // Change reference to ametys object, re-init contents workflow, update site name, ...
        _copySiteComponent.updateSiteAfterCopy(site, cSite);
        
        return cSite;
        
    }
    
    /**
     * Returns true if the given site exists.
     * @param siteName the site name.
     * @return true if the given site exists.
     */
    public boolean hasSite(String siteName)
    {
        Map<String, String> uuidCache = _getUUIDCache();
        if (uuidCache.containsKey(siteName))
        {
            // As cache is computed from default JCR workspace, we need to check if the site exists into the current JCR workspace 
            return _resolver.hasAmetysObjectForId(uuidCache.get(siteName));
        }
        return false;
    }
    
    /**
     * Returns the named {@link Site}.
     * @param siteName the site name.
     * @return the named {@link Site} or null if the siteName is null
     * @throws UnknownAmetysObjectException if the named site does not exist
     */
    public Site getSite(String siteName) throws UnknownAmetysObjectException
    {
        return getSite(siteName, null);
    }
    
    /**
     * Returns the named {@link Site}.
     * @param siteName the site name.
     * @param session the JCR Session to use to retrieve the site
     * @return the named {@link Site} or null if the siteName is null
     * @throws UnknownAmetysObjectException if the named site does not exist
     */
    public Site getSite(String siteName, Session session) throws UnknownAmetysObjectException
    {
        if (StringUtils.isBlank(siteName))
        {
            return null;
        }
        
        Request request = _getRequest();
        if (request == null)
        {
            // There is no request to store cache
            return _computeSite(siteName, session);
        }
        
        Cache<RequestSiteCacheKey, Site> sitesCache = _getRequestCache();
        
        // The site key in the cache is of the form {site + workspace}.
        String workspaceName = session != null
                               ? session.getWorkspace().getName()
                               : _workspaceSelector.getWorkspace();
        RequestSiteCacheKey siteKey = RequestSiteCacheKey.of(siteName, workspaceName);
        
        try
        {
            Site site = sitesCache.get(siteKey, __ -> _computeSite(siteName, session));
            return site;
        }
        catch (CacheException e)
        {
            if (e.getCause() instanceof UnknownAmetysObjectException)
            {
                throw (UnknownAmetysObjectException) e.getCause();
            }
            else 
            {
                throw e;
            }
        }
    }
    
    private Site _computeSite(String siteName, Session session)
    {
        try
        {
            if (hasSite(siteName))
            {
                String uuid = _getUUIDCache().get(siteName);
                return _resolver.<Site>resolveById(uuid, session);
            }
            else
            {
                // Site may be present in cache for 'default' workspace but does not exist in current JCR workspace
                throw new UnknownAmetysObjectException("There is no site named '" + siteName + "'");
            }
        }
        catch (RepositoryException e)
        {
            throw new AmetysRepositoryException(e);
        }
    }
    
    /**
     * Clear the site cache
     */
    public void clearCache ()
    {
        _getMemoryCache().invalidateAll();
        _getRequestCache().invalidateAll();
    }

    private Cache<String, String> _getMemoryCache()
    {
        return _cacheManager.get(MEMORY_CACHE);
    }
    
    private Cache<RequestSiteCacheKey, Site> _getRequestCache()
    {
        return _cacheManager.get(REQUEST_CACHE);
    }
    
    private static final class RequestSiteCacheKey extends AbstractCacheKey
    {
        private RequestSiteCacheKey(String siteName, String workspaceName)
        {
            super(siteName, workspaceName);
        }
        
        static RequestSiteCacheKey of(String siteName, String workspaceName)
        {
            return new RequestSiteCacheKey(siteName, workspaceName);
        }
    }
}