/*******************************************************************************
 * Copyright (c) 2009 University of Illinois at Urbana-Champaign and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     UIUC - Initial API and implementation
 *******************************************************************************/
package org.eclipse.rephraserengine.core.vpg.eclipse;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Set;

import org.eclipse.core.resources.IFile;
import org.eclipse.core.resources.IProject;
import org.eclipse.core.resources.IResource;
import org.eclipse.core.resources.IResourceChangeEvent;
import org.eclipse.core.resources.IResourceChangeListener;
import org.eclipse.core.resources.IResourceDelta;
import org.eclipse.core.resources.IResourceDeltaVisitor;
import org.eclipse.core.resources.IResourceVisitor;
import org.eclipse.core.resources.IWorkspace;
import org.eclipse.core.resources.IWorkspaceRoot;
import org.eclipse.core.resources.ResourcesPlugin;
import org.eclipse.core.resources.WorkspaceJob;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.core.runtime.IStatus;
import org.eclipse.core.runtime.OperationCanceledException;
import org.eclipse.core.runtime.Status;
import org.eclipse.core.runtime.jobs.MultiRule;
import org.eclipse.rephraserengine.core.vpg.TokenRef;
import org.eclipse.rephraserengine.core.vpg.VPG;
import org.eclipse.rephraserengine.core.vpg.VPGDB;


/**
 * A virtual program graph for use in an Eclipse environment.
 * <a href="../../../../overview-summary.html#Eclipse">More Information</a>
 * <p>
 * This class is intended to be subclassed directly.
 *
 * @author Jeff Overbey
 */
public abstract class EclipseVPG<A, T, R extends TokenRef<T>, D extends VPGDB<A, T, R, L>, L extends EclipseVPGLog<T, R>>
              extends VPG<A, T, R, D, L>
{
    private String syncMessage;

    public EclipseVPG(L log, D database, String syncMessage, int transientASTCacheSize)
    {
        super(log, database, transientASTCacheSize);
        this.syncMessage = syncMessage;
    }

    public EclipseVPG(L log, D database, String syncMessage)
    {
        super(log, database);
        this.syncMessage = syncMessage;
    }

    /** Enqueues a job to make sure the VPG is up-to-date with the
     *  workspace, and instructs it to automatically update itself
     *  when files are added, changed, or deleted in the workspace.
     */
    public void start()
    {
        log.readLogFromFile();
        
        // Now listen for changes to workspace resources
        ResourcesPlugin.getWorkspace().addResourceChangeListener(new VPGResourceChangeListener(), IResourceChangeEvent.POST_CHANGE);

        // The C/C++ Development Tool (see org.eclipse.cdt.internal.core.model.CModelManager) handles
        // IResourceChangeEvent.POST_CHANGE | IResourceChangeEvent.PRE_DELETE | IResourceChangeEvent.PRE_CLOSE

        // and also executes
        // Platform.getContentTypeManager().addContentTypeChangeListener(this);

        queueJobToEnsureVPGIsUpToDate();
    }

    ///////////////////////////////////////////////////////////////////////////
    // Resource Visitor
    ///////////////////////////////////////////////////////////////////////////

    public WorkspaceJob queueJobToEnsureVPGIsUpToDate()
    {
        WorkspaceJob job = new VPGInitialWorkspaceSyncJob(syncMessage);
        job.setRule(MultiRule.combine(VPGSchedulingRule.getInstance(),
                    ResourcesPlugin.getWorkspace().getRoot()));
        job.schedule();
        return job;
    }

    private final class VPGInitialWorkspaceSyncJob extends VPGJob<A, T>
    {
        private VPGInitialWorkspaceSyncJob(String name)
        {
            super(name);
        }

        @Override public IStatus runInWorkspace(final IProgressMonitor monitor)
        {
            try
            {
                monitor.beginTask("Indexing", IProgressMonitor.UNKNOWN);
                return ensureVPGIsUpToDate(monitor);
            }
            finally
            {
                monitor.done();
            }
        }
    }

    /** Ensures that the VPG database contains up-to-date information for all of
     *  the resources in the workspace.
     */
    public IStatus ensureVPGIsUpToDate(IProgressMonitor monitor)
    {
        try
        {
            WorkspaceSyncResourceVisitor visitor = new WorkspaceSyncResourceVisitor();
            collectFilesToIndex(visitor, monitor);
            visitor.calculateDependencies(monitor);
            visitor.index(monitor);
            return Status.OK_STATUS;
        }
        catch (CoreException e)
        {
            return e.getStatus();
        }
    }

    private void collectFilesToIndex(WorkspaceSyncResourceVisitor visitor, IProgressMonitor monitor) throws CoreException
    {
        monitor.subTask("Searching for workspace modifications...");
        IWorkspaceRoot workspaceRoot = ResourcesPlugin.getWorkspace().getRoot();
        workspaceRoot.accept(visitor); // Collect list of files to index
    }

    private final class WorkspaceSyncResourceVisitor implements IResourceVisitor
    {
        private final ArrayList<String> files;

        private WorkspaceSyncResourceVisitor()
        {
            this.files = new ArrayList<String>(1024);
        }

        public boolean visit(IResource resource)
        {
            try
            {
                if (!resource.isAccessible()) return false;

                if (resource instanceof IProject && !shouldProcessProject((IProject)resource)) return false;

                if (resource instanceof IFile && shouldProcessFile((IFile)resource))
                    files.add(EclipseVPG.getFilenameForIFile((IFile)resource));
            }
            catch (Exception e)
            {
                log.logError(e);
            }
            return !(resource instanceof IFile);
        }

        public void calculateDependencies(IProgressMonitor monitor)
        {
            ArrayList<String> queue = files;
            int completed = 0, total = queue.size();
            for (String filename : queue)
            {
                if (monitor.isCanceled()) throw new OperationCanceledException();

                monitor.subTask(filename + " (calculating dependencies - file " + (++completed) + " of " + total + ")");
                calculateDependenciesIfNotUpToDate(filename);
            }
        }

        public void index(IProgressMonitor monitor)
        {
            List<String> queue = sortFilesAccordingToDependencies(files, monitor);

            int completed = 0, total = countFilesInQueue(queue);
            for (String filename : queue)
            {
                if (monitor.isCanceled()) throw new OperationCanceledException();

                if (shouldListFileInIndexerProgressMessages(filename))
                    monitor.subTask(filename + " (" + (++completed) + " of " + total + ")");

                indexIfNotUpToDate(filename);
            }
        }
    }

    private int countFilesInQueue(List<String> queue)
    {
        int total = 0;
        for (String filename : queue)
            if (shouldListFileInIndexerProgressMessages(filename))
                total++;
        return total;
    }

    protected boolean shouldListFileInIndexerProgressMessages(String filename) {
        return !isVirtualFile(filename);
    }

    //public ArrayList<String> sortFilesAccordingToDependencies(final ArrayList<String> files, final IProgressMonitor monitor)

    ///////////////////////////////////////////////////////////////////////////
    // Resource Change Listener
    ///////////////////////////////////////////////////////////////////////////

    private final class VPGResourceChangeListener implements IResourceChangeListener
    {
        public void resourceChanged(IResourceChangeEvent event)
        {
            if (!(event.getSource() instanceof IWorkspace)) return;

            if (event.getType() != IResourceChangeEvent.POST_CHANGE) return;

            final IResourceDelta delta = event.getDelta();
            if (delta == null) return;

            new VPGResourceDeltaJob(syncMessage, delta).schedule();
        }
    }

    private final class VPGResourceDeltaJob extends VPGJob<A, T>
    {
        private final IResourceDelta delta;

        private VPGResourceDeltaJob(String name, IResourceDelta delta)
        {
            super(name);
            this.delta = delta;
        }

        @Override public IStatus runInWorkspace(final IProgressMonitor monitor)
        {
            try
            {
                monitor.beginTask("Indexing", IProgressMonitor.UNKNOWN);
                // Re-index or delete entries for files when they are added/changed or deleted, respectively
                VPGResourceDeltaVisitor visitor = new VPGResourceDeltaVisitor();
                monitor.subTask("Searching for workspace modifications...");
                delta.accept(visitor); // Collect files to index
                visitor.calculateDependencies(monitor);
                visitor.index(monitor);
                return Status.OK_STATUS;
            }
            catch (CoreException e)
            {
                return e.getStatus();
            }
            finally
            {
                monitor.done();
            }
        }
    }

    private final class VPGResourceDeltaVisitor implements IResourceDeltaVisitor
    {
        private ArrayList<String> files;
        private HashMap<String, Boolean> forceReindex;

        public VPGResourceDeltaVisitor()
        {
            this.files = new ArrayList<String>(256);
            this.forceReindex = new HashMap<String, Boolean>(256);
        }

        public boolean visit(IResourceDelta delta)
        {
            try
            {
                IResource resource = delta.getResource();
                if (!(resource instanceof IFile))
                {
                    if (resource instanceof IProject)
                        return shouldProcessProject((IProject)resource);
                    else
                        return true;
                }
                IFile file = (IFile)resource;
                if (!shouldProcessFile(file)) return true;

                String filename = getFilenameForIFile(file);

                switch (delta.getKind())
                {
                case IResourceDelta.ADDED:
                    debug("Resource Delta: Add", filename);
                    files.add(filename);
                    forceReindex.put(filename, true); // Was false
                    break;

                case IResourceDelta.CHANGED:
                    debug("Resource Delta: Change", filename);
                    if ((delta.getFlags() & (IResourceDelta.CONTENT|IResourceDelta.REPLACED)) != 0)
                    {
                        files.add(filename);
                        forceReindex.put(filename, true);
                    }
                    break;

                case IResourceDelta.REMOVED:
                    debug("Resource Delta: Remove", filename);
                    log.clearEntriesFor(filename);
                    db.deleteAllEntriesFor(filename);
                    break;
                }
            }
            catch (Exception e)
            {
                log.logError(e);
            }
            return true;
        }

        public void calculateDependencies(IProgressMonitor monitor)
        {
            ArrayList<String> queue = files;
            int completed = 0, total = queue.size();
            for (String filename : queue)
            {
                if (monitor.isCanceled()) throw new OperationCanceledException();

                monitor.subTask(filename + " (" + (++completed) + " of " + total + ")");
                Boolean force = forceReindex.get(filename);
                if (force == null || force)
                    forceRecomputationOfDependencies(filename);
                else
                    calculateDependenciesIfNotUpToDate(filename);
            }
        }

        public void index(IProgressMonitor monitor)
        {
            List<String> queue = sortFilesAccordingToDependencies(files, monitor);
            int completed = 0, total = countFilesInQueue(queue);
            for (String filename : queue)
            {
                if (monitor.isCanceled()) throw new OperationCanceledException();

                if (shouldListFileInIndexerProgressMessages(filename))
                    monitor.subTask(filename + " (" + (++completed) + " of " + total + ")");

                Boolean force = forceReindex.get(filename);
                if (force == null || force)
                    forceRecomputationOfEdgesAndAnnotations(filename);
                else
                    indexIfNotUpToDate(filename);
            }
        }
    }

    /** Updates the VPG database's dependency information for the given file
     *  if the stored information is out of date
     * @param monitor */
    protected void calculateDependenciesIfNotUpToDate(String filename)
    {
        if (db.isOutOfDate(filename))
        {
            debug("Indexing", filename);
            forceRecomputationOfDependencies(filename);
        }
        else
        {
            debug("Index is up to date", filename);
        }
    }

    /** Updates the VPG database information for the given file if the stored
     *  information is out of date
     * @param monitor */
    protected void indexIfNotUpToDate(String filename)
    {
        if (db.isOutOfDate(filename))
        {
            debug("Indexing", filename);
            forceRecomputationOfEdgesAndAnnotations(filename);
        }
        else
        {
            debug("Index is up to date", filename);
        }
    }

    ///////////////////////////////////////////////////////////////////////////
    // Abstract Methods (Resource Filtering)
    ///////////////////////////////////////////////////////////////////////////

    /** @return true iff the given file should be parsed */
    @Override protected boolean shouldProcessFile(String filename)
    {
        IFile file = getIFileForFilename(filename);
        return file == null ? false : shouldProcessFile(file);
    }

    /** @return true if the given project should be indexed */
    protected abstract boolean shouldProcessProject(IProject project);

    /** @return true iff the given file should be indexed */
    protected abstract boolean shouldProcessFile(IFile file);

    ///////////////////////////////////////////////////////////////////////////
    // Utility Methods (IFile<->Filename Mapping)
    ///////////////////////////////////////////////////////////////////////////

    public static IFile getIFileForFilename(String filename)
    {
        IResource resource = getIResourceForFilename(filename);
        if (resource instanceof IFile)
            return (IFile)resource;
        else
            return null;
    }

    public static String getFilenameForIFile(IFile file)
    {
        return getFilenameForIResource(file);
    }

    public static IResource getIResourceForFilename(String filename)
    {
        return ResourcesPlugin.getWorkspace().getRoot().findMember(filename);
    }

    public static String getFilenameForIResource(IResource resource)
    {
        if (resource == null)
            return null;
        else
            return resource.getFullPath().toString();
    }

    ///////////////////////////////////////////////////////////////////////////
    // IFile-Based AST Acquisition & Release API
    ///////////////////////////////////////////////////////////////////////////

    public A acquireTransientAST(IFile file)
    {
        return file == null ? null : acquireTransientAST(getFilenameForIFile(file));
    }

    public A acquirePermanentAST(IFile file)
    {
        return file == null ? null : acquirePermanentAST(getFilenameForIFile(file));
    }
    
    public A makeTransientASTPermanent(IFile file)
    {
        return file == null ? null : makeTransientASTPermanent(getFilenameForIFile(file));
    }

    public A makeTransientASTPermanent(IFile file, A ast)
    {
        return file == null ? null : makeTransientASTPermanent(getFilenameForIFile(file), ast);
    }

    public void releaseAST(IFile file)
    {
        if (file != null) releaseAST(getFilenameForIFile(file));
    }
    
    public IFile getIFileCorrespondingTo(A ast)
    {
        String filename = getFilenameCorrespondingTo(ast);
        return filename == null ? null : getIFileForFilename(filename);
    }

    ///////////////////////////////////////////////////////////////////////////
    // VPG Overrides
    ///////////////////////////////////////////////////////////////////////////

    @Override protected void processingDependent(String filename, String dependentFilename)
    {
//        if (progressMonitor != null)
//            progressMonitor.subTask(filename
//                                    + " - reindexing dependent file "
//                                    + dependentFilename);
        super.processingDependent(filename, dependentFilename);
    }

    /** Forces the database to be updated based on the current in-memory AST for the given file */
    public void commitChangesFromInMemoryASTs(IProgressMonitor pm, int ticks, IFile file)
    {
        commitChangesFromInMemoryASTs(pm, ticks, getFilenameForIFile(file));
    }

    /** Forces the database to be updated based on the current in-memory ASTs for the given files */
    public void commitChangesFromInMemoryASTs(IProgressMonitor pm, int ticks, Set<IFile> files)
    {
        String[] filenames = new String[files.size()];
        int i = 0;
        for (IFile file : files)
            filenames[i++] = getFilenameForIFile(file);
        
        commitChangesFromInMemoryASTs(pm, ticks, filenames);
    }
}