/*
 *  Copyright 2010 Anyware Services
 *
 *  Licensed under the Apache License, Version 2.0 (the "License");
 *  you may not use this file except in compliance with the License.
 *  You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 *  Unless required by applicable law or agreed to in writing, software
 *  distributed under the License is distributed on an "AS IS" BASIS,
 *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 *  See the License for the specific language governing permissions and
 *  limitations under the License.
 */
package org.ametys.web.filter;

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.List;
import java.util.Map;
import java.util.Set;

import javax.jcr.Node;
import javax.jcr.Property;
import javax.jcr.PropertyType;
import javax.jcr.RepositoryException;

import org.apache.commons.lang.StringUtils;
import org.apache.jackrabbit.util.ISO9075;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import org.ametys.cms.contenttype.ContentTypeExtensionPoint;
import org.ametys.cms.filter.DefaultContentFilter;
import org.ametys.cms.repository.Content;
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.plugins.repository.AmetysObjectIterable;
import org.ametys.plugins.repository.AmetysObjectResolver;
import org.ametys.plugins.repository.AmetysRepositoryException;
import org.ametys.plugins.repository.ChainedAmetysObjectIterable;
import org.ametys.plugins.repository.CollatingUniqueAmetysObjectIterable;
import org.ametys.plugins.repository.CollectionIterable;
import org.ametys.plugins.repository.EmptyIterable;
import org.ametys.plugins.repository.UnknownAmetysObjectException;
import org.ametys.plugins.repository.jcr.JCRAmetysObject;
import org.ametys.plugins.repository.metadata.CompositeMetadata;
import org.ametys.plugins.repository.query.SortCriteria;
import org.ametys.plugins.repository.query.SortCriteria.SortCriterion;
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.NotExpression;
import org.ametys.plugins.repository.query.expression.OrExpression;
import org.ametys.plugins.repository.query.expression.StringExpression;
import org.ametys.runtime.i18n.I18nizableText;
import org.ametys.web.repository.content.jcr.DefaultWebContent;
import org.ametys.web.repository.page.Page;
import org.ametys.web.repository.site.Site;
import org.ametys.web.repository.site.SiteManager;
import org.ametys.web.tags.TagExpression;
import org.ametys.web.tags.TagExpression.LogicalOperator;

/**
 *  This is the default implementation of a {@link WebContentFilter}. The filter's property are set by setter function and constructor
 */
public class DefaultWebContentFilter extends DefaultContentFilter implements WebContentFilter
{
    /** The search contexts. */
    protected List<FilterSearchContext> _searchContexts;
    
    /** The mask orphan contents property */
    protected boolean _maskOrphan;
    /** The access limitation */
    protected AccessLimitation _accessLimitation;
    /** The title */
    protected I18nizableText _title;
    /** The description */
    protected I18nizableText _description;
    /** The logger */
    protected Logger _logger = LoggerFactory.getLogger(this.getClass());
    /** The site manager */
    protected SiteManager _siteManager;
    /** The tag provider */
    protected TagProviderExtensionPoint _tagProviderEP;
    
    /**
     * Constructor
     */
    public DefaultWebContentFilter ()
    {
        // Empty
        _searchContexts = new ArrayList<>();
    }
    
    /**
     * Creates a new filter
     * @param id The filter unique identifier
     * @param resolver The ametys object resolver
     * @param contentTypeExtensionPoint The extension point for content types
     * @param siteManager The site manager
     * @param tagProviderEP The tag provider
     */
    public DefaultWebContentFilter(String id, AmetysObjectResolver resolver, ContentTypeExtensionPoint contentTypeExtensionPoint, SiteManager siteManager, TagProviderExtensionPoint tagProviderEP)
    {
        super(id, resolver, contentTypeExtensionPoint);
        _siteManager = siteManager;
        _tagProviderEP = tagProviderEP;
        _searchContexts = new ArrayList<>();
    }
    
    /**
     * Creates a new filter from copy of another
     * @param id The filter unique identifier
     * @param originalFilter The original filter to be copied
     * @param resolver The ametys object resolver
     * @param contentTypeExtensionPoint The extension point for content types
     * @param siteManager The site manager
     * @param tagProviderEP The tag provider
     */
    public DefaultWebContentFilter(String id, DefaultWebContentFilter originalFilter, AmetysObjectResolver resolver, ContentTypeExtensionPoint contentTypeExtensionPoint, SiteManager siteManager, TagProviderExtensionPoint tagProviderEP)
    {
        super(id, originalFilter, resolver, contentTypeExtensionPoint);
        _siteManager = siteManager;
        _tagProviderEP = tagProviderEP;
        _searchContexts = new ArrayList<>(originalFilter._searchContexts);
        _title = originalFilter._title;
        _description = originalFilter._description;
        _maskOrphan = originalFilter._maskOrphan;
        _accessLimitation = originalFilter._accessLimitation;
    }
    
    @Override
    public I18nizableText getTitle()
    {
        return _title;
    }
    
    @Override
    public void setTitle(I18nizableText title)
    {
        _title = title;
    }
    
    @Override
    public I18nizableText getDescription()
    {
        return _description;
    }
    
    @Override
    public void setDescription(I18nizableText description)
    {
        _description = description;
    }
    
    @Override
    public ContextLanguage getContextLanguage()
    {
        throw new UnsupportedOperationException("This implementation use multiple context languages, use getSearchContexts instead.");
    }
    
    @Override
    public void setContextLanguage(ContextLanguage context)
    {
        throw new UnsupportedOperationException("This implementation use multiple context languages, use setSearchContexts instead.");
    }
    
    @Override
    public void addMetadata(String metadataId, String value)
    {
        if (_metadata == null)
        {
            _metadata = new HashMap<>();
        }
        _metadata.put(metadataId, value);
    }
    
    @Override
    public List<FilterSearchContext> getSearchContexts()
    {
        return Collections.unmodifiableList(_searchContexts);
    }
    
    @Override
    public FilterSearchContext addSearchContext()
    {
        FilterSearchContext context = createSeachContext();
        _searchContexts.add(context);
        return context;
    }
    
    /**
     * Create a search context.
     * @return the created search context.
     */
    protected FilterSearchContext createSeachContext()
    {
        return new DefaultFilterSearchContext(_siteManager);
    }
    
    @Override
    public void setMaskOrphanContents(boolean mask)
    {
        _maskOrphan = mask;
    }
    
    @Override
    public boolean maskOrphanContents()
    {
        return _maskOrphan;
    }
    
    @Override
    public AccessLimitation getAccessLimitation()
    {
        // Default to PAGE_ACCESS.
        return _accessLimitation == null ? AccessLimitation.PAGE_ACCESS : _accessLimitation;
    }
    
    @Override
    public void setAccessLimitation(AccessLimitation limitation)
    {
        _accessLimitation = limitation;
    }
    
    @Override
    public AmetysObjectIterable<Content> getMatchingContents(String siteName, String lang, Page page)
    {
        List<AmetysObjectIterable<Content>> iterables = new ArrayList<>();
        
        for (FilterSearchContext context : _searchContexts)
        {
            AmetysObjectIterable<Content> contents = getMatchingContents(siteName, lang, page, context);
            if (contents != null)
            {
                iterables.add(contents);
            }
        }
        
        AmetysObjectIterable<Content> contents = null;
        
        if (!iterables.isEmpty())
        {
            Comparator<Content> comparator = new ContentComparator(_sortCriteria);
            contents = new CollatingUniqueAmetysObjectIterable<>(iterables, comparator);
        }
        else
        {
            if (_logger.isInfoEnabled())
            {
                _logger.info("The filter '" + _id + "' has a null content collection");
            }
            contents = new EmptyIterable<>();
        }
        
        return contents;
    }
    
    /**
     * Get the matching contents for the given search context.
     * @param siteName the site name.
     * @param lang the language.
     * @param page the context page.
     * @param filterContext the search context.
     * @return An iterable over matching Contents.
     */
    protected AmetysObjectIterable<Content> getMatchingContents(String siteName, String lang, Page page, FilterSearchContext filterContext)
    {
        AmetysObjectIterable<Content> contents = null;
        
        Context context = filterContext.getContext();
        int depth = filterContext.getDepth();
        
        Page parentPage = page;
        if (filterContext.getPageId() != null)
        {
            parentPage = _resolver.resolveById(filterContext.getPageId());
            try
            {
                parentPage = _resolver.resolveById(filterContext.getPageId());
            }
            catch (UnknownAmetysObjectException e)
            {
                _logger.warn("the page '" + filterContext.getPageId() + "' can not be found for content's filter of id '" + _id + "'");
                Collection<Content> emptyList = Collections.emptyList();
                return new CollectionIterable<>(emptyList);
            }
        }
        String xpathQuery = null;
        if (parentPage == null && context.equals(Context.CHILD_PAGES))
        {
            // Leave null.
            _logger.warn("The current page can not be null for content's filter of id '" + _id + "'");
        }
        else if (context.equals(Context.CHILD_PAGES) && (depth == 0 || depth == 1))
        {
            xpathQuery = getXPathQuery(siteName, parentPage, depth, filterContext);
            contents = _resolver.query(xpathQuery);
        }
        else if (context.equals(Context.CHILD_PAGES))
        {
            List<AmetysObjectIterable<Content>> itList = new ArrayList<>();
            for (int i = 1; i <= depth; i++)
            {
                xpathQuery = getXPathQuery(siteName, parentPage, i, filterContext);
                AmetysObjectIterable<Content> it = _resolver.query(xpathQuery);
                itList.add(it);
            }
            contents = new ChainedAmetysObjectIterable<>(itList);
        }
        else
        {
            xpathQuery = getXPathQuery(siteName, lang, filterContext);
            contents = _resolver.query(xpathQuery);
        }
        
        return contents;
    }
    
    /**
     * Creates the XPath query corresponding to this filter.
     * @param siteName The current site name
     * @param lang The current language
     * @param filterContext the filter search context.
     * @return the created XPath query
     */
    public String getXPathQuery(String siteName, String lang, FilterSearchContext filterContext)
    {
        List<Expression> exprs = new ArrayList<>();
        
        Expression filterExpr = getFilterExpression();
        if (filterExpr != null)
        {
            exprs.add(filterExpr);
        }
        
        Expression contextExpr = filterContext.getFullExpression(siteName, lang);
        if (contextExpr != null)
        {
            exprs.add(contextExpr);
        }
        
        Expression expr = exprs.size() > 0 ? new AndExpression(exprs.toArray(new Expression[exprs.size()])) : null;
        
        return org.ametys.plugins.repository.query.QueryHelper.getXPathQuery(null, "ametys:content", expr, _sortCriteria);
    }
    
    /**
     * Creates the XPath query corresponding to specified {@link Page}, {@link Expression} and {@link SortCriteria}.
     * @param siteName The current site name
     * @param page The page where to start the search
     * @param depth the search depth
     * @param filterContext the filter search context.
     * @return the created XPath query
     */
    protected String getXPathQuery(String siteName, Page page, int depth, FilterSearchContext filterContext)
    {
        String depthPath = "";
        if (depth == 0)
        {
            depthPath = "/";
        }
        else if (depth == 1)
        {
            depthPath = "";
        }
        else
        {
            for (int i = 0; i < depth; i++)
            {
                depthPath += "/*";
            }
        }
        
        // Build the content expression
        Expression expr = getFilterExpression(siteName, filterContext);
        
        String xpath = "//element(" + page.getSite().getName() + ", ametys:site)/ametys-internal:sitemaps/" + _encode(page.getSitemap().getName())
            + "/" + page.getPathInSitemap()
            + depthPath 
            + "/element(*, ametys:page)/ametys-internal:zones/*/ametys-internal:zoneItems/*/jcr:deref(@ametys-internal:content, '*')" + (expr != null ? "[" + expr.build() + "]" : "")
            + (_sortCriteria != null ? (" " + _sortCriteria.build()) : "");
        return xpath;
        
    }
    
    /**
     * Get the filter expression for a given search context.
     * @param siteName The current site name
     * @param filterContext the filter search context.
     * @return the filter expression.
     */
    protected Expression getFilterExpression(String siteName, FilterSearchContext filterContext)
    {
        Expression expr = super.getFilterExpression();
        
        Expression tagExpr = filterContext.getTagsExpression(siteName);
        if (tagExpr != null)
        {
            expr = expr != null ? new AndExpression(expr, tagExpr) : tagExpr;
        }
        
        return expr;
    }
    
    private static String _encode(String path)
    {
        if (path == null || path.length() == 0)
        {
            return "";
        }
        
        int pos = path.indexOf("/");
        if (pos == -1)
        {
            return ISO9075.encode(path);
        }
        else
        {
            return ISO9075.encode(path.substring(0, pos)) + "/" + _encode(path.substring(pos + 1));
        }
    }
    
    /**
     * Default implementation of a filter search context.
     */
    public class DefaultFilterSearchContext implements FilterSearchContext
    {
        /** The tags. */
        protected List<String> _tags;
        /** The tags condition*/
        protected Condition _tagsCondition;
        /** The tags auto posting */
        protected boolean _tagsAutoPosting;
        /** The context for search */
        protected Context _context;
        /** The list of sites to match*/
        protected List<String> _sites;
        /** The search depth */
        protected int _depth;
        /** The list of content languages to match */
        @SuppressWarnings("hiding")
        protected ContextLanguage _contextLang;
        /** The parent page Id */
        protected String _pageId;
        /** The list of content languages to match */
        @SuppressWarnings("hiding")
        protected SiteManager _siteManager;
        
        /**
         * Build a DefaultFilterSearchContext.
         * @param siteManager the site manager.
         */
        public DefaultFilterSearchContext(SiteManager siteManager)
        {
            _siteManager = siteManager;
            _tags = new ArrayList<>();
            _sites = new ArrayList<>();
        }
        
        @Override
        public int getDepth()
        {
            return _depth;
        }

        @Override
        public List<String> getTags()
        {
            return _tags;
        }

        @Override
        public Condition getTagsCondition ()
        {
            return _tagsCondition;
        }
        
        @Override
        public boolean getTagsAutoPosting()
        {
            return _tagsAutoPosting;
        }
        
        @Override
        public Context getContext()
        {
            return _context;
        }
        
        @Override
        public List<String> getSites()
        {
            return _sites;
        }
        
        @Override
        public void addTag(String tag)
        {
            _tags.add(tag);
        }
        
        @Override
        public void setTagsCondition(Condition condition)
        {
            _tagsCondition = condition;
        }
        
        @Override
        public void setTagsAutoPosting(boolean enable)
        {
            _tagsAutoPosting = enable;
        }
        
        @Override
        public void setContext(Context context)
        {
            _context = context;
        }
        
        @Override
        public void addSite(String siteName)
        {
            _sites.add(siteName);
        }
        
        @Override
        public void setDepth(int depth)
        {
            _depth = depth;
        }

        @Override
        public ContextLanguage getContextLanguage()
        {
            return _contextLang;
        }
        
        @Override
        public void setContextLanguage(ContextLanguage language)
        {
            _contextLang = language;
        }
        
        @Override
        public Expression getFullExpression(String siteName, String language)
        {
            List<Expression> exprs = new ArrayList<>();
            
            Expression contextExpr = getContextExpression(siteName);
            if (contextExpr != null)
            {
                exprs.add(contextExpr);
            }
            
            Expression langExpr = getContextLanguagesExpression(language);
            if (langExpr != null)
            {
                exprs.add(langExpr);
            }
            
            Expression sharedExpr = getSharedContentsExpression(siteName);
            if (sharedExpr != null)
            {
                exprs.add(sharedExpr);
            }
            
            Expression tagExpr = getTagsExpression(siteName);
            if (tagExpr != null)
            {
                exprs.add(tagExpr);
            }
            
            Expression expr = exprs.size() > 0 ? new AndExpression(exprs.toArray(new Expression[exprs.size()])) : null;
            
            return expr;
        }
        
        @Override
        public Expression getTagsExpression(String siteName)
        {
            if (_tags != null && _tags.size() > 0)
            {
                List<Expression> tagsExpr = new ArrayList<>();
                for (String tagName : _tags)
                {
                    if (_tagsAutoPosting)
                    {
                        Tag tag = _getTag(siteName, tagName);
                        if (tag != null)
                        {
                            Set<String> descendantNames = TagHelper.getDescendantNames(tag, true);
                            tagsExpr.add(new TagExpression(Operator.EQ, descendantNames.toArray(new String[descendantNames.size()]), LogicalOperator.OR));
                        }
                    }
                    else
                    {
                        tagsExpr.add(new TagExpression(Operator.EQ, tagName));
                    }
                }
                
                if (_tagsCondition == Condition.OR)
                {
                    return new OrExpression(tagsExpr.toArray(new Expression[tagsExpr.size()]));
                }
                else
                {
                    return new AndExpression(tagsExpr.toArray(new Expression[tagsExpr.size()]));
                }
            }
            
            return null;
        }
        
        /**
         * Internal tag getter given the search context
         * @param currentSiteName The name of the current site
         * @param tagName the name of the tag
         * @return The tag or null
         */
        protected Tag _getTag(String currentSiteName, String tagName)
        {
            Map<String, Object> parameters = new HashMap<>();
            
            Tag tag = null;
            
            switch (_context)
            {
                case CURRENT_SITE:
                case CHILD_PAGES:
                    parameters.put("siteName", currentSiteName);
                    tag = _tagProviderEP.getTag(tagName, parameters);
                    break;
                case SITES_LIST:
                    if (_sites != null && _sites.size() == 1)
                    {
                        parameters.put("siteName", _sites.get(0));
                        tag = _tagProviderEP.getTag(tagName, parameters);
                    }
                    break;
                case SITES:
                case OTHER_SITES:
                    tag = _tagProviderEP.getTag(tagName, null);
                    break;
                default:
                    // nothing
                    break;
            }
            
            return tag;
        }
        
        /**
         * Get the {@link Expression} associated with the given site context
         * @param siteName The current site name
         * @return a {@link Expression} associated with the given site context
         */
        protected Expression getContextExpression(String siteName)
        {
            Expression expr = null;
            
            if (Context.CURRENT_SITE.equals(_context))
            {
                expr = new StringExpression(DefaultWebContent.METADATA_SITE, Operator.EQ, siteName);
            }
            else if (Context.OTHER_SITES.equals(_context))
            {
                expr = new StringExpression(DefaultWebContent.METADATA_SITE, Operator.NE, siteName);
            }
            else if (Context.SITES_LIST.equals(_context))
            {
                List<Expression> sitesExpr = new ArrayList<>();
                if (_sites != null && _sites.size() > 0)
                {
                    for (String site : _sites)
                    {
                        sitesExpr.add(new StringExpression(DefaultWebContent.METADATA_SITE, Operator.EQ, site));
                    }
                }
                expr = new OrExpression(sitesExpr.toArray(new Expression[sitesExpr.size()]));
            }
            else if (Context.NO_SITE.equals(_context))
            {
                expr = new NotExpression(new MetadataExpression(DefaultWebContent.METADATA_SITE));
            }
            
            return expr;
        }
        
        /**
         * Get the expression for shared contents
         * @param currentSiteName the current site name
         * @return the expression to aware of privacy of contents
         */
        protected Expression getSharedContentsExpression(String currentSiteName)
        {
            if (Context.OTHER_SITES.equals(_context) || Context.SITES.equals(_context))
            {
                return SharedContentsHelper.getSharedContentsExpression(_siteManager.getSite(currentSiteName), _siteManager.getSites());
            }
            else if (Context.SITES_LIST.equals(_context))
            {
                List<Site> sites = new ArrayList<>();
                for (String siteName : _sites)
                {
                    sites.add(_siteManager.getSite(siteName));
                }
                
                return SharedContentsHelper.getSharedContentsExpression(_siteManager.getSite(currentSiteName), new CollectionIterable<>(sites));
            }
            
            return null;
            
        }
        
        /**
         * Get the {@link Expression} associated with the given language context
         * @param lang The current language
         * @return a {@link Expression} associated with the given language context
         */
        protected Expression getContextLanguagesExpression(String lang)
        {
            if (lang == null)
            {
                return null;
            }
            
            Expression expr = null;
            
            if (ContextLanguage.CURRENT.equals(_contextLang))
            {
                expr = new LanguageExpression(Operator.EQ, lang);
            }
            else if (ContextLanguage.OTHERS.equals(_contextLang))
            {
                expr = new LanguageExpression(Operator.NE, lang);
            }
            
            return expr;
        }

        @Override
        public String getPageId()
        {
            return this._pageId;
        }

        @Override
        public void setPageId(String pageId)
        {
            this._pageId = pageId;
        }
    }
    
    /**
     * Compares two contents based on a given list of sort criteria.
     * In jackrabbit, in ascending order, if the first content does not have the wanted value set,
     * it's considered to be ordered *before* ("less than") the second content (the JCR spec specifies this behavior as "implementation-defined").
     */
    protected class ContentComparator implements Comparator<Content>
    {
        
        /** The sort criteria. */
        protected SortCriteria _sort;
        
        /**
         * Build a content comparator from sort criteria.
         * @param sortCriteria The sort criteria
         */
        public ContentComparator(SortCriteria sortCriteria)
        {
            _sort = sortCriteria;
        }
        
        @Override
        public int compare(Content c1, Content c2)
        {
            try
            {
                for (SortCriterion criterion : _sort.getCriteria())
                {
                    boolean ascending = criterion.isAscending();
                    String metadataPath = criterion.getMetadataPath();
                    String jcrProperty = criterion.getJcrProperty();
                    boolean normalize = criterion.isNormalizedSort();
                    
                    int compareAsc = 0;
                    
                    if (StringUtils.isNotEmpty(metadataPath))
                    {
                        compareAsc = compareMetadataAscending(c1, c2, metadataPath, normalize);
                    }
                    else
                    {
                        compareAsc = compareJcrPropertyAscending(c1, c2, jcrProperty, normalize);
                    }
                    
                    if (compareAsc != 0)
                    {
                        return ascending ? compareAsc : (0 - compareAsc);
                    }
                }
            }
            catch (RepositoryException e)
            {
                _logger.warn("A repository error occurred trying to compare two contents.", e);
            }
            catch (AmetysRepositoryException e)
            {
                _logger.warn("A repository error occurred trying to compare two contents.", e);
            }
            
            return 0;
        }
        
        private int compareMetadataAscending(Content c1, Content c2, String metadataPath, boolean normalize)
        {
            CompositeMetadata meta1 = c1.getMetadataHolder();
            CompositeMetadata meta2 = c2.getMetadataHolder();
            
            // Traverse the composites until the one containing the meta.
            String[] path = StringUtils.split(metadataPath, '/');
            for (int i = 0; i < (path.length - 1); i++)
            {
                // If the first content does not have a composite, then it's before ("less than") the second. 
                if (!meta1.hasMetadata(path[i]))
                {
                    return -1;
                }
                if (!meta2.hasMetadata(path[i]))
                {
                    return 1;
                }
                
                meta1 = meta1.getCompositeMetadata(path[i]);
                meta2 = meta2.getCompositeMetadata(path[i]);
            }
            
            String metaName = path[path.length - 1];
            
            // If the first content does not have the metadata set, then it's before ("less than") the second. 
            if (!meta1.hasMetadata(metaName))
            {
                return -1;
            }
            if (!meta2.hasMetadata(metaName))
            {
                return 1;
            }
            
            // Compare values depending on theit type.
            switch (meta1.getType(metaName))
            {
                case STRING:
                    String string1 = meta1.getString(metaName);
                    String string2 = meta2.getString(metaName);
                    return normalize ? string1.compareToIgnoreCase(string2) : string1.compareTo(string2);
                case DATE:
                    Date date1 = meta1.getDate(metaName);
                    Date date2 = meta2.getDate(metaName);
                    return date1.compareTo(date2);
                case LONG:
                    Long long1 = meta1.getLong(metaName);
                    Long long2 = meta2.getLong(metaName);
                    return long1.compareTo(long2);
                case DOUBLE:
                    Double double1 = meta1.getDouble(metaName);
                    Double double2 = meta2.getDouble(metaName);
                    return double1.compareTo(double2);
                case BINARY:
                case BOOLEAN:
                case COMPOSITE:
                case RICHTEXT:
                case MULTILINGUAL_STRING:
                default:
                    // Cannot compare these values, return 0;
                    return 0;
            }
        }
        
        private int compareJcrPropertyAscending(Content c1, Content c2, String jcrProperty, boolean normalize) throws RepositoryException
        {
            if (c1 instanceof JCRAmetysObject && c2 instanceof JCRAmetysObject)
            {
                Node node1 = ((JCRAmetysObject) c1).getNode();
                Node node2 = ((JCRAmetysObject) c2).getNode();
                
                // If the first content does not have the property set, then it's before ("less than") the second.
                if (!node1.hasProperty(jcrProperty))
                {
                    return -1;
                }
                if (!node2.hasProperty(jcrProperty))
                {
                    return 1;
                }
                
                Property prop1 = node1.getProperty(jcrProperty);
                Property prop2 = node2.getProperty(jcrProperty);
                
                // Compare values depending on theit type.
                switch (prop1.getType())
                {
                    case PropertyType.STRING:
                        String string1 = prop1.getString();
                        String string2 = prop2.getString();
                        return normalize ? string1.compareToIgnoreCase(string2) : string1.compareTo(string2);
                    case PropertyType.DATE:
                        Calendar date1 = prop1.getDate();
                        Calendar date2 = prop2.getDate();
                        return date1.compareTo(date2);
                    case PropertyType.LONG:
                        Long long1 = prop1.getLong();
                        Long long2 = prop2.getLong();
                        return long1.compareTo(long2);
                    case PropertyType.DOUBLE:
                        Double double1 = prop1.getDouble();
                        Double double2 = prop2.getDouble();
                        return double1.compareTo(double2);
                    default:
                        // Cannot compare these values, return 0;
                        return 0;
                }
            }
            
            return 0;
        }
        
    }
}