/*
 *  Copyright 2016 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 java.util.Collection;
import java.util.stream.Collectors;

import org.apache.commons.lang3.StringUtils;
import org.apache.solr.client.solrj.util.ClientUtils;

import org.ametys.cms.content.indexing.solr.SolrFieldHelper;
import org.ametys.cms.search.query.join.JoinKey;
import org.ametys.cms.search.solr.schema.SchemaHelper;
import org.ametys.core.util.LambdaUtils;

/**
 * Represents a {@link Query} on a joined document.
 */
public class JoinQuery implements Query
{
    
    /** The field path. */
    protected Query _subQuery;
    
    /** The join keys (paths and optional nested queries) */
    protected Collection<JoinKey> _joinKeys;
    
    /**
     * Build a join query.
     * @param subQuery The sub query.
     * @param joinPaths The field's join paths
     */
    public JoinQuery(Query subQuery, String... joinPaths)
    {
        this(subQuery, Arrays.asList(joinPaths));
    }
    
    /**
     * Build a join query.
     * @param subQuery The sub query.
     * @param joinPaths The field's join paths
     */
    public JoinQuery(Query subQuery, Collection<String> joinPaths)
    {
        this(joinPaths.stream().map(jp -> new JoinKey(jp, null)).collect(Collectors.toList()));
        _subQuery = subQuery;
    }
    
    /**
     * Build a join query.
     * @param joinKeys The join paths and optional nested queries
     */
    public JoinQuery(JoinKey... joinKeys)
    {
        this(Arrays.asList(joinKeys));
    }
    
    /**
     * Build a join query.
     * @param joinKeys The join paths and optional nested queries
     */
    public JoinQuery(Collection<JoinKey> joinKeys)
    {
        _joinKeys = joinKeys;
        _checkValidPathNames();
        _checkJoinParams();
    }
    
    private void _checkValidPathNames()
    {
        for (JoinKey joinKey : _joinKeys)
        {
            String path = joinKey.getKey();
            if (!SchemaHelper.isNameValid(path))
            {
                throw new IllegalArgumentException("Invalid path name '" + path + "' in join.");
            }
        }
    }
    
    private void _checkJoinParams()
    {
        if (_subQuery == null && _joinKeys.isEmpty())
        {
            throw new IllegalArgumentException("The join path is empty and there is no subquery in JoinQuery.");
        }
    }
    
    @Override
    public String build() throws QuerySyntaxException
    {
        StringBuilder queryString = new StringBuilder();
        
        queryString.append("{!ametys join=\"");
        boolean first = true;
        for (JoinKey joinKey : _joinKeys)
        {
            if (!first)
            {
                queryString.append("->");
            }
            first = false;
            String path = joinKey.getKey();
            queryString.append(SolrFieldHelper.getJoinFieldName(path));
            joinKey.getNestedQuery()
                   .map(LambdaUtils.wrap(this::_buildQuery))
                   .filter(StringUtils::isNotBlank)
                   .ifPresent(nq -> queryString.append('[').append(nq).append(']'));
        }
        queryString.append('"');
        
        if (_subQuery != null)
        {
            String subQuery = _buildQuery(_subQuery);
            queryString.append(" q=\"")
                       .append(subQuery)
                       .append('"');
        }
        
        queryString.append('}');
        
        return queryString.toString();
    }
    
    private String _buildQuery(Query query) throws QuerySyntaxException
    {
        return ClientUtils.escapeQueryChars(query.build());
    }
    
    @Override
    public String toString(int indent)
    {
        final String joinLineIndent = StringUtils.repeat(' ', indent);
        final int subIndent = indent + 2;
        final String subLineIndent = StringUtils.repeat(' ', subIndent);
        final String join = subLineIndent + "[PATH]" + _joinKeys
                .stream()
                .map(JoinKey::toString)
                .collect(Collectors.joining("->"))
            + "[/PATH]";
        final String subq = subLineIndent + "[Q]" + (_subQuery == null ? String.valueOf(_subQuery) : ("\n" + _subQuery.toString(subIndent + 2) + "\n" + subLineIndent)) + "[/Q]";
        return joinLineIndent + "[JOIN]\n" + join + "\n" + subq + "\n" + joinLineIndent + "[/JOIN]";
    }

    @Override
    public int hashCode()
    {
        final int prime = 31;
        int result = 1;
        result = prime * result + ((_joinKeys == null) ? 0 : _joinKeys.hashCode());
        result = prime * result + ((_subQuery == null) ? 0 : _subQuery.hashCode());
        return result;
    }

    @Override
    public boolean equals(Object obj)
    {
        if (this == obj)
        {
            return true;
        }
        if (obj == null)
        {
            return false;
        }
        if (getClass() != obj.getClass())
        {
            return false;
        }
        JoinQuery other = (JoinQuery) obj;
        if (_joinKeys == null)
        {
            if (other._joinKeys != null)
            {
                return false;
            }
        }
        else if (!_joinKeys.equals(other._joinKeys))
        {
            return false;
        }
        if (_subQuery == null)
        {
            if (other._subQuery != null)
            {
                return false;
            }
        }
        else if (!_subQuery.equals(other._subQuery))
        {
            return false;
        }
        return true;
    }
}