/*
 *  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.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;

import org.apache.avalon.framework.configuration.Configuration;
import org.apache.avalon.framework.service.ServiceException;
import org.apache.avalon.framework.service.ServiceManager;
import org.apache.cocoon.xml.XMLUtils;
import org.apache.commons.lang.BooleanUtils;
import org.apache.solr.common.SolrInputDocument;
import org.xml.sax.ContentHandler;
import org.xml.sax.SAXException;

import org.ametys.cms.content.indexing.solr.SolrContentIndexer;
import org.ametys.cms.content.indexing.solr.SolrFieldNames;
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.query.Query;
import org.ametys.cms.search.query.Query.Operator;
import org.ametys.cms.search.query.TagQuery;
import org.ametys.cms.search.solr.field.TagSearchField;
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.cms.tag.Tag;
import org.ametys.cms.tag.TagHelper;
import org.ametys.cms.tag.TagProviderExtensionPoint;
import org.ametys.core.util.JSONUtils;
import org.ametys.runtime.i18n.I18nizableText;

/**
 * {@link SystemProperty} which represents the tags of a Content.
 */
public class TagsSystemProperty extends AbstractSystemProperty
{
    /** The tag provider extension point. */
    protected TagProviderExtensionPoint _tagProviderEP;
    /** The JSON utils */
    protected JSONUtils _jsonUtils;
    
    @Override
    public void service(ServiceManager manager) throws ServiceException
    {
        super.service(manager);
        _tagProviderEP = (TagProviderExtensionPoint) manager.lookup(TagProviderExtensionPoint.ROLE);
        _jsonUtils = (JSONUtils) manager.lookup(JSONUtils.ROLE);
    }
    
    @Override
    public MetadataType getType()
    {
        return MetadataType.STRING;
    }
    
    @Override
    public boolean isMultiple()
    {
        return true;
    }
    
    @Override
    public boolean isSortable()
    {
        return false;
    }
    
    @SuppressWarnings("unchecked")
    @Override
    public Query getQuery(Object value, Operator operator, String language, Map<String, Object> contextualParameters)
    {
        if (value instanceof Map<?, ?>)
        {
            // Handle autoposting
            Map<String, Object> valueAsMap = (Map<String, Object>) value;
            
            String[] tagNames = parseStringArray(valueAsMap.get("value"));
            
            boolean autoposting = BooleanUtils.isTrue((Boolean) valueAsMap.get("autoposting"));
            return new TagQuery(operator, autoposting, tagNames);
        }
        else
        {
            return new TagQuery(operator, parseStringArray(value));
        }
    }
    
    @Override
    public SearchField getSearchField()
    {
        return new TagSearchField();
    }
    
    @Override
    public String getWidget()
    {
        return "edition.tag";
    }
    
    @Override
    public Map<String, I18nizableText> getWidgetParameters(Configuration configuration)
    {
        Map<String, I18nizableText> params = new HashMap<>();
        
        params.put("targetType", new I18nizableText("CONTENT"));
        params.put("allowToggleAutoposting", new I18nizableText("true"));
        
        return params;
    }
    
    @Override
    public String getRenderer()
    {
        return "Ametys.plugins.cms.search.SearchGridHelper.renderTag";
    }
    
    @Override
    public String getConverter()
    {
        return "Ametys.plugins.cms.search.SearchGridHelper.convertTag";
    }
    
    @Override
    public void index(Content content, SolrInputDocument document)
    {
        Set<String> tagsWithAncestors = new HashSet<>();
        String language = content.getLanguage();
        
        for (String tagName : content.getTags())
        {
            document.addField(SolrFieldNames.TAGS, tagName);
            
            if (!tagsWithAncestors.contains(tagName))
            {
                document.addField(SolrFieldNames.ALL_TAGS, tagName);
                tagsWithAncestors.add(tagName);
            }
            
            Tag tag = _tagProviderEP.getTag(tagName, getTagContextualParameters(content));
            if (tag != null)
            {
                String title = _i18nUtils.translate(tag.getTitle(), language);
                SolrContentIndexer.indexFulltextValue(document, title, language);
            }
            
            // Index ancestors (descendant autoposting)
            Set<Tag> ancestors = TagHelper.getAncestors(tag, false);
            
            for (Tag ancestor : ancestors)
            {
                String ancestorName = ancestor.getName();
                if (!tagsWithAncestors.contains(ancestorName))
                {
                    document.addField(SolrFieldNames.ALL_TAGS, ancestorName);
                    
                    // Plain text + autocompletion on ancestors (if enabled)
                    if (isAutopostingEnabled(content))
                    {
                        String title = _i18nUtils.translate(ancestor.getTitle(), language);
                        SolrContentIndexer.indexFulltextValue(document, title, language);
                    }
                    
                    tagsWithAncestors.add(tagName);
                }
            }
        }
    }
    
    @Override
    public Object getValue(Content content)
    {
        Set<String> tags = content.getTags();
        return tags.toArray(new String[tags.size()]);
    }
   
    @Override
    public Object getJsonValue(Content content, boolean full)
    {
        String[] tags = (String[]) getValue(content);
        if (full)
        {
            List<Map<String, Object>> fullValue = new ArrayList<>();
            
            Map<String, Object> params = getTagContextualParameters(content);
            
            for (String tagName : tags)
            {
                Map<String, Object> infos = new HashMap<>();
                infos.put("name", tagName);
                
                Tag tag = _tagProviderEP.getTag(tagName, params);
                if (tag != null)
                {
                    infos.put("label", tag.getTitle());
                }
                
                fullValue.add(infos);
            }
            
            return fullValue;
        }
        
        return tags;
    }   
    
    @Override
    public void saxValue(ContentHandler handler, Content content) throws SAXException
    {
        String[] tags = (String[]) getValue(content);
        
        XMLUtils.startElement(handler, getId());
        
        for (String tag : tags)
        {
            XMLUtils.createElement(handler, "tag", tag);
        }
        
        XMLUtils.endElement(handler, getId());
    }
    
    /**
     * Get the tags contextual parameters.
     * @param content The content.
     * @return the tags contextual parameters.
     */
    protected Map<String, Object> getTagContextualParameters(Content content)
    {
        return Collections.emptyMap();
    }
    
    /**
     * Test if autoposting is enabled.
     * @param content The content.
     * @return true if enabled.
     */
    protected boolean isAutopostingEnabled(Content content)
    {
        return true;
    }
    
    @Override
    public Collection<SchemaDefinition> getSchemaDefinitions()
    {
        Collection<SchemaDefinition> definitions = super.getSchemaDefinitions();
        
        // Add allTags solr field
        definitions.add(new FieldDefinition(SolrFieldNames.ALL_TAGS, SchemaHelper.getSchemaType(getType()), isMultiple(), false));
        return definitions;
    }
}