/*
 *  Copyright 2015 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.Arrays;

import org.ametys.cms.content.indexing.solr.SolrFieldNames;


/**
 * Represents a {@link Query} testing if an object possesses one or more tags.
 */
public class TagQuery implements Query
{
    
    private Operator _operator;
    private String[] _values;
    private LogicalOperator _logicalOperator;
    private boolean _descendantAutoposting;
    
    /**
     * Build a TagQuery.
     * @param value the tag id to test.
     */
    public TagQuery(String value)
    {
        this(new String[] {value});
    }
    
    /**
     * Build a TagQuery.
     * @param values the tag IDs to test.
     */
    public TagQuery(String... values)
    {
        this(Operator.EQ, values);
    }
    
    /**
     * Build a TagQuery.
     * @param operator the operator.
     * @param value the tag id to test.
     */
    public TagQuery(Operator operator, String value)
    {
        this(operator, new String[] {value});
    }
    
    /**
     * Build a TagQuery.
     * @param operator the operator.
     * @param values the tag IDs to test.
     */
    public TagQuery(Operator operator, String... values)
    {
        this(operator, false, values);
    }
    
    /**
     * Build a TagQuery.
     * @param operator the operator.
     * @param descendantAutoposting true to enable descendant autoposting (parent tags are found), false otherwise.
     * @param value the tag id to test.
     */
    public TagQuery(Operator operator, boolean descendantAutoposting, String value)
    {
        this(operator, descendantAutoposting, new String[] {value});
    }
    
    /**
     * Build a TagQuery.
     * @param operator the operator.
     * @param descendantAutoposting true to enable descendant autoposting (parent tags are found), false otherwise.
     * @param values the tag IDs to test.
     */
    public TagQuery(Operator operator, boolean descendantAutoposting, String... values)
    {
        this(operator, descendantAutoposting, LogicalOperator.OR, values);
    }
    
    /**
     * Build a TagQuery.
     * @param operator the operator. The operator is applied to each value individually. 
     * For instance, if operator is {@link Query.Operator#NE NE} and logicalOperator is
     * {@link Query.LogicalOperator#OR OR}, then the Query represents: <code>(NOT A) OR (NOT B) ...</code>
     * @param descendantAutoposting true to enable descendant autoposting (parent tags are found), false otherwise.
     * @param logicalOperator the logical operator.
     * @param values the tag IDs to test.
     */
    public TagQuery(Operator operator, boolean descendantAutoposting, LogicalOperator logicalOperator, String... values)
    {
        if (Operator.EQ != operator && Operator.NE != operator && Operator.EXISTS != operator)
        {
            throw new IllegalArgumentException("Test operator '" + operator + "' can't be used for a tag query.");
        }
        
        _operator = operator;
        _logicalOperator = logicalOperator;
        _values = values;
        _descendantAutoposting = descendantAutoposting;
    }

    /**
     * Get the operator.
     * @return the operator
     */
    public Operator getOperator()
    {
        return _operator;
    }

    /**
     * Get the values.
     * @return the values
     */
    public String[] getValues()
    {
        return _values;
    }

    /**
     * Get the logicalOperator.
     * @return the logicalOperator
     */
    public LogicalOperator getLogicalOperator()
    {
        return _logicalOperator;
    }
    
    @Override
    public String build() throws QuerySyntaxException
    {
        StringBuilder query = new StringBuilder();

        if (_operator == Operator.EXISTS)
        {
            query.append(SolrFieldNames.ALL_TAGS).append(":").append(QueryHelper.EXISTS_VALUE);
            
            return query.toString();
        }
        
        if (_values.length > 0)
        {
            for (int i = 0; i < _values.length; i++)
            {
                if (i > 0)
                {
                    query.append(' ').append(_logicalOperator).append(' ');
                }
                if (_values.length > 1)
                {
                    query.append('(');
                }
                
                if (_operator == Operator.NE)
                {
                    NotQuery.appendNegation(query);
                }
                
                query.append(_descendantAutoposting ? SolrFieldNames.ALL_TAGS : SolrFieldNames.TAGS)
                    .append(':').append(_values[i]);
                
                if (_values.length > 1)
                {
                    query.append(')');
                }
            }
        }
        
        return query.toString();
    }

    @Override
    public int hashCode()
    {
        final int prime = 31;
        int result = 1;
        result = prime * result + (_descendantAutoposting ? 1231 : 1237);
        result = prime * result + ((_logicalOperator == null) ? 0 : _logicalOperator.hashCode());
        result = prime * result + ((_operator == null) ? 0 : _operator.hashCode());
        result = prime * result + Arrays.hashCode(_values);
        return result;
    }

    @Override
    public boolean equals(Object obj)
    {
        if (this == obj)
        {
            return true;
        }
        if (obj == null)
        {
            return false;
        }
        if (getClass() != obj.getClass())
        {
            return false;
        }
        TagQuery other = (TagQuery) obj;
        if (_descendantAutoposting != other._descendantAutoposting)
        {
            return false;
        }
        if (_logicalOperator != other._logicalOperator)
        {
            return false;
        }
        if (_operator != other._operator)
        {
            return false;
        }
        if (!Arrays.equals(_values, other._values))
        {
            return false;
        }
        return true;
    }
}