/*
 *  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.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Objects;
import java.util.Optional;
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 List<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, List<String> joinPaths)
    {
        this(subQuery, joinPaths.stream().map(jp -> new JoinKey(jp)).toArray(JoinKey[]::new));
    }
    
    /**
     * Build a join query.
     * @param joinKeys The join paths and optional nested queries
     */
    public JoinQuery(JoinKey... joinKeys)
    {
        this(null, joinKeys);
    }
    
    /**
     * Build a join query.
     * @param subQuery The sub query.
     * @param joinKeys The join paths and optional nested queries
     */
    public JoinQuery(Query subQuery, JoinKey... joinKeys)
    {
        _subQuery = subQuery;
        _joinKeys = Arrays.asList(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.");
        }
        
        if (!_joinKeys.isEmpty() && _joinKeys.get(_joinKeys.size() - 1).getNestedQuery().isPresent() && _subQuery != null)
        {
            throw new IllegalArgumentException("The JoinQuery may either contain a subQuery or a nested query on the last JoinKey, not both.");
        }
    }
    
    @Override
    public String build() throws QuerySyntaxException
    {
        StringBuilder queryString = new StringBuilder();
        
        queryString.append("{!ametys join=\"")
                   .append(_joinKeys.stream()
                                    .map(LambdaUtils.wrap(k -> k.build(true)))
                                    .collect(Collectors.joining("->")))
                   .append('"');
        
        if (_subQuery != null)
        {
            String subQuery = ClientUtils.escapeQueryChars(_subQuery.build());
            queryString.append(" q=\"")
                       .append(subQuery)
                       .append('"');
        }
        
        queryString.append('}');
        
        return queryString.toString();
    }
    
    @Override
    public Optional<Object> buildAsJson() throws QuerySyntaxException
    {
        Map<String, Object> joinMap = new HashMap<>();
        
        joinMap.put("join", _joinKeys.stream()
                                     .map(LambdaUtils.wrap(k -> k.build(false)))
                                     .collect(Collectors.joining("->")));
        
        if (_subQuery != null)
        {
            Optional<Object> subQueryAsJson = _subQuery.buildAsJson();
            if (subQueryAsJson.isPresent())
            {
                joinMap.put("q", subQueryAsJson.get());
            }
        }
        
        return Optional.of(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);
    }
}