/*
 *  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.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.apache.commons.lang.BooleanUtils;
import org.joda.time.DateTime;

import org.ametys.cms.ObservationConstants;
import org.ametys.cms.repository.Content;
import org.ametys.cms.repository.ContentLanguageExpression;
import org.ametys.cms.repository.ContentTypeExpression;
import org.ametys.cms.tag.Tag;
import org.ametys.cms.tag.TagHelper;
import org.ametys.cms.tag.TagProviderExtensionPoint;
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.repository.AmetysObjectIterable;
import org.ametys.plugins.repository.AmetysObjectResolver;
import org.ametys.plugins.repository.metadata.CompositeMetadata;
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.web.WebConstants;
import org.ametys.web.repository.content.jcr.DefaultWebContent;
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 metadata for date of post */
    public static final String POST_METADATA_DATE = "date";
    
    /** The avalon role. */
    public static final String ROLE = BlogCacheManager.class.getName();
    
    /** 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;
    
    /** Map of PostDateCache by workspace, site and sitemap/language. */
    protected Map<String, Map<String, Map<String, PostDateCache>>> _postsByDate;
    
    /** Map of PostTagCache by workspace, site and sitemap/language. */
    protected Map<String, Map<String, Map<String, PostTagCache>>> _postsByTag;
    
    /** Map of PostDateCache by workspace, site and sitemap/language. */
    protected Map<String, Map<String, Map<String, AllPostCache>>> _allPosts;
    
    /** Map of FuturePostCache by workspace, site and sitemap/language. */
    protected Map<String, Map<String, Map<String, FuturePostCache>>> _futurePostsCache;
    
    /** Caches are initialized by workspace, site and sitemap/language. */
    protected Map<String, Map<String, Map<String, Boolean>>> _initialized;
    
    /** Future caches are updated by workspace, site and sitemap/language. */
    protected Map<String, Map<String, Map<String, Date>>> _lastUpdateFuturePosts;
    
    @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);
    }
    
    @Override
    public void initialize() throws Exception
    {
        _postsByDate = new HashMap<>();
        _postsByTag = new HashMap<>();
        _allPosts = new HashMap<>();
        _futurePostsCache = new HashMap<>();
        _initialized = new HashMap<>();
        _lastUpdateFuturePosts = new HashMap<>();
    }
    
    /**
     * 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 = siteName != null ? BooleanUtils.isTrue(_siteConf.getValueAsBoolean(siteName, "display-future-posts")) : true;

        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 = siteName != null ? BooleanUtils.isTrue(_siteConf.getValueAsBoolean(siteName, "display-future-posts")) : true;
        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 = siteName != null ? BooleanUtils.isTrue(_siteConf.getValueAsBoolean(siteName, "display-future-posts")) : true;

        // Get the "live" caches.
        PostDateCache dateCache = getOrCreatePostDateCache(WebConstants.LIVE_WORKSPACE, siteName, language);
        PostTagCache tagCache = getOrCreatePostTagCache(WebConstants.LIVE_WORKSPACE, siteName, language);
        AllPostCache allCache = getOrCreateAllPostCache(WebConstants.LIVE_WORKSPACE, siteName, language);
        FuturePostCache futureCache = getOrCreateFuturePostCache(WebConstants.LIVE_WORKSPACE, siteName, language);
        
        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 = getOrCreatePostDateCache(WebConstants.LIVE_WORKSPACE, siteName, language);
            PostTagCache workspaceTagCache = getOrCreatePostTagCache(WebConstants.LIVE_WORKSPACE, siteName, language);
            AllPostCache workspaceAllCache = getOrCreateAllPostCache(WebConstants.LIVE_WORKSPACE, siteName, language);
            
            // 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 = getOrCreateFuturePostCache(WebConstants.LIVE_WORKSPACE, siteName, language);
            
            // Update the cache
            removePost(futureCache, post);
            removePost(workspaceFutureCache, post);
        }
    }
    
    /**
     * Clear the caches.
     */
    public void clearCaches()
    {
        _postsByDate.clear();
        _postsByTag.clear();
        _allPosts.clear();
        _futurePostsCache.clear();
        
        _initialized.clear();
    }
    
    /**
     * 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 (String workspaceName : _postsByDate.keySet())
        {
            PostDateCache dateCache = getOrCreatePostDateCache(workspaceName, siteName, language);
            dateCache.clear();
        }
        
        for (String workspaceName : _postsByTag.keySet())
        {
            PostTagCache tagCache = getOrCreatePostTagCache(workspaceName, siteName, language);
            tagCache.clear();
        }
        
        for (String workspaceName : _allPosts.keySet())
        {
            AllPostCache cache = getOrCreateAllPostCache(workspaceName, siteName, language);
            cache.clear();
        }
        
        for (String workspaceName : _futurePostsCache.keySet())
        {
            FuturePostCache cache = getOrCreateFuturePostCache(workspaceName, siteName, language);
            cache.clear();
        }
        
        for (String workspaceName : _initialized.keySet())
        {
            setInitialized(workspaceName, siteName, language, Boolean.FALSE);
        }
    }
    
    /**
     * 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 (!isInitialized(workspaceName, siteName, language))
        {
            initializeCaches(workspaceName, siteName, language);
        }
        
        // Update the future posts cache.
        _updateFuturePosts(workspaceName, siteName, language);
        
        return _postsByDate.get(workspaceName).get(siteName).get(language);
    }
    
    /**
     * Get the post date cache.
     * @param workspaceName The workspace
     * @param siteName The site name
     * @param language The language
     * @return the post date cache for the given site and language.
     */
    protected PostDateCache getOrCreatePostDateCache(String workspaceName, String siteName, String language)
    {
        Map<String, Map<String, PostDateCache>> workspaceCache;
        if (_postsByDate.containsKey(workspaceName))
        {
            workspaceCache = _postsByDate.get(workspaceName);
        }
        else
        {
            workspaceCache = new HashMap<>();
            _postsByDate.put(workspaceName, workspaceCache);
        }
        
        Map<String, PostDateCache> siteCache;
        if (workspaceCache.containsKey(siteName))
        {
            siteCache = workspaceCache.get(siteName);
        }
        else
        {
            siteCache = new HashMap<>();
            workspaceCache.put(siteName, siteCache);
        }
        
        PostDateCache cache;
        if (siteCache.containsKey(language))
        {
            cache = siteCache.get(language);
        }
        else
        {
            cache = new PostDateCache();
            siteCache.put(language, cache);
        }
        
        return cache;
    }
    
    /**
     * 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 (!isInitialized(workspaceName, siteName, language))
        {
            initializeCaches(workspaceName, siteName, language);
        }
        
        // Update the future posts cache.
        _updateFuturePosts(workspaceName, siteName, language);
        
        return _postsByTag.get(workspaceName).get(siteName).get(language);
    }
    
    /**
     * Get the post tag cache.
     * @param workspaceName The workspace
     * @param siteName The site name
     * @param language The language
     * @return the post tag cache for the given site and language.
     */
    protected PostTagCache getOrCreatePostTagCache(String workspaceName, String siteName, String language)
    {
        Map<String, Map<String, PostTagCache>> workspaceCache;
        if (_postsByTag.containsKey(workspaceName))
        {
            workspaceCache = _postsByTag.get(workspaceName);
        }
        else
        {
            workspaceCache = new HashMap<>();
            _postsByTag.put(workspaceName, workspaceCache);
        }
        
        Map<String, PostTagCache> siteCache;
        if (workspaceCache.containsKey(siteName))
        {
            siteCache = workspaceCache.get(siteName);
        }
        else
        {
            siteCache = new HashMap<>();
            workspaceCache.put(siteName, siteCache);
        }
        
        PostTagCache cache;
        if (siteCache.containsKey(language))
        {
            cache = siteCache.get(language);
        }
        else
        {
            cache = new PostTagCache();
            siteCache.put(language, cache);
        }
        
        return cache;
    }
    
    /**
     * 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 (!isInitialized(workspaceName, siteName, language))
        {
            initializeCaches(workspaceName, siteName, language);
        }
        
        // Update the future posts cache.
        _updateFuturePosts(workspaceName, siteName, language);
        
        return _allPosts.get(workspaceName).get(siteName).get(language);
    }
    
    /**
     * Get the exhaustive post cache.
     * @param workspaceName The workspace name
     * @param siteName The site name
     * @param language The language
     * @return the post date cache for the given site and language.
     */
    protected AllPostCache getOrCreateAllPostCache(String workspaceName, String siteName, String language)
    {
        Map<String, Map<String, AllPostCache>> workspaceCache;
        if (_allPosts.containsKey(workspaceName))
        {
            workspaceCache = _allPosts.get(workspaceName);
        }
        else
        {
            workspaceCache = new HashMap<>();
            _allPosts.put(workspaceName, workspaceCache);
        }
        
        Map<String, AllPostCache> siteCache;
        if (workspaceCache.containsKey(siteName))
        {
            siteCache = workspaceCache.get(siteName);
        }
        else
        {
            siteCache = new HashMap<>();
            workspaceCache.put(siteName, siteCache);
        }
        
        AllPostCache cache;
        if (siteCache.containsKey(language))
        {
            cache = siteCache.get(language);
        }
        else
        {
            cache = new AllPostCache();
            siteCache.put(language, cache);
        }
        
        return cache;
    }
    
    
    /**
     * 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 (!isInitialized(workspaceName, siteName, language))
        {
            initializeCaches(workspaceName, siteName, language);
        }
        
        return _futurePostsCache.get(workspaceName).get(siteName).get(language);
    }
    
    /**
     * Get the future post cache.
     * @param workspaceName the name of the workspace
     * @param siteName the name of the site
     * @param language the language
     * @return the future post cache for the given site and language.
     */
    protected FuturePostCache getOrCreateFuturePostCache(String workspaceName, String siteName, String language)
    {
        Map<String, Map<String, FuturePostCache>> workspaceCache;
        if (_futurePostsCache.containsKey(workspaceName))
        {
            workspaceCache = _futurePostsCache.get(workspaceName);
        }
        else
        {
            workspaceCache = new HashMap<>();
            _futurePostsCache.put(workspaceName, workspaceCache);
        }
        
        Map<String, FuturePostCache> siteCache;
        if (workspaceCache.containsKey(siteName))
        {
            siteCache = workspaceCache.get(siteName);
        }
        else
        {
            siteCache = new HashMap<>();
            workspaceCache.put(siteName, siteCache);
        }
        
        FuturePostCache cache;
        if (siteCache.containsKey(language))
        {
            cache = siteCache.get(language);
        }
        else
        {
            cache = new FuturePostCache();
            siteCache.put(language, cache);
        }
        
        return cache;
    }
    
    /**
     * Get the exhaustive post cache.
     * @param workspaceName The workspace name
     * @param siteName The site name
     * @param language The language
     * @return the post date cache for the given site and language.
     */
    protected boolean isInitialized(String workspaceName, String siteName, String language)
    {
        if (_initialized.containsKey(workspaceName))
        {
            Map<String, Map<String, Boolean>> workspaceInitialized = _initialized.get(workspaceName);
            if (workspaceInitialized.containsKey(siteName))
            {
                Map<String, Boolean> siteInitialized = workspaceInitialized.get(siteName);
                
                if (siteInitialized.containsKey(language))
                {
                    return siteInitialized.get(language);
                }
            }
        }
        
        return false;
    }
    
    /**
     * Set the initialized map
     * @param siteName The site name
     * @param language The language
     */
    protected void setInitialized(String siteName, String language)
    {
        setInitialized(siteName, language, Boolean.TRUE);
    }
    
    /**
     * Set the initialized map
     * @param siteName The site name
     * @param language The language
     * @param initialized true to set initialized
     */
    protected void setInitialized(String siteName, String language, Boolean initialized)
    {
        String workspaceName = _workspaceSelector.getWorkspace();
        
        setInitialized(workspaceName, siteName, language, initialized);
    }
    
    /**
     * Set the initialized map
     * @param workspaceName The workspace name
     * @param siteName The site name
     * @param language The language
     * @param initialized true if to set initialized
     */
    protected void setInitialized(String workspaceName, String siteName, String language, Boolean initialized)
    {
        Map<String, Map<String, Boolean>> workspaceInitialized;
        if (_initialized.containsKey(workspaceName))
        {
            workspaceInitialized = _initialized.get(workspaceName);
        }
        else
        {
            workspaceInitialized = new HashMap<>();
            _initialized.put(workspaceName, workspaceInitialized);
        }
        
        Map<String, Boolean> siteInitialized;
        if (workspaceInitialized.containsKey(siteName))
        {
            siteInitialized = workspaceInitialized.get(siteName);
        }
        else
        {
            siteInitialized = new HashMap<>();
            workspaceInitialized.put(siteName, siteInitialized);
        }
        
        siteInitialized.put(language, initialized);
    }
    
    /**
     * 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 = getOrCreatePostDateCache(workspaceName, siteName, language);
        PostTagCache tagCache = getOrCreatePostTagCache(workspaceName, siteName, language);
        AllPostCache allCache = getOrCreateAllPostCache(workspaceName, siteName, language);
        FuturePostCache futureCache = getOrCreateFuturePostCache(workspaceName, siteName, language);
        
        ContentTypeExpression cTypeExpr = new ContentTypeExpression(Operator.EQ, PostContentType.CONTENT_TYPE);
        Expression siteExpr = new StringExpression(DefaultWebContent.METADATA_SITE, Operator.EQ, siteName);
        Expression languageExpr = new ContentLanguageExpression(Operator.EQ, language);
        MetadataExpression dateExpr = new MetadataExpression("date");
        
        Expression expression = new AndExpression(cTypeExpr, siteExpr, languageExpr, dateExpr);
        
        boolean displayFuturePosts = siteName != null ? BooleanUtils.isTrue(_siteConf.getValueAsBoolean(siteName, "display-future-posts")) : true;
        
        SortCriteria sort = new SortCriteria();
        sort.addCriterion("date", 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);
                }
            }
            setInitialized(siteName, language);
        }
    }
    
    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
            _lastUpdateFuturePosts.get(workspaceName).get(siteName).put(language, roundedNow);
            
            // Remove past "future posts"
            FuturePostCache futureCache = getOrCreateFuturePostCache(workspaceName, siteName, language);
            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 = _getOrCreateLastUpdateFuturePosts(workspaceName, siteName, language);
        
        if (lastUpdate != null)
        {
            long duration  = roundedNow.getTime() - lastUpdate.getTime();
            long diffInMinutes = TimeUnit.MILLISECONDS.toMinutes(duration);
            
            return diffInMinutes >= 15;
        }
        
        return true;
    }
    
    private Date _getOrCreateLastUpdateFuturePosts(String workspaceName, String siteName, String language)
    {
        Map<String, Map<String, Date>> workspaceMap;
        if (_lastUpdateFuturePosts.containsKey(workspaceName))
        {
            workspaceMap = _lastUpdateFuturePosts.get(workspaceName);
        }
        else
        {
            workspaceMap = new HashMap<>();
            _lastUpdateFuturePosts.put(workspaceName, workspaceMap);
        }
        
        Map<String, Date> siteMap;
        if (workspaceMap.containsKey(siteName))
        {
            siteMap = workspaceMap.get(siteName);
        }
        else
        {
            siteMap = new HashMap<>();
            workspaceMap.put(siteName, siteMap);
        }
        
        Date lastUpdate = null;
        if (siteMap.containsKey(language))
        {
            lastUpdate = siteMap.get(language);
        }
        
        return lastUpdate;
    }
    
    private boolean _isFuturePost (Content post)
    {
        Date postDate = post.getMetadataHolder().getDate(POST_METADATA_DATE, null);
        return postDate != null && postDate.after(new Date());
    }
    
    /**
     * 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();
        if (_allPosts.containsKey(workspaceName))
        {
            Map<String, Map<String, AllPostCache>> workspacePosts = _allPosts.get(workspaceName);
            
            if (workspacePosts.containsKey(siteName))
            {
                Map<String, AllPostCache> sitePosts = workspacePosts.get(siteName);
                
                for (Entry<String, AllPostCache> langPosts : sitePosts.entrySet())
                {
                    if (langPosts.getValue().hasPost(postId))
                    {
                        String language = langPosts.getKey();
                        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();
        if (_futurePostsCache.containsKey(workspaceName))
        {
            Map<String, Map<String, FuturePostCache>> workspacePosts = _futurePostsCache.get(workspaceName);
            
            if (workspacePosts.containsKey(siteName))
            {
                Map<String, FuturePostCache> sitePosts = workspacePosts.get(siteName);
                
                for (Entry<String, FuturePostCache> langPosts : sitePosts.entrySet())
                {
                    if (langPosts.getValue().hasPost(postId))
                    {
                        String language = langPosts.getKey();
                        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)
    {
        CompositeMetadata meta = content.getMetadataHolder();
        Date postDate = meta.getDate("date", null);
        
        // Dispatch by date.
        if (postDate != null)
        {
            DateTime dateTime = new DateTime(postDate.getTime());
            int month = dateTime.getMonthOfYear();
            int year = dateTime.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)
    {
        Date postDate = post.getDate();
        
        // Dispatch by date.
        if (postDate != null)
        {
            DateTime dateTime = new DateTime(postDate.getTime());
            int month = dateTime.getMonthOfYear();
            int year = dateTime.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)
    {
        CompositeMetadata meta = content.getMetadataHolder();
        String[] postTags = meta.getStringArray("tags", 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)
    {
        CompositeMetadata meta = content.getMetadataHolder();
        Date postDate = meta.getDate("date", null);
        
        // Dispatch by date.
        if (postDate != null)
        {
            DateTime dateTime = new DateTime(postDate.getTime());
            int month = dateTime.getMonthOfYear();
            int year = dateTime.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)
    {
        Date postDate = post.getDate();
        
        // Dispatch by date.
        if (postDate != null)
        {
            DateTime dateTime = new DateTime(postDate.getTime());
            int month = dateTime.getMonthOfYear();
            int year = dateTime.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)
    {
        CompositeMetadata meta = content.getMetadataHolder();
        String[] postTags = meta.getStringArray("tags", 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)
    {
        Date oldDate = post.getDate();
        Date newDate = postContent.getMetadataHolder().getDate("date");
        
        if (!newDate.equals(oldDate))
        {
            if (oldDate != null)
            {
                DateTime oldDateTime = new DateTime(oldDate.getTime());
                dateCache.removePost(postContent.getId(), oldDateTime.getYear(), oldDateTime.getMonthOfYear());
            }
                
            DateTime newDateTime = new DateTime(newDate.getTime());
            dateCache.addPost(postContent, newDateTime.getYear(), newDateTime.getMonthOfYear());
        }
    }
    
    /**
     * 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)
    {
        CompositeMetadata meta = postContent.getMetadataHolder();
        String[] oldPostTags = post.getTags();
        String[] newPostTags = meta.getStringArray("tags", 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 class Post
    {
        
        /** The post content id. */
        protected String _id;
        
        /** The post content name. */
        protected String _name;
        
        /** The post date. */
        protected Date _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 Date getDate()
        {
            return _date;
        }
        
        /**
         * Set the date.
         * @param date the date to set
         */
        public void setDate(Date 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 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 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);
            
            CompositeMetadata meta = content.getMetadataHolder();
            
            Post post = new Post();
            post.setId(content.getId());
            post.setName(content.getName());
            post.setDate(meta.getDate("date"));
            post.setTags(meta.getStringArray("tags", 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 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);
            
            CompositeMetadata meta = content.getMetadataHolder();
            
            Post post = new Post();
            post.setId(content.getId());
            post.setName(content.getName());
            post.setDate(meta.getDate("date"));
            post.setTags(meta.getStringArray("tags", 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 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)
        {
            CompositeMetadata meta = content.getMetadataHolder();
            
            Post post = new Post();
            post.setId(content.getId());
            post.setName(content.getName());
            if (meta.hasMetadata("date"))
            {
                post.setDate(meta.getDate("date"));
            }
            post.setTags(meta.getStringArray("tags", 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 class FuturePostCache
    {
        /** The posts, indexed by ID. */
        private Map<String, Post> _posts;
        
        /** The posts id, indexed by date. */
        private Multimap<Date, 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<Date> sortedDates = _sortedPostIds.keySet();
            Iterator<Date> iterator = sortedDates.iterator();
            boolean isFuture = false;
            Date now = new Date();
            
            while (iterator.hasNext() && !isFuture)
            {
                Date date = iterator.next();
                isFuture = date.after(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)
        {
            CompositeMetadata meta = content.getMetadataHolder();
            String id = content.getId();
            
            if (_posts.containsKey(id))
            {
                removePost(content);
            }
            
            Date date = meta.getDate("date");
            
            Post post = new Post();
            post.setId(id);
            post.setName(content.getName());
            post.setDate(meta.getDate("date"));
            post.setTags(meta.getStringArray("tags", 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());
        }
    }
    
}