/*
 *  Copyright 2019 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.inputdata;

import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;

import org.apache.avalon.framework.activity.Initializable;
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.cocoon.ProcessingException;
import org.apache.cocoon.xml.AttributesImpl;
import org.apache.cocoon.xml.XMLUtils;
import org.apache.commons.lang.StringUtils;
import org.apache.commons.lang3.tuple.Pair;
import org.xml.sax.ContentHandler;
import org.xml.sax.SAXException;

import org.ametys.cms.tag.TagProviderExtensionPoint;
import org.ametys.core.cache.AbstractCacheManager;
import org.ametys.core.cache.Cache;
import org.ametys.core.right.RightManager;
import org.ametys.core.user.CurrentUserProvider;
import org.ametys.core.user.UserIdentity;
import org.ametys.core.util.SizeUtils;
import org.ametys.core.util.SizeUtils.Sized;
import org.ametys.plugins.core.impl.cache.AbstractCacheKey;
import org.ametys.plugins.repository.AmetysObjectResolver;
import org.ametys.plugins.repository.provider.WorkspaceSelector;
import org.ametys.runtime.i18n.I18nizableText;
import org.ametys.runtime.model.type.ElementType;
import org.ametys.runtime.model.type.ModelItemType;
import org.ametys.runtime.plugin.component.AbstractLogEnabled;
import org.ametys.web.pageaccess.RestrictedPagePolicy;
import org.ametys.web.renderingcontext.RenderingContext;
import org.ametys.web.renderingcontext.RenderingContextHandler;
import org.ametys.web.repository.page.Page;
import org.ametys.web.repository.page.Page.PageType;
import org.ametys.web.repository.site.Site;
import org.ametys.web.repository.site.SiteManager;
import org.ametys.web.repository.sitemap.Sitemap;

/**
 * Send a sitemap as SAX events.
 * Handles both cacheable and non-cacheable cases.
 */
public class SitemapSaxer extends AbstractLogEnabled implements Serviceable, Component, Initializable
{
    /** Avalon role. */
    public static final String ROLE = SitemapSaxer.class.getName();
    
    /** Prefix for sitemap namespace. */
    public static final String NAMESPACE_PREFIX = "sitemap";
    /** URI for sitemap namespace. */
    public static final String NAMESPACE_URI = "http://www.ametys.org/inputdata/sitemap/3.0";
    
    static RightManager _rightManager;
    static AmetysObjectResolver _resolver;
    static TagProviderExtensionPoint _tagProviderExtensionPoint;
    
    private RenderingContextHandler _renderingContextHandler;
    private CurrentUserProvider _currentUserProvider;
    private WorkspaceSelector _workspaceSelector;
    private SiteManager _siteManager;
    private AbstractCacheManager _cacheManager;
    
    static class PageElementKey extends AbstractCacheKey
    {
        PageElementKey(String siteName, String workspace, String sitemap)
        {
            super(siteName, workspace, sitemap);
        }

        static PageElementKey of(String siteName, String workspace, String sitemap)
        {
            return new PageElementKey(siteName, workspace, sitemap);
        } 
        
        static PageElementKey of(String siteName, String workspace)
        {
            return of(siteName, workspace, null);
        }
    }
    
    static enum PageStatus 
    {
        NOT_IN_PATH,
        IN_PATH,
        CURRENT,
        DESCENDANT
    }

    @Override
    public void service(ServiceManager manager) throws ServiceException
    {
        _rightManager = (RightManager) manager.lookup(RightManager.ROLE);
        _currentUserProvider = (CurrentUserProvider) manager.lookup(CurrentUserProvider.ROLE);
        _renderingContextHandler = (RenderingContextHandler) manager.lookup(RenderingContextHandler.ROLE);
        _workspaceSelector = (WorkspaceSelector) manager.lookup(WorkspaceSelector.ROLE);
        _siteManager = (SiteManager) manager.lookup(SiteManager.ROLE);
        _cacheManager = (AbstractCacheManager) manager.lookup(AbstractCacheManager.ROLE);
        _tagProviderExtensionPoint = (TagProviderExtensionPoint) manager.lookup(TagProviderExtensionPoint.ROLE);
        _resolver = (AmetysObjectResolver) manager.lookup(AmetysObjectResolver.ROLE);
    }
    
    @Override
    public void initialize() throws Exception
    {
        _cacheManager.createMemoryCache(ROLE, 
                new I18nizableText("plugin.web", "PLUGINS_WEB_SITE_MAP_SAXER_CACHE_LABEL"),
                new I18nizableText("plugin.web", "PLUGINS_WEB_SITE_MAP_SAXER_CACHE_DESCRIPTION"),
                true,
                null);
    }
    
    /**
     * Clear the page cache.
     * @param siteName the site.
     * @param workspace the JCR workspace.
     */
    public void clearCache(String siteName, String workspace)
    {
        _getCache().invalidate(PageElementKey.of(siteName, workspace));
    }

    /**
     * Send SAX events representing pages from a sitemap.
     * @param contentHandler the SAX handler.
     * @param siteName the site name.
     * @param sitemapName the sitemap name.
     * @param currentPage the current {@link Page}.
     * @param initialDepth max depth from the root.
     * @param descendantDepth max depth under the current page.
     * @throws SAXException if an error occurs with the content handler.
     * @throws ProcessingException if an error occurs while processing data.
     */
    @SuppressWarnings("unchecked")
    public void toSAX(ContentHandler contentHandler, String siteName, String sitemapName, Page currentPage, int initialDepth, int descendantDepth) throws SAXException, ProcessingException
    {
        RenderingContext renderingContext = _renderingContextHandler.getRenderingContext();
        String workspace = _workspaceSelector.getWorkspace();
        UserIdentity user = _currentUserProvider.getUser();
        
        Site site = _siteManager.getSite(siteName);
        Sitemap sitemap = site.getSitemap(sitemapName);
        RestrictedPagePolicy policy = site.getRestrictedPagePolicy();
        
        List<? extends PageWrapper> pages = null;
        
        boolean useCache = policy == RestrictedPagePolicy.DISPLAYED;
        PageElementKey cacheKey = PageElementKey.of(siteName, workspace, sitemapName);
        
        if (!useCache)
        {
            // input data not cacheable, so no need to cache anything
            pages = sitemap.getChildrenPages().stream()
                                              .map(RepositoryPage::new)
                                              .collect(Collectors.toList());
        }
        else
        {
            // cache is filled incrementaly, so let's initialize it with the first level
            pages = _getCache().get(cacheKey, __ -> sitemap.getChildrenPages().stream().map(BufferedPage::new).collect(Collectors.toList()));
        }
        
        contentHandler.startPrefixMapping(NAMESPACE_PREFIX, NAMESPACE_URI);

        AttributesImpl attrs = new AttributesImpl();
        attrs.addCDATAAttribute(NAMESPACE_URI, "site", NAMESPACE_PREFIX + ":site", siteName);
        attrs.addCDATAAttribute(NAMESPACE_URI, "lang", NAMESPACE_PREFIX + ":lang", sitemapName);
        attrs.addCDATAAttribute(NAMESPACE_URI, "id", NAMESPACE_PREFIX + ":id", sitemap.getId());

        XMLUtils.startElement(contentHandler, "sitemap", attrs);

        // Process recursively pages
        boolean hasChanged = _saxPages(contentHandler, pages, currentPage, currentPage != null ? currentPage.getPathInSitemap() : null, user, renderingContext, site.getRestrictedPagePolicy(), initialDepth, descendantDepth, 1, -1);
        
        if (useCache && hasChanged)
        {
            // force cache size computing by inserting again the pages
            _getCache().put(cacheKey, (List<BufferedPage>) pages);
        }

        XMLUtils.endElement(contentHandler, "sitemap");
        contentHandler.endPrefixMapping(NAMESPACE_PREFIX);
    }
    
    private boolean _saxPages(ContentHandler handler, List<? extends PageWrapper> pages, Page currentPage, String currentPagePath, UserIdentity userIdentity, RenderingContext renderingContext, RestrictedPagePolicy policy, int initialDepth, int descendantDepth, int currentDepth, int currentDescendantDepth) throws SAXException
    {
        boolean inBackOffice = renderingContext == RenderingContext.BACK || renderingContext == RenderingContext.PREVIEW;
        boolean hasChanged = false;

        for (PageWrapper page : pages)
        {
            String pagePath = page.getPath();

            if (inBackOffice || policy == RestrictedPagePolicy.DISPLAYED || page.hasReadAccess(userIdentity))
            {
                if (page.isVisible() || StringUtils.isNotBlank(currentPagePath) && currentPagePath.startsWith(pagePath))
                {
                    boolean hasChangedInPage = _saxPage(handler, page, currentPage, currentPagePath, userIdentity, renderingContext, policy, initialDepth, descendantDepth, currentDepth, currentDescendantDepth);
                    hasChanged = hasChanged || hasChangedInPage;
                }
            }
        }
        
        return hasChanged;
    }
    
    private boolean _saxPage(ContentHandler handler, PageWrapper page, Page currentPage, String currentPagePath, UserIdentity userIdentity, RenderingContext renderingContext, RestrictedPagePolicy policy, int initialDepth, int descendantDepth, int currentDepth, int currentDescendantDepth) throws SAXException
    {
        String pagePath = page.getPath();

        AttributesImpl attrs = new AttributesImpl();
        Map<String, String> internalAttributes = page.getInternalAttributes();
        
        for (String name : internalAttributes.keySet())
        {
            attrs.addCDATAAttribute(NAMESPACE_URI, name, NAMESPACE_PREFIX + ':' + name, internalAttributes.get(name));
        }
        
        Map<String, String> attributes = page.getAttributes();
        
        for (String name : attributes.keySet())
        {
            attrs.addCDATAAttribute(name, attributes.get(name));
        }
        
        PageStatus pageStatus = _saxCurrentStatus(currentPagePath, pagePath, attrs);
        
        boolean hasChanged = false;
        
        XMLUtils.startElement(handler, "page", attrs);
        
        // Continue if current depth is less than initial depth
        // or if we are inside current path or in current page descendants
        if (currentDepth <= initialDepth || pageStatus == PageStatus.IN_PATH || pageStatus == PageStatus.CURRENT && descendantDepth > 0 || pageStatus == PageStatus.DESCENDANT && currentDescendantDepth < descendantDepth)
        {
            int descendant = (pageStatus == PageStatus.CURRENT) ? 1 : (pageStatus == PageStatus.DESCENDANT ? currentDescendantDepth + 1 : -1);
            Pair<List< ? extends PageWrapper>, Boolean> children = page.getChildren();
            boolean hasChangedInPage = children.getRight();
            
            boolean hasChangedInChildren = _saxPages(handler, children.getLeft(), currentPage, currentPagePath, userIdentity, renderingContext, policy, initialDepth, descendantDepth, currentDepth + 1, descendant);
            
            hasChanged = hasChangedInPage || hasChangedInChildren;
        }
        
        XMLUtils.endElement(handler, "page");
        
        return hasChanged;
    }
    
    /**
     * SAX current status.
     * @param currentPagePath the path to the current page.
     * @param pagePath the path to the page to process.
     * @param attrs the attributes to populate.
     * @return the current status.
     */
    protected PageStatus _saxCurrentStatus(String currentPagePath, String pagePath, AttributesImpl attrs)
    {
        PageStatus result = PageStatus.NOT_IN_PATH;

        if (currentPagePath == null)
        {
            return PageStatus.NOT_IN_PATH;
        }

        // If the page in an ancestor of the current page
        boolean isPageCurrent = currentPagePath.equals(pagePath);

        if (currentPagePath.startsWith(pagePath + "/") || isPageCurrent)
        {
            attrs.addCDATAAttribute(NAMESPACE_URI, "in-path", NAMESPACE_PREFIX + ":in-path", "true");
            result = PageStatus.IN_PATH;
        }
        else if (pagePath.startsWith(currentPagePath))
        {
            result = PageStatus.DESCENDANT;
        }

        // If this is the current page
        if (isPageCurrent)
        {
            attrs.addCDATAAttribute(NAMESPACE_URI, "current", NAMESPACE_PREFIX + ":current", "true");
            result = PageStatus.CURRENT;
        }

        return result;
    }
    
    interface PageWrapper
    {
        boolean isVisible();
        String getPath();
        Map<String, String> getAttributes();
        Map<String, String> getInternalAttributes();
        boolean hasReadAccess(UserIdentity user);
        
        // actual children + a boolean indicating newly-fetched children 
        Pair<List<? extends PageWrapper>, Boolean> getChildren();
        
        default Map<String, String> _getInternalAttributes(Page page)
        {
            Map<String, String> internalAttributes = new HashMap<>();
            String path = page.getPathInSitemap();
            PageType pageType = page.getType();
            internalAttributes.put("id", page.getId());
            internalAttributes.put("name", page.getName());
            internalAttributes.put("title", page.getTitle());
            internalAttributes.put("long-title", page.getLongTitle());
            internalAttributes.put("path", path);
            internalAttributes.put("type", page.getType().name());
            
            if (!page.isVisible())
            {
                internalAttributes.put("invisible", "true");
            }
            
            if (!_rightManager.hasAnonymousReadAccess(page))
            {
                internalAttributes.put("restricted", "true");
            }
            
            // Add a flag if there is data
            if (pageType == PageType.CONTAINER)
            {
                internalAttributes.put("container", "true");
            }
            // Add URL if found
            else if (pageType == PageType.LINK)
            {
                internalAttributes.put("link", page.getURL());
                internalAttributes.put("link-type", page.getURLType().name());
            }
            
            return internalAttributes;
        }
        
        @SuppressWarnings("unchecked")
        default Map<String, String> _getAttributes(Page page)
        {
            Map<String, String> attributes = new HashMap<>();
            
            for (String dataName : page.getDataNames())
            {
                // SAX only non composite and non multivalued data
                ModelItemType type = page.getType(dataName);
                if (type instanceof ElementType && !page.isMultiple(dataName))
                {
                    Object value = page.getValue(dataName);
                    attributes.put(dataName, ((ElementType) type).toString(value));
                }
            }
            
            // tags
            for (String tag : page.getTags())
            {
                Map<String, Object> params = Map.of("siteName", page.getSiteName());
                if (_tagProviderExtensionPoint.hasTag(tag, params))
                {
                    attributes.put("PLUGIN_TAGS_" + tag, "empty");
                }
            }
            
            return attributes;
        }
    }

    static class BufferedPage implements PageWrapper, Sized
    {
        String _path;
        Map<String, String> _attributes;
        Map<String, String> _internalAttributes;
        boolean _visible = true;
        boolean _childrenFetched;
        long _size = -1;
        
        List<BufferedPage> _children;
        
        BufferedPage(Page page)
        {
            _path = page.getPathInSitemap();
            
            Map<String, String> internalAttributes = _getInternalAttributes(page);
            _internalAttributes = internalAttributes;
            if ("true".equals(internalAttributes.get("invisible")))
            {
                _visible = false;
            }
            
            _attributes = _getAttributes(page);
        }
        
        public long getSize()
        {
            if (_size == -1)
            {
                _size = SizeUtils.shallowSizeOf(this) + SizeUtils.totalSizeOf(_path, _attributes, _internalAttributes);
            }
            
            long size = _size;
            
            if (_children != null)
            {
                for (BufferedPage child : _children)
                {
                    size += child.getSize();
                }
            }
            
            return size;
        }
        
        @Override
        public Pair<List<? extends PageWrapper>, Boolean> getChildren()
        {
            boolean hasChanged = false;
            
            if (!_childrenFetched)
            {
                // fill cache when needed
                String pageId = _internalAttributes.get("id");
                Page page = _resolver.resolveById(pageId);
                
                _children = page.getChildrenPages().stream().map(BufferedPage::new).collect(Collectors.toList());
                _childrenFetched = true;
                hasChanged = true;
            }
            
            return Pair.of(_children, hasChanged);
        }
        
        @Override
        public boolean isVisible()
        {
            return _visible;
        }
        
        @Override
        public String getPath()
        {
            return _path;
        }
        
        @Override
        public Map<String, String> getAttributes()
        {
            return _attributes;
        }
        
        @Override
        public Map<String, String> getInternalAttributes()
        {
            return _internalAttributes;
        }
        
        @Override
        public boolean hasReadAccess(UserIdentity user)
        {
            throw new UnsupportedOperationException("A BufferedPage has no concept of read access");
        }
    }
    
    class RepositoryPage implements PageWrapper
    {
        Page _page;
        
        RepositoryPage(Page page)
        {
            _page = page;
        }
        
        @Override
        public Pair<List<? extends PageWrapper>, Boolean> getChildren()
        {
            return Pair.of(_page.getChildrenPages().stream().map(RepositoryPage::new).collect(Collectors.toList()), false);
        }
        
        @Override
        public boolean isVisible()
        {
            return _page.isVisible();
        }
        
        @Override
        public String getPath()
        {
            return _page.getPathInSitemap();
        }
        
        @Override
        public Map<String, String> getAttributes()
        {
            return _getAttributes(_page);
        }
        
        @Override
        public Map<String, String> getInternalAttributes()
        {
            return _getInternalAttributes(_page);
        }
        
        @Override
        public boolean hasReadAccess(UserIdentity user)
        {
            return _rightManager.hasReadAccess(user, _page);
        }
    }

    private Cache<PageElementKey, List<BufferedPage>> _getCache()
    {
        return _cacheManager.get(ROLE);
    }
}