/*
 *  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.solr;

import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.Optional;
import java.util.Set;
import java.util.stream.Stream;

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.context.Context;
import org.apache.avalon.framework.service.ServiceException;
import org.apache.avalon.framework.service.ServiceManager;
import org.apache.commons.lang3.StringUtils;
import org.slf4j.Logger;

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.ui.model.AbstractSearchUIModel;
import org.ametys.cms.search.ui.model.SearchUIColumn;
import org.ametys.cms.search.ui.model.SearchUICriterion;
import org.ametys.cms.search.ui.model.SearchUIModel;
import org.ametys.cms.search.ui.model.SearchUIModelExtensionPoint;
import org.ametys.cms.search.ui.model.impl.IndexingFieldSearchUICriterion;
import org.ametys.cms.search.ui.model.impl.MetadataSearchUIColumn;
import org.ametys.cms.search.ui.model.impl.SystemSearchUIColumn;
import org.ametys.cms.search.ui.model.impl.SystemSearchUICriterion;
import org.ametys.runtime.plugin.component.ThreadSafeComponentManager;

/**
 * Search model wrapper which handles custom on-the-fly columns and facets.
 */
public class CriteriaSearchUIModelWrapper extends AbstractSearchUIModel
{
    
    /** ComponentManager for {@link SearchUICriterion}s. */
    protected ThreadSafeComponentManager<SearchUICriterion> _searchUICriterionManager;
    
    /** ComponentManager for {@link SearchUIColumn}s. */
    protected ThreadSafeComponentManager<SearchUIColumn> _searchUIColumnManager;
    
    private SearchUIModelExtensionPoint _searchModelEP;
    private SystemPropertyExtensionPoint _sysPropEP;
    
    private SearchUIModel _wrappedModel;
    
    private int _criteriaIndex;
    
    /**
     * Build a model wrapper.
     * @param model the search model to wrap.
     * @param manager the service manager.
     * @param context the component context.
     * @param logger the logger.
     */
    public CriteriaSearchUIModelWrapper(SearchUIModel model, ServiceManager manager, Context context, Logger logger)
    {
        _wrappedModel = model;
        
        _logger = logger;
        
        try
        {
            _searchUICriterionManager = new ThreadSafeComponentManager<>();
            _searchUICriterionManager.setLogger(logger);
            _searchUICriterionManager.contextualize(context);
            _searchUICriterionManager.service(manager);
            
            _searchUIColumnManager = new ThreadSafeComponentManager<>();
            _searchUIColumnManager.setLogger(logger);
            _searchUIColumnManager.contextualize(context);
            _searchUIColumnManager.service(manager);
        }
        catch (Exception e)
        {
            _logger.error("Error initializing the SearchModel", e);
        }
    }
    
    @Override
    public void service(ServiceManager manager) throws ServiceException
    {
        super.service(manager);
        _searchModelEP = (SearchUIModelExtensionPoint) manager.lookup(SearchUIModelExtensionPoint.ROLE);
        _sysPropEP = (SystemPropertyExtensionPoint) manager.lookup(SystemPropertyExtensionPoint.ROLE);
    }
    
    /**
     * Set the custom faceted criteria.
     * @param contentTypeId the reference content type ID, can be null.
     * @param criteriaIds the criteria IDs
     * @param contextualParameters the contextual parameters
     * @return the valid criteria IDs
     * @throws Exception if an error occurs initializing criteria.
     */
    public Collection<String> setFacetedCriteria(String contentTypeId, Collection<String> criteriaIds, Map<String, Object> contextualParameters) throws Exception
    {
        Collection<String> resultCriteriaIds = null;
        
        if (criteriaIds != null)
        {
            _facetedCriteria = new LinkedHashMap<>(criteriaIds.size());
            
            List<Object> searchToolCriterionRoles = new ArrayList<>();
            
            resultCriteriaIds = configureFacets(searchToolCriterionRoles, contentTypeId, criteriaIds, _wrappedModel, contextualParameters);
            
            _searchUICriterionManager.initialize();
            
            for (Object critObj : searchToolCriterionRoles)
            {
                SearchUICriterion criterion = null;
                if (critObj instanceof SearchUICriterion)
                {
                    // Already existing SearchUICriterion object (taken from the wrapped model).
                    criterion = (SearchUICriterion) critObj;
                }
                else if (critObj instanceof String)
                {
                    // Criterion just added in the local component manager, we have to look it up.
                    criterion = _searchUICriterionManager.lookup((String) critObj);
                }
                
                if (criterion != null && criterion.isFacetable())
                {
                    _facetedCriteria.put(criterion.getId(), criterion);
                }
            }
        }
        
        return resultCriteriaIds != null ? resultCriteriaIds : Collections.emptySet();
    }
    
    /**
     * Set the custom columns.
     * @param contentTypeId the reference content type ID, can be null.
     * @param columns The columns
     * @param contextualParameters the contextual parameters
     * @throws Exception if an error occurs initializing columns.
     */
    public void setResultColumns(String contentTypeId, Collection<Column> columns, Map<String, Object> contextualParameters) throws Exception
    {
        String wrappedModelId = (String) contextualParameters.get("wrappedModelId");
        if (StringUtils.isNotEmpty(wrappedModelId))
        {
            // Dashboard
            SearchUIModel model = _searchModelEP.getExtension(wrappedModelId);
            _columns = model.getResultFields(contextualParameters);
        }
        else if (columns != null)
        {
            _columns = new LinkedHashMap<>(columns.size());
            
            List<Object> columnRoles = new ArrayList<>();
            
            configureColumns(columnRoles, contentTypeId, columns, _wrappedModel, contextualParameters);
            
            _searchUIColumnManager.initialize();
            
            for (Object col : columnRoles)
            {
                SearchUIColumn column = null;
                if (col instanceof SearchUIColumn)
                {
                    // Already existing SearchUIColumn object (taken from the wrapped model).
                    column = (SearchUIColumn) col;
                }
                else if (col instanceof String)
                {
                    // Column just added in the local component manager, we have to look it up.
                    column = _searchUIColumnManager.lookup((String) col);
                }

                if (column != null)
                {
                    _columns.put(column.getId(), column);
                }
            }
        }
    }
    
    /**
     * Configure the list of faceted criteria.
     * @param criteriaRoles the roles of criteria to lookup (or the already existing SearchUICriterion objects).
     * @param contentTypeId The reference content type ID.
     * @param criteriaIds the criteria IDs.
     * @param referenceModel the reference model.
     * @param contextualParameters the contextual parameters
     * @return the valid criteria IDs
     * @throws ConfigurationException if an error occurs creating a component configuration.
     */
    protected Collection<String> configureFacets(List<Object> criteriaRoles, String contentTypeId, Collection<String> criteriaIds, SearchUIModel referenceModel, Map<String, Object> contextualParameters) throws ConfigurationException
    {
        Collection<String> resultCriteriaIds = new ArrayList<>();
        
        for (String criterionId : criteriaIds)
        {
            String[] facetPathSegments = StringUtils.split(criterionId, '/');
            String lastSegmentOfFacetPath = facetPathSegments[facetPathSegments.length - 1];
            
            SearchUICriterion referenceCriterion = null;
            if (referenceModel != null)
            {
                referenceCriterion = getCriterion(referenceModel, criterionId, contextualParameters);
            }
            
            if (referenceCriterion != null)
            {
                criteriaRoles.add(referenceCriterion);
            }
            else if (_sysPropEP.hasExtension(lastSegmentOfFacetPath))
            {
                SystemProperty systemProperty = _sysPropEP.getExtension(lastSegmentOfFacetPath);
                if (systemProperty.isFacetable())
                {
                    addSystemCriteriaComponents(criteriaRoles, contentTypeId, criterionId);
                }
                else
                {
                    getLogger().warn("The declared facet '{}' is a system property but is not facetable. Thus, it will not be added to the facets.", criterionId);
                    break;
                }
            }
            else
            {
                if (contentTypeId != null && _cTypeEP.hasExtension(contentTypeId))
                {
                    // Metadata property.
                    addIndexingFieldCriteriaComponents(criteriaRoles, contentTypeId, criterionId);
                }
                else if ("title".equals(criterionId))
                {
                    // title property of a random ContentType.
                    String firstCTypeId = _cTypeEP.getExtensionsIds().iterator().next();
                    addIndexingFieldCriteriaComponents(criteriaRoles, firstCTypeId, criterionId);
                }
                else
                {
                    break;
                }
            }
            
            resultCriteriaIds.add(criterionId);
        }
        
        return resultCriteriaIds;
    }
    
    /**
     * Search a criterion in the reference model from its criterion identifier.
     * @param searchModel the reference search model.
     * @param criterionId the criterion identifier.
     * @param contextualParameters the contextual parameters
     * @return the criterion if found, null otherwise.
     */
    protected SearchUICriterion getCriterion(SearchUIModel searchModel, String criterionId, Map<String, Object> contextualParameters)
    {
        Map<String, SearchUICriterion> criteria = searchModel.getFacetedCriteria(contextualParameters);
        
        for (SearchUICriterion criterion : criteria.values())
        {
            if (criterion instanceof IndexingFieldSearchUICriterion && ((IndexingFieldSearchUICriterion) criterion).getFieldPath().equals(criterionId))
            {
                return criterion;
            }
            else if (criterion instanceof SystemSearchUICriterion && ((SystemSearchUICriterion) criterion).getSystemPropertyId().equals(criterionId))
            {
                return criterion;
            }
            else if (criterion.getId().equals(criterionId))
            {
                return criterion;
            }
        }
        
        return null;
    }
    
    /**
     * Configure the list of search columns.
     * @param columnRoles the roles of columns to lookup (or the already existing SearchUIColumn objects).
     * @param contentTypeId The reference content type ID.
     * @param columnIds The columns
     * @param referenceModel the reference model.
     * @param contextualParameters the contextual parameters
     * @throws ConfigurationException if an error occurs creating a component configuration.
     */
    protected void configureColumns(List<Object> columnRoles, String contentTypeId, Collection<Column> columnIds, SearchUIModel referenceModel, Map<String, Object> contextualParameters) throws ConfigurationException
    {
        for (Column column : columnIds)
        {
            String columnId = column.getId();
            Optional<String> columnLabel = column.getLabel();
            String[] columnPathSegments = StringUtils.split(columnId, '/');
            String lastSegmentOfColumnPath = columnPathSegments[columnPathSegments.length - 1];
            
            SearchUIColumn referenceColumn = null;
            if (referenceModel != null && !columnLabel.isPresent() /* cannot temporary change the label of a reference column on the fly => re-create a component */)
            {
                referenceColumn = getColumn(referenceModel, columnId, contextualParameters);
            }
            
            if (referenceColumn != null)
            {
                columnRoles.add(referenceColumn);
            }
            else if (_sysPropEP.isDisplayable(lastSegmentOfColumnPath))
            {
                // System property.
                addSystemColumnComponent(columnRoles, contentTypeId, columnId, columnLabel);
            }
            else if (_sysPropEP.hasExtension(lastSegmentOfColumnPath))
            {
                getLogger().warn("The column '{}' is a system property but is not displayable. Thus, it will not be displayed.", columnId);
            }
            else 
            {
                // Metadata property.
                if (contentTypeId != null && _cTypeEP.hasExtension(contentTypeId))
                {
                    addMetadataColumnComponents(columnRoles, contentTypeId, columnId, columnLabel);
                }
                else if ("title".equals(columnId))
                {
                    // Get the title property of a random ContentType.
                    String firstCTypeId = _cTypeEP.getExtensionsIds().iterator().next();
                    addMetadataColumnComponents(columnRoles, firstCTypeId, columnId, columnLabel);
                }
            }
        }
    }
    
    /**
     * Search a column in the reference model from its column identifier.
     * @param searchModel the reference search model.
     * @param columnId the column identifier.
     * @param contextualParameters the contextual parameters
     * @return the column if found, null otherwise.
     */
    protected SearchUIColumn getColumn(SearchUIModel searchModel, String columnId, Map<String, Object> contextualParameters)
    {
        Map<String, SearchUIColumn> columns = searchModel.getResultFields(contextualParameters);
        
        for (SearchUIColumn column : columns.values())
        {
            if (column instanceof MetadataSearchUIColumn && ((MetadataSearchUIColumn) column).getFieldPath().equals(columnId))
            {
                return column;
            }
            else if (column instanceof SystemSearchUIColumn && ((SystemSearchUIColumn) column).getSystemPropertyId().equals(columnId))
            {
                return column;
            }
//            else if (column instanceof CustomSearchToolColumn && column.getId().equals(columnId))
//            {
//                return column;
//            }
        }
        
        return null;
    }

    /**
     * Add a indexing field criteria component to the manager.
     * @param searchToolCriterionRoles the criteria role list to fill.
     * @param contentTypeId the reference content type ID, can be null.
     * @param fieldRef the field path.
     * @throws ConfigurationException if an error occurs.
     */
    protected void addIndexingFieldCriteriaComponents(List<Object> searchToolCriterionRoles, String contentTypeId, String fieldRef) throws ConfigurationException
    {
        try
        {
            String slashPath = fieldRef.replace('.', '/');
            
            String role = fieldRef + _criteriaIndex;
            _criteriaIndex++;
            Configuration criteriaConf = getIndexingFieldCriteriaConfiguration(contentTypeId, slashPath, Operator.EQ);
            
            _searchUICriterionManager.addComponent("search", null, role, IndexingFieldSearchUICriterion.class, criteriaConf);
            
            searchToolCriterionRoles.add(role);
        }
        catch (Exception e)
        {
            throw new ConfigurationException("Unable to instanciate IndexingFieldSearchUICriterion for field " + fieldRef, e);
        }        
    }
    
    /**
     * Add a system criteria component to the manager.
     * @param searchToolCriterionRoles the criteria role list to fill.
     * @param contentTypeId the reference content type ID, can be null.
     * @param property the system property id.
     * @throws ConfigurationException if an error occurs.
     */
    protected void addSystemCriteriaComponents(List<Object> searchToolCriterionRoles, String contentTypeId, String property) throws ConfigurationException
    {
        try
        {
            String role = property + _criteriaIndex;
            _criteriaIndex++;
            
            Configuration criteriaConf = getSystemCriteriaConfiguration(contentTypeId, property);
            _searchUICriterionManager.addComponent("search", null, role, SystemSearchUICriterion.class, criteriaConf);
            
            searchToolCriterionRoles.add(role);
        }
        catch (Exception e)
        {
            throw new ConfigurationException("Unable to instanciate SystemSearchUICriterion for property " + property, e);
        }
    }
    
    private Configuration addLabelInColumnConf(Configuration originalConf, String label) throws ConfigurationException
    {
        DefaultConfiguration confWithLabel = new DefaultConfiguration(originalConf);
        Stream.of(confWithLabel.getChildren("label")).forEach(confWithLabel::removeChild);
        DefaultConfiguration labelConf = new DefaultConfiguration("label");
        labelConf.setValue(label);
        confWithLabel.addChild(labelConf);
        return confWithLabel;
    }
    
    /**
     * Add a metadata column component to the manager.
     * @param columnsRolesToLookup the columns roles
     * @param contentTypeId the reference content type ID, can be null.
     * @param metadataPath the metadata path.
     * @param columnLabel The (optional) label of the column. If not present, the column label will be the metadata one.
     * @throws ConfigurationException if an error occurs.
     */
    protected void addMetadataColumnComponents(List<Object> columnsRolesToLookup, String contentTypeId, String metadataPath, Optional<String> columnLabel) throws ConfigurationException
    {
        try
        {
            Configuration columnConf = getMetadataColumnConfiguration(contentTypeId, metadataPath);
            if (columnLabel.isPresent())
            {
                columnConf = addLabelInColumnConf(columnConf, columnLabel.get());
            }
            
            _searchUIColumnManager.addComponent("search", null, metadataPath, MetadataSearchUIColumn.class, columnConf);
            columnsRolesToLookup.add(metadataPath);
        }
        catch (Exception e)
        {
            throw new ConfigurationException("Unable to instanciate MetadataSearchUIColumn for metadata " + metadataPath, e);
        }
    }
    
    /**
     * Add a system column component to the manager.
     * @param columnsRolesToLookup the columns roles
     * @param contentTypeId the reference content type ID, can be null.
     * @param property the system property.
     * @param columnLabel The (optional) label of the column. If not present, the column label will be the metadata one.
     * @throws ConfigurationException if an error occurs.
     */
    protected void addSystemColumnComponent(List<Object> columnsRolesToLookup, String contentTypeId, String property, Optional<String> columnLabel) throws ConfigurationException
    {
        try
        {
            Configuration conf = getSystemColumnConfiguration(contentTypeId, property);
            if (columnLabel.isPresent())
            {
                conf = addLabelInColumnConf(conf, columnLabel.get());
            }
            
            _searchUIColumnManager.addComponent("cms", null, property, SystemSearchUIColumn.class, conf);
            columnsRolesToLookup.add(property);
        }
        catch (Exception e)
        {
            throw new ConfigurationException("Unable to instanciate SystemSearchUIColumn for property " + property, e);
        }
    }
    
    @Override
    public Map<String, SearchUICriterion> getFacetedCriteria(Map<String, Object> contextualParameters)
    {
        if (_facetedCriteria != null && !_facetedCriteria.isEmpty())
        {
            return Collections.unmodifiableMap(_facetedCriteria);
        }
        else
        {
            return _wrappedModel.getFacetedCriteria(contextualParameters);
        }
    }
    
    @Override
    public Map<String, SearchUIColumn> getResultFields(Map<String, Object> contextualParameters)
    {
        if (_columns != null && !_columns.isEmpty())
        {
            return Collections.unmodifiableMap(_columns);
        }
        else
        {
            return _wrappedModel.getResultFields(contextualParameters);
        }
    }
    
    @Override
    public SearchUIColumn getResultField(String id, Map<String, Object> contextualParameters)
    {
        if (_columns != null && !_columns.isEmpty())
        {
            return getResultFields(contextualParameters).get(id);
        }
        else
        {
            return _wrappedModel.getResultField(id, contextualParameters);
        }
    }
    
    //// PROXY METHODS ////
    
    @Override
    public Set<String> getContentTypes(Map<String, Object> contextualParameters)
    {
        return _wrappedModel.getContentTypes(contextualParameters);
    }
    
    @Override
    public Set<String> getExcludedContentTypes(Map<String, Object> contextualParameters)
    {
        return _wrappedModel.getExcludedContentTypes(contextualParameters);
    }
    
    @Override
    public String getSearchUrl(Map<String, Object> contextualParameters)
    {
        return _wrappedModel.getSearchUrl(contextualParameters);
    }

    @Override
    public String getSearchUrlPlugin(Map<String, Object> contextualParameters)
    {
        return _wrappedModel.getSearchUrlPlugin(contextualParameters);
    }

    @Override
    public String getExportCSVUrl(Map<String, Object> contextualParameters)
    {
        return _wrappedModel.getExportCSVUrl(contextualParameters);
    }

    @Override
    public String getExportCSVUrlPlugin(Map<String, Object> contextualParameters)
    {
        return _wrappedModel.getExportCSVUrlPlugin(contextualParameters);
    }

    @Override
    public String getExportDOCUrl(Map<String, Object> contextualParameters)
    {
        return _wrappedModel.getExportDOCUrl(contextualParameters);
    }

    @Override
    public String getExportDOCUrlPlugin(Map<String, Object> contextualParameters)
    {
        return _wrappedModel.getExportDOCUrlPlugin(contextualParameters);
    }

    @Override
    public String getExportXMLUrl(Map<String, Object> contextualParameters)
    {
        return _wrappedModel.getExportXMLUrl(contextualParameters);
    }

    @Override
    public String getExportXMLUrlPlugin(Map<String, Object> contextualParameters)
    {
        return _wrappedModel.getExportXMLUrlPlugin(contextualParameters);
    }

    @Override
    public String getPrintUrl(Map<String, Object> contextualParameters)
    {
        return _wrappedModel.getPrintUrl(contextualParameters);
    }

    @Override
    public String getPrintUrlPlugin(Map<String, Object> contextualParameters)
    {
        return _wrappedModel.getPrintUrlPlugin(contextualParameters);
    }
    
    @Override
    public boolean allowSortOnMultipleJoin()
    {
        return _wrappedModel.allowSortOnMultipleJoin();
    }

    @Override
    public Map<String, SearchUICriterion> getCriteria(Map<String, Object> contextualParameters)
    {
        return _wrappedModel.getCriteria(contextualParameters);
    }
    
    @Override
    public SearchUICriterion getCriterion(String id, Map<String, Object> contextualParameters)
    {
        return _wrappedModel.getCriterion(id, contextualParameters);
    }
    
    @Override
    public Map<String, SearchUICriterion> getAdvancedCriteria(Map<String, Object> contextualParameters)
    {
        return _wrappedModel.getAdvancedCriteria(contextualParameters);
    }
    
    /**
     * A column and its (optional) label
     */
    public static final class Column
    {
        private String _id;
        private Optional<String> _label;

        /**
         * Creates a {@link Column} object, wrapping a column id and its (optional) label.
         * <br>If the provided label is <code>null</code>, then a default label will be applied to the column.
         * @param columnId The id of the column
         * @param columnLabel The label of the column. Cannot contain the comma character (<b>,</b>). Can be null
         */
        public Column(String columnId, String columnLabel)
        {
            _id = columnId;
            _label = Optional.ofNullable(columnLabel);
            if (_label.filter(l -> l.contains(",")).isPresent())
            {
                throw new IllegalArgumentException("The label cannot contain a comma.");
            }
        }
        
        /**
        * Gets the id of the column
        * @return the id of the column
        */
        public String getId()
        {
            return _id;
        }
        
        /**
        * Gets the label of the column
        * @return the label of the column 
        */
        public Optional<String> getLabel()
        {
            return _label;
        }
        
        @Override
        public String toString()
        {
            return "Column<" + _id + ", \"" + _label.orElse("<NO LABEL>") + "\">";
        }

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

        // only based on the column id
        @Override
        public boolean equals(Object obj)
        {
            if (this == obj)
            {
                return true;
            }
            if (obj == null)
            {
                return false;
            }
            if (getClass() != obj.getClass())
            {
                return false;
            }
            Column other = (Column) obj;
            if (_id == null)
            {
                if (other._id != null)
                {
                    return false;
                }
            }
            else if (!_id.equals(other._id))
            {
                return false;
            }
            return true;
        }
    }
}