/*
 *  Copyright 2017 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.plugins.extraction.component;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import java.util.HashSet;
import java.util.LinkedHashSet;
import java.util.List;
import java.util.Locale;
import java.util.Map;
import java.util.Set;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import java.util.stream.Collectors;

import org.apache.avalon.framework.configuration.Configuration;
import org.apache.avalon.framework.configuration.ConfigurationException;
import org.apache.avalon.framework.service.ServiceException;
import org.apache.avalon.framework.service.ServiceManager;
import org.xml.sax.ContentHandler;

import org.ametys.cms.content.ContentHelper;
import org.ametys.cms.contenttype.ContentConstants;
import org.ametys.cms.contenttype.ContentType;
import org.ametys.cms.contenttype.MetadataDefinition;
import org.ametys.cms.contenttype.MetadataType;
import org.ametys.cms.repository.Content;
import org.ametys.cms.search.GetQueryFromJSONHelper;
import org.ametys.cms.search.QueryBuilder;
import org.ametys.cms.search.content.ContentSearcherFactory;
import org.ametys.cms.search.content.ContentSearcherFactory.SimpleContentSearcher;
import org.ametys.cms.search.model.SystemProperty;
import org.ametys.cms.search.model.SystemPropertyExtensionPoint;
import org.ametys.cms.search.query.Query.Operator;
import org.ametys.cms.search.query.QuerySyntaxException;
import org.ametys.cms.search.query.StringQuery;
import org.ametys.cms.search.solr.SolrQuerySearchAction;
import org.ametys.cms.search.ui.model.SearchUIModel;
import org.ametys.core.util.JSONUtils;
import org.ametys.core.util.LambdaUtils;
import org.ametys.core.util.StringUtils;
import org.ametys.plugins.extraction.execution.ExtractionExecutionContext;
import org.ametys.plugins.extraction.execution.ExtractionExecutionContextHierarchyElement;
import org.ametys.plugins.queriesdirectory.Query;
import org.ametys.plugins.repository.AmetysObjectIterable;
import org.ametys.plugins.repository.AmetysObjectResolver;
import org.ametys.plugins.repository.EmptyIterable;
import org.ametys.plugins.thesaurus.ThesaurusDAO;

/**
 * This class represents an extraction component with a solr query
 */
public abstract class AbstractSolrExtractionComponent extends AbstractExtractionComponent
{
    /**
     * Regex used to extract variables from a join expression: \$\{(\.\.(?:\/\.\.)*(?:\/[^\/}]+)?)\}
     * a variable is inside a ${}
     * variable starts with .. (to get the direct parent),
     * has several /.. (to get parent of parent of (...))
     * and can have a /metadataName (to specify the metadata to join on)
     */
    private static final String EXTRACT_JOIN_VARIABLES_REGEX = "\\$\\{(\\.\\.(?:\\/\\.\\.)*(?:\\/[^\\/}]+)?)\\}";
    
    /** Content types concerned by the solr search */
    protected Set<String> _contentTypes = new HashSet<>();
    
    /** Reference id of a recorded query */
    protected String _queryReferenceId;
    
    /** The list of clauses */
    protected List<ExtractionClause> _clauses = new ArrayList<>();
    
    /** Helper to resolve referenced query infos */
    protected GetQueryFromJSONHelper _getQueryFromJSONHelper;
    
    /** Util class to manipulate JSON String */
    protected JSONUtils _jsonUtils;
    
    private AmetysObjectResolver _resolver;
    private SystemPropertyExtensionPoint _systemPropertyExtensionPoint;
    private ContentHelper _contentHelper;
    private ContentSearcherFactory _contentSearcherFactory;
    private QueryBuilder _queryBuilder;
    
    @Override
    public void service(ServiceManager serviceManager) throws ServiceException
    {
        super.service(serviceManager);
        _jsonUtils = (JSONUtils) serviceManager.lookup(JSONUtils.ROLE);
        _getQueryFromJSONHelper = (GetQueryFromJSONHelper) serviceManager.lookup(GetQueryFromJSONHelper.ROLE);
        _resolver = (AmetysObjectResolver) serviceManager.lookup(AmetysObjectResolver.ROLE);
        _systemPropertyExtensionPoint = (SystemPropertyExtensionPoint) serviceManager.lookup(SystemPropertyExtensionPoint.ROLE);
        _contentHelper = (ContentHelper) serviceManager.lookup(ContentHelper.ROLE);
        _contentSearcherFactory = (ContentSearcherFactory) serviceManager.lookup(ContentSearcherFactory.ROLE);
        _queryBuilder = (QueryBuilder) serviceManager.lookup(QueryBuilder.ROLE);
    }
    
    @Override
    public void configure(Configuration configuration) throws ConfigurationException
    {
        super.configure(configuration);
        
        Configuration clauses = configuration.getChild("clauses");
        for (Configuration clause : clauses.getChildren("clause"))
        {
            addClauses(clause.getValue());
        }

        _contentTypes = new HashSet<>();
        if (Arrays.asList(configuration.getAttributeNames()).contains("ref"))
        {
            if (Arrays.asList(configuration.getAttributeNames()).contains("contentTypes"))
            {
                throw new IllegalArgumentException(getLogsPrefix() + "a component with a query reference should not specify a content type");
            }
            
            _queryReferenceId = configuration.getAttribute("ref");
        }
        else
        {
            String contentTypesString = configuration.getAttribute("contentTypes");
            _contentTypes.addAll(StringUtils.stringToCollection(contentTypesString));
        }
    }
    
    @Override
    public void prepareComponentExecution(ExtractionExecutionContext context) throws Exception
    {
        super.prepareComponentExecution(context);
        
        if (_queryReferenceId != null && !_queryReferenceId.isEmpty())
        {
            Query referencedQuery = _resolver.resolveById(_queryReferenceId);
            computeReferencedQueryInfos(referencedQuery.getContent());
        }
        
        _computeClausesInfos(context);
    }

    /**
     * Manages the stored query referenced by the component
     * @param refQueryContent referenced query content
     * @throws QuerySyntaxException if there is a syntax error in the referenced query
     */
    @SuppressWarnings("unchecked")
    protected void computeReferencedQueryInfos(String refQueryContent) throws QuerySyntaxException
    {
        Map<String, Object> contentMap = _jsonUtils.convertJsonToMap(refQueryContent);
        Map<String, Object> exportParams = (Map<String, Object>) contentMap.get("exportParams");
        String modelId = (String) exportParams.get("model");
        
        String q;
        if (modelId.contains("solr"))
        {
            Map<String, Object> values = (Map<String, Object>) exportParams.get("values");
            String baseQuery = (String) values.get("query");
            
            _contentTypes = new HashSet<>((List<String>) values.get("contentTypes"));
            
            q = SolrQuerySearchAction.buildQuery(_queryBuilder, baseQuery, _contentTypes, Collections.emptySet());
        }
        else
        {
            SearchUIModel model = _getQueryFromJSONHelper.getSearchUIModel(exportParams);
            List<String> contentTypesToFill = new ArrayList<>();
            org.ametys.cms.search.query.Query query = _getQueryFromJSONHelper.getQueryFromModel(model, exportParams, contentTypesToFill);
            
            q = query.build();
            _contentTypes = new HashSet<>(contentTypesToFill);
        }
        
        ExtractionClause clause = new ExtractionClause();
        clause.setExpression(q);
        _clauses.add(0, clause);
    }

    private void _computeClausesInfos(ExtractionExecutionContext context)
    {
        for (ExtractionClause clause : _clauses)
        {
            String clauseExpression = clause.getExpression();
            clause.setExpression(_resolveExpression(clauseExpression, context.getClauseVariables()));
            
            List<ExtractionClauseGroup> groups = _extractGroupExpressionsFromClause(clauseExpression);
            if (!groups.isEmpty())
            {
                Collection<String> groupExpressions = groups.stream()
                        .map(ExtractionClauseGroup::getCompleteExpression)
                        .collect(Collectors.toList());
                if (_hasVariablesOutsideGroups(clauseExpression, groupExpressions))
                {
                    throw new IllegalArgumentException(getLogsPrefix() + "if there's at least one group, every variable should be in a group.");
                }
            }
            else
            {
                // The only group is the entire expression
                // The complete expression is the same as the classic one (there is no characters used to identify the group)
                ExtractionClauseGroup group = new ExtractionClauseGroup();
                group.setCompleteExpression(clauseExpression);
                group.setExpression(clauseExpression);
                groups.add(group);
            }
            
            for (ExtractionClauseGroup group : groups)
            {
                Set<String> variables = new HashSet<>(_extractVariableFromClauseExpression(group.getExpression()));
                if (!variables.isEmpty())
                {
                    if (variables.size() > 1)
                    {
                        throw new IllegalArgumentException(getLogsPrefix() + "only variables with same name are allowed within a single group");
                    }
                    
                    for (String variable : variables)
                    {
                        String[] pathSegments = variable.split(JOIN_HIERARCHY_SEPARATOR);
                        String fieldPath = pathSegments[pathSegments.length - 1];
    
                        group.setVariable(variable);
                        group.setFieldPath(fieldPath);
                    }
                }
                
                clause.addGroup(group);
            }
        }
    }
    
    private String _resolveExpression(String expression, Map<String, String> queryVariables)
    {
        String resolvedExpression = expression;
        for (Map.Entry<String, String> entry : queryVariables.entrySet())
        {
            String variableName = entry.getKey();
            String contentId = entry.getValue();
            String escapedContentId = StringQuery.escapeStringValue(contentId, Operator.EQ);
            resolvedExpression = resolvedExpression.replace("${" + variableName + "}", escapedContentId);
        }
        
        return resolvedExpression;
    }
    
    private boolean _hasVariablesOutsideGroups(String clauseExpression, Collection<String> groupExpressions)
    {
        List<String> variablesInClause = _extractVariableFromClauseExpression(clauseExpression);
        List<String> variablesInGroups = new ArrayList<>();
        for (String groupExpression : groupExpressions)
        {
            variablesInGroups.addAll(_extractVariableFromClauseExpression(groupExpression));
        }
        return variablesInClause.size() > variablesInGroups.size();
    }

    List<ExtractionClauseGroup> _extractGroupExpressionsFromClause(String expression)
    {
        List<ExtractionClauseGroup> groupExpressions = new ArrayList<>();
        int indexOfGroup = expression.indexOf("#{");
        while (indexOfGroup != -1)
        {
            StringBuilder currentGroupSb = new StringBuilder();
            int endIndex = indexOfGroup;
            int braceLevel = 0;
            for (int i = indexOfGroup + 2; i < expression.length(); i++)
            {
                endIndex = i;
                char currentChar = expression.charAt(i);
                if ('{' == currentChar)
                {
                    braceLevel++;
                }
                else if ('}' == currentChar)
                {
                    if (0  == braceLevel)
                    {
                        ExtractionClauseGroup group = new ExtractionClauseGroup();
                        String currentGroup = currentGroupSb.toString();
                        group.setCompleteExpression("#{" + currentGroup + "}");
                        group.setExpression(currentGroup);
                        groupExpressions.add(group);
                        break;
                    }
                    braceLevel--;
                }
                currentGroupSb.append(currentChar);
            }
            
            indexOfGroup = expression.indexOf("#{", endIndex);
        }
        return groupExpressions;
    }

    List<String> _extractVariableFromClauseExpression(String expression)
    {
        List<String> variables = new ArrayList<>();
        
        Pattern pattern = Pattern.compile(EXTRACT_JOIN_VARIABLES_REGEX);
        Matcher matcher = pattern.matcher(expression);
        
        while (matcher.find())
        {
            variables.add(matcher.group(1));
        }
        
        return variables;
    }

    @Override
    public void executeComponent(ContentHandler contentHandler, ExtractionExecutionContext context) throws Exception
    {
        Iterable<Content> contents = getContents(context);
        if (contents.iterator().hasNext())
        {
            processContents(contents, contentHandler, context);
        }
    }
    
    List<String> _getClauseQueries(ExtractionExecutionContext context)
    {
        List<String> clauseQueries = new ArrayList<>();
        
        for (ExtractionClause clause : _clauses)
        {
            String expression = clause.getExpression();
            
            for (ExtractionClauseGroup group : clause.getGroups())
            {
                String variable = group.getVariable();
                
                if (variable != null && !variable.isEmpty())
                {
                    ExtractionExecutionContextHierarchyElement currentContextHierarchyElement = _getCurrentContextElementFromVariable(variable, context.getHierarchyElements());
                    
                    String fieldPath = group.getFieldPath();
                    
                    ExtractionComponent contextComponent = currentContextHierarchyElement.getComponent();
                    MetadataType metadataType = _getMetadataType(fieldPath, contextComponent.getContentTypes());
                    Collection<Object> values = _getValuesFromVariable(fieldPath, metadataType, currentContextHierarchyElement, context.getDefaultLocale());
                    
                    if (values.isEmpty())
                    {
                        getLogger().warn(getLogsPrefix() + "no value found for field '" + fieldPath + "'. The query of this component can't be achieved");
                        return null;
                    }
                    
                    Collection<String> groupExpressions = new ArrayList<>();
                    for (Object value : values)
                    {
                        String valueAsString = _getValueAsString(value, metadataType, fieldPath);
                        groupExpressions.add(group.getExpression().replace("${" + variable + "}", valueAsString));
                    }
                    
                    String groupReplacement =  org.apache.commons.lang3.StringUtils.join(groupExpressions, " OR ");
                    expression = expression.replace(group.getCompleteExpression(), "(" + groupReplacement + ")");
                }
            }
            
            clauseQueries.add(expression);
        }
        
        return clauseQueries;
    }

    private ExtractionExecutionContextHierarchyElement _getCurrentContextElementFromVariable(String variable, List<ExtractionExecutionContextHierarchyElement> context)
    {
        int lastIndexOfSlash = variable.lastIndexOf(JOIN_HIERARCHY_SEPARATOR);
        int indexOfCurrentContext = -1;
        if (lastIndexOfSlash == -1)
        {
            indexOfCurrentContext = context.size() - 1;
        }
        else
        {
            int hierarchicalLevel = (lastIndexOfSlash + 1) / 3;
            indexOfCurrentContext = context.size() - hierarchicalLevel;
            if (variable.endsWith(JOIN_HIERARCHY_ELEMENT))
            {
                indexOfCurrentContext--;
            }
        }
        if (indexOfCurrentContext < 0 || indexOfCurrentContext >= context.size())
        {
            throw new IllegalArgumentException(getLogsPrefix() + "join on '" + variable + "' does not refer to an existing parent");
        }
        return context.get(indexOfCurrentContext);
    }
    
    /**
     * Retrieves the field path's metadata type from content types
     * @param fieldPath the field path
     * @param contentTypes the content types
     * @return the metadata type
     */
    protected MetadataType _getMetadataType(String fieldPath, Collection<String> contentTypes)
    {
        // Manage direct content references
        if (JOIN_HIERARCHY_ELEMENT.equals(fieldPath))
        {
            return MetadataType.CONTENT;
        }
        
        // Manage System Properties
        String[] pathSegments = fieldPath.split(EXTRACTION_METADATA_PATH_SEPARATOR);
        String propertyName = pathSegments[pathSegments.length - 1];
        if (_systemPropertyExtensionPoint.hasExtension(propertyName))
        {
            SystemProperty systemProperty = _systemPropertyExtensionPoint.getExtension(propertyName);
            return systemProperty.getType();
        }
        
        // Get content types common ancestor
        ContentType contentTypesAncestor = null;
        String contentTypesAncestorId = _contentTypesHelper.getCommonAncestor(contentTypes);
        if (contentTypesAncestorId != null && _contentTypeExtensionPoint.hasExtension(contentTypesAncestorId))
        {
            contentTypesAncestor = _contentTypeExtensionPoint.getExtension(contentTypesAncestorId);
        }
        
        // Manage metadata
        if (contentTypesAncestor != null)
        {
            String fieldPathWthClassicSeparator = fieldPath.replaceAll(EXTRACTION_METADATA_PATH_SEPARATOR, ContentConstants.METADATA_PATH_SEPARATOR);
            MetadataDefinition definition = _contentTypesHelper.getMetadataDefinition(fieldPathWthClassicSeparator, contentTypesAncestor);
            if (definition != null)
            {
                return definition.getType();
            }
            throw new IllegalArgumentException(getLogsPrefix() + "join on '" + fieldPath + "'. This metadata is not available for '" + contentTypesAncestor.getId() + "' content type");
        }
        
        throw new IllegalArgumentException(getLogsPrefix() + "join on '" + fieldPath + "'. This metadata is not available");
    }

    private Collection<Object> _getValuesFromVariable(String fieldPath, MetadataType metadataType, ExtractionExecutionContextHierarchyElement contextHierarchyElement, Locale defaultLocale)
    {
        Collection<Object> values = new LinkedHashSet<>();
        
        Iterable<Content> contents = contextHierarchyElement.getContents();
        for (Content content: contents)
        {
            boolean isAutoposting = contextHierarchyElement.isAutoposting();
            Collection<Object> contentValues = _getContentValuesFromVariable(content, fieldPath, metadataType, isAutoposting, defaultLocale);
            values.addAll(contentValues);
        }
        
        return values;
    }
    
    private Collection<Object> _getContentValuesFromVariable(Content content, String fieldPath, MetadataType metadataType, boolean isAutoposting, Locale defaultLocale)
    {
        Collection<Object> values = new LinkedHashSet<>();
        
        Object value = _getContentValue(content, fieldPath, defaultLocale);
        if (value == null)
        {
            return Collections.emptyList();
        }
        
        if (value instanceof Collection<?>)
        {
            values.addAll((Collection<?>) value);
        }
        else
        {
            values.add(value);
        }
        
        Collection<Object> result = new LinkedHashSet<>(values);
        
        if (isAutoposting)
        {
            switch (metadataType)
            {
                case CONTENT:
                    for (Object object : values)
                    {
                        Content parent = (Content) object;
                        ContentType contentType = _contentTypesHelper.getFirstContentType(parent);
                        
                        // Manage autoposting only if the current value is a thesaurus term
                        if (Arrays.asList(_contentTypesHelper.getSupertypeIds(contentType.getId()).getLeft()).contains(ThesaurusDAO.MICROTHESAURUS_ABSTRACT_CONTENT_TYPE))
                        {
                            AmetysObjectIterable<Content> chidren = _thesaurusDAO.getChildTerms(contentType.getId(), parent.getId());
                            for (Content child : chidren)
                            {
                                Collection<Object> childValues = _getContentValuesFromVariable(child, JOIN_HIERARCHY_ELEMENT, metadataType, isAutoposting, defaultLocale);
                                result.addAll(childValues);
                            }
                        }
                    }
                    
                    break;
                default:
                    break;
            }
        }

        return result;
    }
    
    private Object _getContentValue(Content content, String fieldPath, Locale defaultLocale)
    {
        if (JOIN_HIERARCHY_ELEMENT.equals(fieldPath))
        {
            return content;
        }
        else 
        {
            String fieldPathWthClassicSeparator = fieldPath.replaceAll(EXTRACTION_METADATA_PATH_SEPARATOR, ContentConstants.METADATA_PATH_SEPARATOR);
            return _contentHelper.getValue(content, fieldPathWthClassicSeparator, defaultLocale, true);
        }
    }
    
    private String _getValueAsString(Object value, MetadataType metadataType, String fieldPath)
    {
        String valueAsString;
        switch (metadataType)
        {
            case STRING:
            case LONG:
            case DOUBLE:
            case BOOLEAN:
                valueAsString = value.toString();
                break;
            case CONTENT:
                valueAsString = ((Content) value).getId();
                break;
            default:
                throw new IllegalArgumentException(getLogsPrefix() + "join on '" + fieldPath + "'. Metadata type '" + metadataType + "' is not supported by extraction module");
        }
        
        return StringQuery.escapeStringValue(valueAsString, Operator.EQ);
    }
    
    /**
     * Retrieves the content searcher to use for solr search
     * @return the content searcher
     */
    protected SimpleContentSearcher getContentSearcher()
    {
        return _contentSearcherFactory.create(_contentTypes);
    }
    
    /**
     * Gets the content results from Solr
     * @param context component execution context
     * @return the content results from Solr
     * @throws Exception if an error occurs
     */
    protected Iterable<Content> getContents(ExtractionExecutionContext context) throws Exception
    {
        List<String> clauseQueries = _getClauseQueries(context);
        if (clauseQueries == null)
        {
            return new EmptyIterable<>();
        }
        else
        {
            List<String> filterQueryStrings = clauseQueries
                    .stream()
                    .map(LambdaUtils.wrap(clauseQuery -> SolrQuerySearchAction.buildQuery(_queryBuilder, clauseQuery, Collections.emptySet(), Collections.emptySet())))
                    .collect(Collectors.toList());
            return getContentSearcher()
                    .withFilterQueryStrings(filterQueryStrings)
                    .setCheckRights(false)
                    .search("*:*");
        }
    }

    /**
     * Process result contents to format the result document
     * @param contents search results
     * @param contentHandler result document
     * @param context component execution context
     * @throws Exception if an error occurs
     */
    protected abstract void processContents(Iterable<Content> contents, ContentHandler contentHandler, ExtractionExecutionContext context) throws Exception;

    @Override
    public Map<String, Object> getComponentDetailsForTree()
    {
        Map<String, Object> details = super.getComponentDetailsForTree();
        
        @SuppressWarnings("unchecked")
        Map<String, Object> data = (Map<String, Object>) details.get("data");
        
        List<String> clauses = new ArrayList<>();
        for (ExtractionClause clause : this.getClauses())
        {
            clauses.add(clause.getExpression());
        }
        data.put("clauses", clauses);
        
        data.put("useQueryRef", org.apache.commons.lang.StringUtils.isNotEmpty(_queryReferenceId));
        data.put("contentTypes", this.getContentTypes());
        data.put("queryReferenceId", this.getQueryReferenceId());
        
        return details;
    }
    
    public Set<String> getContentTypes()
    {
        return _contentTypes;
    }

    /**
     * Add content types to component
     * @param contentTypes Array of content types to add
     */
    public void addContentTypes(String... contentTypes)
    {
        _contentTypes.addAll(Arrays.asList(contentTypes));
    }

    /**
     * Retrieves the id of the referenced query
     * @return the id of the referenced query
     */
    public String getQueryReferenceId()
    {
        return _queryReferenceId;
    }
    
    /**
     * Sets the id of the referenced query
     * @param queryReferenceId The id of the referenced query to set
     */
    public void setQueryReferenceId(String queryReferenceId)
    {
        _queryReferenceId = queryReferenceId;
    }

    /**
     * Retrieves the component clauses
     * @return the component clauses
     */
    public List<ExtractionClause> getClauses()
    {
        return _clauses;
    }

    /**
     * Add clauses to the component. Do not manage clauses' groups
     * @param expressions Array clauses expressions to add
     */
    public void addClauses(String... expressions)
    {
        for (String expression : expressions)
        {
            ExtractionClause clause = new ExtractionClause();
            clause.setExpression(expression);
            _clauses.add(clause);
        }
    }
}