/*
*  Copyright 2016 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.workspaces.repository.maintenance;

import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.ArrayList;

import javax.jcr.RepositoryException;
import javax.jcr.Session;
import javax.jcr.SimpleCredentials;

import org.apache.jackrabbit.core.RepositoryContext;
import org.apache.jackrabbit.core.persistence.IterablePersistenceManager;
import org.apache.jackrabbit.core.persistence.PersistenceManager;
import org.apache.jackrabbit.core.persistence.bundle.AbstractBundlePersistenceManager;
import org.apache.jackrabbit.core.persistence.check.ConsistencyCheckListener;
import org.apache.jackrabbit.core.persistence.check.ConsistencyReport;
import org.apache.jackrabbit.core.persistence.check.ReportItem;
import org.apache.jackrabbit.core.version.InternalVersionManagerImpl;
import org.slf4j.LoggerFactory;

/**
 * ConsistencyCheckTask
 */
public class ConsistencyCheckTask extends AbstractMaintenanceTask implements ConsistencyCheckListener
{
    /** The JackRabbit RepositoryImpl Context */
    protected RepositoryContext _repositoryContext;

    /** The JCR Session bound to this task. */
    protected Session _session;

    private IterablePersistenceManager[] _pmList;

    @Override
    protected void initialize() throws RepositoryException
    {
        // Create the repository and log in the session.
        _repositoryContext = RepositoryContext.create(_repositoryConfig);
        _session = _repositoryContext.getRepository().login(new SimpleCredentials("__MAINTENANCE_TASK__", "".toCharArray()));

        // Workaround to get the list of the PersistenceManager
        ArrayList<PersistenceManager> pmList = new ArrayList<>();

        // PM of version manager
        InternalVersionManagerImpl vm = _repositoryContext.getInternalVersionManager();
        pmList.add(vm.getPersistenceManager());

        // PMs of workspaces.
        String[] wspNames = _repositoryContext.getWorkspaceManager().getWorkspaceNames();
        for (int i = 0; i < wspNames.length; i++)
        {
            pmList.add(getPM(wspNames[i]));
        }

        // Filtering on IterablePersistenceManager
        _pmList = new IterablePersistenceManager[pmList.size()];
        for (int i = 0; i < pmList.size(); i++)
        {
            PersistenceManager pm = pmList.get(i);
            if (!(pm instanceof IterablePersistenceManager))
            {
                _pmList = null;
                break;
            }
            _pmList[i] = (IterablePersistenceManager) pm;
        }

        // Initialize the task progress object.
        int count = 0; // number of item that will be scanned.

        try
        {
            for (IterablePersistenceManager pm : _pmList)
            {
                count += pm.getAllNodeIds(null, 0).size();
            }
            _progress = new TaskProgress(count);
        }
        catch (Exception e)
        {
            _progress = new TaskProgress(0);
            _progress.setInErrorState(e);
            _logger.error(e.getLocalizedMessage(), e);
        }
    }
    
    @Override
    protected void setLogger()
    {
        setLogger(LoggerFactory.getLogger(ConsistencyCheckTask.class));
    }

    @Override
    protected void apply() throws RepositoryException
    {
        for (PersistenceManager pm : _pmList)
        {
            // Do PM consistency check
            if (pm instanceof AbstractBundlePersistenceManager)
            {
                // Perform the check
                // null -> all uuids, true -> recursive, false -> nofix, null, 
                // lost+found -> null, this -> listener 
                ConsistencyReport report = ((AbstractBundlePersistenceManager) pm).check(null, true, false, null, this);
                
                _logger.info("Consistency check done for persistence manager : '" + pm.toString() + "' in " + (report.getElapsedTimeMs() / 1000f) + " s.");
                _logger.info(report.getNodeCount() + " nodes were checked.");
                _logger.info(report.getItems().isEmpty() ? "No consistency problems were reported." : report.getItems().size() + " consistency problems were reported."); 
            }
        }
    }

    @Override
    protected void close()
    {
        if (_session != null)
        {
            _session.logout();
        }

        if (_repositoryContext != null && _repositoryContext.getRepository() != null)
        {
            _repositoryContext.getRepository().shutdown();
        }
        
        if (_progress != null)
        {
            _progress.progressRelativePercentage(100);
        }
    }

    /**
     * Retrieves JackRabbit Persistence Manager for currently opened repository. This method uses
     * Privileged access and will fail with security exception if used in environment with enabled security manager.
     * @param workspaceName The workspace name
     * @return Persistence manager used by repository.
     */
    protected PersistenceManager getPM(String workspaceName)
    {
        try
        {
            Object workspaceInfo = findAndInvokeMethod(_repositoryContext.getRepository(), "getWorkspaceInfo", new Object[] {workspaceName});
            return (PersistenceManager) (findAndInvokeMethod(workspaceInfo, "getPersistenceManager", null));
        }
        catch (Exception e)
        {
            throw new RuntimeException(e);
        }
    }

    private static Object findAndInvokeMethod(Object obj, String name, Object[] parameters) throws IllegalArgumentException, IllegalAccessException, InvocationTargetException
    {
        Method m = null;
        Method[] ms = obj.getClass().getDeclaredMethods();
        for (int i = 0; i < ms.length; i++)
        {
            final Method x = ms[i];
            if (x.getName().equals(name))
            {
                m = x;
                m.setAccessible(true);
                return m.invoke(obj, parameters);
            }
        }
        
        return null;
    }

    // Listener methods 

    @Override
    public void startCheck(String id)
    {
        if (_progress != null)
        {
            _progress.progress();
        }
    }

    @Override
    public void report(ReportItem item)
    {
        _logger.warn(item.toString());
    }

    @Override
    public void error(String id, String message)
    {
        _logger.error("error during the consistency check -> id : [ " + id + "]\n" + message);
    }

    @Override
    public void info(String id, String message)
    {
        _logger.info("error during the consistency check -> id : [ " + id + "]\n" + message);
    }
}