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

import javax.jcr.Item;
import javax.jcr.Node;
import javax.jcr.Property;
import javax.jcr.RepositoryException;
import javax.jcr.version.OnParentVersionAction;

import org.apache.commons.collections.Predicate;
import org.apache.commons.collections.PredicateUtils;
import org.apache.commons.lang.ArrayUtils;

import org.ametys.plugins.repository.RepositoryConstants;
import org.ametys.plugins.repository.jcr.NodeTypeHelper;

/**
 * Provides the following predicates:
 * <ul>
 * <li>propertyNamePredicate - accept a property depending on his name.
 * <li>nodeNamePredicate - accept a node depending on his name.
 * <li>nodeTypePredicate - accept a node depending on his node type.
 * </ul>
 */
public class AmetysPredicateUtils extends PredicateUtils
{
    private static AllowedForLivePredicate _allowedLivePredicate = new  AllowedForLivePredicate();
    
    /** 
     * Tests if the property has the following name.
     * @param propertyName the property name.
     * @return <code>true</code> if the property has the given name,
     *         <code>false</code> otherwise.
     */
    public static Predicate propertyNamePredicate(final String propertyName)
    {
        return new Predicate()
        {
            @Override
            public boolean evaluate(Object object)
            {
                if (object instanceof Property)
                {
                    try
                    {
                        return ((Property) object).getName().equals(propertyName);
                    }
                    catch (RepositoryException e)
                    {
                        throw new RuntimeException("Unable to get property name", e);
                    }
                }
                
                return false;
            }
        };
    }
    
    /** 
     * Tests if the property has a given name in a list.
     * @param propertyNames one or several property names.
     * @return <code>true</code> if the property has on of the given names,
     *         <code>false</code> otherwise.
     */
    public static Predicate propertyNamesPredicate(final String ... propertyNames)
    {
        return new Predicate()
        {
            @Override
            public boolean evaluate(Object object)
            {
                if (object instanceof Property)
                {
                    try
                    {
                        String propName = ((Property) object).getName();
                        return ArrayUtils.contains(propertyNames, propName);
                    }
                    catch (RepositoryException e)
                    {
                        throw new RuntimeException("Unable to get property name", e);
                    }
                }
                return false;
            }
        };
    }
    
    /** 
     * Tests if the property is not a protected one (e.g. jcr:uuid).
     * @param predicate the additional predicate to evaluate.
     * @return <code>true</code> if the property has the given name,
     *         <code>false</code> otherwise.
     */
    public static Predicate ignoreProtectedProperties(final Predicate predicate)
    {
        return new IgnoreProtectedPredicate(predicate);
    }
    
    /** 
     * Tests if the node has the following name.
     * @param nodeName the node name.
     * @return <code>true</code> if the node has the given name,
     *         <code>false</code> otherwise.
     */
    public static Predicate nodeNamePredicate(final String nodeName)
    {
        return new Predicate()
        {
            @Override
            public boolean evaluate(Object object)
            {
                if (object instanceof Node)
                {
                    try
                    {
                        return ((Node) object).getName().equals(nodeName);
                    }
                    catch (RepositoryException e)
                    {
                        throw new RuntimeException("Unable to get node name", e);
                    }
                }
                
                return false;
            }
        };
    }
    
    /** 
     * Tests if the node or property is a Ametys attribute, ie. it is prefixed by 'ametys:' 
     * @return <code>true</code> if the name starts with 'ametys:' 
     *         <code>false</code> otherwise.
     */
    public static Predicate ametysAttributePredicate()
    {
        return new Predicate()
        {
            @Override
            public boolean evaluate(Object object)
            {
                if (object instanceof Item)
                {
                    try
                    {
                        return ((Item) object).getName().startsWith(RepositoryConstants.NAMESPACE_PREFIX + ":");
                    }
                    catch (RepositoryException e)
                    {
                        throw new RuntimeException("Unable to get item name", e);
                    }
                }
                
                return false;
            }
        };
    }
    
    /** 
     * Tests if the node is of the given node type.
     * @param nodeTypeName the node type name.
     * @return <code>true</code> if the node has the given node type,
     *         <code>false</code> otherwise.
     */
    public static Predicate nodeTypePredicate(final String nodeTypeName)
    {
        return new Predicate()
        {
            @Override
            public boolean evaluate(Object object)
            {
                if (object instanceof Node)
                {
                    try
                    {
                        return ((Node) object).isNodeType(nodeTypeName);
                    }
                    catch (RepositoryException e)
                    {
                        throw new RuntimeException("Unable to test node type", e);
                    }
                }
                
                return false;
            }
        };
    }
    
    private static final class IgnoreProtectedPredicate implements Predicate
    {
        private Predicate _predicate;
        
        IgnoreProtectedPredicate(Predicate predicate)
        {
            _predicate = predicate;
        }
        
        @Override
        public boolean evaluate(Object object)
        {
            if (object instanceof Property)
            {
                Property property = (Property) object;
                
                try
                {
                    Node parentNode = property.getParent();
                    String propertyName = property.getName();
                    
                    if (parentNode.isNodeType("nt:frozenNode"))
                    {
                        if (propertyName.startsWith("jcr:"))
                        {
                            if (!propertyName.equals("jcr:encoding") && !propertyName.equals("jcr:mimeType")
                                    && !propertyName.equals("jcr:data") && !propertyName.equals("jcr:lastModified"))
                            {
                                // Refuse potential protected property
                                return false;
                            }
                        }
                        
                        return _predicate.evaluate(object);
                    }
                    else
                    {
                        // If property is not protected, do process it
                        return !property.getDefinition().isProtected() && _predicate.evaluate(object);
                    }
                }
                catch (RepositoryException e)
                {
                    throw new RuntimeException("Unable to process property", e);
                }
            }
            
            return false;
        }
    }
    
    /** 
     * Tests if the node or property is allowed in the live workspace
     * @return <code>true</code> if the property or node is allowed,
     *         <code>false</code> otherwise.
     */
    public static Predicate isAllowedForLiveContent()
    {
        return _allowedLivePredicate;
    }
    
    private static final class AllowedForLivePredicate implements Predicate
    {
        AllowedForLivePredicate()
        {
        }
        
        @Override
        public boolean evaluate(Object object)
        {
            if (object instanceof Property)
            {
               
                Property property = (Property) object;
                try
                {
                    // oswf:* item are not allowed
                    return !property.getName().startsWith("oswf:") 
                            && !property.getName().equals(RepositoryConstants.NAMESPACE_PREFIX_INTERNAL + ":initial-content") 
                            && !property.getName().equals(RepositoryConstants.NAMESPACE_PREFIX_INTERNAL + ":workflowRef");
                }
                catch (RepositoryException e)
                {
                    throw new RuntimeException("Unable to process property", e);
                }
            }
            else if (object instanceof Node)
            {
                Node node = (Node) object;
                try
                {
                    String nodeType = NodeTypeHelper.getNodeTypeName(node);
                    
                    // oswf:* item are not allowed
                    return !nodeType.startsWith("oswf:");
                }
                catch (RepositoryException e)
                {
                    throw new RuntimeException("Unable to process node", e);
                }
            }
            
            return false;
        }
    }
    
    
    /** 
     * Tests if the node or property is allowed in the live workspace
     * @param node The parent node.
     * @return <code>true</code> if the property or node is allowed,
     *         <code>false</code> otherwise.
     */
    public static Predicate isNonVersionned(Node node)
    {
        return new NonVersionnedPredicate(node);
    }
    
    private static final class NonVersionnedPredicate implements Predicate
    {
        private Node _node;

        NonVersionnedPredicate(Node node)
        {
            _node = node;
        }
        
        @Override
        public boolean evaluate(Object object)
        {
            if (object instanceof Property)
            {
                Property property = (Property) object;
                
                try
                {
                    if (!property.getParent().getIdentifier().equals(_node.getIdentifier()))
                    {
                        // The property must be one of a child node (of a non versionned node)
                        return true;
                    }
                    return property.getDefinition().getOnParentVersion() == OnParentVersionAction.IGNORE;
                }
                catch (RepositoryException e)
                {
                    throw new RuntimeException("Unable to process property", e);
                }
            }
            else if (object instanceof Node)
            {
                Node node = (Node) object;
                try
                {
                    if (!node.getParent().getIdentifier().equals(_node.getIdentifier()))
                    {
                        // The node must be one of a child node (of a non versionned node)
                        return true;
                    }
                    return node.getDefinition().getOnParentVersion() == OnParentVersionAction.IGNORE;
                }
                catch (RepositoryException e)
                {
                    throw new RuntimeException("Unable to process node", e);
                }
            }
            
            return false;
        }
    }
}