/*
 *  Copyright 2018 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.search.query;

import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Objects;
import java.util.Set;

import org.apache.solr.client.solrj.util.ClientUtils;

import org.ametys.cms.content.ContentHelper;
import org.ametys.cms.content.referencetable.HierarchicalReferenceTablesHelper;
import org.ametys.cms.content.referencetable.search.ParentContentSearchField;
import org.ametys.cms.repository.Content;
import org.ametys.plugins.repository.AmetysObjectResolver;

/**
 * Represents a {@link Query} testing a content field.
 */
public class ContentQuery extends AbstractFieldQuery
{
    /** The value to test. */
    protected Object _value;
    /** The operator */
    protected Operator _operator;
    /** The resolver to resolve the results. */
    protected AmetysObjectResolver _resolver;
    /** The extension point. */
    protected ContentHelper _contentHelper;
    /** <code>true</code> if the query should be executed with an AndQuery. */
    protected boolean _isAndMultipleOperand;
    /** The helper to resolve the reference tables. */
    protected HierarchicalReferenceTablesHelper _refTableHelper;
    /** <code>true</code> if the query should be executed by resolving the children. */
    protected boolean _resolveChildren;

    /**
     * Build a content query.
     * @param fieldPath the field's path
     * @param operator the operator
     * @param value the value
     * @param resolver the resolver
     * @param contentHelper the content helper
     */
    public ContentQuery(String fieldPath, Operator operator, Object value, AmetysObjectResolver resolver, ContentHelper contentHelper)
    {

        this(fieldPath, operator, value, resolver, contentHelper, false);
    }
    
    /**
     * Build a content query by testing the operand.
     * @param fieldPath the field's path
     * @param operator the operator
     * @param value the value
     * @param resolver the resolver
     * @param contentHelper the content helper
     * @param isAndMultipleOperand 'true' to execute an AndQuery, OrQuery otherwise 
     */
    public ContentQuery(String fieldPath, Operator operator, Object value, AmetysObjectResolver resolver, ContentHelper contentHelper, boolean isAndMultipleOperand)
    {
        this(fieldPath, operator, value, resolver, contentHelper, null, false, isAndMultipleOperand);
    }
    
    /**
     * Build a content query by testing if the ancestors should be resolved.
     * @param fieldPath the field's path
     * @param operator the operator
     * @param value the value
     * @param resolver the resolver
     * @param contentHelper the content helper
     * @param refTableHelper The helper to resolve the ancestors
     * @param resolveChildren 'true' to execute an OrQuery on the ancestors and itself, 'false' will execute a join request
     */
    public ContentQuery(String fieldPath, Operator operator, Object value, AmetysObjectResolver resolver, ContentHelper contentHelper, HierarchicalReferenceTablesHelper refTableHelper, boolean resolveChildren)
    {
        this(fieldPath, operator, value, resolver, contentHelper, refTableHelper, resolveChildren, false);
    }
    
    /**
     * Build a content query by testing the operand and if the ancestors should be resolved.
     * @param fieldPath the field's path
     * @param operator The operator. Only {@link Query.Operator#EQ} and {@link Query.Operator#NE} are allowed.
     * @param value the value
     * @param resolver the resolver
     * @param contentHelper the content helper
     * @param refTableHelper The helper to resolve the ancestors
     * @param resolveChildren 'true' to execute an OrQuery on the ancestors and itself, 'false' will execute a join request
     * @param isAndMultipleOperand 'true' to execute an AndQuery, OrQuery otherwise
     */
    public ContentQuery(String fieldPath, Operator operator, Object value, AmetysObjectResolver resolver, ContentHelper contentHelper, HierarchicalReferenceTablesHelper refTableHelper, boolean resolveChildren, boolean isAndMultipleOperand)
    {
        super(fieldPath);
        if (Operator.EQ != operator && Operator.NE != operator && Operator.EXISTS != operator)
        {
            throw new IllegalArgumentException("Test operator '" + operator + "' can't be used for a content query.");
        }
        
        this._value = value;
        this._operator = operator;
        this._resolver = resolver;
        this._contentHelper = contentHelper;
        this._refTableHelper = refTableHelper;
        this._resolveChildren = resolveChildren;
        this._isAndMultipleOperand = isAndMultipleOperand;
    }


    /**
     * Get the value.
     * @return the value
     */
    public Object getValue()
    {
        return this._value;
    }
    
    @SuppressWarnings("unchecked")
    public String build() throws QuerySyntaxException
    {
        if (_operator == Operator.EXISTS)
        {
            StringBuilder query = new StringBuilder();
            query.append(_fieldPath).append("_s:").append(QueryHelper.EXISTS_VALUE);
            return query.toString();
        }
        
        if (_value instanceof Map<?, ?>)
        {
            Map<String, Object> mapValues = (Map<String, Object>) this._value;
            Object values = mapValues.get("value");
            boolean autoposting = (boolean) mapValues.get("autoposting");
            if (autoposting)
            {
                if (_resolveChildren)
                {
                    Query query = null;
                    if (values instanceof Collection<?>)
                    {
                        query = _getChildrenOrSelfQuery((Collection<String>) values, _operator);
                    }
                    else
                    {
                        query = _getChildrenOrSelfQuery(Collections.singletonList((String) values), _operator);
                    }
                    
                    return query.build();
                }
                else
                {
                    Query subQuery = null;
                    if (values instanceof Collection<?>)
                    {
                        subQuery = _createRefParentsQuery((Collection<String>) values, _operator);
                    }
                    else
                    {
                        subQuery = _createRefParentsQuery(Collections.singletonList((String) values), _operator);
                    }
                    
                    Query joinQuery = new JoinQuery(subQuery, _fieldPath);
                    return joinQuery.build();
                }
                
            }
            else
            {
                Query query = _createQueryString(values, _operator);
                return query.build();
            }
        }
        else 
        {
            Query query = _createQueryString(_value, _operator);
            return query.build();
        }
    }
    
    private Query _getChildrenOrSelfQuery(Collection<String> values, Operator operator)
    {
        List<Query> queries = new ArrayList<>();
        
        if (_isAndMultipleOperand)
        {
            for (String value: values)
            {
                Set<String> childrenAndSelf = _getChildrenOrSelf(value);
                
                List<Query> subQueries = new ArrayList<>();
                for (String id : childrenAndSelf)
                {
                    subQueries.add(_createQueryString(id, operator));
                }
                
                queries.add(new OrQuery(subQueries));
            }
            
            return new AndQuery(queries);
        }
        else
        {
            Set<String> allChildrenAndSelf = new HashSet<>();
            for (String value: values)
            {
                allChildrenAndSelf.addAll(_getChildrenOrSelf(value));
            }
            
            List<Query> subQueries = new ArrayList<>();
            for (String id : allChildrenAndSelf)
            {
                subQueries.add(_createQueryString(id, operator));
            }
            
            return new OrQuery(subQueries);
        }
    }
    
    private Set<String> _getChildrenOrSelf(String id)
    {
        Content content = _resolver.resolveById(id);
        
        Set<String> childrenOrSelf = new HashSet<>();
        childrenOrSelf.add(id);
        if (_contentHelper.isReferenceTable(content) && _refTableHelper.isHierarchical(content))
        {
            childrenOrSelf.addAll(_refTableHelper.getAllChildren(content));
        }
        
        return childrenOrSelf;
    }
    
    private Query _createQueryString(Object value, Operator operator)
    {
        String fieldPath = getFieldPath();
        
        if (value instanceof Collection<?>)
        {
            @SuppressWarnings("unchecked")
            List<String> stringValues = (List<String>) value;
            
            List<Query> queries = new ArrayList<>();
            for (String val : stringValues)
            {
                queries.add(new StringQuery(fieldPath, operator, val, null));
            }
  
            return _isAndMultipleOperand ? new AndQuery(queries) : new OrQuery(queries);
        }
        else
        {
            return new StringQuery(fieldPath, operator, (String) value, null);
        }
    }
    
    /**
     * Create a subQuery in order to create the join query
     * @param values the values to add in the query
     * @param operator the operator
     * @return The non-null query 
     */
    private Query _createRefParentsQuery(Collection<String> values, Operator operator)
    {
        List<Query> queries = new ArrayList<>();
        for (String val: values)
        {
            queries.add(() -> 
            {
                StringBuilder q = new StringBuilder();
                if (Operator.NE == operator)
                {
                    NotQuery.appendNegation(q).append('(');
                }
                q.append(ParentContentSearchField.NAME).append(":").append(ClientUtils.escapeQueryChars(val));
                if (Operator.NE == operator)
                {
                    q.append(')');
                }
                return q.toString();
            });
        }
        
        if (queries.size() == 1)
        {
            return queries.get(0);
        }
        else
        {
            return _isAndMultipleOperand ? new AndQuery(queries) : new OrQuery(queries);
        }
    }

    @Override
    public int hashCode()
    {
        final int prime = 31;
        int result = super.hashCode();
        result = prime * result + Objects.hash(_isAndMultipleOperand, _operator, _resolveChildren, _value);
        return result;
    }

    @Override
    public boolean equals(Object obj)
    {
        if (this == obj)
        {
            return true;
        }
        if (!super.equals(obj))
        {
            return false;
        }
        if (getClass() != obj.getClass())
        {
            return false;
        }
        ContentQuery other = (ContentQuery) obj;
        return _isAndMultipleOperand == other._isAndMultipleOperand && _operator == other._operator && _resolveChildren == other._resolveChildren && Objects.equals(_value, other._value);
    }
}