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

import java.io.IOException;
import java.util.Set;

import javax.jcr.Repository;
import javax.jcr.RepositoryException;
import javax.jcr.Session;

import org.apache.avalon.framework.component.Component;
import org.apache.avalon.framework.context.Context;
import org.apache.avalon.framework.context.ContextException;
import org.apache.avalon.framework.context.Contextualizable;
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.components.ContextHelper;
import org.apache.cocoon.environment.Request;
import org.apache.solr.client.solrj.SolrServerException;

import org.ametys.cms.content.indexing.solr.SolrIndexer;
import org.ametys.cms.indexing.IndexingException;
import org.ametys.cms.indexing.WorkspaceIndexer;
import org.ametys.cms.repository.RequestAttributeWorkspaceSelector;
import org.ametys.core.ui.Callable;
import org.ametys.plugins.repository.provider.AbstractRepository;
import org.ametys.plugins.repository.provider.WorkspaceSelector;
import org.ametys.runtime.plugin.component.AbstractLogEnabled;

/**
 * Component indexing a workspace in a Solr server.
 */
public class SolrWorkspaceIndexer extends AbstractLogEnabled implements WorkspaceIndexer, Component, Serviceable, Contextualizable
{
    /** The repository. */
    protected Repository _repository;
    
    /** The solr indexer. */
    protected SolrIndexer _solrIndexer;
    
    /** The workspace selector. */
    protected WorkspaceSelector _workspaceSelector;
    
    /** Additional documents provider extension point. */
    protected DocumentProviderExtensionPoint _docProviderEP;
    
    /** The component context. */
    protected Context _context;
    
    @Override
    public void service(ServiceManager manager) throws ServiceException
    {
        _repository = (Repository) manager.lookup(AbstractRepository.ROLE);
        _solrIndexer = (SolrIndexer) manager.lookup(SolrIndexer.ROLE);
        _workspaceSelector = (WorkspaceSelector) manager.lookup(WorkspaceSelector.ROLE);
        _docProviderEP = (DocumentProviderExtensionPoint) manager.lookup(DocumentProviderExtensionPoint.ROLE);
    }
    
    @Override
    public void contextualize(Context context) throws ContextException
    {
        _context = context;
    }
    
    @Override
    @Callable
    public void indexAllWorkspaces() throws IndexingException
    {
        try
        {
            // Get all the workspaces and reindex them.
            Session session = _repository.login();
            String[] workspaceNames = session.getWorkspace().getAccessibleWorkspaceNames();
            
            for (String workspaceName : workspaceNames)
            {
                index(workspaceName);
            }
        }
        catch (RepositoryException e)
        {
            getLogger().error("Error while indexing the workspaces.", e);
            throw new IndexingException("Error while indexing the workspaces.", e);
        }
    }
    
    @Override
    public void index(String workspaceName) throws IndexingException
    {
        try
        {
            // Create the core corresponding to the workspace if it doesn't exist.
            ensureCoreExists(workspaceName);
            
            _solrIndexer.sendSchema();
            
            getLogger().info("Start indexing workspace {}...", workspaceName);
            
            _forceWorkspaceAndDoIndex(workspaceName);
            
            getLogger().info("Successfully indexed workspace {}", workspaceName);
        }
        catch (IOException | SolrServerException e)
        {
            getLogger().error("Error while sending schema.", e);
            throw new IndexingException("Error while sending schema.", e);
        }
    }
    
    private void _forceWorkspaceAndDoIndex(String workspaceName) throws IndexingException
    {
        Request request = ContextHelper.getRequest(_context);
        
        // Retrieve the current workspace.
        String currentWsp = RequestAttributeWorkspaceSelector.getForcedWorkspace(request);
        
        try
        {
            // Force the workspace.
            RequestAttributeWorkspaceSelector.setForcedWorkspace(request, workspaceName);
            doIndex(workspaceName);
        }
        finally
        {
            // Restore context
            RequestAttributeWorkspaceSelector.setForcedWorkspace(request, currentWsp);
        }
        
    }
    
    /**
     * Index the given workspace.
     * @param workspaceName The workspace name.
     * @throws IndexingException If an error occurs indexing the workspace.
     */
    protected void doIndex(String workspaceName) throws IndexingException
    {
        try
        {
            // First, unindex all documents.
            _solrIndexer.unindexAllDocuments(workspaceName, false);
            
            // Index all contents.
            _solrIndexer.indexAllContents(workspaceName, false);
            
            // Index all resources.
            _solrIndexer.indexAllResources(workspaceName, false);
            
            // Eventually index additional documents.
            indexAdditionalDocuments(workspaceName);
            
            // Commit changes
            _solrIndexer.commit(workspaceName);
            // When done indexing, optimize.
            _solrIndexer.optimize(workspaceName);
        }
        catch (Exception e)
        {
            getLogger().error("Error indexing the workspace '" + workspaceName + "'.", e);
            throw new IndexingException("Error indexing the workspace '" + workspaceName + "'.", e);
        }
    }
    
    /**
     * Index additional documents provided by the extensions.
     * @param workspaceName The workspace name.
     * @throws IndexingException If an error occurs while indexing.
     */
    protected void indexAdditionalDocuments(String workspaceName) throws IndexingException
    {
        for (String id : _docProviderEP.getExtensionsIds())
        {
            DocumentProvider docProvider = _docProviderEP.getExtension(id);
            docProvider.indexDocuments(workspaceName);
        }
    }
    
    /**
     * Create the given core if it doesn't exist.
     * @param coreName The core name.
     * @throws IOException If an I/O error occurs.
     * @throws SolrServerException If a solr error occurs.
     */
    protected void ensureCoreExists(String coreName) throws IOException, SolrServerException
    {
        Set<String> coreNames = _solrIndexer.getCoreNames();
        if (!coreNames.contains(coreName))
        {
            _solrIndexer.createCore(coreName);
        }
    }
    
}