/*
 *  Copyright 2015 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.systemprop;

import java.util.ArrayList;
import java.util.Collection;
import java.util.Date;
import java.util.List;
import java.util.Locale;
import java.util.Map;

import org.apache.avalon.framework.configuration.Configurable;
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.apache.avalon.framework.service.Serviceable;
import org.apache.cocoon.xml.AttributesImpl;
import org.apache.cocoon.xml.XMLUtils;
import org.apache.solr.common.SolrInputDocument;
import org.xml.sax.ContentHandler;
import org.xml.sax.SAXException;

import org.ametys.cms.content.indexing.solr.SolrFieldHelper;
import org.ametys.cms.content.indexing.solr.SolrIndexer;
import org.ametys.cms.contenttype.MetadataType;
import org.ametys.cms.repository.Content;
import org.ametys.cms.search.SearchField;
import org.ametys.cms.search.model.SystemProperty;
import org.ametys.cms.search.solr.schema.CopyFieldDefinition;
import org.ametys.cms.search.solr.schema.FieldDefinition;
import org.ametys.cms.search.solr.schema.SchemaDefinition;
import org.ametys.cms.search.solr.schema.SchemaHelper;
import org.ametys.core.user.User;
import org.ametys.core.user.UserIdentity;
import org.ametys.core.util.I18nUtils;
import org.ametys.plugins.core.user.UserHelper;
import org.ametys.plugins.repository.AmetysObjectResolver;
import org.ametys.plugins.repository.UnknownAmetysObjectException;
import org.ametys.runtime.i18n.I18nizableText;
import org.ametys.runtime.parameter.ParameterHelper;
import org.ametys.runtime.parameter.ParameterHelper.ParameterType;
import org.ametys.runtime.plugin.component.AbstractLogEnabled;
import org.ametys.runtime.plugin.component.PluginAware;

/**
 * Abstract class providing standard behavior and helper methods for a
 * {@link SystemProperty}.
 */
public abstract class AbstractSystemProperty extends AbstractLogEnabled implements SystemProperty, Serviceable, Configurable, PluginAware
{
    /** The i18n utils. */
    protected I18nUtils _i18nUtils;

    /** The property ID. */
    protected String _id;

    /** The property label. */
    protected I18nizableText _label;

    /** The property description. */
    protected I18nizableText _description;

    /** The property plugin name. */
    protected String _pluginName;

    /** The user helper */
    protected UserHelper _userHelper;
    /** The ametys object resolver */
    protected AmetysObjectResolver _resolver;

    @Override
    public void setPluginInfo(String pluginName, String featureName, String id)
    {
        _pluginName = pluginName;
        _id = id;
    }

    public void service(ServiceManager manager) throws ServiceException
    {
        _i18nUtils = (I18nUtils) manager.lookup(I18nUtils.ROLE);
        _userHelper = (UserHelper) manager.lookup(UserHelper.ROLE);
        _resolver = (AmetysObjectResolver) manager.lookup(AmetysObjectResolver.ROLE);
    }

    @Override
    public void configure(Configuration configuration) throws ConfigurationException
    {
        _label = _parseI18nizableText(configuration, _pluginName, "label");
        _description = _parseI18nizableText(configuration, _pluginName, "description");
    }

    @Override
    public String getId()
    {
        return _id;
    }

    @Override
    public I18nizableText getLabel()
    {
        return _label;
    }

    @Override
    public I18nizableText getDescription()
    {
        return _description;
    }

    @SuppressWarnings("unchecked")
    @Override
    public void index(Content content, SolrInputDocument document)
    {
        Object value = getValue(content);
        
        SearchField searchField = getSearchField();
        
        if (value == null || searchField == null || searchField.getName() == null)
        {
            // Nothing to index
            return;
        }

        MetadataType type = getType();
        switch (type)
        {
            case STRING:
            case CONTENT:
                if (isMultiple())
                {
                    _indexStringValues(searchField, (String[]) value, document);
                }
                else
                {
                    _indexStringValue(searchField, (String) value, document);
                }
                break;
            case DOUBLE:
                if (isMultiple())
                {
                    _indexDoubleValues(searchField, (Double[]) value, document);
                }
                else
                {
                    _indexDoubleValue(searchField, (Double) value, document);
                }
                break;
            case LONG:
                if (isMultiple())
                {
                    _indexLongValues(searchField, (Long[]) value, document);
                }
                else
                {
                    _indexLongValue(searchField, (Long) value, document);
                }
                break;
            case GEOCODE:
                _indexGeocodeValue(searchField, (Map<String, Double>) value, document);
                break;
            case BOOLEAN:
                if (isMultiple())
                {
                    _indexBooleanValues(searchField, (Boolean[]) value, document);
                }
                else
                {
                    _indexBooleanValue(searchField, (Boolean) value, document);
                }
                break;
            case DATE:
            case DATETIME:
                if (isMultiple())
                {
                    _indexDateValues(searchField, (Date[]) value, document);
                }
                else
                {
                    _indexDateValue(searchField, (Date) value, document);
                }
                break;
            case USER:
                if (isMultiple())
                {
                    _indexUserValues(searchField, (UserIdentity[]) value, document);
                }
                else
                {
                    _indexUserValue(searchField, (UserIdentity) value, document);
                }
                break;
            case FILE:
            case BINARY:
            case COMPOSITE:
            case RICH_TEXT:
            case REFERENCE:
            case SUB_CONTENT:
            case MULTILINGUAL_STRING:
                getLogger().warn("Type '" + type + "' is not supported for indexation on a system indexing field");
                break;
            default:
                break;
        }
        
        // Index sort field
        Object sortValue = getSortValue(content);
        if (isSortable() && sortValue != null && searchField.getSortField() != null && !searchField.getName().equals(searchField.getSortField()))
        {
            document.setField(searchField.getSortField(), sortValue);
        }
    }

    @Override
    public Object getSortValue(Content content)
    {
        // Default to getValue(), override to provide a specific sort value.
        Object value = getValue(content);
        
        if (value == null)
        {
            return null;
        }

        if (isMultiple() && value instanceof Object[] && ((Object[]) value).length > 0)
        {
            return ((Object[]) value)[0]; // return the first value
        }
        else
        {
            return value;
        }
    }
    
    @SuppressWarnings("unchecked")
    public void saxValue(ContentHandler handler, Content content) throws SAXException
    {
        Object value = getValue(content);
        
        if (value == null)
        {
            return;
        }
        
        MetadataType type = getType();
        switch (type)
        {
            case USER:
                if (value instanceof UserIdentity[])
                {
                    for (UserIdentity identity : (UserIdentity[]) value)
                    {
                        _saxUserIdentityValue(handler, identity);
                    }
                }
                else if (value instanceof UserIdentity)
                {
                    _saxUserIdentityValue(handler, (UserIdentity) value);
                }
                break;
            case CONTENT:
                Locale locale = content.getLanguage() != null ? new Locale(content.getLanguage()) : null;
                if (isMultiple())
                {
                    for (String id : (String[]) value)
                    {
                        _saxContentValue(handler, id, locale);
                    }
                }
                else
                {
                    _saxContentValue(handler, (String) value, locale);
                }
                break;
            case GEOCODE:
                _saxGeocodeValue(handler, (Map<String, Double>) value);
                break;
            case BOOLEAN:
            case DOUBLE:
            case LONG:
            case DATE:
            case DATETIME:
            case STRING:
                if (isMultiple())
                {
                    for (Object v : (Object[]) value)
                    {
                        _saxSingleValue(handler, v);
                    }
                }
                else
                {
                    _saxSingleValue(handler, value);
                }
                break;
            case BINARY:
            case COMPOSITE:
            case REFERENCE:
            case RICH_TEXT:
            case SUB_CONTENT:
            case MULTILINGUAL_STRING:
            default:
                getLogger().warn("Type '" + type + "' is not supported for saxing on a system indexing field");
                break;
                
        }
    }
    
    private void _saxContentValue(ContentHandler handler, String value, Locale locale) throws SAXException
    {
        try
        {
            Content content = _resolver.resolveById(value);
            
            AttributesImpl attrs = new AttributesImpl();
            attrs.addCDATAAttribute("id", content.getId());
            attrs.addCDATAAttribute("name", content.getName());
            attrs.addCDATAAttribute("title", content.getTitle(locale));
            if (content.getLanguage() != null)
            {
                attrs.addCDATAAttribute("language", content.getLanguage());
            }
            attrs.addCDATAAttribute("createdAt", ParameterHelper.valueToString(content.getCreationDate()));
            attrs.addCDATAAttribute("creator", content.getCreator().getLogin());
            attrs.addCDATAAttribute("lastModifiedAt", ParameterHelper.valueToString(content.getLastModified()));
            XMLUtils.createElement(handler, getId(), attrs);
        }
        catch (UnknownAmetysObjectException e)
        {
            if (getLogger().isWarnEnabled())
            {
                getLogger().warn("The system property'" + getId() + "' references a non-existing content '" + value + "'. It will be ignored.", e);
            }
        }
    }
    
    private void _saxUserIdentityValue(ContentHandler handler, UserIdentity value) throws SAXException
    {
        User user = _userHelper.getUser(value);
        if (user != null)
        {
            AttributesImpl attrs = new AttributesImpl();
            attrs.addCDATAAttribute("login", value.getLogin());
            attrs.addCDATAAttribute("populationId", value.getPopulationId());
            attrs.addCDATAAttribute("email", user.getEmail());
            XMLUtils.createElement(handler, getId(), attrs, user.getFullName());
        }
    }
    
    private void _saxGeocodeValue(ContentHandler handler, Map<String, Double> value) throws SAXException
    {
        AttributesImpl attrs = new AttributesImpl();
        attrs.addCDATAAttribute("longitude", String.valueOf(value.get("longitude")));
        attrs.addCDATAAttribute("latitude", String.valueOf(value.get("latitude")));

        XMLUtils.createElement(handler, getId(), attrs);
    }
    
    private void _saxSingleValue(ContentHandler handler, Object value) throws SAXException
    {
        XMLUtils.createElement(handler, getId(), ParameterHelper.valueToString(value));
    }
    
    
    
    @Override
    public Collection<SchemaDefinition> getSchemaDefinitions()
    {
        List<SchemaDefinition> definitions = new ArrayList<>();

        SearchField searchField = getSearchField();
        if (searchField != null)
        {
            String name = searchField.getName();
            String sortFieldName = searchField.getSortField();
            String facetFieldName = searchField.getFacetField();
            boolean multiple = isMultiple();
            String type = SchemaHelper.getSchemaType(getType());

            if (type != null)
            {
                definitions.add(new FieldDefinition(name, type, multiple, false));

                if (sortFieldName != null && !sortFieldName.equals(name))
                {
                    definitions.add(new FieldDefinition(sortFieldName, type, false, false));
                }

                if (facetFieldName != null && !facetFieldName.equals(name))
                {
                    // By default the index value in field name will be automatically copy in facet field
                    // So we do not need the index facet field manually
                    definitions.add(new FieldDefinition(facetFieldName, type, multiple, true));
                    definitions.add(new CopyFieldDefinition(name, facetFieldName));
                }
            }
        }

        return definitions;
    }

    /**
     * Parse an i18n text.
     * 
     * @param config the configuration to use.
     * @param pluginName the current plugin name.
     * @param name the child name.
     * @return the i18n text.
     * @throws ConfigurationException if the configuration is not valid.
     */
    protected I18nizableText _parseI18nizableText(Configuration config, String pluginName, String name) throws ConfigurationException
    {
        return I18nizableText.parseI18nizableText(config.getChild(name), "plugin." + pluginName);
    }

    /**
     * Get the value as a long.
     * 
     * @param value The value as an object.
     * @return The value as a long.
     */
    protected String parseString(Object value)
    {
        if (value instanceof String)
        {
            return (String) value;
        }
        else
        {
            throw new IllegalArgumentException("The value " + value + " for criterion " + getId() + " is not a valid String value.");
        }
    }

    /**
     * Get the value as a long.
     * 
     * @param value The value as an object.
     * @return The value as a long.
     */
    protected long parseLong(Object value)
    {
        if (value instanceof Long)
        {
            return (Long) value;
        }
        else if (value instanceof String)
        {
            return Long.parseLong((String) value);
        }
        else
        {
            throw new IllegalArgumentException("The value " + value + " for criterion " + getId() + " is not a valid long value.");
        }
    }

    /**
     * Get the value as a double.
     * 
     * @param value The value as an object.
     * @return The value as a double.
     */
    protected double parseDouble(Object value)
    {
        if (value instanceof Double)
        {
            return (Double) value;
        }
        else if (value instanceof String)
        {
            return Double.parseDouble((String) value);
        }
        else
        {
            throw new IllegalArgumentException("The value " + value + " for criterion " + getId() + " is not a valid double value.");
        }
    }

    /**
     * Get the value as a boolean.
     * 
     * @param value The value as an object, can be a Boolean or a String.
     * @return The value as a boolean.
     */
    protected boolean parseBoolean(Object value)
    {
        if (value instanceof Boolean)
        {
            return (Boolean) value;
        }
        else if (value instanceof String)
        {
            return Boolean.parseBoolean((String) value);
        }
        else
        {
            throw new IllegalArgumentException("The value " + value + " for criterion " + getId() + " is not a valid boolean value.");
        }
    }

    /**
     * Get the value as a date.
     * 
     * @param value The value as an object, can be a Date or a String.
     * @return The value as a Date object.
     */
    protected Date parseDate(Object value)
    {
        if (value instanceof Date)
        {
            return (Date) value;
        }
        else if (value instanceof String)
        {
            return (Date) ParameterHelper.castValue((String) value, ParameterType.DATE);
        }
        else
        {
            throw new IllegalArgumentException("The value " + value + " for criterion " + getId() + " is not a valid date value.");
        }
    }
    
    /**
     * Get the value as array of {@link UserIdentity}
     * @param value The value to parse
     * @return A array of {@link UserIdentity}
     */
    @SuppressWarnings("unchecked")
    protected UserIdentity[] parseUserArray (Object value)
    {
        if (value instanceof UserIdentity)
        {
            return new UserIdentity[] {(UserIdentity) value};
        }
        else if (value instanceof UserIdentity[])
        {
            return (UserIdentity[]) value;
        }
        else if (value instanceof List<?>)
        {
            return (UserIdentity[]) ((List<?>) value).stream().map(v -> _userHelper.json2userIdentity((Map<String, String>) v)).toArray();
        }
        else if (value instanceof Map)
        {
            UserIdentity userIdentity = _userHelper.json2userIdentity((Map<String, String>) value);
            if (userIdentity != null)
            {
                return new UserIdentity[] {userIdentity};
            }
            return new UserIdentity[0];
        }
        else
        {
            throw new IllegalArgumentException("The value " + value + " for criterion " + getId() + " is not a valid UserIdentity values.");
        }
    }

    /**
     * Get the value as a array of String
     * @param value The value as an object to parse
     * @return The values as a String array
     */
    protected String[] parseStringArray(Object value)
    {
        if (value instanceof String)
        {
            return new String[] {(String) value};
        }
        else if (value instanceof String[])
        {
            return (String[]) value;
        }
        else if (value instanceof List<?>)
        {
            return ((List<?>) value).stream()
                    .map(v -> String.valueOf(v))
                    .toArray(String[]::new);
        }
        else
        {
            throw new IllegalArgumentException("The value " + value + " for criterion " + getId() + " is not a valid String[] values.");
        }
    }
    
    // ------------------------------------------------------
    //                  INDEX
    // ------------------------------------------------------
    /**
     * Index multiple String values
     * @param field The search field
     * @param values The values
     * @param document The Solr document to index into
     */
    protected void _indexStringValues (SearchField field, String[] values, SolrInputDocument document)
    {
        document.setField(field.getName(), values);
    }
    
    /**
     * Index String value
     * @param field The search field
     * @param value The value
     * @param document The Solr document to index into
     */
    protected void _indexStringValue (SearchField field, String value, SolrInputDocument document)
    {
        document.setField(field.getName(), value);
        // NB : facet field if present will be indexed automatically thanks to solr copy field (see #getSchemaDefinitions)
    }
    
    /**
     * Index multiple Date values
     * @param field The search field
     * @param values The values
     * @param document The Solr document to index into
     */
    protected void _indexDateValues (SearchField field, Date[] values, SolrInputDocument document)
    {
        document.setField(field.getName(), values);
    }
    
    /**
     * Index Date value
     * @param field The search field
     * @param value The value
     * @param document The Solr document to index into
     */
    protected void _indexDateValue (SearchField field, Date value, SolrInputDocument document)
    {
        document.setField(field.getName(), SolrIndexer.dateFormat().format(value));
        // NB : facet field if present will be indexed automatically thanks to solr copy field (see #getSchemaDefinitions)
    }
    
    /**
     * Index multiple Long values
     * @param field The search field
     * @param values The values
     * @param document The Solr document to index into
     */
    protected void _indexLongValues(SearchField field, Long[] values, SolrInputDocument document)
    {
        document.setField(field.getName(), values);
    }
    
    /**
     * Index Long value
     * @param field The search field
     * @param value The value
     * @param document The Solr document to index into
     */
    protected void _indexLongValue(SearchField field, Long value, SolrInputDocument document)
    {
        document.setField(field.getName(), value);
        // NB : facet field if present will be indexed automatically thanks to solr copy field (see #getSchemaDefinitions)
    }
    
    /**
     * Index multiple Double values
     * @param field The search field
     * @param values The values
     * @param document The Solr document to index into
     */
    protected void _indexDoubleValues(SearchField field, Double[] values, SolrInputDocument document)
    {
        document.setField(field.getName(), values);
    }
    
    /**
     * Index Double value
     * @param field The search field
     * @param value The value
     * @param document The Solr document to index into
     */
    protected void _indexDoubleValue(SearchField field, Double value, SolrInputDocument document)
    {
        document.setField(field.getName(), value);
        // NB : facet field if present will be indexed automatically thanks to solr copy field (see #getSchemaDefinitions)
    }
    
    /**
     * Index multiple Boolean values
     * @param field The search field
     * @param values The values
     * @param document The Solr document to index into
     */
    protected void _indexBooleanValues(SearchField field, Boolean[] values, SolrInputDocument document)
    {
        document.setField(field.getName(), values);
    }
    
    /**
     * Index Boolean value
     * @param field The search field
     * @param value The value
     * @param document The Solr document to index into
     */
    protected void _indexBooleanValue(SearchField field, Boolean value, SolrInputDocument document)
    {
        document.setField(field.getName(), value);
        // NB : facet field if present will be indexed automatically thanks to solr copy field (see #getSchemaDefinitions)
    }
    
    /**
     * Index multiple UserIdentity values
     * @param field The search field
     * @param values The values
     * @param document The Solr document to index into
     */
    protected void _indexUserValues(SearchField field, UserIdentity[] values, SolrInputDocument document)
    {
        document.setField(field.getName(), values);
    }
    
    /**
     * Index UserIdentity value
     * @param field The search field
     * @param value The value
     * @param document The Solr document to index into
     */
    protected void _indexUserValue(SearchField field, UserIdentity value, SolrInputDocument document)
    {
        document.setField(field.getName(), UserIdentity.userIdentityToString(value));
        // NB : facet field if present will be indexed automatically thanks to solr copy field (see #getSchemaDefinitions)
    }
    
    /**
     * Index geocode value
     * @param field The search field
     * @param value The value
     * @param document The Solr document to index into
     */
    protected void _indexGeocodeValue(SearchField field, Map<String, Double> value, SolrInputDocument document)
    {
        double longitude = value.get("longitude");
        double latitude = value.get("latitude");
        
        document.setField(field.getName() + "$longitude_d", longitude);
        document.setField(field.getName() + "$latitude_d", latitude);
        
        String geoFieldName = SolrFieldHelper.getIndexingFieldName(MetadataType.GEOCODE, field.getName());
        document.setField(geoFieldName, longitude + " " + latitude);
    }
    
    
}