/*
 *  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.Collections;
import java.util.Date;
import java.util.List;
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.solr.common.SolrInputDocument;

import org.ametys.cms.content.indexing.solr.SolrIndexer;
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.UserIdentity;
import org.ametys.core.util.I18nUtils;
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;

    @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);
    }

    @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;
    }

    @Override
    public EnumeratorDefinition getEnumeratorDefinition(Collection<String> contentTypes, Configuration configuration)
    {
        // Default null, override to set an enumerator.
        return null;
    }

    @Override
    public String getContentTypeId()
    {
        return null;
    }

    @Override
    public boolean isSearchable()
    {
        // Default to true: override when the property is not searchable.
        return true;
    }

    @Override
    public boolean isDisplayable()
    {
        // Default to true: override when the property is not displayable.
        return true;
    }

    @Override
    public String getWidget()
    {
        return null;
    }

    public Map<String, I18nizableText> getWidgetParameters()
    {
        return Collections.emptyMap();
    }

    @Override
    public String getRenderer()
    {
        return null;
    }

    @Override
    public String getConverter()
    {
        return null;
    }

    @Override
    public Integer getColumnWidth()
    {
        return null;
    }

    @Override
    public void index(Content content, SolrInputDocument document)
    {
        SearchField searchField = getSearchField();
        String fieldName = searchField != null ? searchField.getName() : null;
        String sortFieldName = searchField != null ? searchField.getSortField() : null;
        Object value = getValue(content);

        if (value != null && fieldName != null)
        {
            if (isMultiple())
            {
                if (value instanceof Collection< ? > || value.getClass().isArray())
                {
                    // FIXME can lead to indexation mistakes if collection or array of dates
                    document.setField(fieldName, value);
                }
                else
                {
                    _indexSingleValue(document, fieldName, value);
                }
            }
            else
            {
                _indexSingleValue(document, fieldName, value);
            }

            Object sortValue = getSortValue(content);
            if (isSortable() && sortValue != null && sortFieldName != null && !fieldName.equals(sortFieldName))
            {
                document.setField(sortFieldName, sortValue);
            }
        }
    }
    
    private void _indexSingleValue(SolrInputDocument document, String fieldName, Object value)
    {
        if (value instanceof Date)
        {
            document.setField(fieldName, SolrIndexer.dateFormat().format((Date) value));
        }
        else
        {
            // Index the single value.
            document.setField(fieldName, value);
        }
    }

    @Override
    public Object getFullValue(Content content)
    {
        // Default to getValue(), override to provide a specific "full" value.
        return getValue(content);
    }

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

    @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))
                {
                    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 -> new UserIdentity(((Map<String, String>) v).get("login"), ((Map<String, String>) v).get("populationId"))).toArray();
        }
        else if (value instanceof Map)
        {
            Map<String, Object> userValue = (Map<String, Object>) value;
            
            String login = (String) userValue.get("login");
            String populationId = (String) userValue.get("populationId");
            
            if (login != null && populationId != null)
            {
                return new UserIdentity[] {new UserIdentity(login, populationId)};
            }
            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.");
        }
    }

}