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

import java.text.Normalizer;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.HashSet;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.Objects;
import java.util.Set;
import java.util.SortedSet;
import java.util.TreeSet;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
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.commons.lang3.StringUtils;

import org.ametys.cms.contenttype.ContentType;
import org.ametys.cms.contenttype.ContentTypeExtensionPoint;
import org.ametys.cms.repository.Content;
import org.ametys.cms.repository.ContentTypeExpression;
import org.ametys.cms.repository.LanguageExpression;
import org.ametys.core.cache.AbstractCacheManager;
import org.ametys.core.cache.Cache;
import org.ametys.plugins.core.impl.cache.AbstractCacheKey;
import org.ametys.plugins.repository.AmetysObjectIterable;
import org.ametys.plugins.repository.AmetysObjectResolver;
import org.ametys.plugins.repository.AmetysRepositoryException;
import org.ametys.plugins.repository.UnknownAmetysObjectException;
import org.ametys.plugins.repository.provider.WorkspaceSelector;
import org.ametys.plugins.repository.query.QueryHelper;
import org.ametys.plugins.repository.query.SortCriteria;
import org.ametys.plugins.repository.query.expression.AndExpression;
import org.ametys.plugins.repository.query.expression.Expression;
import org.ametys.plugins.repository.query.expression.Expression.Operator;
import org.ametys.plugins.repository.query.expression.OrExpression;
import org.ametys.plugins.repository.query.expression.StringExpression;
import org.ametys.plugins.repository.query.expression.VirtualFactoryExpression;
import org.ametys.plugins.userdirectory.page.VirtualUserDirectoryPageFactory;
import org.ametys.runtime.i18n.I18nizableText;
import org.ametys.runtime.plugin.component.AbstractLogEnabled;
import org.ametys.web.repository.page.Page;
import org.ametys.web.repository.page.PageQueryHelper;

/**
 * Component providing methods to retrieve user directory virtual pages, such as the user directory root,
 * transitional page and user page.
 */
public class UserDirectoryPageHandler extends AbstractLogEnabled implements Component, Serviceable, Initializable
{
    /** The avalon role. */
    public static final String ROLE = UserDirectoryPageHandler.class.getName();
    
    /** The data name for the content type of the user directory */
    public static final String CONTENT_TYPE_DATA_NAME = "user-directory-root-contenttype";
    /** The data name for the users' view to use */
    public static final String USER_VIEW_NAME = "user-directory-root-view-name";
    /** The data name for the classification attribute of the user directory */
    public static final String CLASSIFICATION_ATTRIBUTE_DATA_NAME = "user-directory-root-classification-metadata";
    /** The data name for the depth of the user directory */
    public static final String DEPTH_DATA_NAME = "user-directory-root-depth";
    /** The parent content type id */
    public static final String ABSTRACT_USER_CONTENT_TYPE = "org.ametys.plugins.userdirectory.Content.user";
    /** The user directory root pages cache id */
    protected static final String ROOT_PAGES_CACHE = UserDirectoryPageHandler.class.getName() + "$rootPageIds";
    /** The user directory transitional pages cache id */
    protected static final String TRANSITIONAL_PAGES_CACHE = UserDirectoryPageHandler.class.getName() + "$transitionalPageIds";
    /** The user directory user pages cache id */
    protected static final String USER_PAGES_CACHE = UserDirectoryPageHandler.class.getName() + "$userPages";
    
    /** The workspace selector. */
    protected WorkspaceSelector _workspaceSelector;
    /** The ametys object resolver. */
    protected AmetysObjectResolver _resolver;
    /** The extension point for content types */
    protected ContentTypeExtensionPoint _contentTypeEP;
    /** The cache manager */
    protected AbstractCacheManager _abstractCacheManager;
    
    @Override
    public void service(ServiceManager manager) throws ServiceException
    {
        _workspaceSelector = (WorkspaceSelector) manager.lookup(WorkspaceSelector.ROLE);
        _resolver = (AmetysObjectResolver) manager.lookup(AmetysObjectResolver.ROLE);
        _contentTypeEP = (ContentTypeExtensionPoint) manager.lookup(ContentTypeExtensionPoint.ROLE);
        _abstractCacheManager = (AbstractCacheManager) manager.lookup(AbstractCacheManager.ROLE);
    }
    
    @Override
    public void initialize() throws Exception
    {
        _abstractCacheManager.createMemoryCache(ROOT_PAGES_CACHE, 
                new I18nizableText("plugin.user-directory", "PLUGINS_USER_DIRECTORY_CACHE_ROOT_PAGES_LABEL"),
                new I18nizableText("plugin.user-directory", "PLUGINS_USER_DIRECTORY_CACHE_ROOT_PAGES_DESCRIPTION"),
                true,
                null);
        _abstractCacheManager.createMemoryCache(TRANSITIONAL_PAGES_CACHE, 
                new I18nizableText("plugin.user-directory", "PLUGINS_USER_DIRECTORY_CACHE_TRANSITIONAL_PAGES_LABEL"),
                new I18nizableText("plugin.user-directory", "PLUGINS_USER_DIRECTORY_CACHE_TRANSITIONAL_PAGES_DESCRIPTION"),
                true,
                null);
        _abstractCacheManager.createMemoryCache(USER_PAGES_CACHE, 
                new I18nizableText("plugin.user-directory", "PLUGINS_USER_DIRECTORY_CACHE_USER_PAGES_LABEL"),
                new I18nizableText("plugin.user-directory", "PLUGINS_USER_DIRECTORY_CACHE_USER_PAGES_DESCRIPTION"),
                true,
                null);
    }
    
    /**
     * Gets the user directory root pages from the given content type id, whatever the site.
     * @param contentTypeId The content type id
     * @return the user directory root pages.
     * @throws AmetysRepositoryException  if an error occured.
     */
    public Set<Page> getUserDirectoryRootPages(String contentTypeId) throws AmetysRepositoryException
    {
        Expression expression = new VirtualFactoryExpression(VirtualUserDirectoryPageFactory.class.getName());
        Expression contentTypeExp = new StringExpression(CONTENT_TYPE_DATA_NAME, Operator.EQ, contentTypeId);
        
        AndExpression andExp = new AndExpression(expression, contentTypeExp);
        
        String query = PageQueryHelper.getPageXPathQuery(null, null, null, andExp, null);
        
        AmetysObjectIterable<Page> pages = _resolver.query(query);
        
        return pages.stream().collect(Collectors.toSet());
    }
    
    /**
     * Gets the user directory root page of a specific content type.
     * @param siteName The site name
     * @param sitemapName The sitemap
     * @param contentTypeId The content type id
     * @return the user directory root pages.
     * @throws AmetysRepositoryException  if an error occured.
     */
    public Page getUserDirectoryRootPage(String siteName, String sitemapName, String contentTypeId) throws AmetysRepositoryException
    {
        String contentTypeIdToCompare = contentTypeId != null ? contentTypeId : "";
        
        for (Page userDirectoryRootPage : getUserDirectoryRootPages(siteName, sitemapName))
        {
            if (contentTypeIdToCompare.equals(getContentTypeId(userDirectoryRootPage)))
            {
                return userDirectoryRootPage;
            }
        }
        
        return null;
    }
    
    /**
     * Gets the user directory root pages.
     * @param siteName The site name
     * @param sitemapName The sitemap
     * @return the user directory root pages.
     * @throws AmetysRepositoryException  if an error occured.
     */
    public Set<Page> getUserDirectoryRootPages(String siteName, String sitemapName) throws AmetysRepositoryException
    {
        Set<Page> rootPages = new HashSet<>();
        
        String workspace = _workspaceSelector.getWorkspace();
        
        Cache<RootPageCacheKey, Set<String>> cache = getRootPagesCache();
        
        RootPageCacheKey key = RootPageCacheKey.of(workspace, siteName, sitemapName);
        if (cache.hasKey(key))
        {
            rootPages = cache.get(key).stream()
                    .map(this::_resolvePage)
                    .filter(Objects::nonNull)
                    .collect(Collectors.toSet());
        }
        else
        {
            rootPages = _getUserDirectoryRootPages(siteName, sitemapName);
            Set<String> userDirectoryRootPageIds = rootPages.stream()
                    .map(Page::getId)
                    .collect(Collectors.toSet());
            cache.put(key, userDirectoryRootPageIds);
        }
        
        return rootPages;
    }
    
    private Page _resolvePage(String pageId)
    {
        try
        {
            return _resolver.resolveById(pageId);
        }
        catch (UnknownAmetysObjectException e)
        {
            // The page stored in cache may have been deleted
            return null;
        }
    }
    
    /**
     * Get the user directory root pages, without searching in the cache.
     * @param siteName the current site.
     * @param sitemapName the sitemap name.
     * @return the user directory root pages
     * @throws AmetysRepositoryException if an error occured.
     */
    protected Set<Page> _getUserDirectoryRootPages(String siteName, String sitemapName) throws AmetysRepositoryException
    {
        Expression expression = new VirtualFactoryExpression(VirtualUserDirectoryPageFactory.class.getName());
        
        String query = PageQueryHelper.getPageXPathQuery(siteName, sitemapName, null, expression, null);
        
        AmetysObjectIterable<Page> pages = _resolver.query(query);
        
        return pages.stream().collect(Collectors.toSet());
    }
    
    /**
     * Gets the depth of the user directory root page
     * @param rootPage The user directory root page
     * @return the depth of the user directory root page
     */
    public int getDepth(Page rootPage)
    {
        return Math.toIntExact(rootPage.getValue(DEPTH_DATA_NAME));
    }
    
    /**
     * Gets the name of the classification attribute
     * @param rootPage The user directory root page
     * @return the name of the classification attribute
     */
    public String getClassificationAttribute(Page rootPage)
    {
        return rootPage.getValue(CLASSIFICATION_ATTRIBUTE_DATA_NAME);
    }
    
    /**
     * Gets the content type id
     * @param rootPage The user directory root page
     * @return the content type id
     */
    public String getContentTypeId(Page rootPage)
    {
        return rootPage.getValue(CONTENT_TYPE_DATA_NAME);
    }
    
    /**
     * Gets the content type
     * @param rootPage The user directory root page
     * @return the content type
     */
    public ContentType getContentType(Page rootPage)
    {
        String contentTypeId = getContentTypeId(rootPage);
        return StringUtils.isNotBlank(contentTypeId) ? _contentTypeEP.getExtension(contentTypeId) : null;
    }
    
    /**
     * Gets the value of the classification attribute for the given content, transformed for building tree hierarchy
     * <br>The transformation takes the lower-case of all characters, removes non-alphanumeric characters,
     * and takes the first characters to not have a string with a size bigger than the depth
     * <br>For instance, if the value for the content is "Aéa Foo-bar" and the depth is 7,
     * then this method will return "aeafoob"
     * @param rootPage The user directory root page
     * @param content The content
     * @return the transformed value of the classification attribute for the given content. Can be null
     */
    public String getTransformedClassificationValue(Page rootPage, Content content)
    {
        String attribute = getClassificationAttribute(rootPage);
        int depth = getDepth(rootPage);
        
        // 1) get value of the classification attribute
        String classification = content.getValue(attribute);
        
        if (classification == null)
        {
            // The classification does not exists for the content
            getLogger().info("The classification attribute '{}' does not exist for the content {}", attribute, content);
            return null;
        }
        
        try
        {
            // 2) replace special character
            // 3) remove '-' characters
            
            // FIXME CMS-5758 FilterNameHelper.filterName do not authorized name with numbers only.
            // So code of FilterNamehelper is temporarily duplicated here with a slightly modified RegExp
//            String transformedValue = FilterNameHelper.filterName(classification).replace("-", "");
            String transformedValue = _filterName(classification).replace("-", "");
            
            // 4) only keep 'depth' first characters (if depth = 3, "de" becomes "de", "debu" becomes "deb", etc.)
            return StringUtils.substring(transformedValue, 0, depth);
        }
        catch (IllegalArgumentException e)
        {
            // The value of the classification attribute is not valid
            getLogger().warn("The classification attribute '{}' does not have a valid value ({}) for the content {}", attribute, classification, content);
            return null;
        }
    }
    
    private String _filterName(String name)
    {
        Pattern pattern = Pattern.compile("^()[0-9-_]*[a-z0-9].*$");
        // Use lower case
        // then remove accents
        // then replace contiguous spaces with one dash
        // and finally remove non-alphanumeric characters except -
        String filteredName = Normalizer.normalize(name.toLowerCase(), Normalizer.Form.NFD).replaceAll("[\\p{InCombiningDiacriticalMarks}]", "").trim(); 
        filteredName = filteredName.replaceAll("œ", "oe").replaceAll("æ", "ae").replaceAll(" +", "-").replaceAll("[^\\w-]", "-").replaceAll("-+", "-");

        Matcher m = pattern.matcher(filteredName);
        if (!m.matches())
        {
            throw new IllegalArgumentException(filteredName + " doesn't match the expected regular expression : " + pattern.pattern());
        }

        filteredName = filteredName.substring(m.end(1));

        // Remove characters '-' and '_' at the start and the end of the string
        return StringUtils.strip(filteredName, "-_");
    }
    
    /**
     * Get all transitional page child from page name
     * @param rootPage the root page
     * @param pagePath the page path
     * @return all transitional page child from page name
     */
    public SortedSet<String> getTransitionalPagesName(Page rootPage, String pagePath)
    {
        String cachePagePath = getName(pagePath);
        
        String workspace = _workspaceSelector.getWorkspace();
        String site = rootPage.getSiteName();
        String contentType = getContentTypeId(rootPage);
        _initializeCaches(rootPage, workspace, contentType);
        PageCacheKey key = PageCacheKey.of(workspace, contentType, site, rootPage.getSitemapName(), cachePagePath);
        Cache<PageCacheKey, SortedSet<String>> transitionalPagesCache = getTransitionalPagesCache();
        return transitionalPagesCache.get(key, k -> new TreeSet<>());
    }
    
    private void _initializeCaches(Page rootPage, String workspace, String contentType)
    {
        String language = rootPage.getSitemapName();
        String site = rootPage.getSiteName();
        
        
        // Get transitional page cache
        PageCacheKey transitionalPagesCacheKey = PageCacheKey.of(workspace, contentType, site, language, null);
        Cache<PageCacheKey, SortedSet<String>> transitionalPagesCache = getTransitionalPagesCache();
        
        // Get user page cache
        PageCacheKey userPagesCacheKey = PageCacheKey.of(workspace, contentType, site, language, null);
        Cache<PageCacheKey, Map<String, String>> userPagesCache = getUserPagesCache();
        
        if (transitionalPagesCache.hasKey(transitionalPagesCacheKey) && userPagesCache.hasKey(userPagesCacheKey))
        {
            // Both caches are initialized
            getLogger().debug("TransitionalPageCache and UserPageCache are initialized for workspace '{}' and content type '{}' and language '{}'", workspace, contentType, language);
            return;
        }
        
        // Get all contents which will appear in the sitemap
        AmetysObjectIterable<Content> contents = getContentsForRootPage(rootPage);
        
        // Get their classification attribute value
        Map<Content, String> transformedValuesByContent = new LinkedHashMap<>();
        for (Content content : contents)
        {
            String value = getTransformedClassificationValue(rootPage, content);
            if (value != null)
            {
                transformedValuesByContent.put(content, value);
            }
        }
        
        if (!transitionalPagesCache.hasKey(transitionalPagesCacheKey))
        {
            Set<String> transformedValues = new HashSet<>(transformedValuesByContent.values());
            _buildTransitionalPageCache(transformedValues, workspace, contentType, site, language);
            getLogger().info("Transitional page cache was built for workspace '{}' and content type '{}' and language '{}'", workspace, contentType, language);
        }
        
        if (!userPagesCache.hasKey(userPagesCacheKey))
        {
            int depth = getDepth(rootPage);
            _buildUserPageCache(transformedValuesByContent, depth, workspace, contentType, site, language);
            getLogger().info("User page cache was built for workspace '{}' and content type '{}' and language '{}'", workspace, contentType, language);
        }
    }
    
    private void _buildTransitionalPageCache(Set<String> transformedValues, String workspace, String contentTypeId, String siteName, String siteMapName)
    {
        Cache<PageCacheKey, SortedSet<String>> transitionalPagesCache = getTransitionalPagesCache();
        for (String value : transformedValues)
        {
            char[] charArray = value.toCharArray();
            for (int i = 0; i < charArray.length; i++)
            {
                String lastChar = String.valueOf(charArray[i]);
                if (i == 0)
                {
                    // case _root
                    SortedSet<String> root = transitionalPagesCache.get(PageCacheKey.of(workspace, contentTypeId, siteName, siteMapName, "_root"), k -> new TreeSet<>());
                    if (!root.contains(lastChar))
                    {
                        root.add(lastChar);
                    }
                }
                else
                {
                    String currentPrefixWithoutLastChar = value.substring(0, i); // if value == "debu", equals to "deb"
                    String currentPathWithoutLastChar = StringUtils.join(currentPrefixWithoutLastChar.toCharArray(), '/'); // if value == "debu", equals to "d/e/b"
                    SortedSet<String> childPageNames = transitionalPagesCache.get(PageCacheKey.of(workspace, contentTypeId, siteName, siteMapName, currentPathWithoutLastChar), k -> new TreeSet<>());
                    
                    if (!childPageNames.contains(lastChar))
                    {
                        childPageNames.add(lastChar); // if value == "debu", add "u" in childPageNames for key "d/e/b"
                    }
                }
            }
        }
    }
    
    private void _buildUserPageCache(Map<Content, String> transformedValuesByContent, int depth, String workspace, String contentTypeId, String siteName, String language)
    {
        if (depth == 0)
        {
            Map<String, String> rootContents = new LinkedHashMap<>();
            for (Content content : transformedValuesByContent.keySet())
            {
                rootContents.put(content.getName(), content.getId());
            }
            getUserPagesCache().put(PageCacheKey.of(workspace, contentTypeId, siteName, language, "_root"), rootContents);
            return;
        }
        
        for (Content content : transformedValuesByContent.keySet())
        {
            String transformedValue = transformedValuesByContent.get(content);
            for (int i = 0; i < depth; i++)
            {
                String currentPrefix = StringUtils.substring(transformedValue, 0, i + 1);
                String currentPath = StringUtils.join(currentPrefix.toCharArray(), '/');
                PageCacheKey userPageKey = PageCacheKey.of(workspace, contentTypeId, siteName, language, currentPath);
                Map<String, String> contentsForPath = getUserPagesCache().get(userPageKey, k -> new LinkedHashMap<>());
                
                String contentName = content.getName();
                if (!contentsForPath.containsKey(contentName))
                {
                    contentsForPath.put(contentName, content.getId());
                }
            }
        }
    }
    
    /**
     * Get all user page child from page name
     * @param rootPage the root page
     * @param pagePath the page path
     * @return all user page child from page name
     */
    public Map<String, String> getUserPagesContent(Page rootPage, String pagePath)
    {
        String cachePagePath = getName(pagePath);
        
        String workspace = _workspaceSelector.getWorkspace();
        String site = rootPage.getSiteName();
        String contentType = getContentTypeId(rootPage);
        _initializeCaches(rootPage, workspace, contentType);
        
        return getUserPagesCache().get(PageCacheKey.of(workspace, contentType, site, rootPage.getSitemapName(), cachePagePath), k -> new HashMap<>());
    }
    
    /**
     * Get the user contents for a given root page
     * @param rootPage the root page
     * @return the user contents
     */
    public AmetysObjectIterable<Content> getContentsForRootPage(Page rootPage)
    {
        String contentType = getContentTypeId(rootPage);
        String lang = rootPage.getSitemapName();
        
        Set<String> subTypes = _contentTypeEP.getSubTypes(contentType);
        
        List<Expression> contentTypeExpressions = new ArrayList<>();
        contentTypeExpressions.add(new ContentTypeExpression(Operator.EQ, contentType));
        for (String subType : subTypes)
        {
            contentTypeExpressions.add(new ContentTypeExpression(Operator.EQ, subType));
        }
        
        Expression contentTypeExpression = new OrExpression(contentTypeExpressions.toArray(new Expression[subTypes.size() + 1]));
        
        Expression finalExpr = new AndExpression(contentTypeExpression, new LanguageExpression(Operator.EQ, lang));
        
        SortCriteria sort = new SortCriteria();
        sort.addCriterion(Content.ATTRIBUTE_TITLE, true, true);
        
        String xPathQuery = QueryHelper.getXPathQuery(null, "ametys:content", finalExpr, sort);
        
        return _resolver.query(xPathQuery);
    }
    
    /**
     * Gets name form path name
     * @param pathName the path name
     * @return the name
     */
    public String getName(String pathName)
    {
        String prefix = "page-";
        String name = "";
        for (String transitionalPageName : pathName.split("/"))
        {
            if (!name.equals(""))
            {
                name += "/";
            }
            name += StringUtils.startsWith(transitionalPageName, prefix) ? StringUtils.substringAfter(transitionalPageName, prefix) : transitionalPageName;
        }
        return name;
    }
    
    /**
     * Checks if name contains only Unicode digits and if so, prefix it with "page-"
     * @param name The page name
     * @return The potentially prefixed page name
     */
    public String getPathName(String name)
    {
        return StringUtils.isNumeric(name) ? "page-" + name : name; 
    }
    
    /**
     * Clear root page cache
     * @param rootPage the root page
     */
    public void clearCache(Page rootPage)
    {
        clearCache(getContentTypeId(rootPage));
    }
    
    /**
     * Clear root page cache
     * @param contentTypeId the content type id
     */
    public void clearCache(String contentTypeId)
    {
        getTransitionalPagesCache().invalidate(PageCacheKey.of(null, contentTypeId, null, null, null));
        
        getUserPagesCache().invalidate(PageCacheKey.of(null, contentTypeId, null, null, null));
        
        getRootPagesCache().invalidateAll();
    }
    
    /**
     * Cache of the user directory root pages.
     * The cache store a Set of TODO indexed by the workspaceName, siteName, siteMapName
     * @return the cache
     */
    protected Cache<RootPageCacheKey, Set<String>> getRootPagesCache()
    {
        return _abstractCacheManager.get(ROOT_PAGES_CACHE);
    }
    
    /**
     * Key to index a user directory root page in a cache
     */
    protected static final class RootPageCacheKey extends AbstractCacheKey
    {
        /**
         * Basic constructor
         * @param workspaceName the workspace name. Can be null.
         * @param siteName the site name. Can be null.
         * @param language the sitemap name. Can be null.
         */
        public RootPageCacheKey(String workspaceName, String siteName, String language)
        {
            super(workspaceName, siteName, language);
        }
        
        /**
         * Generate a cache key
         * @param workspaceName the workspace name. Can be null.
         * @param siteName the site name. Can be null.
         * @param language the sitemap name. Can be null.
         * @return the cache key
         */
        public static RootPageCacheKey of(String workspaceName, String siteName, String language)
        {
            return new RootPageCacheKey(workspaceName, siteName, language);
        }
    }
    
    /**
     * Cache of the user directory transitional pages.
     * The cache store a sorted set of TODO indexed by the workspaceName, siteName, siteMapName, pageName.
     * @return the cache
     */
    protected Cache<PageCacheKey, SortedSet<String>> getTransitionalPagesCache()
    {
        return _abstractCacheManager.get(TRANSITIONAL_PAGES_CACHE);
    }
    
    /**
     * Cache of the user directory user pages.
     * The cache store a {@link Map} of (content name, content id) of all the content of the page.
     * The cache is indexed by workspaceName, siteName, siteMapName, pageName.
     * @return the cache
     */
    protected Cache<PageCacheKey, Map<String, String>> getUserPagesCache()
    {
        return _abstractCacheManager.get(USER_PAGES_CACHE);
    }
    
    /**
     * Key to index a user directory page in a cache
     */
    protected static final class PageCacheKey extends AbstractCacheKey
    {
        
        /**
         * Basic constructor
         * @param workspaceName the workspace name. Can be null.
         * @param contentTypeId the contentType id. Can be null.
         * @param siteName the site name. Can be null.
         * @param language the sitemap name. Can be null.
         * @param pageName the page name. Can be null.
         */
        public PageCacheKey(String workspaceName, String contentTypeId, String siteName, String language, String pageName)
        {
            super(workspaceName, contentTypeId, siteName, language, pageName);
        }
        
        /**
         * Generate a cache key
         * @param workspaceName the workspace name. Can be null.
         * @param contentTypeId the contentType id. Can be null.
         * @param siteName the site name. Can be null.
         * @param language the sitemap name. Can be null.
         * @param pageName the page name. Can be null.
         * @return the cache key
         */
        public static PageCacheKey of(String workspaceName, String contentTypeId, String siteName, String language, String pageName)
        {
            return new PageCacheKey(workspaceName, contentTypeId, siteName, language, pageName);
        }
    }
}