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

import java.util.Collection;
import java.util.Collections;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;

import org.apache.avalon.framework.component.Component;
import org.apache.avalon.framework.service.ServiceException;
import org.apache.avalon.framework.service.ServiceManager;
import org.apache.avalon.framework.service.Serviceable;
import org.apache.commons.collections.CollectionUtils;

import org.ametys.cms.contenttype.ContentConstants;
import org.ametys.cms.contenttype.ContentType;
import org.ametys.cms.contenttype.ContentTypeExtensionPoint;
import org.ametys.cms.contenttype.ContentTypesHelper;
import org.ametys.cms.contenttype.MetadataDefinition;
import org.ametys.cms.contenttype.MetadataDefinitionHolder;
import org.ametys.cms.contenttype.MetadataType;
import org.ametys.cms.contenttype.RepeaterDefinition;
import org.ametys.cms.repository.Content;
import org.ametys.cms.search.model.ResultField;
import org.ametys.cms.search.model.SearchModel;
import org.ametys.cms.search.model.SystemProperty;
import org.ametys.cms.search.model.SystemPropertyExtensionPoint;
import org.ametys.runtime.parameter.Enumerator;
import org.ametys.runtime.plugin.component.AbstractLogEnabled;

/**
 * Component creating content values extractors from {@link SearchModel}s or content type IDs.
 */
public class ContentValuesExtractorFactory extends AbstractLogEnabled implements Component, Serviceable
{
    
    /** The component role. */
    public static final String ROLE = ContentValuesExtractorFactory.class.getName();
    
    /** The content type extension point. */
    protected ContentTypeExtensionPoint _cTypeEP;
    
    /** The content type helper. */
    protected ContentTypesHelper _cTypeHelper;
    
    /** The content type helper. */
    protected ContentSearchHelper _searchHelper;
    
    /** The system property extension point. */
    protected SystemPropertyExtensionPoint _sysPropEP;
    
    @Override
    public void service(ServiceManager manager) throws ServiceException
    {
        _cTypeEP = (ContentTypeExtensionPoint) manager.lookup(ContentTypeExtensionPoint.ROLE);
        _cTypeHelper = (ContentTypesHelper) manager.lookup(ContentTypesHelper.ROLE);
        _searchHelper = (ContentSearchHelper) manager.lookup(ContentSearchHelper.ROLE);
        _sysPropEP = (SystemPropertyExtensionPoint) manager.lookup(SystemPropertyExtensionPoint.ROLE);
    }
    
    /**
     * Create a ContentValuesExtractor from a search model.
     * @param searchModel The reference search model.
     * @return a ContentValuesExtractor backed by the given search model.
     */
    public SearchModelContentValuesExtractor create(SearchModel searchModel)
    {
        return new SearchModelContentValuesExtractor(searchModel);
    }
    
    /**
     * Create a simple ContentValuesExtractor from a list of content types.
     * @param contentTypes The content types to search on.
     * @return a ContentValuesExtractor referencing the given content types.
     */
    public SimpleContentValuesExtractor create(Collection<String> contentTypes)
    {
        return create(contentTypes, Collections.emptyList());
    }
    
    /**
     * Create a simple ContentValuesExtractor from a list of content types.
     * @param contentTypes The content types to search on.
     * @param fields The fields to extract.
     * @return a ContentValuesExtractor referencing the given content types.
     */
    public SimpleContentValuesExtractor create(Collection<String> contentTypes, List<String> fields)
    {
        return new SimpleContentValuesExtractor(contentTypes, fields);
    }
    
    /**
     * A ContentValuesExtractor backed by a {@link SearchModel}.
     */
    public class SearchModelContentValuesExtractor
    {
        private SearchModel _searchModel;
        private boolean _fullValues;
        
        /**
         * Build a ContentValuesExtractor referencing a {@link SearchModel}.
         * @param searchModel the {@link SearchModel}.
         */
        public SearchModelContentValuesExtractor(SearchModel searchModel)
        {
            _searchModel = searchModel;
            _fullValues = false;
        }
        
        /**
         * Whether to return full values or not.
         * @param fullValues true to return full values, false otherwise.
         * @return The ContentValuesExtractor itself.
         */
        public SearchModelContentValuesExtractor setFullValues(boolean fullValues)
        {
            _fullValues = fullValues;
            return this;
        }
        
        /**
         * Get the values from the given content.
         * @param content The content.
         * @return the extracted values.
         */
        public Map<String, Object> getValues(Content content)
        {
            return getValues(content, Collections.emptyMap());
        }
        
        /**
         * Get the values from the given content.
         * @param content The content.
         * @param contextualParameters The search contextual parameters.
         * @return the extracted values.
         */
        public Map<String, Object> getValues(Content content, Map<String, Object> contextualParameters)
        {
            Map<String, Object> properties = new HashMap<>();
            
            Map<String, ? extends ResultField> resultFields = _searchModel.getResultFields(contextualParameters);
            
            for (ResultField field : resultFields.values())
            {
                Object value = _fullValues ? field.getFullValue(content) : field.getValue(content);
                
                if (value != null)
                {
                    putPropertyValue(properties, field, value);
                }
            }
            
            return properties;
        }
        
        /**
         * Put a result value at its right place in the properties map.
         * @param properties the properties map to fill.
         * @param column the search column.
         * @param value the result value.
         */
        protected void putPropertyValue(Map<String, Object> properties, ResultField column, Object value)
        {
            String id = column.getId();
            properties.put(id.replace('.', '/'), value);  
        }
        
    }
    
    /**
     * A simple ContentValuesExtractor on a list of content types.
     */
    public class SimpleContentValuesExtractor
    {
        private Set<String> _contentTypes;
        private Map<String, Object> _fields;
        private boolean _fullValues;
        
        /**
         * Build a simple ContentValuesExtractor on a list of content types.
         * @param contentTypes The content types, can be empty.
         * @param fieldNames The field names.
         */
        public SimpleContentValuesExtractor(Collection<String> contentTypes, List<String> fieldNames)
        {
            this._contentTypes = contentTypes != null ? new HashSet<>(contentTypes) : Collections.emptySet();
            this._fields = initializeFields(fieldNames);
            this._fullValues = false;
        }
        
        /**
         * Initialize the fields from the field names.
         * @param fieldNames The field names.
         * @return The fields definitions (either MetadataDefinition or SystemProperty), indexed by field name.
         */
        protected Map<String, Object> initializeFields(List<String> fieldNames)
        {
            LinkedHashMap<String, Object> fields = new LinkedHashMap<>();
            
            if (CollectionUtils.isEmpty(fieldNames))
            {
                addAllFields(fields);
            }
            else
            {
                addFields(fields, fieldNames);
            }
            
            return fields;
        }
        
        /**
         * Add all possible fields to the map.
         * @param fields The map of field definitions to fill.
         */
        protected void addAllFields(Map<String, Object> fields)
        {
            // Add all metadatas
            if (_contentTypes.isEmpty())
            {
                // Add only title.
                fields.put("title", new MetadataReference(ContentTypesHelper.getTitleMetadataDefinition(), false));
            }
            else
            {
                // Add all metadatas.
                for (String id : _contentTypes)
                {
                    addAllMetadatas(fields, _cTypeEP.getExtension(id), "", false);
                }
            }
            
            // Add system properties
            for (String propName : _sysPropEP.getDisplayProperties())
            {
                fields.put(propName, _sysPropEP.getExtension(propName));
            }
        }
        
        /**
         * Add the given fields to the map.
         * @param fields The map of field definitions to fill.
         * @param fieldNames The fields to add.
         */
        protected void addFields(Map<String, Object> fields, List<String> fieldNames)
        {
            for (String field : fieldNames)
            {
                if (_sysPropEP.hasExtension(field))
                {
                    if (_sysPropEP.isDisplayable(field))
                    {
                        fields.put(field, _sysPropEP.getExtension(field));
                    }
                    else
                    {
                        throw new IllegalArgumentException("The system property '" + field + "' is not displayable.");
                    }
                }
                else
                {
                    String metadataPath = field;
                    
                    Iterator<String> ids = _contentTypes.iterator();
                    MetadataReference metaRef = null;
                    while (ids.hasNext() && metaRef == null)
                    {
                        ContentType cType = _cTypeEP.getExtension(ids.next());
                        List<MetadataDefinition> metaDefs = _cTypeHelper.getMetadataDefinitionPath(metadataPath, cType);
                        if (CollectionUtils.isNotEmpty(metaDefs))
                        {
                            MetadataDefinition metaDef = metaDefs.get(metaDefs.size() - 1);
                            metaRef = new MetadataReference(metaDef, isMultiple(metaDefs));
                        }
                    }
                    
                    // Take the standard title metadata definition if no specific content type is defined.
                    if (metaRef == null && field.equals("title") && _contentTypes.isEmpty())
                    {
                        metaRef = new MetadataReference(ContentTypesHelper.getTitleMetadataDefinition(), false);
                    }
                    
                    if (metaRef != null)
                    {
                        fields.put(field, metaRef);
                    }
                    else
                    {
                        throw new IllegalArgumentException("The field '" + field + "' can't be found in the given content types.");
                    }
                }
            }
        }
        
        /**
         * Add all the metadata present in a holder.
         * @param fields The field map to fill.
         * @param defHolder The definition holder.
         * @param prefix The metadata path prefix.
         * @param parentIsMultiple true if the parent is multiple.
         */
        protected void addAllMetadatas(Map<String, Object> fields, MetadataDefinitionHolder defHolder, String prefix, boolean parentIsMultiple)
        {
            for (String name : defHolder.getMetadataNames())
            {
                MetadataDefinition definition = defHolder.getMetadataDefinition(name);
                String path = prefix + name;
                // The metadata is considered multiple if any of its parent is multiple or it's itself multiple.
                boolean multiple = parentIsMultiple || definition.isMultiple() || definition instanceof RepeaterDefinition;
                
                if (definition.getType() == MetadataType.COMPOSITE)
                {
                    // Composite or repeater: add nothing at this level and recurse.
                    addAllMetadatas(fields, definition, path + ContentConstants.METADATA_PATH_SEPARATOR, multiple);
                }
                else if (!fields.containsKey(path))
                {
                    // Add the metadata to the field map (if it's not present already).
                    fields.put(path, new MetadataReference(definition, multiple));
                }
            }
        }
        
        /**
         * Whether to return full values or not.
         * @param fullValues true to return full values, false otherwise.
         * @return The ContentValuesExtractor itself.
         */
        public SimpleContentValuesExtractor setFullValues(boolean fullValues)
        {
            _fullValues = fullValues;
            return this;
        }
        
        /**
         * Get the values from the given content.
         * @param content The content.
         * @return the extracted values.
         */
        public Map<String, Object> getValues(Content content)
        {
            return getValues(content, Collections.emptyMap());
        }
        
        /**
         * Get the values from the given content.
         * @param content The content.
         * @param contextualParameters The search contextual parameters.
         * @return the extracted values.
         */
        public Map<String, Object> getValues(Content content, Map<String, Object> contextualParameters)
        {
            Map<String, Object> properties = new LinkedHashMap<>();
            
            for (String fieldName : _fields.keySet())
            {
                Object field = _fields.get(fieldName);
                
                Object value = getValue(content, fieldName, field);
                if (value != null)
                {
                    properties.put(fieldName, value);
                }
            }
            
            return properties;
        }
        
        /**
         * Get a value from the Content.
         * @param content The content.
         * @param fieldName The field name.
         * @param field The field definition.
         * @return The value.
         */
        protected Object getValue(Content content, String fieldName, Object field)
        {
            Object value = null;
            
            if (field instanceof SystemProperty)
            {
                value = ((SystemProperty) field).getValue(content);
            }
            else if (field instanceof MetadataReference)
            {
                String metadataPath = fieldName;
                MetadataReference metaRef = (MetadataReference) field;
                value = _searchHelper.getMetadataValues(content, metadataPath, metaRef.getType(), metaRef.isMultiple(), metaRef.getEnumerator(), _fullValues);
            }
            
            return value;
        }

        /**
         * Test if any metadata definition in a chain is multiple or a repeater.
         * @param metaDefs The metadata definition chain.
         * @return <code>true</code> if any metadata definition in a chain is multiple or a repeater.
         */
        protected boolean isMultiple(List<MetadataDefinition> metaDefs)
        {
            for (MetadataDefinition def : metaDefs)
            {
                if (def.isMultiple() || def instanceof RepeaterDefinition)
                {
                    return true;
                }
            }
            
            return false;
        }
        
    }
    
    /**
     * Represents a metadata definition and a multiple status, which can be different
     * from the metadata definition's own multiple status.
     */
    class MetadataReference
    {
        private MetadataDefinition _definition;
        
        private boolean _multiple;
        
        /**
         * Build a MetadataReference object.
         * @param definition The reference MetadataDefinition.
         * @param multiple The multiple status.
         */
        public MetadataReference(MetadataDefinition definition, boolean multiple)
        {
            this._definition = definition;
            this._multiple = multiple;
        }
        
        /**
         * Get the reference MetadataDefinition.
         * @return the reference MetadataDefinition.
         */
        public MetadataDefinition getDefinition()
        {
            return _definition;
        }
        
        /**
         * Get the multiple status.
         * @return The multiple status.
         */
        public boolean isMultiple()
        {
            return _multiple;
        }
        
        /**
         * Get the metadata type.
         * @return the metadata type.
         */
        public MetadataType getType()
        {
            return _definition.getType();
        }
        
        /**
         * Get the metadata enumerator.
         * @return the metadata enumerator.
         */
        public Enumerator getEnumerator()
        {
            return _definition.getEnumerator();
        }
    }
    
}