/*
 *  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.HashMap;
import java.util.Map;
import java.util.Objects;
import java.util.stream.Collectors;

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

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(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 Map<String, Object> buildAsJson() throws QuerySyntaxException
    {
        StringBuilder joinString = new StringBuilder();
        
        boolean first = true;
        for (JoinKey joinKey : _joinKeys)
        {
            if (!first)
            {
                joinString.append("->");
            }
            first = false;
            String path = joinKey.getKey();
            joinString.append(path);
            joinKey.getNestedQuery()
                   .map(LambdaUtils.wrap(q -> q.build()))
                   .filter(StringUtils::isNotBlank)
                   .ifPresent(nq -> joinString.append('[').append(nq).append(']'));
        }
        
        Map<String, Object> joinMap = new HashMap<>();
        
        joinMap.put("join", joinString.toString());
        
        if (_subQuery != null)
        {
            joinMap.put("q", _subQuery.buildAsJson());
        }
        
        return Map.of("ametys", joinMap);
    }
    
    @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()
    {
        return Objects.hash(_joinKeys, _subQuery);
    }

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