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

import java.io.InputStream;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;
import java.util.Locale;
import java.util.Optional;

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.lang3.StringUtils;
import org.apache.solr.common.SolrInputDocument;
import org.apache.tika.Tika;
import org.apache.tika.exception.ZeroByteFileException;

import org.ametys.cms.data.type.indexing.IndexableDataContext;
import org.ametys.cms.data.type.indexing.IndexableElementTypeHelper;
import org.ametys.cms.languages.LanguagesManager;
import org.ametys.cms.search.solr.field.FirstValidationSearchField;
import org.ametys.cms.search.solr.field.LastMajorValidationSearchField;
import org.ametys.cms.search.solr.field.LastModifiedSearchField;
import org.ametys.cms.search.solr.field.LastValidationSearchField;
import org.ametys.core.file.TikaProvider;
import org.ametys.core.user.UserIdentity;
import org.ametys.plugins.explorer.resources.Resource;
import org.ametys.plugins.explorer.resources.ResourceCollection;
import org.ametys.plugins.explorer.resources.ResourceHelper;
import org.ametys.plugins.repository.AmetysObject;
import org.ametys.plugins.repository.TraversableAmetysObject;
import org.ametys.plugins.repository.dublincore.DublinCoreAwareAmetysObject;
import org.ametys.runtime.plugin.component.AbstractLogEnabled;

/**
 * Solr resource indexer.<p>
 * Populate a Solr input document with the following fields:
 * <dl>
 *  <dt>id
 *  <dd>resource id
 *  <dt>type
 *  <dd>with <code>"document"</code> value
 *  <dt>full
 *  <dd>resource content
 * </dl>
 */
public class SolrResourceIndexer extends AbstractLogEnabled implements Component, Serviceable, SolrFieldNames
{
    /** The avalon role. */
    public static final String ROLE = SolrResourceIndexer.class.getName();
    
    /** The Tika instance. */
    protected Tika _tika;
    
    /** The language manager. */
    protected LanguagesManager _langManager;

    /** The solr indexer */
    protected SolrIndexer _solrIndexer;
    
    @Override
    public void service(ServiceManager manager) throws ServiceException
    {
        TikaProvider tikaProvider = (TikaProvider) manager.lookup(TikaProvider.ROLE);
        _tika = tikaProvider.getTika();
        _langManager = (LanguagesManager) manager.lookup(LanguagesManager.ROLE);
        _solrIndexer = (SolrIndexer) manager.lookup(SolrIndexer.ROLE);
    }
    
    /**
     * Index a resource.
     * @param resource The resource to index.
     * @param document The Solr document to index into.
     * @param documentType The document type of the resource
     * @throws Exception if an error occurs.
     */
    public void indexResource(Resource resource, SolrInputDocument document, String documentType) throws Exception
    {
        indexResource(resource, document, documentType, null, null);
    }
    
    /**
     * Index a resource.
     * @param resource The resource to index.
     * @param document The Solr document to index into.
     * @param documentType The document type of the resource
     * @param language The query language.
     * @throws Exception if an error occurs.
     */
    public void indexResource(Resource resource, SolrInputDocument document, String documentType, String language) throws Exception
    {
        indexResource(resource, document, documentType, language, null);
    }
    
    /**
     * Index a resource.
     * @param resource The resource to index.
     * @param document The Solr document to index into.
     * @param documentType The document type of the resource
     * @param resourceRoot The resource root, can be null. When null, it will have to be computed.
     * @throws Exception if an error occurs.
     */
    public void indexResource(Resource resource, SolrInputDocument document, String documentType, TraversableAmetysObject resourceRoot) throws Exception
    {
        indexResource(resource, document, documentType, null, resourceRoot);
    }
    
    /**
     * Index a resource.
     * @param resource The resource to index.
     * @param document The Solr document to index into.
     * @param documentType The document type of the resource
     * @param language The language, can be null.
     * @param resourceRoot The resource root, can be null. When null, it will have to be computed.
     * @throws Exception if an error occurs.
     */
    public void indexResource(Resource resource, SolrInputDocument document, String documentType, String language, TraversableAmetysObject resourceRoot) throws Exception
    {
        // Resource id
        document.addField(ID, resource.getId());
        // Type is resource
        document.addField(DOCUMENT_TYPE, documentType);
        document.addField(PSEUDO_CONTENT_TYPES, PSEUDO_CONTENT_TYPE_VALUE_RESOURCE);
        // The resource path.
        document.setField(PATH, resource.getResourcePath());
        document.addField(FILENAME, resource.getName());
        
        // Title
        String title = StringUtils.substringBeforeLast(resource.getName(), ".");
        // Index title like other string values (like content attributes)
        IndexableDataContext context = IndexableDataContext.newInstance();
        if (StringUtils.isNotEmpty(language))
        {
            context.withLocale(new Locale(language));
        }
        IndexableElementTypeHelper.indexStringValue(document, document, TITLE, title, context, getLogger());
        // Add sort indexation
        document.setField(TITLE_SORT, resource.getName());
        document.addField(TITLE + "_s_sort", title);
        // Add title to "full" (already added to "systemFull")
        IndexableDataContext fullContext = context.cloneContext()
                .withIndexForFullTextField(true)
                .withFullTextFieldName(SolrFieldNames.FULL);
        IndexableElementTypeHelper.indexFulltextValue(document, title, fullContext);
        
        _populateDatesOfPage(resource, document);

        // Mime types
        document.addField(MIME_TYPES, resource.getMimeType());
        // Length
        document.addField(LENGTH, resource.getLength());
        
        AmetysObject root = resourceRoot == null ? ResourceHelper.getResourceRoot(resource) : resourceRoot;
        document.addField(RESOURCE_ROOT_ID, root.getId());
        
        // Parents resource collections of the resource
        _indexAncestorIds(resource, document);
        
        // Resource author
        String author = UserIdentity.userIdentityToString(resource.getCreator());
        if (StringUtils.isNotBlank(author))
        {
            document.setField(RESOURCE_CREATOR, author);
        }
        
        // Hard-coded content type for facets.
        // TODO Move to specific "embedded mode" method?
        document.addField(CONTENT_TYPES, CONTENT_TYPE_RESOURCE);
        
        // Indexation of ACL initial values
        _solrIndexer.indexAclInitValues(resource, document);
        
        indexResourceContent(resource, document, language);
    }
    
    /**
     * Populate the solr input document with dates from the resource
     * @param resource The resource
     * @param document The Solr document
     */
    protected void _populateDatesOfPage(Resource resource, SolrInputDocument document)
    {
        // Last modified
        String lastModifiedStr = SolrIndexer.dateFormat().format(resource.getLastModified());
        // For 'new' search service
        document.addField(LastModifiedSearchField.NAME, lastModifiedStr);
        // For 'old' search service
        document.addField(LAST_MODIFIED + "_dt", lastModifiedStr);
        
        // For 'new' search service => last validation, last major validation
        document.addField(LastValidationSearchField.NAME, lastModifiedStr);
        document.addField(LastMajorValidationSearchField.NAME, lastModifiedStr);
        
        // For 'new' search service => first validation
        String creationDateStr = SolrIndexer.dateFormat().format(resource.getCreationDate());
        document.addField(FirstValidationSearchField.NAME, creationDateStr);
        
        // Solr facet specific : dates-facet
        Date date = resource.getDCDate();
        String formattedDate = SolrIndexer.dateFormat().format(date);
        if (formattedDate != null)
        {
            document.setField(RESOURCE_DATE, formattedDate);
            document.setField(DATE_FOR_SORTING, formattedDate);
            document.setField(DATES_FACET, formattedDate);
        }
    }
    
    private void _indexAncestorIds(Resource resource, SolrInputDocument document)
    {
        // Ancestors
        List<String> ancestorIds = new ArrayList<>();
        AmetysObject parent = resource.getParent();
        while (parent instanceof ResourceCollection)
        {
            ancestorIds.add(parent.getId());
            parent = parent.getParent();
        }
        
        document.addField(RESOURCE_ANCESTOR_IDS, ancestorIds);
        
        // Ancestors and self
        List<String> ancestorAndSelfIds = new ArrayList<>();
        ancestorAndSelfIds.add(resource.getId());
        ancestorAndSelfIds.addAll(ancestorIds);
        document.addField(RESOURCE_ANCESTOR_AND_SELF_IDS, ancestorAndSelfIds);
    }
    
    /**
     * Index a collection of resources.
     * @param resourceCollection the resource collection to index.
     * @param document The document to index into.
     * @param language The current language.
     * @throws Exception if an error occurs while indexing.
     */
    public void indexResourceCollection(ResourceCollection resourceCollection, SolrInputDocument document, String language) throws Exception
    {
        if (resourceCollection == null)
        {
            return;
        }
        
        for (AmetysObject object : resourceCollection.getChildren())
        {
            if (object instanceof ResourceCollection)
            {
                indexResourceCollection((ResourceCollection) object, document, language);
            }
            else if (object instanceof Resource)
            {
                indexResourceContent((Resource) object, document, language);
            }
        }
    }
    
    /**
     * Index a resource content (text in case of a document, and Dublin Core metadata).
     * @param resource The resource to index.
     * @param document The document to index into.
     * @param language The current language, can be null.
     */
    public void indexResourceContent(Resource resource, SolrInputDocument document, String language)
    {
        try (InputStream is = resource.getInputStream())
        {
            String value = _getResourceContent(resource);
            
            indexFulltextValue(document, value, language);
            
            if (StringUtils.isNotBlank(value))
            {
                int summaryEndIndex = value.lastIndexOf(' ', 200);
                if (summaryEndIndex == -1)
                {
                    summaryEndIndex = value.length();
                }
                document.addField(EXCERPT, value.substring(0, summaryEndIndex) + (summaryEndIndex != value.length() ? "…" : ""));
            }
            
            for (String keyword : resource.getDCSubject())
            {
                indexFulltextValue(document, keyword, language);
            }

            String desc = resource.getDCDescription();
            if (desc != null)
            {
                indexFulltextValue(document, desc, language);
            }
            
            // DC meta
            indexDublinCoreMetadata(resource, document);
        }
        catch (Throwable e)
        {
            getLogger().error("Unable to index resource at " + resource.getPath(), e);
        }
    }
    
    private String _getResourceContent(Resource resource) throws Throwable
    {
        try (InputStream is = resource.getInputStream())
        {
            return _tika.parseToString(is);
        }
        catch (ZeroByteFileException e)
        {
            // Ignore it, the file is empty, nothing to do
            return StringUtils.EMPTY;
        }
        catch (Throwable e)
        {
            throw e;
        }
    }
    
    /**
     * Index a full-text value.
     * @param document The document to index into.
     * @param text The text to index.
     * @param language The content language, can be null.
     */
    protected void indexFulltextValue(SolrInputDocument document, String text, String language)
    {
        IndexableDataContext context = IndexableDataContext.newInstance()
                .withIndexForFullTextField(true); // Facultative here because not asked by the following methods, but a protection for the future
        if (StringUtils.isNotEmpty(language))
        {
            context.withLocale(new Locale(language));
        }
        
        // Index the document in systemFull
        IndexableElementTypeHelper.indexFulltextValue(document, text, context);
        
        // Then in full
        IndexableElementTypeHelper.indexFulltextValue(document, text, context.withFullTextFieldName(SolrFieldNames.FULL));
    }
    
    ///////////////////////////////////////////////////////////////////////////
    
    /**
     * Index Dublin core metadata.
     * @param object the {@link DublinCoreAwareAmetysObject} holding Dublin Core metadata.
     * @param document the solr input document to populate.
     */
    public void indexDublinCoreMetadata(DublinCoreAwareAmetysObject object, SolrInputDocument document)
    {
        _indexNonNullValue(document, DC_TITLE, object.getDCTitle());
        _indexNonNullValue(document, DC_SUBJECT, object.getDCSubject());
        _indexNonNullValue(document, DC_DESCRIPTION, object.getDCDescription());
        _indexNonNullValue(document, DC_CONTRIBUTOR, object.getDCContributor());
        _indexNonNullValue(document, DC_COVERAGE, object.getDCCoverage());
        _indexNonNullValue(document, DC_CREATOR, object.getDCCreator());
        String mimeType = _getDcFormatToIndex(object);
        _indexNonNullValue(document, DC_FORMAT, mimeType);
        _indexNonNullValue(document, DC_LANGUAGE, object.getDCLanguage());
        _indexNonNullValue(document, DC_PUBLISHER, object.getDCPublisher());
        _indexNonNullValue(document, DC_RIGHTS, object.getDCRights());
        _indexNonNullValue(document, DC_DATE, SolrIndexer.dateFormat().format(object.getDCDate()));
        
        SolrResourceGroupedMimeTypes.getGroup(mimeType)
                .ifPresent(groupMimeType -> document.addField(RESOURCE_MIME_TYPE_GROUP, groupMimeType));
    }
    
    private static String _getDcFormatToIndex(DublinCoreAwareAmetysObject object)
    {
        return Optional.of(object)
                .map(DublinCoreAwareAmetysObject::getDCFormat)
                // According to https://en.wikipedia.org/wiki/Media_type#Naming
                // input format is:
                // type "/" [tree "."] subtype ["+" suffix] *[";" parameter]
                // just output the part without optional parameters
                .map(mimeType -> StringUtils.substringBefore(mimeType, ";"))
                // According to https://en.wikipedia.org/wiki/Media_type#Naming
                // Types, subtypes, and parameter names are case-insensitive
                .map(String::toLowerCase)
                .orElse(null);
    }
    
    private static void _indexNonNullValue(SolrInputDocument document, String fieldName, String value)
    {
        if (value != null)
        {
            document.addField(fieldName, value);
        }
    }
    
    private static void _indexNonNullValue(SolrInputDocument document, String fieldName, String[] values)
    {
        if (values != null)
        {
            for (String value : values)
            {
                document.addField(fieldName, value);
            }
        }
    }
    
    /*private static void _indexNonNullValue(SolrInputDocument document, String fieldName, Date value)
    {
        if (value != null)
        {
            document.addField(fieldName, value);
        }
    }*/
}