/*
 *  Copyright 2011 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.blog;

import java.time.ZonedDateTime;
import java.util.ArrayList;
import java.util.Calendar;
import java.util.Collection;
import java.util.Collections;
import java.util.Comparator;
import java.util.Date;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;
import java.util.concurrent.TimeUnit;

import org.apache.avalon.framework.activity.Initializable;
import org.apache.avalon.framework.component.Component;
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.ametys.cms.ObservationConstants;
import org.ametys.cms.repository.Content;
import org.ametys.cms.repository.ContentTypeExpression;
import org.ametys.cms.repository.LanguageExpression;
import org.ametys.cms.tag.Tag;
import org.ametys.cms.tag.TagHelper;
import org.ametys.cms.tag.TagProviderExtensionPoint;
import org.ametys.core.cache.AbstractCacheManager;
import org.ametys.core.cache.Cache;
import org.ametys.core.observation.Event;
import org.ametys.core.observation.ObservationManager;
import org.ametys.core.user.UserIdentity;
import org.ametys.plugins.blog.posts.PostContentType;
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.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.MetadataExpression;
import org.ametys.plugins.repository.query.expression.StringExpression;
import org.ametys.runtime.i18n.I18nizableText;
import org.ametys.web.WebConstants;
import org.ametys.web.repository.SiteAwareAmetysObject;
import org.ametys.web.repository.site.Site;
import org.ametys.web.repository.site.SiteManager;
import org.ametys.web.site.SiteConfigurationExtensionPoint;

import com.google.common.collect.Multimap;
import com.google.common.collect.TreeMultimap;

/**
 * Blog cache manager.
 */
public class BlogCacheManager extends AbstractLogEnabled implements Component, Serviceable, Initializable
{
    /** The name of the date attribute of post */
    public static final String POST_DATE_ATTRIBUTE = "date";

    /** The name of the tags attribute of post */
    public static final String POST_TAGS_ATTRIBUTE = "tags";
    
    /** The avalon role. */
    public static final String ROLE = BlogCacheManager.class.getName();

    private static final String __LAST_UPDATE_FUTURE_POST_CACHE = ROLE + "$lastUpdate";

    private static final String __POST_BY_DATE_CACHE = ROLE + "$postsByDate";
    
    private static final String __POST_BY_TAG_CACHE = ROLE + "$postsByTag";
    
    private static final String __ALL_POSTS_CACHE = ROLE + "$allPosts";
    
    private static final String __FUTURE_POSTS_CACHE = ROLE + "$futurePosts";
    
    /** The ametys object resolver. */
    protected AmetysObjectResolver _ametysResolver;
    
    /** Th tag provider */
    protected TagProviderExtensionPoint _tagProviderEP;
    
    /** The Site manager. */
    protected SiteManager _siteManager;
    
    /** The site configuration extension point */
    protected SiteConfigurationExtensionPoint _siteConf;
    
    /** The blog root page handler. */
    protected BlogPageHandler _blogRootHandler;
    
    /** The workspace selector. */
    protected WorkspaceSelector _workspaceSelector;
    
    /** The Ametys resolver */
    protected AmetysObjectResolver _resolver;
    
    /** The observation manager */
    protected ObservationManager _observationManager;
    
    /** CacheManager used to create and get cache */
    protected AbstractCacheManager _cacheManager;
    
    @Override
    public void service(ServiceManager serviceManager) throws ServiceException
    {
        _ametysResolver = (AmetysObjectResolver) serviceManager.lookup(AmetysObjectResolver.ROLE);
        _siteManager = (SiteManager) serviceManager.lookup(SiteManager.ROLE);
        _siteConf = (SiteConfigurationExtensionPoint) serviceManager.lookup(SiteConfigurationExtensionPoint.ROLE);
        _blogRootHandler = (BlogPageHandler) serviceManager.lookup(BlogPageHandler.ROLE);
        _workspaceSelector = (WorkspaceSelector) serviceManager.lookup(WorkspaceSelector.ROLE);
        _tagProviderEP = (TagProviderExtensionPoint) serviceManager.lookup(TagProviderExtensionPoint.ROLE);
        _resolver = (AmetysObjectResolver) serviceManager.lookup(AmetysObjectResolver.ROLE);
        _observationManager = (ObservationManager) serviceManager.lookup(ObservationManager.ROLE);
        _cacheManager = (AbstractCacheManager) serviceManager.lookup(AbstractCacheManager.ROLE);
    }
    
    @Override
    public void initialize() throws Exception
    {
        _cacheManager.createMemoryCache(__LAST_UPDATE_FUTURE_POST_CACHE, 
                new I18nizableText("plugin.blog", "PLUGINS_CORE_LAST_UPDATE_FUTURE_POST_CACHE_LABEL"),
                new I18nizableText("plugin.blog", "PLUGINS_CORE_LAST_UPDATE_FUTURE_POST_CACHE_DESCRIPTION"),
                true,
                null);
        _cacheManager.createMemoryCache(__POST_BY_DATE_CACHE, 
                new I18nizableText("plugin.blog", "PLUGINS_CORE_CACHE_POST_BY_DATE_LABEL"),
                new I18nizableText("plugin.blog", "PLUGINS_CORE_CACHE_POST_BY_DATE_DESCRIPTION"),
                true,
                null);
        _cacheManager.createMemoryCache(__POST_BY_TAG_CACHE, 
                new I18nizableText("plugin.blog", "PLUGINS_CORE_CACHE_POST_BY_TAG_LABEL"),
                new I18nizableText("plugin.blog", "PLUGINS_CORE_CACHE_POST_BY_TAG_DESCRIPTION"),
                true,
                null);
        _cacheManager.createMemoryCache(__ALL_POSTS_CACHE, 
                new I18nizableText("plugin.blog", "PLUGINS_CORE_CACHE_ALL_POSTS_LABEL"),
                new I18nizableText("plugin.blog", "PLUGINS_CORE_CACHE_ALL_POSTS_DESCRIPTION"),
                true,
                null);
        _cacheManager.createMemoryCache(__FUTURE_POSTS_CACHE, 
                new I18nizableText("plugin.blog", "PLUGINS_CORE_CACHE_FUTURE_POSTS_LABEL"),
                new I18nizableText("plugin.blog", "PLUGINS_CORE_CACHE_FUTURE_POSTS_DESCRIPTION"),
                true,
                null);
    }
    
    /**
     * Get the years with posts.
     * @param siteName the site name.
     * @param language the language.
     * @param year the year
     * @return the years with posts as a Set of Integer.
     */
    public boolean hasYear(String siteName, String language, int year)
    {
        PostDateCache cache = getPostDateCache(siteName, language);
        
        return cache.hasYear(year);
    }
    
    /**
     * Get the years with posts.
     * @param siteName the site name.
     * @param language the language.
     * @return the years with posts as a Set of Integer.
     */
    public Set<Integer> getYears(String siteName, String language)
    {
        PostDateCache cache = getPostDateCache(siteName, language);
        
        return cache.getYears();
    }
    
    /**
     * Get the years with posts.
     * @param siteName the site name.
     * @param language the language.
     * @param year the year
     * @param month the month
     * @return the years with posts as a Set of Integer.
     */
    public boolean hasMonth(String siteName, String language, int year, int month)
    {
        PostDateCache cache = getPostDateCache(siteName, language);
        
        return cache.hasMonth(year, month);
    }
    
    /**
     * Get the months with posts for a specified year.
     * @param siteName the site name.
     * @param language the language.
     * @param year the year.
     * @return the months with posts in the specified year as a Set of Integer.
     */
    public Set<Integer> getMonths(String siteName, String language, int year)
    {
        PostDateCache cache = getPostDateCache(siteName, language);
        
        return cache.getMonths(year);
    }
    
    /**
     * Get the posts for a year-month couple.
     * @param siteName the site name.
     * @param language the language.
     * @param year the year.
     * @param month the month.
     * @return the posts in the specified year and month.
     */
    public Map<String, Post> getPostsByMonth(String siteName, String language, int year, int month)
    {
        PostDateCache cache = getPostDateCache(siteName, language);
        
        return cache.getPosts(year, month);
    }
    
    /**
     * Get the posts for a year-month couple.
     * @param siteName the site name.
     * @param language the language.
     * @param year the year.
     * @param month the month.
     * @return the posts in the specified year and month.
     */
    public Collection<Post> getSortedPostsByMonth(String siteName, String language, int year, int month)
    {
        PostDateCache cache = getPostDateCache(siteName, language);
        
        List<Post> sortedPosts = new ArrayList<>(cache.getPosts(year, month).values());
        
        Collections.sort(sortedPosts, new ReverseDatePostComparator());
        
        return sortedPosts;
    }
    
    /**
     * Get the posts for a year.
     * @param siteName the site name.
     * @param language the language.
     * @param year the year.
     * @return the posts in the specified year.
     */
    public Map<String, Post> getPostsByYear(String siteName, String language, int year)
    {
        PostDateCache cache = getPostDateCache(siteName, language);
        
        return cache.getPosts(year);
    }
    
    /**
     * Get the posts for a year.
     * @param siteName the site name.
     * @param language the language.
     * @param year the year.
     * @return the posts in the specified year.
     */
    public Collection<Post> getSortedPostsByYear(String siteName, String language, int year)
    {
        PostDateCache cache = getPostDateCache(siteName, language);
        
        List<Post> sortedPosts = new ArrayList<>(cache.getPosts(year).values());
        
        Collections.sort(sortedPosts, new ReverseDatePostComparator());
        
        return sortedPosts;
    }
    
    /**
     * Get the posts for a year-month couple.
     * @param siteName the site name.
     * @param language the language.
     * @param year the year.
     * @param month the month.
     * @param name the name 
     * @return the posts in the specified year and month.
     */
    public Post getPostByName(String siteName, String language, int year, int month, String name)
    {
        PostDateCache cache = getPostDateCache(siteName, language);
        
        return cache.getPostByName(year, month, name);
    }
    
    /**
     * Get the posts for a year-month couple.
     * @param siteName the site name.
     * @param language the language.
     * @param year the year.
     * @param month the month.
     * @param id the id of post
     * @return the posts in the specified year and month.
     */
    public boolean hasPost(String siteName, String language, int year, int month, String id)
    {
        PostDateCache cache = getPostDateCache(siteName, language);
        
        return cache.hasPost(year, month, id);
    }
    
    /**
     * Get the posts for a year-month couple.
     * @param siteName the site name.
     * @param language the language.
     * @param year the year.
     * @param month the month.
     * @param name the name of post
     * @return the posts in the specified year and month.
     */
    public boolean hasPostByName(String siteName, String language, int year, int month, String name)
    {
        PostDateCache cache = getPostDateCache(siteName, language);
        
        return cache.hasPostByName(year, month, name);
    }
    
    /////////////////////////////////////////////////
    ///            POSTS BY TAG METHODS           ///
    /////////////////////////////////////////////////
    
    /**
     * Get the tags for a site and language.
     * @param siteName The site name
     * @param language The language
     * @return the tag list.
     */
    public Set<String> getTags(String siteName, String language)
    {
        PostTagCache cache = getPostTagCache(siteName, language);
        
        return cache.getTags();
    }
    
    /**
     * Test if a tag exists in the given site and language.
     * @param siteName The site name
     * @param language The language
     * @param tagName The tag name
     * @return true if the tag exists, false otherwise.
     */
    public boolean hasTag(String siteName, String language, String tagName)
    {
        PostTagCache cache = getPostTagCache(siteName, language);
        
        Map<String, Object> params = new HashMap<>();
        params.put("siteName", siteName);
        Tag tag = _tagProviderEP.getTag(tagName, params);
        Set<String> descendantNamesAndItSelf = TagHelper.getDescendantNames(tag, true);
        
        for (String descendantName : descendantNamesAndItSelf)
        {
            if (cache.hasTag(descendantName))
            {
                return true;
            }
        }
        
        return false;
    }
    
    /**
     * Get the posts for a given tag.
     * @param siteName The site name
     * @param language The language
     * @param tagName The tag name
     * @return the tag posts, indexed by ID.
     */
    public Map<String, Post> getPostsByTag(String siteName, String language, String tagName)
    {
        PostTagCache cache = getPostTagCache(siteName, language);
        
        return cache.getPosts(tagName);
    }
    
    /**
     * Get the posts for a given tag.
     * @param siteName The site name
     * @param language The language
     * @param tagName The tag name
     * @return the tag posts, indexed by ID.
     */
    public Collection<Post> getSortedPostsByTag(String siteName, String language, String tagName)
    {
        return getSortedPostsByTag (siteName, language, tagName, false);
    }
    
    /**
     * Get the posts for a given tag.
     * @param siteName The site name
     * @param language the language
     * @param tagName the tag name
     * @param deepSearch true to perform deep search
     * @return the tag posts, indexed by ID.
     */
    public Collection<Post> getSortedPostsByTag(String siteName, String language, String tagName, boolean deepSearch)
    {
        PostTagCache cache = getPostTagCache(siteName, language);
        
        List<Post> sortedPosts = new ArrayList<>(cache.getPosts(tagName).values());
        
        if (deepSearch)
        {
            Map<String, Object> contextualParams = new HashMap<>();
            contextualParams.put("siteName", siteName);
            
            Tag tag = _tagProviderEP.getTag(tagName, contextualParams);
            if (tag != null)
            {
                Set<String> descendantsNames = TagHelper.getDescendantNames(tag, false);
                for (String descendantsName : descendantsNames)
                {
                    sortedPosts.addAll(cache.getPosts(descendantsName).values());
                }
            }
        }
        
        Collections.sort(sortedPosts, new ReverseDatePostComparator());
        
        return sortedPosts;
    }
    
    /**
     * Test if a given post has a tag, by its ID.
     * @param siteName The site name
     * @param language The language
     * @param tagName The tag name
     * @param postId The id of post
     * @return true if the given post has the given tag.
     */
    public boolean hasPostByTag(String siteName, String language, String tagName, String postId)
    {
        PostTagCache cache = getPostTagCache(siteName, language);
        
        return cache.hasPost(tagName, postId);
    }
    
    /**
     * Get the posts for a year-month couple.
     * @param siteName The site name
     * @param language The language
     * @param tagName The tag name
     * @param id The id of post
     * @return the posts in the specified year and month.
     */
    public Post getPost(String siteName, String language, String tagName, String id)
    {
        PostTagCache cache = getPostTagCache(siteName, language);
        
        return cache.getPost(tagName, id);
    }
    
    /**
     * Get the posts for a year-month couple.
     * @param siteName The site name
     * @param language The language
     * @param tagName The tag name
     * @param name the name of post
     * @return the posts in the specified year and month.
     */
    public Post getPostByName(String siteName, String language, String tagName, String name)
    {
        PostTagCache cache = getPostTagCache(siteName, language);
        
        return cache.getPostByName(tagName, name);
    }
    
    /**
     * Get the posts for a year-month couple.
     * @param siteName The site name
     * @param language The language
     * @param tagName The tag name
     * @param id The id of post
     * @return the posts in the specified year and month.
     */
    public boolean hasPost(String siteName, String language, String tagName, String id)
    {
        PostTagCache cache = getPostTagCache(siteName, language);
        
        return cache.hasPost(tagName, id);
    }
    
    /**
     * Get the posts for a year-month couple.
     * @param siteName The site name
     * @param language The language
     * @param tagName The tag name
     * @param name the name of post
     * @return the posts in the specified year and month.
     */
    public boolean hasPostByName(String siteName, String language, String tagName, String name)
    {
        PostTagCache cache = getPostTagCache(siteName, language);
        
        return cache.hasPostByName(tagName, name);
    }
    
    /////////////////////////////////////////////////
    ///              ALL POSTS METHODS            ///
    /////////////////////////////////////////////////
    
    /**
     * Get a list of all the posts' IDs.
     * @param siteName the site name.
     * @param language the language.
     * @return all the posts' IDs as a Set.
     */
    public Set<String> getPostIds(String siteName, String language)
    {
        AllPostCache cache = getAllPostCache(siteName, language);
        
        return cache.getPostIds();
    }
    
    /**
     * Get the exhaustive list of Posts.
     * @param siteName the site name.
     * @param language the language.
     * @return the exhaustive list of Posts, indexed by their ID.
     */
    public Map<String, Post> getPosts(String siteName, String language)
    {
        AllPostCache cache = getAllPostCache(siteName, language);
        
        return cache.getPosts();
    }
    
    /**
     * Get the exhaustive list of Posts.
     * @param siteName the site name.
     * @param language the language.
     * @return the exhaustive list of Posts, indexed by their ID.
     */
    public Collection<Post> getSortedPosts(String siteName, String language)
    {
        AllPostCache cache = getAllPostCache(siteName, language);
        
        List<Post> sortedPosts = new ArrayList<>(cache.getPosts().values());
        
        Collections.sort(sortedPosts, new ReverseDatePostComparator());
        
        return sortedPosts;
    }
    
    /**
     * Test if a post exists, provided its ID.
     * @param id the post content ID.
     * @param siteName the site name.
     * @param language the language.
     * @return the Post.
     */
    public Post getPost(String siteName, String language, String id)
    {
        AllPostCache cache = getAllPostCache(siteName, language);
        
        return cache.getPost(id);
    }
    
    /**
     * Test if a post exists, provided its content name.
     * @param name the post content name.
     * @param siteName the site name.
     * @param language the language.
     * @return true if the post exists.
     */
    public Post getPostByName(String siteName, String language, String name)
    {
        AllPostCache cache = getAllPostCache(siteName, language);
        
        return cache.getPostByName(name);
    }
    
    
    /**
     * Test if a post exists, provided its ID.
     * @param id the post content ID.
     * @param siteName the site name.
     * @param language the language.
     * @return true if the post exists.
     */
    public boolean hasPost(String siteName, String language, String id)
    {
        AllPostCache cache = getAllPostCache(siteName, language);
        
        return cache.hasPost(id);
    }
    
    /**
     * Test if a post exists, provided its content name.
     * @param name the post content name.
     * @param siteName the site name.
     * @param language the language.
     * @return true if the post exists.
     */
    public boolean hasPostByName(String siteName, String language, String name)
    {
        AllPostCache cache = getAllPostCache(siteName, language);
        
        return cache.hasPostByName(name);
    }
    
    /**
     * Add a post content to the cache.
     * @param siteName The site name
     * @param language The language
     * @param postContent The content
     */
    public void addPost(String siteName, String language, Content postContent)
    {
        PostDateCache dateCache = getPostDateCache(siteName, language);
        PostTagCache tagCache = getPostTagCache(siteName, language);
        AllPostCache allCache = getAllPostCache(siteName, language);
        FuturePostCache futureCache = getFuturePostCache(siteName, language);
        
        boolean displayFuturePosts = _getDisplayFuturePost(siteName);

        boolean isFuturePost = _isFuturePost(postContent);
        if (displayFuturePosts || !isFuturePost)
        {
            dispatchPost(dateCache, postContent);
            dispatchPost(tagCache, postContent);
            dispatchPost(allCache, postContent);
        }
        else // => !displayFuturePosts && isFuturePost
        {
            dispatchPost(futureCache, postContent);
        }
    }
    
    /**
     * Modify a post content in the cache.
     * @param siteName The site name
     * @param language The language
     * @param postContent The content
     */
    public void modifyPost(String siteName, String language, Content postContent)
    {
        PostDateCache dateCache = getPostDateCache(siteName, language);
        PostTagCache tagCache = getPostTagCache(siteName, language);
        AllPostCache allCache = getAllPostCache(siteName, language);
        FuturePostCache futureCache = getFuturePostCache(siteName, language);
        
        Post post = allCache.getPost(postContent.getId());
        Post futurePost = futureCache.getPost(postContent.getId());
        
        boolean displayFuturePosts = _getDisplayFuturePost(siteName);
        boolean isFuturePost = _isFuturePost(postContent);
        
        if (displayFuturePosts || !isFuturePost)
        {
            if (futurePost != null)
            {
                removePost(futureCache, futurePost);
            }
            
            if (post == null)
            {
                dispatchPost(dateCache, postContent);
                dispatchPost(tagCache, postContent);
                dispatchPost(allCache, postContent);
            }
            else
            {
                modifyPost(dateCache, post, postContent);
                modifyPost(tagCache, post, postContent);
                modifyPost(allCache, post, postContent);
            }
        }
        else // => !displayFuturePosts && isFuturePost
        {
            if (futurePost == null)
            {
                dispatchPost(futureCache, postContent);
            }
            else
            {
                modifyPost(futureCache, futurePost, postContent);
            }
            
            if (post != null)
            {
                removePost(dateCache, post);
                removePost(tagCache, post);
                removePost(allCache, post);
            }
        }
    }
    
    /**
     * Validate a post content.
     * @param siteName The site name
     * @param language The language
     * @param postContent The content
     */
    public void validatePost(String siteName, String language, Content postContent)
    {
        boolean displayFuturePosts = _getDisplayFuturePost(siteName);

        // Get the "live" caches.
        PostDateCache dateCache = _getPostByDateCache().get(BlogPageElementKey.of(WebConstants.LIVE_WORKSPACE, siteName, language), k-> new PostDateCache());
        PostTagCache tagCache = _getPostByTagCache().get(BlogPageElementKey.of(WebConstants.LIVE_WORKSPACE, siteName, language), k-> new PostTagCache());
        AllPostCache allCache = _getAllPosts().get(BlogPageElementKey.of(WebConstants.LIVE_WORKSPACE, siteName, language), k-> new AllPostCache());
        FuturePostCache futureCache = _getFuturePosts().get(BlogPageElementKey.of(WebConstants.LIVE_WORKSPACE, siteName, language), k-> new FuturePostCache());
        
        if (displayFuturePosts || !_isFuturePost(postContent))
        {
            // Dispatch the post in the live caches.
            removePost(futureCache, postContent);
            
            dispatchPost(dateCache, postContent);
            dispatchPost(tagCache, postContent);
            dispatchPost(allCache, postContent);
        }
        else // => !displayFuturePosts && isFuturePost
        {
            dispatchPost(futureCache, postContent);
            
            removePost(dateCache, postContent);
            removePost(tagCache, postContent);
            removePost(allCache, postContent);
        }
    }
    
    /**
     * Remove a post content from the cache.
     * @param siteName The site name
     * @param language The language
     * @param postContent The content
     */
    public void removePost(String siteName, String language, Content postContent)
    {
        PostDateCache dateCache = getPostDateCache(siteName, language);
        PostTagCache tagCache = getPostTagCache(siteName, language);
        AllPostCache allCache = getAllPostCache(siteName, language);
        FuturePostCache futureCache = getFuturePostCache(siteName, language);
        
        removePost(dateCache, postContent);
        removePost(tagCache, postContent);
        removePost(allCache, postContent);
        removePost(futureCache, postContent);
    }
    
    /**
     * Remove a post content from the cache.
     * @param siteName the site name.
     * @param postId the post ID.
     */
    public void removePostById(String siteName, String postId)
    {
        PostSiteLang postWithSiteLang = getPost(siteName, postId);
        PostSiteLang futurePostWithSiteLang = getFuturePost(siteName, postId);
        
        if (postWithSiteLang != null)
        {
            Post post = postWithSiteLang.getPost();
            String language = postWithSiteLang.getLanguage();
            
            // Get cache from current workspace
            PostDateCache dateCache = getPostDateCache(siteName, language);
            PostTagCache tagCache = getPostTagCache(siteName, language);
            AllPostCache allCache = getAllPostCache(siteName, language);
            
            // Get cache from live workspace
            PostDateCache workspaceDateCache = _getPostByDateCache().get(BlogPageElementKey.of(WebConstants.LIVE_WORKSPACE, siteName, language), k-> new PostDateCache());
            PostTagCache workspaceTagCache = _getPostByTagCache().get(BlogPageElementKey.of(WebConstants.LIVE_WORKSPACE, siteName, language), k-> new PostTagCache());
            AllPostCache workspaceAllCache = _getAllPosts().get(BlogPageElementKey.of(WebConstants.LIVE_WORKSPACE, siteName, language), k-> new AllPostCache());
            
            // Update the cache
            removePost(dateCache, post);
            removePost(tagCache, post);
            removePost(allCache, post);
            
            removePost(workspaceDateCache, post);
            removePost(workspaceTagCache, post);
            removePost(workspaceAllCache, post);
        }
        
        if (futurePostWithSiteLang != null)
        {
            Post post = futurePostWithSiteLang.getPost();
            String language = futurePostWithSiteLang.getLanguage();
            
            // Get cache from current workspace
            FuturePostCache futureCache = getFuturePostCache(siteName, language);
            
            // Get cache from live workspace
            FuturePostCache workspaceFutureCache = _getFuturePosts().get(BlogPageElementKey.of(WebConstants.LIVE_WORKSPACE, siteName, language), k-> new FuturePostCache());
            
            // Update the cache
            removePost(futureCache, post);
            removePost(workspaceFutureCache, post);
        }
    }
    
    /**
     * Clear the caches.
     */
    public void clearCaches()
    {
        _getPostByDateCache().invalidateAll();
        _getPostByTagCache().invalidateAll();
        _getAllPosts().invalidateAll();
        _getFuturePosts().invalidateAll();
    }
    
    /**
     * Clear the caches for a given siteName and language.
     * @param siteName The site name
     * @param language The language
     */
    public void clearCaches(String siteName, String language)
    {
        for (BlogPageElementKey key : _getPostByDateCache().asMap().keySet())
        {
            PostDateCache cache = _getPostByDateCache().get(BlogPageElementKey.of((String) key.getFields().get(0), siteName, language));
            cache.clear();
        }

        for (BlogPageElementKey key : _getPostByTagCache().asMap().keySet())
        {
            PostTagCache cache = _getPostByTagCache().get(BlogPageElementKey.of((String) key.getFields().get(0), siteName, language));
            cache.clear();
        }
        
        for (BlogPageElementKey key : _getAllPosts().asMap().keySet())
        {
            AllPostCache cache = _getAllPosts().get(BlogPageElementKey.of((String) key.getFields().get(0), siteName, language));
            cache.clear();
        }
        
        for (BlogPageElementKey key : _getFuturePosts().asMap().keySet())
        {
            FuturePostCache cache = _getFuturePosts().get(BlogPageElementKey.of((String) key.getFields().get(0), siteName, language));
            cache.clear();
        }
    }
    
    /**
     * Get the post date cache.
     * @param siteName The site name
     * @param language The language
     * @return the post date cache for the given site and language.
     */
    protected PostDateCache getPostDateCache(String siteName, String language)
    {
        // Get the workspace name.
        String workspaceName = _workspaceSelector.getWorkspace();
        
        // Ensure the cache is created and initialized for the site and language.
        if (!_getPostByDateCache().hasKey(BlogPageElementKey.of(workspaceName, siteName, language)))
        {
            initializeCaches(workspaceName, siteName, language);
        }
        
        // Update the future posts cache.
        _updateFuturePosts(workspaceName, siteName, language);
        return _getPostByDateCache().get(BlogPageElementKey.of(workspaceName, siteName, language));
    }
    
    /**
     * Get the post tag cache.
     * @param siteName The site name
     * @param language The language
     * @return the post tag cache for the given site and language.
     */
    protected PostTagCache getPostTagCache(String siteName, String language)
    {
        // Get the workspace name.
        String workspaceName = _workspaceSelector.getWorkspace();
        
        // Ensure the cache is created and initialized for the site and language.
        if (!_getPostByTagCache().hasKey(BlogPageElementKey.of(workspaceName, siteName, language)))
        {
            initializeCaches(workspaceName, siteName, language);
        }
        
        // Update the future posts cache.
        _updateFuturePosts(workspaceName, siteName, language);
        
        return _getPostByTagCache().get(BlogPageElementKey.of(workspaceName, siteName, language));
    }
    
    /**
     * Get the exhaustive post cache.
     * @param siteName The site name
     * @param language The language
     * @return the post date cache for the given site and language.
     */
    protected AllPostCache getAllPostCache(String siteName, String language)
    {
        // Get the workspace name.
        String workspaceName = _workspaceSelector.getWorkspace();
        
        // Ensure the cache is created and initialized for the site and language.
        if (!_getAllPosts().hasKey(BlogPageElementKey.of(workspaceName, siteName, language)))
        {
            initializeCaches(workspaceName, siteName, language);
        }
        
        // Update the future posts cache.
        _updateFuturePosts(workspaceName, siteName, language);
        return _getAllPosts().get(BlogPageElementKey.of(workspaceName, siteName, language));
    }
        
    
    /**
     * Get the future post cache.
     * @param siteName the name of the site
     * @param language the language
     * @return the post date cache for the given site and language.
     */
    protected FuturePostCache getFuturePostCache(String siteName, String language)
    {
        // Get the workspace name.
        String workspaceName = _workspaceSelector.getWorkspace();
        
        // Ensure the cache is created and initialized for the site and language.
        if (!_getFuturePosts().hasKey(BlogPageElementKey.of(workspaceName, siteName, language)))
        {
            initializeCaches(workspaceName, siteName, language);
        }
        
        return _getFuturePosts().get(BlogPageElementKey.of(workspaceName, siteName, language));
    }
               
    /**
     * Initialize all the caches.
     * @param workspaceName The workspace name
     * @param siteName The site name
     * @param language The language
     */
    protected void initializeCaches(String workspaceName, String siteName, String language)
    {
        PostDateCache dateCache = _getPostByDateCache().get(BlogPageElementKey.of(workspaceName, siteName, language), k-> new PostDateCache());
        PostTagCache tagCache = _getPostByTagCache().get(BlogPageElementKey.of(workspaceName, siteName, language), k-> new PostTagCache());
        AllPostCache allCache = _getAllPosts().get(BlogPageElementKey.of(workspaceName, siteName, language), k-> new AllPostCache());
        FuturePostCache futureCache = _getFuturePosts().get(BlogPageElementKey.of(workspaceName, siteName, language), k-> new FuturePostCache());
        
        ContentTypeExpression cTypeExpr = new ContentTypeExpression(Operator.EQ, PostContentType.CONTENT_TYPE);
        Expression siteExpr = new StringExpression(SiteAwareAmetysObject.METADATA_SITE, Operator.EQ, siteName);
        Expression languageExpr = new LanguageExpression(Operator.EQ, language);
        MetadataExpression dateExpr = new MetadataExpression(POST_DATE_ATTRIBUTE);
        
        Expression expression = new AndExpression(cTypeExpr, siteExpr, languageExpr, dateExpr);
        
        boolean displayFuturePosts = _getDisplayFuturePost(siteName);
        
        SortCriteria sort = new SortCriteria();
        sort.addCriterion(POST_DATE_ATTRIBUTE, false, false);
        sort.addJCRPropertyCriterion("ametys:lastModified", false, false);
        
        String query = QueryHelper.getXPathQuery(null, "ametys:content", expression, sort);
        
        try (AmetysObjectIterable<Content> posts = _ametysResolver.query(query);)
        {
            for (Content postContent : posts)
            {
                if (displayFuturePosts || !_isFuturePost(postContent))
                {
                    dispatchPost(dateCache, postContent);
                    dispatchPost(tagCache, postContent);
                    dispatchPost(allCache, postContent);
                }
                else
                {
                    dispatchPost(futureCache, postContent);
                }
            }
        }
    }
    
    private boolean _getDisplayFuturePost(String siteName)
    {
        boolean displayFuturePosts = true;
        if (siteName != null)
        {
            Site site = _siteManager.getSite(siteName);
            displayFuturePosts = site.getValue("display-future-posts", false, false);
        }
        return displayFuturePosts;
    }
    
    private void _updateFuturePosts(String workspaceName, String siteName, String language)
    {
        Date now = new Date();
        
        Calendar calendar = Calendar.getInstance();
        calendar.setTime(now);

        int minutes = calendar.get(Calendar.MINUTE);
        
        int mod = minutes % 15;
        calendar.add(Calendar.MINUTE, -mod);
        calendar.set(Calendar.SECOND, 0);   
        calendar.set(Calendar.MILLISECOND, 0);
        
        Date roundedNow = calendar.getTime();
        
        if (_needUpdateFuturePosts(workspaceName, siteName, language, roundedNow))
        {
            // Update the last update time
            _getLastUpdateFuturePosts().put(BlogPageElementKey.of(workspaceName, siteName, language), roundedNow);
            
            // Remove past "future posts"
            FuturePostCache futureCache = _getFuturePosts().get(BlogPageElementKey.of(workspaceName, siteName, language), k-> new FuturePostCache());
            Collection<Post> pastPosts = futureCache.removePastPosts();
            
            // Notify that the posts are pasts, and must be visible now.
            for (Post pastPost : pastPosts)
            {
                if (_resolver.hasAmetysObjectForId(pastPost.getId()))
                {
                    Content content = _resolver.resolveById(pastPost.getId());
                    
                    Map<String, Object> eventParams = new HashMap<>();
                    eventParams.put(ObservationConstants.ARGS_CONTENT, content);
                    _observationManager.notify(new Event(BlogObservationConstants.EVENT_FUTURE_CONTENT_VISIBLE, new UserIdentity("admin", "admin"), eventParams));
                }
            }
        }
    }
    
    private boolean _needUpdateFuturePosts(String workspaceName, String siteName, String language, Date roundedNow)
    {
        Date lastUpdate = _getLastUpdateFuturePosts().get(BlogPageElementKey.of(workspaceName, siteName, language));
        
        if (lastUpdate != null)
        {
            long duration  = roundedNow.getTime() - lastUpdate.getTime();
            long diffInMinutes = TimeUnit.MILLISECONDS.toMinutes(duration);
            
            return diffInMinutes >= 15;
        }
        
        return true;
    }
    
    private boolean _isFuturePost (Content post)
    {
        ZonedDateTime postDate = post.getValue(POST_DATE_ATTRIBUTE);
        return postDate != null && postDate.isAfter(ZonedDateTime.now());
    }
    
    /**
     * Get a post by its site name and id.
     * @param siteName the site name.
     * @param postId the post ID.
     * @return the Post if it exists in the cache, or null if it doesn't.
     */
    protected PostSiteLang getPost(String siteName, String postId)
    {
        String workspaceName = _workspaceSelector.getWorkspace();

        for (Entry<BlogPageElementKey, AllPostCache> langPosts : _getAllPosts().getAll(BlogPageElementKey.of(workspaceName, siteName)).entrySet())
        {
            BlogPageElementKey blogPageElementKey = langPosts.getKey();
            List<Object> fields = blogPageElementKey.getFields();
            if (langPosts.getValue().hasPost(postId))
            {
                String language = (String) fields.get(2);
                Post post = langPosts.getValue().getPost(postId);
                
                return new PostSiteLang(post, siteName, language);
            }
        }
        
        return null;
    }
    
    /**
     * Get a future post by its site name and id.
     * @param siteName the site name.
     * @param postId the post ID.
     * @return the Post if it exists in the cache, or null if it doesn't.
     */
    protected PostSiteLang getFuturePost(String siteName, String postId)
    {

        String workspaceName = _workspaceSelector.getWorkspace();

        
        for (Entry<BlogPageElementKey, FuturePostCache> langPosts : _getFuturePosts().getAll(BlogPageElementKey.of(workspaceName, siteName)).entrySet())
        {
            BlogPageElementKey blogPageElementKey = langPosts.getKey();
            List<Object> fields = blogPageElementKey.getFields();
            if (langPosts.getValue().hasPost(postId))
            {
                String language = (String) fields.get(2);
                Post post = langPosts.getValue().getPost(postId);
                
                return new PostSiteLang(post, siteName, language);
            }
            
        }
        
        return null;
    }
    
    /**
     * Dispatch a post content in the post date cache.
     * @param dateCache the post date cache.
     * @param content the Post content.
     */
    protected void dispatchPost(PostDateCache dateCache, Content content)
    {
        ZonedDateTime postDate = content.getValue(POST_DATE_ATTRIBUTE);
        
        // Dispatch by date.
        if (postDate != null)
        {
            int month = postDate.getMonthValue();
            int year = postDate.getYear();
            
            dateCache.addPost(content, year, month);
        }
    }
    
    /**
     * Add a post in the post date cache.
     * @param dateCache the post date cache.
     * @param post the Post to add.
     */
    protected void dispatchPost(PostDateCache dateCache, Post post)
    {
        ZonedDateTime postDate = post.getDate();
        
        // Dispatch by date.
        if (postDate != null)
        {
            int month = postDate.getMonthValue();
            int year = postDate.getYear();
            
            dateCache.addPost(post, year, month);
        }
    }
    
    /**
     * Dispatch a post content in the post tag cache.
     * @param tagCache the post tag cache.
     * @param content the Post content.
     */
    protected void dispatchPost(PostTagCache tagCache, Content content)
    {
        String[] postTags = content.getValue(POST_TAGS_ATTRIBUTE, false, new String[0]);
        
        for (String tagName : postTags)
        {
            tagCache.addPost(content, tagName);
        }
    }
    
    /**
     * Dispatch a post in the post tag cache.
     * @param tagCache the post tag cache.
     * @param post the Post to add.
     */
    protected void dispatchPost(PostTagCache tagCache, Post post)
    {
        String[] postTags = post.getTags();
        
        for (String tagName : postTags)
        {
            tagCache.addPost(post, tagName);
        }
    }
    
    /**
     * Dispatch a post content in the post cache.
     * @param cache the post cache.
     * @param content the Post content.
     */
    protected void dispatchPost(AllPostCache cache, Content content)
    {
        cache.addPost(content);
    }
    
    /**
     * Dispatch a post in the post cache.
     * @param cache the post cache.
     * @param post the Post content.
     */
    protected void dispatchPost(AllPostCache cache, Post post)
    {
        cache.addPost(post);
    }
    
    /**
     * Dispatch a post content in the future post cache.
     * @param cache the future post cache.
     * @param content the Post content.
     */
    protected void dispatchPost(FuturePostCache cache, Content content)
    {
        cache.addPost(content);
    }
    
    /**
     * Remove a post content.
     * @param dateCache the post date cache.
     * @param content the Post content.
     */
    protected void removePost(PostDateCache dateCache, Content content)
    {
        ZonedDateTime postDate = content.getValue(POST_DATE_ATTRIBUTE);
        
        // Dispatch by date.
        if (postDate != null)
        {
            int month = postDate.getMonthValue();
            int year = postDate.getYear();
            
            dateCache.removePost(content.getId(), year, month);
        }
    }
    
    /**
     * Remove a post content.
     * @param dateCache the post date cache.
     * @param post the Post object to remove.
     */
    protected void removePost(PostDateCache dateCache, Post post)
    {
        ZonedDateTime postDate = post.getDate();
        
        // Dispatch by date.
        if (postDate != null)
        {
            int month = postDate.getMonthValue();
            int year = postDate.getYear();
            
            dateCache.removePost(post.getId(), year, month);
        }
    }
    
    /**
     * Remove a post content.
     * @param cache the post tag cache.
     * @param content the Post content.
     */
    protected void removePost(PostTagCache cache, Content content)
    {
        String[] postTags = content.getValue(POST_TAGS_ATTRIBUTE, false, new String[0]);
        
        for (String tagName : postTags)
        {
            cache.removePost(content.getId(), tagName);
        }
    }
    
    /**
     * Remove a post content.
     * @param cache the post tag cache.
     * @param post the Post to remove.
     */
    protected void removePost(PostTagCache cache, Post post)
    {
        String[] postTags = post.getTags();
        
        for (String tagName : postTags)
        {
            cache.removePost(post.getId(), tagName);
        }
    }
    
    /**
     * Remove a post content.
     * @param cache the post cache.
     * @param content the Post content.
     */
    protected void removePost(AllPostCache cache, Content content)
    {
        cache.removePost(content);
    }
    
    /**
     * Remove a post content.
     * @param cache the post cache.
     * @param post the Post to remove.
     */
    protected void removePost(AllPostCache cache, Post post)
    {
        cache.removePost(post.getId(), post.getName());
    }
    
    /**
     * Remove a future post content.
     * @param cache the future post cache.
     * @param content the Post content to remove.
     */
    protected void removePost(FuturePostCache cache, Content content)
    {
        cache.removePost(content);
    }
    
    /**
     * Remove a future post content.
     * @param cache the future post cache.
     * @param post the Post to remove.
     */
    protected void removePost(FuturePostCache cache, Post post)
    {
        cache.removePost(post);
    }
    
    /**
     * Remove a post content.
     * @param dateCache the post date cache.
     * @param post the post content
     * @param postContent the post Content.
     */
    protected void modifyPost(PostDateCache dateCache, Post post, Content postContent)
    {
        ZonedDateTime oldDate = post.getDate();
        ZonedDateTime newDate = postContent.getValue(POST_DATE_ATTRIBUTE);
        
        if (!newDate.equals(oldDate))
        {
            if (oldDate != null)
            {
                int month = oldDate.getMonthValue();
                int year = oldDate.getYear();
                dateCache.removePost(postContent.getId(), year, month);
            }

            int month = newDate.getMonthValue();
            int year = newDate.getYear();
            dateCache.addPost(postContent, year, month);
        }
    }
    
    /**
     * Remove a post content.
     * @param cache the post tag cache.
     * @param post the post content
     * @param postContent the post Content.
     */
    protected void modifyPost(PostTagCache cache, Post post, Content postContent)
    {
        String[] oldPostTags = post.getTags();
        String[] newPostTags = postContent.getValue(POST_TAGS_ATTRIBUTE, false, new String[0]);
        
        for (String oldTagName : oldPostTags)
        {
            cache.removePost(postContent.getId(), oldTagName);
        }
        
        for (String newTagName : newPostTags)
        {
            cache.addPost(postContent, newTagName);
        }
    }
    
    /**
     * Modify a post content.
     * @param cache the post cache.
     * @param post the post content
     * @param postContent the post Content.
     */
    protected void modifyPost(AllPostCache cache, Post post, Content postContent)
    {
        cache.removePost(postContent);
        cache.addPost(postContent);
    }
    
    /**
     * Modify a future post content.
     * @param cache the post cache.
     * @param post the post
     * @param postContent the post Content.
     */
    protected void modifyPost(FuturePostCache cache, Post post, Content postContent)
    {
        cache.removePost(postContent);
        cache.addPost(postContent);
    }
    
    /**
     * Class representing a Post in the cache.
     */
    public static class Post
    {
        
        /** The post content id. */
        protected String _id;
        
        /** The post content name. */
        protected String _name;
        
        /** The post date. */
        protected ZonedDateTime _date;
        
        /** The post tags. */
        protected String[] _tags;
        
        /**
         * Get the id.
         * @return the id
         */
        public String getId()
        {
            return _id;
        }

        /**
         * Set the id.
         * @param id the id to set
         */
        public void setId(String id)
        {
            this._id = id;
        }

        /**
         * Get the name.
         * @return the name
         */
        public String getName()
        {
            return _name;
        }

        /**
         * Set the name.
         * @param name the name to set
         */
        public void setName(String name)
        {
            this._name = name;
        }

        /**
         * Get the tags.
         * @return the tags
         */
        public String[] getTags()
        {
            return _tags;
        }
        
        /**
         * Set the tags.
         * @param tags the tags to set
         */
        public void setTags(String[] tags)
        {
            this._tags = new String[tags.length];
            System.arraycopy(tags, 0, _tags, 0, tags.length);
        }
        
        /**
         * Get the date.
         * @return the date
         */
        public ZonedDateTime getDate()
        {
            return _date;
        }
        
        /**
         * Set the date.
         * @param date the date to set
         */
        public void setDate(ZonedDateTime date)
        {
            this._date = date;
        }
        
        @Override
        public int hashCode()
        {
            return _id.hashCode();
        }
        
        @Override
        public boolean equals(Object obj)
        {
            if (this == obj)
            {
                return true;
            }
            if (obj == null)
            {
                return false;
            }
            if (getClass() != obj.getClass())
            {
                return false;
            }
            Post other = (Post) obj;
            if (_id == null)
            {
                if (other._id != null)
                {
                    return false;
                }
            }
            else if (!_id.equals(other._id))
            {
                return false;
            }
            return true;
        }
        
    }
    
    /**
     * A Post with site name and language.
     */
    protected static class PostSiteLang extends Post
    {
        
        /** The post. */
        protected Post _post;
        
        /** The post site name. */
        protected String _siteName;
        
        /** The post language. */
        protected String _language;
        
        /**
         * Default constructor.
         */
        public PostSiteLang()
        {
            // Nothing to do.
        }
        
        /**
         * Constructor with all parameters.
         * @param post the Post.
         * @param siteName the site name.
         * @param language the language.
         */
        public PostSiteLang(Post post, String siteName, String language)
        {
            super();
            this._post = post;
            this._siteName = siteName;
            this._language = language;
        }

        /**
         * Get the post.
         * @return the post
         */
        public Post getPost()
        {
            return _post;
        }

        /**
         * Set the post.
         * @param post the post to set
         */
        public void setPost(Post post)
        {
            this._post = post;
        }

        /**
         * Get the siteName.
         * @return the siteName
         */
        public String getSiteName()
        {
            return _siteName;
        }

        /**
         * Set the siteName.
         * @param siteName the siteName to set
         */
        public void setSiteName(String siteName)
        {
            this._siteName = siteName;
        }

        /**
         * Get the language.
         * @return the language
         */
        public String getLanguage()
        {
            return _language;
        }

        /**
         * Set the language.
         * @param language the language to set
         */
        public void setLanguage(String language)
        {
            this._language = language;
        }
        
    }
    
    /**
     * Post cache by date.
     */
    protected static class PostDateCache
    {
        /** The posts, indexed by year, month and ID. */
        private Map<Integer, Map<Integer, Map<String, Post>>> _posts;
        
        /**
         * Construct a PostDateCache instance.
         */
        public PostDateCache()
        {
            _posts = new HashMap<>();
        }
        
        /**
         * Determines if the year page exists
         * @param year the year
         * @return true if there are posts for this year
         */
        public boolean hasYear(int year)
        {
            return _posts.containsKey(year);
        }
        
        /**
         * Get the years with posts.
         * @return the years with posts as a Set of Integer.
         */
        public Set<Integer> getYears()
        {
            return _posts.keySet();
        }
        
        /**
         * Determines if the page month exists in given year
         * @param year The year
         * @param month  The month
         * @return true if there are posts for this year/month couple
         */
        public boolean hasMonth(int year, int month)
        {
            boolean hasMonth = false;
            
            if (_posts.containsKey(year))
            {
                hasMonth = _posts.get(year).containsKey(month);
            }
            
            return hasMonth;
        }
        
        /**
         * Get the months with posts for a specified year.
         * @param year the year.
         * @return the months with posts in the specified year as a Set of Integer.
         */
        public Set<Integer> getMonths(int year)
        {
            Set<Integer> months = new HashSet<>();
            
            if (_posts.containsKey(year))
            {
                months = _posts.get(year).keySet();
            }
            
            return months;
        }
        
        /**
         * Get the posts for a year couple.
         * @param year the year.
         * @return the posts in the specified year.
         */
        public Map<String, Post> getPosts(int year)
        {
            Map<String, Post> posts = new HashMap<>();
            
            if (_posts.containsKey(year))
            {
                Map<Integer, Map<String, Post>> months = _posts.get(year);
                
                for (Map<String, Post> month : months.values())
                {
                    posts.putAll(month);
                }
            }
            
            return posts;
        }
        
        /**
         * Get the posts for a year-month couple.
         * @param year the year.
         * @param month the month.
         * @return the posts in the specified year and month.
         */
        public Map<String, Post> getPosts(int year, int month)
        {
            Map<String, Post> posts = new HashMap<>();
            
            if (_posts.containsKey(year))
            {
                Map<Integer, Map<String, Post>> months = _posts.get(year);
                
                if (months.containsKey(month))
                {
                    posts = months.get(month);
                }
            }
            
            return posts;
        }
        
        /**
         * Add a post to the cache.
         * @param content The content
         * @param year the year
         * @param month the month
         */
        public void addPost(Content content, int year, int month)
        {
            Map<String, Post> posts = getOrCreatePostMap(year, month);
            
            Post post = new Post();
            post.setId(content.getId());
            post.setName(content.getName());
            post.setDate(content.getValue(POST_DATE_ATTRIBUTE));
            post.setTags(content.getValue(POST_TAGS_ATTRIBUTE, false, new String[0]));
            
            posts.put(post.getId(), post);
        }
        
        /**
         * Add a post to the cache.
         * @param post the post
         * @param year the year of the post
         * @param month the month of the post
         */
        public void addPost(Post post, int year, int month)
        {
            Map<String, Post> posts = getOrCreatePostMap(year, month);
            posts.put(post.getId(), post);
        }
        
        /**
         * Remove a post from the cache.
         * @param contentId The content id
         * @param year the year
         * @param month the month
         */
        public void removePost(String contentId, int year, int month)
        {
            if (_posts.containsKey(year))
            {
                Map<Integer, Map<String, Post>> months = _posts.get(year);
                
                if (months.containsKey(month))
                {
                    Map<String, Post> posts = months.get(month);
                    
                    posts.remove(contentId);
                    if (posts.isEmpty())
                    {
                        months.remove(month);
                    }
                }
                
                if (months.isEmpty())
                {
                    _posts.remove(year);
                }
            }
        }
        
        /**
         * Test if the post with the given ID exists for this year and month.
         * @param year the year.
         * @param month the month.
         * @param id the id of post
         * @return the posts in the specified year and month.
         */
        public boolean hasPost(int year, int month, String id)
        {
            return getPosts(year, month).containsKey(id);
        }
        
        /**
         * Get the posts for a year-month couple.
         * @param year the year.
         * @param month the month.
         * @param name the name of post
         * @return the posts in the specified year and month.
         */
        public Post getPostByName(int year, int month, String name)
        {
            Post post = null;
            
            Iterator<Post> posts = getPosts(year, month).values().iterator();
            while (posts.hasNext() && post == null)
            {
                Post currentPost = posts.next();
                if (currentPost.getName().equals(name))
                {
                    post = currentPost;
                }
            }
            
            return post;
        }
        
        /**
         * Get the posts for a year-month couple.
         * @param year the year.
         * @param month the month.
         * @param name the name of post
         * @return the posts in the specified year and month.
         */
        public boolean hasPostByName(int year, int month, String name)
        {
            boolean hasPost = false;
            
            Iterator<Post> posts = getPosts(year, month).values().iterator();
            while (posts.hasNext() && !hasPost)
            {
                hasPost = posts.next().getName().equals(name);
            }
            
            return hasPost;
        }
        
        /**
         * Clear the cache.
         */
        public void clear()
        {
            _posts.clear();
        }
        
        /**
         * Get or create the post set for the specified year and month.
         * @param year the year.
         * @param month the month.
         * @return the post set.
         */
        protected Map<String, Post> getOrCreatePostMap(int year, int month)
        {
            Map<String, Post> posts;
            
            Map<Integer, Map<String, Post>> months;
            
            if (_posts.containsKey(year))
            {
                months = _posts.get(year);
            }
            else
            {
                months = new HashMap<>();
                _posts.put(year, months);
            }
            
            if (months.containsKey(month))
            {
                posts = months.get(month);
            }
            else
            {
                posts = new LinkedHashMap<>();
                months.put(month, posts);
            }
            
            return posts;
        }
                                
    }
    
    /**
     * Post cache by tag.
     */
    protected static class PostTagCache
    {
        
        /** The posts, indexed by tag and ID. */
        private Map<String, Map<String, Post>> _posts;
        
        /**
         * Construct a PostTagCache instance.
         */
        public PostTagCache()
        {
            _posts = new HashMap<>();
        }
        
        /**
         * Get the years with posts.
         * @param tagId The id of tag
         * @return the years with posts as a Set of Integer.
         */
        public boolean hasTag(String tagId)
        {
            return _posts.containsKey(tagId);
        }
        
        /**
         * Get the years with posts.
         * @return the years with posts as a Set of Integer.
         */
        public Set<String> getTags()
        {
            return _posts.keySet();
        }
        
        /**
         * Get the posts for a year-month couple.
         * @param tagId the year.
         * @return the posts in the specified year and month.
         */
        public Map<String, Post> getPosts(String tagId)
        {
            Map<String, Post> posts = new HashMap<>();
            
            if (_posts.containsKey(tagId))
            {
                posts = _posts.get(tagId);
            }
            
            return posts;
        }
        
        /**
         * Add a post to the cache.
         * @param content The content
         * @param tagId the tag ID.
         */
        public void addPost(Content content, String tagId)
        {
            Map<String, Post> posts = getOrCreatePostMap(tagId);
            
            Post post = new Post();
            post.setId(content.getId());
            post.setName(content.getName());
            post.setDate(content.getValue(POST_DATE_ATTRIBUTE));
            post.setTags(content.getValue(POST_TAGS_ATTRIBUTE, false, new String[0]));
            
            posts.put(post.getId(), post);
        }
        
        /**
         * Add a post to the cache.
         * @param post the post
         * @param tagId the tag ID.
         */
        public void addPost(Post post, String tagId)
        {
            Map<String, Post> posts = getOrCreatePostMap(tagId);
            posts.put(post.getId(), post);
        }
        
        /**
         * Remove a post from the cache.
         * @param contentId The id of content
         * @param tagId  the id of tag
         */
        public void removePost(String contentId, String tagId)
        {
            if (_posts.containsKey(tagId))
            {
                Map<String, Post> posts = _posts.get(tagId);
                
                posts.remove(contentId);
                if (posts.isEmpty())
                {
                    _posts.remove(tagId);
                }
            }
        }
        
        /**
         * Test if the post with the given ID exists for this year and month.
         * @param tagId the tag id.
         * @param id the post ID.
         * @return the posts in the specified year and month.
         */
        public Post getPost(String tagId, String id)
        {
            return getPosts(tagId).get(id);
        }
        
        /**
         * Test if the post with the given ID exists for this year and month.
         * @param tagId the tag id.
         * @param id the post ID.
         * @return the posts in the specified year and month.
         */
        public boolean hasPost(String tagId, String id)
        {
            return getPosts(tagId).containsKey(id);
        }
        
        /**
         * Get the posts for a year-month couple.
         * @param tagId the year.
         * @param name The name of post
         * @return the posts in the specified year and month.
         */
        public Post getPostByName(String tagId, String name)
        {
            Post post = null;
            
            Iterator<Post> posts = getPosts(tagId).values().iterator();
            while (posts.hasNext() && post == null)
            {
                Post currentPost = posts.next();
                if (currentPost.getName().equals(name))
                {
                    post = currentPost;
                }
            }
            
            return post;
        }
        
        /**
         * Get the posts for a year-month couple.
         * @param tagId the year.
         * @param name the name of post
         * @return the posts in the specified year and month.
         */
        public boolean hasPostByName(String tagId, String name)
        {
            boolean hasPost = false;
            
            Iterator<Post> posts = getPosts(tagId).values().iterator();
            while (posts.hasNext() && !hasPost)
            {
                hasPost = posts.next().getName().equals(name);
            }
            
            return hasPost;
        }
        
        /**
         * Clear the cache.
         */
        public void clear()
        {
            _posts.clear();
        }
        
        /**
         * Get or create the post set for the specified year and month.
         * @param tagId the year.
         * @return the post set, indexed by id.
         */
        protected Map<String, Post> getOrCreatePostMap(String tagId)
        {
            Map<String, Post> posts;
            
            if (_posts.containsKey(tagId))
            {
                posts = _posts.get(tagId);
            }
            else
            {
                posts = new LinkedHashMap<>();
                _posts.put(tagId, posts);
            }
            
            return posts;
        }
        
    }
    
    /**
     * Cache of all the posts.
     */
    protected static class AllPostCache
    {
        
        /** The posts, indexed by ID. */
        private Map<String, Post> _posts;
        
        /** The posts, indexed by name. */
        private Map<String, Post> _postsByName;
        
        /**
         * Construct a AllPostCache instance.
         */
        public AllPostCache()
        {
            _posts = new LinkedHashMap<>();
            _postsByName = new LinkedHashMap<>();
        }
        
        /**
         * Get a list of all the posts' IDs.
         * @return all the posts' IDs as a Set.
         */
        public Set<String> getPostIds()
        {
            return Collections.unmodifiableSet(_posts.keySet());
        }
        
        /**
         * Get the exhaustive list of Posts.
         * @return the exhaustive list of Posts.
         */
        public Map<String, Post> getPosts()
        {
            return Collections.unmodifiableMap(_posts);
        }
        
        /**
         * Test if a post exists, provided its ID.
         * @param id the post content ID.
         * @return true if the post exists.
         */
        public Post getPost(String id)
        {
            return _posts.get(id);
        }
        
        /**
         * Test if a post exists, provided its ID.
         * @param id the post content ID.
         * @return true if the post exists.
         */
        public boolean hasPost(String id)
        {
            return _posts.containsKey(id);
        }
        
        /**
         * Test if a post exists, provided its content name.
         * @param name the post content name.
         * @return true if the post exists.
         */
        public Post getPostByName(String name)
        {
            return _postsByName.get(name);
        }
        
        /**
         * Test if a post exists, provided its content name.
         * @param name the post content name.
         * @return true if the post exists.
         */
        public boolean hasPostByName(String name)
        {
            return _postsByName.containsKey(name);
        }
        
        /**
         * Add a post to the cache.
         * @param content the post content.
         */
        public void addPost(Content content)
        {
            Post post = new Post();
            post.setId(content.getId());
            post.setName(content.getName());
            if (content.hasValue(POST_DATE_ATTRIBUTE))
            {
                post.setDate(content.getValue(POST_DATE_ATTRIBUTE));
            }
            post.setTags(content.getValue(POST_TAGS_ATTRIBUTE, false, new String[0]));
            
            _posts.put(post.getId(), post);
            _postsByName.put(post.getName(), post);
        }
        
        /**
         * Add a post to the cache.
         * @param post The post
         */
        public void addPost(Post post)
        {
            _posts.put(post.getId(), post);
            _postsByName.put(post.getName(), post);
        }
        
        /**
         * Remove a post from the cache.
         * @param content the post content to remove from the cache.
         */
        public void removePost(Content content)
        {
            removePost(content.getId(), content.getName());
        }
        
        /**
         * Remove a post from the cache.
         * @param id The id of post
         * @param name The name of post
         */
        public void removePost(String id, String name)
        {
            _posts.remove(id);
            _postsByName.remove(name);
        }
        
        /**
         * Clear the cache.
         */
        public void clear()
        {
            _posts.clear();
            _postsByName.clear();
        }
    }
    
    /**
     * Cache of identifier of the future posts.
     */
    protected static class FuturePostCache
    {
        /** The posts, indexed by ID. */
        private Map<String, Post> _posts;
        
        /** The posts id, indexed by date. */
        private Multimap<ZonedDateTime, String> _sortedPostIds;
        
        /**
         * Construct a AllPostCache instance.
         */
        public FuturePostCache()
        {
            _posts = new HashMap<>();
            _sortedPostIds = TreeMultimap.create();
        }
        
        /**
         * Remove the post that are not future anymore (given the current date) 
         * @return The collection of past posts
         */
        public Collection<Post> removePastPosts()
        {
            Set<Post> pastPosts = new HashSet<>();
            
            Set<ZonedDateTime> sortedDates = _sortedPostIds.keySet();
            Iterator<ZonedDateTime> iterator = sortedDates.iterator();
            boolean isFuture = false;
            ZonedDateTime now = ZonedDateTime.now();
            
            while (iterator.hasNext() && !isFuture)
            {
                ZonedDateTime date = iterator.next();
                isFuture = date.isAfter(now);
                
                if (!isFuture)
                {
                    Collection<String> pastPostIds = _sortedPostIds.get(date);
                    for (String id : pastPostIds)
                    {
                        Post pastPost = _posts.get(id);
                        if (pastPost != null)
                        {
                            pastPosts.add(pastPost);
                        }
                    }
                }
            }
            
            for (Post pastPost : pastPosts)
            {
                removePost(pastPost);
            }
            
            return pastPosts;
        }

        /**
         * Test if a post exists, provided its ID.
         * @param id the post content ID.
         * @return true if the post exists.
         */
        public Post getPost(String id)
        {
            return _posts.get(id);
        }
        
        /**
         * Test if a post exists, provided its ID.
         * @param id the post content ID.
         * @return true if the post exists.
         */
        public boolean hasPost(String id)
        {
            return _posts.containsKey(id);
        }
        
        /**
         * Add a post to the cache.
         * @param content the post content.
         */
        public void addPost(Content content)
        {
            String id = content.getId();
            
            if (_posts.containsKey(id))
            {
                removePost(content);
            }
            
            ZonedDateTime date = content.getValue(POST_DATE_ATTRIBUTE);
            
            Post post = new Post();
            post.setId(id);
            post.setName(content.getName());
            post.setDate(date);
            post.setTags(content.getValue(POST_TAGS_ATTRIBUTE, false, new String[0]));
            
            _posts.put(post.getId(), post);
            _sortedPostIds.put(date, id);
        }
        
        /**
         * Remove a post from the cache.
         * @param content the post content to remove from the cache.
         */
        public void removePost(Content content)
        {
            Post post = _posts.remove(content.getId());
            if (post != null)
            {
                _sortedPostIds.remove(post.getDate(), post.getId());
            }
        }
        
        /**
         * Remove a post from the cache.
         * @param post the post content to remove from the cache.
         */
        public void removePost(Post post)
        {
            _posts.remove(post.getId());
            _sortedPostIds.remove(post.getDate(), post.getId());
        }
        
        /**
         * Clear the cache.
         */
        public void clear()
        {
            _posts.clear();
            _sortedPostIds.clear();
        }
    }
    
    /**
     * Reverse date post comparator.
     */
    public class ReverseDatePostComparator implements Comparator<Post>
    {
        @Override
        public int compare(Post p1, Post p2)
        {
            if (p1.getDate() == null)
            {
                return 1;
            }
            if (p2.getDate() == null)
            {
                return -1;
            }
            return p2.getDate().compareTo(p1.getDate());
        }
    }

    static class BlogPageElementKey extends AbstractCacheKey
    {
        BlogPageElementKey(String workspace, String siteName, String sitemap)
        {
            super(workspace, siteName, sitemap);
        }

        static BlogPageElementKey of(String workspace, String site, String sitemap)
        {
            return new BlogPageElementKey(workspace, site, sitemap);
        } 
        
        static BlogPageElementKey of(String workspace, String site)
        {
            return new BlogPageElementKey(workspace, site, null);
        } 
        
        static BlogPageElementKey of(String workspace)
        {
            return of(workspace, null);
        }
    }

    private Cache<BlogPageElementKey, PostDateCache> _getPostByDateCache() 
    {
        return this._cacheManager.get(__POST_BY_DATE_CACHE);
    }  

    private Cache<BlogPageElementKey, PostTagCache> _getPostByTagCache() 
    {
        return this._cacheManager.get(__POST_BY_TAG_CACHE);
    }   

    private Cache<BlogPageElementKey, AllPostCache> _getAllPosts() 
    {
        return this._cacheManager.get(__ALL_POSTS_CACHE);
    } 

    private Cache<BlogPageElementKey, FuturePostCache> _getFuturePosts() 
    {
        return this._cacheManager.get(__FUTURE_POSTS_CACHE);
    }   
    
    private Cache<BlogPageElementKey, Date> _getLastUpdateFuturePosts() 
    {
        return this._cacheManager.get(__LAST_UPDATE_FUTURE_POST_CACHE);
    }   
}