/*
 *  Copyright 2014 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.ui.model.impl;

import java.util.ArrayList;
import java.util.LinkedHashMap;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.Optional;
import java.util.Set;
import java.util.stream.Collectors;

import org.apache.avalon.framework.component.ComponentException;
import org.apache.avalon.framework.configuration.Configuration;
import org.apache.avalon.framework.configuration.ConfigurationException;
import org.apache.avalon.framework.configuration.DefaultConfiguration;
import org.apache.avalon.framework.configuration.MutableConfiguration;
import org.apache.avalon.framework.service.ServiceException;
import org.apache.avalon.framework.service.ServiceManager;
import org.apache.commons.lang3.tuple.ImmutablePair;
import org.apache.commons.lang3.tuple.Pair;

import org.ametys.cms.contenttype.ContentTypesHelper;
import org.ametys.cms.contenttype.MetadataType;
import org.ametys.cms.search.query.AndQuery;
import org.ametys.cms.search.query.OrQuery;
import org.ametys.cms.search.query.Query;
import org.ametys.cms.search.query.Query.Operator;
import org.ametys.cms.search.ui.model.SearchUICriterion;
import org.ametys.runtime.plugin.component.ThreadSafeComponentManager;

/**
 * Aggregate multiple indexing field as a unique search criteria.
 * The resulting query is an OR query on all the terms.
 */
public class IndexingFieldAggregatorSearchUICriterion extends AbstractSearchUICriterion
{
    /** Prefix for id of indexing field aggregator search criteria */
    public static final String SEARCH_CRITERIA_METADATA_AGGREGATOR_PREFIX = "metadata-aggregator-";
    
    /** ComponentManager for aggregated {@link SearchUICriterion}s. */
    protected ThreadSafeComponentManager<SearchUICriterion> _fieldCriteriaManager;
    
    /** The map of aggregated criteria */
    protected Map<String, SearchUICriterion> _fieldCriteriaMap;
    
    /** The helper for convenient methods on content types */
    protected ContentTypesHelper _contentTypesHelper;
    
    /** The type of the aggregated fields */
    protected MetadataType _type;

    @Override
    public void service(ServiceManager manager) throws ServiceException
    {
        super.service(manager);
        _contentTypesHelper = (ContentTypesHelper) manager.lookup(ContentTypesHelper.ROLE);
    }
    
    @Override
    public void configure(Configuration configuration) throws ConfigurationException
    {
        try
        {
            super.configure(configuration);
            
            _fieldCriteriaManager = new ThreadSafeComponentManager<>();
            _fieldCriteriaManager.setLogger(_logger);
            _fieldCriteriaManager.contextualize(_context);
            _fieldCriteriaManager.service(_manager);
            
            MutableConfiguration baseConf = new DefaultConfiguration(configuration);
            baseConf.removeChild(baseConf.getChild("field"));
            
            Configuration fieldsConf = configuration.getChild("fields");
            Configuration[] fieldConfs = fieldsConf.getChildren("field");
            
            List<Pair<String, Configuration>> fieldSearchUICriterionToLookup = _fieldSearchUICriterionToLookup(fieldConfs, baseConf);
            
            _initializeFieldCriteria(fieldSearchUICriterionToLookup, fieldsConf);
            
            _configureWidgetAndWidgetParameters(configuration);
        }
        catch (ConfigurationException e)
        {
            throw e;
        }
        catch (Exception e)
        {
            throw new ConfigurationException("Unable to create local component manager.", configuration, e);
        }
    }
    
    private List<Pair<String, Configuration>>  _fieldSearchUICriterionToLookup(Configuration[] fieldConfs, MutableConfiguration baseConf) throws ConfigurationException
    {
        List<Pair<String, Configuration>> fieldSearchUICriterionToLookup = new ArrayList<>();
        
        for (Configuration fieldConf : fieldConfs)
        {
            String path = fieldConf.getAttribute("path");
            
            MutableConfiguration indexingFieldConf = new DefaultConfiguration(baseConf);
            DefaultConfiguration newFieldConf = new DefaultConfiguration(fieldConf);
            indexingFieldConf.addChild(newFieldConf);
            newFieldConf.setAttribute("path", path);
            
            String role = path;
            _fieldCriteriaManager.addComponent("cms", null, role, IndexingFieldSearchUICriterion.class, indexingFieldConf);
            
            fieldSearchUICriterionToLookup.add(ImmutablePair.of(role, fieldConf));
        }
        
        return fieldSearchUICriterionToLookup;
    }
    
    private void _initializeFieldCriteria(List<Pair<String, Configuration>> fieldSearchUICriterionToLookup, Configuration fieldsConf) throws Exception
    {
        String typeAttr = fieldsConf.getAttribute("type", null);
        
        _fieldCriteriaManager.initialize();
        
        _fieldCriteriaMap = new LinkedHashMap<>();
        _type = Optional.ofNullable(typeAttr)
                        .map(String::toUpperCase)
                        .map(MetadataType::valueOf)
                        .orElse(null);
        for (Pair<String, Configuration> pair : fieldSearchUICriterionToLookup)
        {
            String role = pair.getLeft();
            SearchUICriterion criterion;
            try
            {
                criterion = _fieldCriteriaManager.lookup(role);
            }
            catch (ComponentException e)
            {
                throw new ConfigurationException("Impossible to lookup the search criterion of role: " + role, e);
            }
            
            MetadataType criterionType = criterion.getType();
            if (_type == null)
            {
                _type = criterionType;
            }
            else if (_type != criterionType)
            {
                String location = pair.getRight().getLocation();
                throw new ConfigurationException("Search criterion of role '" + role + "' is of type '" + criterionType + "' but should be of type '" + _type + "' at " + location + ".");
            }
            _fieldCriteriaMap.put(criterion.getId(), criterion);
        }
    }
    
    private void _configureWidgetAndWidgetParameters(Configuration configuration) throws ConfigurationException
    {
        setWidget(configureWidget(configuration, null, _type));
        
        String commonContentTypeId = null; 
        if (_type == MetadataType.CONTENT || _type == MetadataType.SUB_CONTENT)
        {
            Set<String> contentTypeIds = _fieldCriteriaMap.values().stream()
                                                          .map(SearchUICriterion::getContentTypeId)
                                                          .collect(Collectors.toSet());
            Set<String> commonContentTypeIds = _contentTypesHelper.getCommonAncestors(contentTypeIds);
            
            if (commonContentTypeIds.size() == 1)
            {
                commonContentTypeId = commonContentTypeIds.iterator().next();
            }
        }
        setWidgetParameters(configureWidgetParameters(configuration, null, _type, commonContentTypeId));
    }
    
    @Override
    protected void configureId(Configuration configuration) throws ConfigurationException
    {
        String customRef = configuration.getAttribute("custom-ref");
        setId(SEARCH_CRITERIA_METADATA_AGGREGATOR_PREFIX + customRef);
    }
    
    @Override
    public MetadataType getType()
    {
        return _type;
    }
    
    @Override
    public Query getQuery(Object value, Operator customOperator, Map<String, Object> allValues, String language, Map<String, Object> contextualParameters)
    {
        List<Query> fieldQueries = new LinkedList<>();
        
        for (String role : _fieldCriteriaMap.keySet())
        {
            SearchUICriterion searchCriteria = _fieldCriteriaMap.get(role);
            Query query = searchCriteria.getQuery(value, customOperator, allValues, language, contextualParameters);
            
            if (query != null)
            {
                fieldQueries.add(query);
            }
        }
        
        if (fieldQueries.isEmpty())
        {
            return null;
        }
        else
        {
            return (customOperator != null && Operator.NE.equals(customOperator)) ? new AndQuery(fieldQueries) : new OrQuery(fieldQueries);
        }
    }
    
    @Override
    public void dispose()
    {
        super.dispose();
        _fieldCriteriaManager.dispose();
        _fieldCriteriaManager = null;
    }
    
    @Override
    public String getFieldId()
    {
        return getId();
    }
    
    @Override
    public boolean isSortable()
    {
        // Not destined to be displayed.
        return false;
    }
    
    @Override
    public Operator getOperator()
    {
        return null;
    }
    
}