/*
 *  Copyright 2017 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.content.referencetable;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.HashMap;
import java.util.HashSet;
import java.util.LinkedHashSet;
import java.util.List;
import java.util.Map;
import java.util.Optional;
import java.util.Set;

import org.apache.avalon.framework.activity.Disposable;
import org.apache.avalon.framework.component.Component;
import org.apache.avalon.framework.service.ServiceException;
import org.apache.avalon.framework.service.ServiceManager;
import org.apache.avalon.framework.service.Serviceable;
import org.apache.commons.lang3.ArrayUtils;
import org.apache.commons.lang3.StringUtils;

import org.ametys.cms.contenttype.ContentAttributeDefinition;
import org.ametys.cms.contenttype.ContentType;
import org.ametys.cms.contenttype.ContentTypeExtensionPoint;
import org.ametys.cms.contenttype.ContentTypesHelper;
import org.ametys.cms.data.ContentValue;
import org.ametys.cms.repository.Content;
import org.ametys.cms.repository.ContentQueryHelper;
import org.ametys.cms.repository.ContentTypeExpression;
import org.ametys.cms.repository.MixinTypeExpression;
import org.ametys.cms.rights.ContentRightAssignmentContext;
import org.ametys.core.ui.Callable;
import org.ametys.plugins.repository.AmetysObjectIterable;
import org.ametys.plugins.repository.AmetysObjectResolver;
import org.ametys.plugins.repository.EmptyIterable;
import org.ametys.plugins.repository.data.holder.ModelAwareDataHolder;
import org.ametys.plugins.repository.data.holder.group.ModelAwareComposite;
import org.ametys.plugins.repository.data.holder.group.ModelAwareRepeater;
import org.ametys.plugins.repository.data.holder.group.ModelAwareRepeaterEntry;
import org.ametys.plugins.repository.model.ViewHelper;
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.NotExpression;
import org.ametys.plugins.repository.query.expression.OrExpression;
import org.ametys.plugins.repository.query.expression.StringExpression;
import org.ametys.runtime.model.Model;
import org.ametys.runtime.model.ModelItem;
import org.ametys.runtime.model.View;
import org.ametys.runtime.model.ViewItemAccessor;
import org.ametys.runtime.plugin.component.AbstractLogEnabled;

import com.google.common.collect.BiMap;
import com.google.common.collect.HashBiMap;

/**
 * Helper component for computing information about hierarchy of reference table Contents.
 * <br><br>
 * 
 * At the startup of the Ametys application, you must call {@link #registerRelation(ContentType, ContentType)} in order to register a <b>relation</b> between a <b>parent</b> content type and its <b>child</b> content type.<br>
 * When all relations are registered, one or several <b>hierarchy(ies)</b> can be inferred, following some basic rules:<br>
 * <ul>
 * <li>A hierarchy of two or more content types cannot be cyclic</li>
 * <li>A content type can have itself as its parent content type</li>
 * <li>A content type cannot have two different parent content types</li>
 * <li>A content type can have only one content type as children, plus possibly itself</li>
 * </ul>
 * From each hierarchy of content types, a <b>tree</b> of contents can be inferred.<br>
 * <br>
 * For instance, the following examples of hierarchy are valid (where <b>X←Y</b> means 'X is the parent content type of Y'; <br>and <b>⤹Z</b> means 'Z is the parent content type of Z'):
 * <ul>
 * <li>B←A</li>
 * <li>E←D←C←B←A</li>
 * <li>⤹B←A (content type B defines two different child content types, but one is itself, which is allowed)</li>
 * <li>⤹E←D←C←B←A</li>
 * <li>⤹A</li>
 * </ul>
 * ; and the following examples of hierarchy are invalid:
 * <ul>
 * <li>C←B and C←A (a content type cannot have multiple content types as children, which are not itself)</li>
 * <li>C←A and B←A (a content type cannot have two different parent content types)</li>
 * <li>⤹A and B←A (a content type cannot have two different parent content types, even if one is itself)</li>
 * <li>A←B and B←A (cyclic hierarchy)</li>
 * <li>A←C←B←A (cyclic hierarchy)</li>
 * </ul>
 */
public class HierarchicalReferenceTablesHelper extends AbstractLogEnabled implements Component, Serviceable, Disposable
{
    /** The Avalon role */
    public static final String ROLE = HierarchicalReferenceTablesHelper.class.getName();
    /** the candidate content type id*/
    public static final String CANDIDATE_CONTENT_TYPE = "org.ametys.cms.referencetable.mixin.Candidate";
    /** The name of the view to defined attributes to filter the contents */
    public static final String SEARCH_FILTERS_VIEW_NAME = "search-filters";
    
    /** Tag for reference table */
    private static final String TAG_CANDIDATE = "allow-candidates";
    
    /** The extension point for content types */
    protected ContentTypeExtensionPoint _contentTypeEP;
    /** The Ametys objet resolver */
    protected AmetysObjectResolver _resolver;
    /** The content types helper */
    protected ContentTypesHelper _cTypeHelper;
    
    /** The map parent -&gt; child (excepted content types pointing on themselves) */
    private BiMap<ContentType, ContentType> _childByContentType = HashBiMap.create();
    /** The content types pointing at themselves */
    private Set<ContentType> _autoReferencingContentTypes = new HashSet<>();
    /** The map leafContentType -&gt; topLevelContentType  */
    private BiMap<ContentType, ContentType> _topLevelTypeByLeafType = HashBiMap.create();

    @Override
    public void service(ServiceManager manager) throws ServiceException
    {
        _contentTypeEP = (ContentTypeExtensionPoint) manager.lookup(ContentTypeExtensionPoint.ROLE);
        _resolver = (AmetysObjectResolver) manager.lookup(AmetysObjectResolver.ROLE);
        _cTypeHelper = (ContentTypesHelper) manager.lookup(ContentTypesHelper.ROLE);
    }
    
    @Override
    public void dispose()
    {
        _childByContentType.clear();
        _autoReferencingContentTypes.clear();
        _topLevelTypeByLeafType.clear();
    }
    
    /**
     * Register a relation between a parent and its child, and update the internal model if it is a valid one.
     * @param parent The parent content type
     * @param child The child content type
     * @return true if the relation is valid, i.e. in accordance with what was registered before
     */
    public boolean registerRelation(ContentType parent, ContentType child)
    {
        if (parent.equals(child))
        {
            _autoReferencingContentTypes.add(parent);
            if (_childByContentType.containsKey(parent))
            {
                // _topLevelTypeByLeafType does not need to be updated as another content type references it
            }
            else
            {
                // _topLevelTypeByLeafType needs to be updated as no other content type references it
                _topLevelTypeByLeafType.put(parent, parent);
            }
            return true;
        }
        else if (_childByContentType.containsKey(parent))
        {
            getLogger().error("Problem of definition of parent for content type '{}'. Its parent '{}' is already declared by '{}'. A content type cannot have multiple content types as children", child, parent, _childByContentType.get(parent));
            return false;
        }
        else if (_checkNoCycle(parent, child))
        {
            // ok valid
            // update _childByContentType
            _childByContentType.put(parent, child);
            
            // update _topLevelTypeByLeafType
            boolean containsParentAsKey = _topLevelTypeByLeafType.containsKey(parent);
            boolean containsChildAsValue = _topLevelTypeByLeafType.containsValue(child);
            if (containsParentAsKey && containsChildAsValue)
            {
                // is currently something as {parent: other, other2: child}, which means the hierarchy is like: other -> parent -> child -> other2
                // we now want {other2: other}
                ContentType other = _topLevelTypeByLeafType.remove(parent);
                ContentType other2 = _topLevelTypeByLeafType.inverse().get(child);
                _topLevelTypeByLeafType.put(other2, other);
            }
            else if (containsParentAsKey)
            {
                // is currently something as {parent: other}, which means the hierarchy is like: other -> ... -> parent -> child
                // we now want {child: other}
                ContentType other = _topLevelTypeByLeafType.remove(parent);
                _topLevelTypeByLeafType.put(child, other);
            }
            else if (containsChildAsValue)
            {
                // is currently something as {other: child}, which means the hierarchy is like: parent -> child -> ... -> other
                // we now want {other: parent}
                ContentType other = _topLevelTypeByLeafType.inverse().get(child);
                _topLevelTypeByLeafType.put(other, parent);
            }
            else
            {
                _topLevelTypeByLeafType.put(child, parent);
            }
            return true;
        }
        else
        {
            // An error was logged in #_checkNoCycle method
            return false;
        }
    }
    
    /**
     * Returns true if at least one hierarchy was registered (i.e. at least one content type defines a valid "parent" metadata)
     * @return true if at least one hierarchy was registered
     */
    public boolean hasAtLeastOneHierarchy()
    {
        return !_childByContentType.isEmpty() || !_autoReferencingContentTypes.isEmpty();
    }
    
    /**
     * Gets the top level content type for the given leaf content type (which defines the hierarchy)
     * @param leafContentType the leaf cotnent type
     * @return the top level content type for the given leaf content type
     */
    public ContentType getTopLevelType(ContentType leafContentType)
    {
        return _topLevelTypeByLeafType.get(leafContentType);
    }
    
    private boolean _checkNoCycle(ContentType parent, ContentType child)
    {
        // at this stage, parent is not equal to child
        
        Set<ContentType> contentTypesInHierarchy = new HashSet<>();
        contentTypesInHierarchy.add(child);
        contentTypesInHierarchy.add(parent);
        
        ContentType parentContentType = parent;
        
        do
        {
            final ContentType currentContentType = parentContentType;
            parentContentType = Optional.ofNullable(currentContentType)
                                        .flatMap(ContentType::getParentAttributeDefinition)
                                        .map(ModelItem::getModel)
                                        .map(Model::getId)
                                        .map(_contentTypeEP::getExtension)
                                        .filter(par -> !currentContentType.equals(par)) // if current equals to parent, set to null as there will be no cycle
                                        .orElse(null);
            
            if (contentTypesInHierarchy.contains(parentContentType))
            {
                // there is a cycle, log an error and return false
                getLogger().error("Problem of definition of parent for content type {}. It defines a cyclic hierarchy (The following content types are involved: {}).", child, contentTypesInHierarchy);
                return false;
            }
            
            contentTypesInHierarchy.add(parentContentType);
        }
        while (parentContentType != null);
        
        // no cycle, it is ok, return true
        return true;
    }
    
    /**
     * Returns true if the given content type has a child content type
     * @param contentType The content type
     * @return true if the given content type has a child content type
     */
    public boolean hasChildContentType(ContentType contentType)
    {
        return _childByContentType.containsKey(contentType) || _autoReferencingContentTypes.contains(contentType);
    }
    
    /**
     * Returns true if the given content has a hierarchical content type, i.e. is part of a hierarchy
     * @param content The content
     * @return true if the given content is part of a hierarchical reference table
     */
    public boolean isHierarchical(Content content)
    {
        String[] types = content.getTypes();
        for (String type : types)
        {
            ContentType contentType = _contentTypeEP.getExtension(type);
            if (isHierarchical(contentType))
            {
                return true;
            }
        }
        
        return false;
    }
    
    /**
     * Returns true if the given content type is hierarchical, i.e. is part of a hierarchy
     * @param contentType The content type
     * @return true if the given content type is hierarchical, i.e. is part of a hierarchy
     */
    public boolean isHierarchical(ContentType contentType)
    {
        return _childByContentType.containsKey(contentType) || _childByContentType.containsValue(contentType) || _autoReferencingContentTypes.contains(contentType);
    }
    
    /**
     * Returns true if the given content type is a leaf content type
     * @param contentType The content type
     * @return true if the given content type is a leaf content type
     */
    public boolean isLeaf(ContentType contentType)
    {
        return _topLevelTypeByLeafType.containsKey(contentType);
    }
    
    /**
     * Get the hierarchy of content types (distinct content types)
     * @param leafContentTypeId The id of leaf content type
     * @return The content types of hierarchy
     */
    public Set<String> getHierarchicalContentTypes(String leafContentTypeId)
    {
        Set<String> hierarchicalTypes = new LinkedHashSet<>();
        hierarchicalTypes.add(leafContentTypeId);
        BiMap<ContentType, ContentType> parentByContentType = _childByContentType.inverse();
     
        ContentType leafContentType = _contentTypeEP.getExtension(leafContentTypeId);
        
        ContentType parentContentType = parentByContentType.get(leafContentType);
        while (parentContentType != null)
        {
            hierarchicalTypes.add(parentContentType.getId());
            parentContentType = parentByContentType.get(parentContentType);
        }
        return hierarchicalTypes;
    }
    
    /**
     * Get the path of reference table entry in its hierarchy
     * @param refTableEntryId The id of entry
     * @return The path from root parent
     */
    @Callable(rights = Callable.NO_CHECK_REQUIRED) // Used by the HierarchicalReferenceTablesTree
    public Map<String, String> getPathInHierarchy(List<String> refTableEntryId)
    {
        Map<String, String> paths = new HashMap<>();
        
        for (String id : refTableEntryId)
        {
            paths.put(id, getPathInHierarchy(id));
        }
        
        return paths;
    }
    
    /**
     * Get the path of reference table entry in its hierarchy
     * @param refTableEntryId The id of entry
     * @return The path from root parent
     */
    @Callable(rights = Callable.NO_CHECK_REQUIRED) // Used by the HierarchicalReferenceTablesTree
    public String getPathInHierarchy(String refTableEntryId)
    {
        Content refTableEntry = _resolver.resolveById(refTableEntryId);
        List<String> paths = new ArrayList<>();
        paths.add(refTableEntry.getName());
        
        String parentId = getParent(refTableEntry);
        while (parentId != null)
        {
            Content parent = _resolver.resolveById(parentId);
            paths.add(parent.getName());
            parentId = getParent(parent);
        }
        
        Collections.reverse(paths);
        return org.apache.commons.lang3.StringUtils.join(paths, "/");
    }
    
    /**
     * Gets the content types the children of the given content can have.
     * The result can contain 0, 1 or 2 content types
     * @param refTableEntry The content
     * @return the content types the children of the given content can have.
     */
    public List<ContentType> getChildContentTypes(Content refTableEntry)
    {
        List<ContentType> result = new ArrayList<>();
        
        for (String cTypeId : refTableEntry.getTypes())
        {
            ContentType cType = _contentTypeEP.getExtension(cTypeId);
            if (_childByContentType.containsKey(cType))
            {
                result.add(_childByContentType.get(cType));
            }
            if (_autoReferencingContentTypes.contains(cType))
            {
                result.add(cType);
            }
            
            if (!result.isEmpty())
            {
                break;
            }
        }
        
        return result;
    }
    
    /**
     * Get the metadata values of a candidate
     * @param contentId the id of candidate
     * @return the candidate's values
     */
    @Callable(rights = Callable.READ_ACCESS, paramIndex = 0, rightContext = ContentRightAssignmentContext.ID)
    public Map<String, Object> getCandidateValues(String contentId)
    {
        Map<String, Object> values = new HashMap<>();
        
        Content content = _resolver.resolveById(contentId);
        values.put("title", content.getValue(Content.ATTRIBUTE_TITLE));
        values.put("comment", content.getValue("comment"));
        
        return values;
    }
    
    /**
     * Get the parent metadata
     * @param contentId The content id
     * @return the path of parent metadata or null if not found
     */
    @Callable(rights = Callable.NO_CHECK_REQUIRED) // Content type definition are public
    public String getParentAttribute(String contentId)
    {
        Content content = _resolver.resolveById(contentId);
        return getParentAttribute(content);
    }
    
    /**
     * Get the parent metadata
     * @param content The content
     * @return the path of parent metadata or null if not found
     */
    public String getParentAttribute(Content content)
    {
        for (String cTypeId : content.getTypes())
        {
            ContentType cType = _contentTypeEP.getExtension(cTypeId);
            Optional<ContentAttributeDefinition> parentMetadata = cType.getParentAttributeDefinition();
            if (!parentMetadata.isEmpty())
            {
                return parentMetadata.get().getPath();
            }
        }
        
        return null;
    }
    
    /**
     * Returns the "parent" attribute value for the given content, or null if it is not defined for its content types
     * See also {@link ContentType#getParentAttributeDefinition()}
     * @param content The content
     * @return the "parent" attribute value for the given content, or null
     */
    public String getParent(Content content)
    {
        for (String cTypeId : content.getTypes())
        {
            if (!_contentTypeEP.hasExtension(cTypeId))
            {
                getLogger().warn("The content {} ({}) has unknown type '{}'", content.getId(), content.getTitle(), cTypeId);
                continue;
            }
            
            ContentType cType = _contentTypeEP.getExtension(cTypeId);
            Optional<String> contentId = cType.getParentAttributeDefinition()
                .map(ContentAttributeDefinition::getName)
                .filter(name -> content.hasValue(name))
                .map(name -> content.getValue(name))
                .map(value -> ((ContentValue) value).getContentId());
            
            if (!contentId.isEmpty())
            {
                return contentId.get();
            }
        }
        return null;
    }
    
    /**
     * Recursively returns the "parent" metadata value for the given content, i.e; will return the parent, the parent of the parent, etc.
     * @param content The content
     * @return all the parents of the given content
     */
    public List<String> getAllParents(Content content)
    {
        List<String> parents = new ArrayList<>();
        
        Content currentContent = content;
        String parentId = getParent(currentContent);
        
        while (parentId != null)
        {
            if (_resolver.hasAmetysObjectForId(parentId))
            {
                parents.add(parentId);
                currentContent = _resolver.resolveById(parentId);
                parentId = getParent(currentContent);
            }
            else
            {
                break;
            }
        }
        
        return parents;
    }
    
    /**
     * Returns the direct children of a content
     * @param content the content to get the direct children from
     * @return the AmetysObjectIterable of the direct children of the content
     */
    public AmetysObjectIterable<Content> getDirectChildren(Content content)
    {
        List<ContentType> childContentTypes = getChildContentTypes(content);
        
        if (!childContentTypes.isEmpty())
        {
            List<Expression> exprs = new ArrayList<>();
            for (ContentType childContentType : childContentTypes)
            {
                String pointingMetadataName = childContentType.getParentAttributeDefinition()
                        .map(ModelItem::getName)
                        .orElse(StringUtils.EMPTY);
                
                if (StringUtils.isNotEmpty(pointingMetadataName))
                {
                    // //element(*, ametys:content)[@ametys-internal:contentType = 'foo.child.contentType' and @ametys:pointingMetadata = 'contentId']
                    Expression cTypeExpr = new ContentTypeExpression(Operator.EQ, childContentType.getId());
                    Expression parentExpr = new StringExpression(pointingMetadataName, Operator.EQ, content.getId());
                    
                    exprs.add(new AndExpression(cTypeExpr, parentExpr));
                }
            }
            
            Expression finalExpr = new OrExpression(exprs.toArray(new Expression[exprs.size()]));
            
            SortCriteria sortCriteria = new SortCriteria();
            sortCriteria.addCriterion("title", true, true);
            String xPathQuery = ContentQueryHelper.getContentXPathQuery(finalExpr, sortCriteria);
            
            return _resolver.query(xPathQuery);
        }
        
        return new EmptyIterable<>();
    }
    
    /**
     * Returns a Set of all the descendants
     * @param content the content to get the children from
     * @return the Set of children
     */
    public Set<String> getAllChildren(Content content)
    {
        AmetysObjectIterable<Content> directChildren = getDirectChildren(content);
        Set<String> children = new HashSet<>();
        for (Content child : directChildren)
        {
            children.add(child.getId());
            children.addAll(getAllChildren(child));
        }
        return children;
    }
    
    /**
     * Return a boolean value to determine if all the contents are simple
     * @param contentTypeLeaf the contentType id of the leaf content
     * @return true if all the contents in the tree are simple, false otherwise
     */
    @Callable(rights = Callable.NO_CHECK_REQUIRED) // Content type definition are public
    public boolean isHierarchicalSimpleTree(String contentTypeLeaf)
    {
        Set<String> cTypeIds = getHierarchicalContentTypes(contentTypeLeaf);
        for (String cTypeId : cTypeIds)
        {
            ContentType cType = _contentTypeEP.getExtension(cTypeId);
            if (cType != null && !cType.isSimple())
            {
                return false;
            }
        }
        
        return true;
    }
    
    /**
     * Return the contents at the root
     * @param rootContentType the content type of the contents at the root
     * @return the contents at the root
     */
    public AmetysObjectIterable<Content> getRootChildren(ContentType rootContentType)
    {
        return getRootChildren(rootContentType, false);
    }
    
    /**
     * Return the contents at the root
     * @param rootContentType the content type of the contents at the root
     * @param excludeCandidates true to exclude candidates
     * @return the contents at the root
     */
    public AmetysObjectIterable<Content> getRootChildren(ContentType rootContentType, boolean excludeCandidates)
    {
        List<Expression> exprs = new ArrayList<>();
        
        exprs.add(new ContentTypeExpression(Operator.EQ, rootContentType.getId()));
        
        // even if it is the top level type, parent attribute can be not null if it references itself as parent
        rootContentType.getParentAttributeDefinition()
            .filter(attribute -> rootContentType.getId().equals(attribute.getContentTypeId()))
            .ifPresent(attribute -> exprs.add(new OrExpression(
                                                    new NotExpression(new MetadataExpression(attribute.getName())),                 // Search for contents without parent,
                                                    new StringExpression(attribute.getName(), Operator.EQ, StringUtils.EMPTY))));   // or with an empty parent
        
        if (excludeCandidates)
        {
            exprs.add(new NotExpression(new MixinTypeExpression(Operator.EQ, CANDIDATE_CONTENT_TYPE)));
        }
        
        SortCriteria sort = new SortCriteria();
        sort.addCriterion(Content.ATTRIBUTE_TITLE, true, true);
        
        String query = ContentQueryHelper.getContentXPathQuery(new AndExpression(exprs.toArray(new Expression[exprs.size()])), sort);
        return _resolver.query(query);
    }
    
    /**
     * Return the candidates for given content type
     * @param cTypeId the id of content type
     * @return the candidates
     */
    public AmetysObjectIterable<Content> getCandidates(String cTypeId)
    {
        Expression cTypeExpr = new ContentTypeExpression(Operator.EQ, cTypeId);
        Expression candidateExpr = new MixinTypeExpression(Operator.EQ, CANDIDATE_CONTENT_TYPE);
        
        SortCriteria sort = new SortCriteria();
        sort.addCriterion(Content.ATTRIBUTE_TITLE, true, true);
        String query = ContentQueryHelper.getContentXPathQuery(new AndExpression(cTypeExpr, candidateExpr), sort);
        return _resolver.query(query);
    }
    
    /**
     * Get the path of node which match filter regexp
     * @param value the value to match
     * @param contentId the content id from where we will filter
     * @param leafContentType the leaf content type
     * @return the matching paths
     */
    @Callable(rights = Callable.NO_CHECK_REQUIRED) // Used by the HierarchicalReferenceTablesTree
    public List<String> filterReferenceTablesByRegExp (String value, String contentId, String leafContentType)
    {
        List<String> results = new ArrayList<>();
        ContentType topLevelContentType = getTopLevelType(_contentTypeEP.getExtension(leafContentType));
        try (AmetysObjectIterable<Content> contents = "root".equals(contentId) ? getRootChildren(topLevelContentType) : getDirectChildren((Content) _resolver.resolveById(contentId)))
        {
            for (Content content: contents)
            {
                _getMatchingPathsFromContent(content, value, results);
            }
        }
        return results;
    }
    
    private void _getMatchingPathsFromContent(Content parent, String value, List<String> result)
    {
        if (_isMatchingContent(parent, value))
        {
            result.add(getPathInHierarchy(parent.getId()));
        }
        
        AmetysObjectIterable<Content> directChildren = getDirectChildren(parent);
        for (Content child : directChildren)
        {
            _getMatchingPathsFromContent(child, value, result);
        }
    }
    
    /**
     * <code>true</code> if the content match to the filter value
     * @param content the content
     * @param filterValue the filter value
     * @return <code>true</code> if the content match to the filter value
     */
    protected boolean _isMatchingContent(Content content, String filterValue)
    {
        String toMatch = org.ametys.core.util.StringUtils.normalizeStringValue(filterValue).trim();
        
        View view = Optional.ofNullable(_cTypeHelper.getView(SEARCH_FILTERS_VIEW_NAME, content))    // Get view of filter attributes for content
                            .orElseGet(() -> View.of(content.getModel(), Content.ATTRIBUTE_TITLE)); // Get a view with only title if search-filters view doesn't exist
        
        return _getStringValuesToFilter(content, view)                           // Get the string values from the content to filter
                    .stream()
                    .anyMatch(v -> _isValueMatching(v, toMatch));                                   // Test if at least one value matches the filter value
    }
    
    /**
     * Get all string value from the view. This method doesn't handle repeaters.
     * @param dataHolder the data holder to get value
     * @param viewItemAccessor the view item accessor where to search string values
     * @return the list of string values
     */
    protected List<String> _getStringValuesToFilter(ModelAwareDataHolder dataHolder, ViewItemAccessor viewItemAccessor)
    {
        List<String> stringValues = new ArrayList<>();
        
        ViewHelper.visitView(viewItemAccessor,
            (element, definition) -> {
                // simple element
                String name = definition.getName();
                if (dataHolder.hasValue(name))
                {
                    // If an element is also a view item accessor, do not check the element itself but only its children
                    if (element instanceof ViewItemAccessor elementAccessor && !(elementAccessor.getViewItems().isEmpty()))
                    {
                        if (definition.isMultiple())
                        {
                            ModelAwareDataHolder[] elementHolders = dataHolder.getValue(name);
                            for (ModelAwareDataHolder elementHolder : elementHolders)
                            {
                                stringValues.addAll(_getStringValuesToFilter(elementHolder, elementAccessor));
                            }
                        }
                        else
                        {
                            ModelAwareDataHolder elementHolder = dataHolder.getValue(name);
                            stringValues.addAll(_getStringValuesToFilter(elementHolder, elementAccessor));
                        }
                    }
                    else
                    {
                        if (definition.isMultiple())
                        {
                            Arrays.stream((Object[]) dataHolder.getValue(name))
                                  .map(value -> definition.getType().toString(value))
                                  .forEach(stringValues::add);
                        }
                        else
                        {
                            Optional.ofNullable(dataHolder.getValue(name))
                                    .map(value -> definition.getType().toString(value))
                                    .ifPresent(stringValues::add);
                        }
                    }
                }
            },
            (group, definition) -> {
                // composite
                String name = definition.getName();
                ModelAwareComposite composite = dataHolder.getComposite(name);
                if (composite != null)
                {
                    stringValues.addAll(_getStringValuesToFilter(composite, group));
                }
            },
            (group, definition) -> {
                // repeater
                String name = definition.getName();
                ModelAwareRepeater repeater = dataHolder.getRepeater(name);
                if (repeater != null)
                {
                    for (ModelAwareRepeaterEntry entry : repeater.getEntries())
                    {
                        stringValues.addAll(_getStringValuesToFilter(entry, group));
                    }
                }
            },
            group -> stringValues.addAll(_getStringValuesToFilter(dataHolder, group)));
        
        return stringValues;
    }
    
    private boolean _isValueMatching(String value, String toMatch)
    {
        String normalizedValue = org.ametys.core.util.StringUtils.normalizeStringValue(value);
        return normalizedValue.contains(toMatch);
    }
    
    /**
     * Determines if this content type supports candidates
     * @param contentType the content type
     * @return true if the the candidates are allowed, false otherwise
     */
    public boolean supportCandidates(ContentType contentType)
    {
        return contentType.hasTag(TAG_CANDIDATE);
    }
    
    /**
     * Determines if this content type supports candidates
     * @param contentTypeId the id of content type
     * @return true if the the candidates are allowed, false otherwise
     */
    @Callable(rights = Callable.NO_CHECK_REQUIRED) // Content type definition are public
    public boolean supportCandidates(String contentTypeId)
    {
        ContentType contentType = _contentTypeEP.getExtension(contentTypeId);
        return supportCandidates(contentType);
    }
    
    /**
     * Check if the content is a candidate
     * @param content the content to test
     * @return true if the content is a candidate, false otherwise
     */
    public boolean isCandidate(Content content)
    {
        return ArrayUtils.contains(content.getMixinTypes(), CANDIDATE_CONTENT_TYPE);
    }
       
    /**
     * Check if the referencing content is the parent of the content
     * @param referencingContentId The referencing content if to check if it's the parent or not
     * @param content the child content
     * @return true if it's the parent, false otherwise
     */
    protected boolean _isParent(String referencingContentId, Content content)
    {
        return Optional.of(content)
            .map(this::getParentAttribute)
            .map(name -> content.getValue(name))
            .map(ContentValue.class::cast)
            .map(ContentValue::getContentId)
            .map(parent -> referencingContentId.equals(parent))
            .orElse(false);
    }
    
    /**
     * Test if content is referenced by other contents than its parent and children
     * @param content The content to test
     * @param contentsId The list of contents id to delete
     * @return true if content is referenced
     */
    protected boolean _isContentReferenced(Content content, List<String> contentsId)
    {
        return _isContentReferenced(content, contentsId, new HashSet<>());
    }
    
    private boolean _isContentReferenced(Content content, List<String> contentsId, Set<String> alreadyVisited)
    {
        // If the content is not currently calculated or has already been calculated (avoid infinite loop)
        if (alreadyVisited.add(content.getId()))
        {
            // For each referencing content
            for (Content referencingContent : content.getReferencingContents())
            {
                String referencingContentId = referencingContent.getId();
                
                // If parent, content is not really referenced
                if (!_isParent(referencingContentId, content))
                {
                    // If the referencing content will be deleted or is a direct children of the current content (should be in the first list)
                    // Then control if the content is referenced in another way
                    if (contentsId.contains(referencingContentId) || _isParent(content.getId(), referencingContent))
                    {
                        if (_isContentReferenced(referencingContent, contentsId, alreadyVisited))
                        {
                            return true;
                        }
                    }
                    // The referencing content is not planned for deletion then the content is referenced
                    else
                    {
                        return true;
                    }
                }
            }
        }
        
        return false;
    }
}