/********************************************************************
 * Copyright (c) 2007 Contributors. 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://eclipse.org/legal/epl-v10.html 
 *  
 * Contributors: IBM Corporation - initial API and implementation 
 *               Helen Hawkins   - initial version (bug 148190)
 *******************************************************************/
package org.eclipse.ajdt.internal.core.ajde;

import java.io.File;
import java.util.ArrayList;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.StringTokenizer;

import org.aspectj.ajde.core.ICompilerConfiguration;
import org.aspectj.ajde.core.IOutputLocationManager;
import org.aspectj.ajdt.internal.core.builder.CompilerConfigurationChangeFlags;
import org.eclipse.ajdt.core.AJLog;
import org.eclipse.ajdt.core.AopXmlPreferences;
import org.eclipse.ajdt.core.AspectJCorePreferences;
import org.eclipse.ajdt.core.AspectJPlugin;
import org.eclipse.ajdt.core.BuildConfig;
import org.eclipse.ajdt.core.CoreUtils;
import org.eclipse.ajdt.core.text.CoreMessages;
import org.eclipse.ajdt.internal.core.builder.BuildClasspathResolver;
import org.eclipse.core.internal.content.ContentTypeManager;
import org.eclipse.core.resources.IContainer;
import org.eclipse.core.resources.IFile;
import org.eclipse.core.resources.IFolder;
import org.eclipse.core.resources.IProject;
import org.eclipse.core.resources.IResource;
import org.eclipse.core.resources.IncrementalProjectBuilder;
import org.eclipse.core.resources.ResourcesPlugin;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.jdt.apt.core.internal.JarFactoryContainer;
import org.eclipse.jdt.apt.core.internal.util.FactoryContainer;
import org.eclipse.jdt.apt.core.internal.util.FactoryPath;
import org.eclipse.jdt.apt.core.internal.util.FactoryPathUtil;
import org.eclipse.jdt.core.IClasspathEntry;
import org.eclipse.jdt.core.IJavaProject;
import org.eclipse.jdt.core.JavaCore;
import org.eclipse.jdt.internal.core.ClasspathEntry;
import org.eclipse.jdt.internal.core.JavaProject;
import org.eclipse.jdt.internal.core.util.Util;
import org.eclipse.osgi.util.NLS;

/**
 * ICompilerConfiguration implementation which returns information for all 
 * methods except getNonStandardOptions().  This implementation is used
 * if ajdt.core plugin is not present in the platform
 */
public class CoreCompilerConfiguration implements ICompilerConfiguration {

    private String cachedClasspath = null;
    protected IProject project; 
    protected CoreOutputLocationManager locationManager;
    protected FileURICache fileCache; 

    // fully qualified list of file names that have been touched since
    // last build
    // set to null originally since we don't know anything 
    // about build state when first created.  Assume everything 
    // has changed.
    private List<File> modifiedFiles = null;
    // set of flags describing what has changed since last
    // build
    // initially set to EVERYTHING since we don't know
    // build state when first created.
    private int configurationChanges;
    
    // list of classpath entries that have been rebuilt since last build
    private List<String> classpathElementsWithModifiedContents = null;

    public CoreCompilerConfiguration(IProject project) {
        this.project = project;
        AJLog.log(AJLog.BUILDER, "Compiler configuration for project " + project.getName() + " doesn't know previous state, so assuming EVERYTHING has changed.");
        configurationChanges = EVERYTHING;
        fileCache = new FileURICache(project);
    }
    
    public void buildStarting() {
        ((CoreOutputLocationManager) getOutputLocationManager()).buildStarting();
    }
    
    public void buildComplete() {
        ((CoreOutputLocationManager) getOutputLocationManager()).buildComplete();
    }
    
    

    @SuppressWarnings("unchecked")
    public Map<String, String> getJavaOptionsMap() {
        Map<String, String> optionsMap = null;

        JavaProject javaProject;
        try {
            javaProject = (JavaProject) project.getNature(JavaCore.NATURE_ID);
            optionsMap = javaProject.getOptions(true);
        } catch (CoreException e) {
        }

        if (optionsMap == null) {
            return JavaCore.getOptions();
        } else {
            return optionsMap;
        }
    }

    public String getNonStandardOptions() {
        // ajdt.ui supplies impl
        return ""; //$NON-NLS-1$
    }

    public Set<File> getAspectPath() {
        String[] v = AspectJCorePreferences.getResolvedProjectAspectPath(project);

        // need to expand any variables on the path
        String aspectpath = expandVariables(v[0], v[2]);

        // Ensure that every entry in the list is a fully qualified one.
        aspectpath = fullyQualifyPathEntries(aspectpath);

        if (aspectpath.length() == 0)
            return null;

        return mapStringToSet(aspectpath, false);
    }

    public String getClasspath() {
        if (cachedClasspath != null)
            return cachedClasspath;
        IJavaProject jp = JavaCore.create(project);
        // bug 73035: use this build classpath resolver which is a direct
        // copy from JDT, so the classpath environment is much closer between
        // AspectJ and Java projects.
        cachedClasspath = new BuildClasspathResolver().getClasspath(AspectJPlugin.getWorkspace().getRoot(), jp);
        return cachedClasspath;
    }

    public Set<File> getInpath() {
        String[] v = AspectJCorePreferences.getResolvedProjectInpath(project);

        // need to expand any variables on the path
        String inpath = expandVariables(v[0], v[2]);

        // Ensure that every entry in the list is a fully qualified one.
        inpath = fullyQualifyPathEntries(inpath);

        if (inpath.length() == 0)
            return null;

        return mapStringToSet(inpath, false);
    }

    public String getOutJar() {
        String outputJar = AspectJCorePreferences.getProjectOutJar(project);

        // If outputJar does not start with a slash, we might need to prepend
        // the project work directory.
        if (outputJar.trim().length() > 0 && !(outputJar.startsWith("\\") || outputJar.startsWith("/"))) { //$NON-NLS-1$ //$NON-NLS-2$
            String trimmedName = outputJar.trim();
            boolean prependProject = true;

            // It might still be a fully qualified path if the 2nd char is a ':'
            // (i.e. its
            // a windows absolute path with a drive letter in it !)
            if (trimmedName.length() > 1) {
                if (trimmedName.charAt(1) == ':')
                    prependProject = false;
            }

            if (prependProject) {
                // Its a relative path, it should be relative to the project.
                String projectBaseDirectory = project.getLocation().toOSString();
                outputJar = projectBaseDirectory + File.separator + outputJar.trim();
            }
        }

        return outputJar;
    }

    public IOutputLocationManager getOutputLocationManager() {
        if (locationManager == null) {
            locationManager = new CoreOutputLocationManager(project, fileCache);
        }
        return locationManager;
    }

    /**
     * bug 270335 need to recreate locationManager if any of the
     * following configuration changes have occurred:
     * ASPECTPATH_CHANGED | CLASSPATH_CHANGED | INPATH_CHANGED | 
     * OUTJAR_CHANGED | OUTPUTDESTINATIONS_CHANGED | INJARS_CHANGED
     * 
     * @return true if {@link #locationManager} field has been reset to 
     * null.  false otherwise
     */
    public boolean flushOutputLocationManagerIfNecessary(int buildKind) {
        if (buildKind == IncrementalProjectBuilder.FULL_BUILD || 
                buildKind == IncrementalProjectBuilder.CLEAN_BUILD) {
            locationManager = null;
        } else if ((configurationChanges & 
                (ASPECTPATH_CHANGED | CLASSPATH_CHANGED | 
                 INPATH_CHANGED | OUTJAR_CHANGED | 
                 OUTPUTDESTINATIONS_CHANGED | INJARS_CHANGED)) != 0) {
            locationManager = null;
        } else {
            // we don't know if bin folders of depending projects
            // have changed, so just assume that they have
            if (locationManager != null) {
                locationManager.zapBinFolderToProjectMap();
            }
        }
        return locationManager == null;
    }
    
    public List<String> getProjectSourceFiles() {
        Set<IFile> files = BuildConfig.getIncludedSourceFiles(project);
        List<String> iofiles = new ArrayList<String>(files.size());
        for (IFile f : files) {
            iofiles.add(f.getLocation().toOSString());
        }
        return iofiles;
    }

    /**
     * AJDT handles resource copying for all builds, so always return null here.
     */
    public Map<String, File> getSourcePathResources() {
        return null;
    }

    public void flushClasspathCache() {
        cachedClasspath = null;
    }

    public String expandVariables(String path, String eKinds) {
        StringBuffer resultBuffer = new StringBuffer();
        StringTokenizer strTok = new StringTokenizer(path, File.pathSeparator);
        StringTokenizer strTok2 = new StringTokenizer(eKinds, File.pathSeparator);
        while (strTok.hasMoreTokens()) {
            String current = strTok.nextToken();
            int entryKind = Integer.parseInt(strTok2.nextToken());
            if (entryKind == IClasspathEntry.CPE_VARIABLE) {
                int slashPos = current.indexOf(AspectJPlugin.NON_OS_SPECIFIC_SEPARATOR, 0);
                if (slashPos != -1) {
                    String exp = JavaCore.getClasspathVariable(current.substring(0, slashPos)).toOSString();
                    resultBuffer.append(exp);
                    resultBuffer.append(current.substring(slashPos));
                } else {
                    String exp = JavaCore.getClasspathVariable(current).toOSString();
                    resultBuffer.append(exp);
                }
            } else {
                resultBuffer.append(current);
            }
            resultBuffer.append(File.pathSeparator);
        }
        return resultBuffer.toString();
    }

    /**
     * @param inputPath
     * @return
     */
    public String fullyQualifyPathEntries(String inputPath) {
        StringBuffer resultBuffer = new StringBuffer();
        StringTokenizer strTok = new StringTokenizer(inputPath, File.pathSeparator);
        while (strTok.hasMoreTokens()) {
            String current = strTok.nextToken();
            File f = new File(current);
            if (f.exists() && f.isAbsolute()) {
                // entry not relative to workspace (it's fully qualifed)
                resultBuffer.append(current);
            } else {
                // Try to resolve path relative to the workspace. Need to
                // replace part of the path string with a fully qualified
                // equivalent.
                String projectName = null;
                int slashPos = current.indexOf(AspectJPlugin.NON_OS_SPECIFIC_SEPARATOR, 1);
                if (slashPos != -1) {
                    projectName = current.substring(1, slashPos);
                } else {
                    projectName = current.substring(1);
                }

                IProject proj = AspectJPlugin.getWorkspace().getRoot().getProject(projectName);

                if (proj != null && proj.getLocation() != null) {
                    String projectPath = proj.getLocation().toString();

                    if (slashPos != -1) {
                        String rest = current.substring(slashPos + 1);
                        IResource res = proj.findMember(rest);
                        if (res != null) {
                            resultBuffer.append(res.getRawLocation().toOSString());
                        } else {
                            resultBuffer.append(projectPath + AspectJPlugin.NON_OS_SPECIFIC_SEPARATOR + rest);
                        }
                    } else {
                        resultBuffer.append(projectPath);
                    }
                }// end if named project found
                else {
                    AJLog.log(AJLog.BUILDER, "AspectJ path entry " + current //$NON-NLS-1$
                            + " does not exist."); //$NON-NLS-1$
                    resultBuffer.append(current);
                }// end else entry not found in workspace
            }// end if entry is relative to workspace
            resultBuffer.append(File.pathSeparator);
        }// end while more tokens to process

        String result = resultBuffer.toString();
        if (result.endsWith(File.pathSeparator)) {
            result = result.substring(0, result.length() - 1);
        }

        return result;
    }

    /**
     * Utility method for converting a semicolon separated list of files stored in a string into a Set of {@link File} objects.
     * 
     */
    private Set<File> mapStringToSet(String input, boolean validateFiles) {
        if (input.length() == 0)
            return null;
        String inputCopy = input;

        StringBuffer invalidEntries = new StringBuffer();

        // For relative paths (they don't start with a File.separator
        // or a drive letter on windows) - we prepend the projectBaseDirectory
        String projectBaseDirectory = project.getLocation().toOSString();

        Set<File> fileSet = new HashSet<File>();
        while (inputCopy.indexOf(File.pathSeparator) != -1) {
            int idx = inputCopy.indexOf(File.pathSeparator);
            String path = inputCopy.substring(0, idx);

            File f = new File(path);
            if (!f.isAbsolute())
                f = new File(projectBaseDirectory + File.separator + path);
            if (validateFiles && !f.exists()) {
                invalidEntries.append(f + "\n"); //$NON-NLS-1$
            } else {
                fileSet.add(f);
            }
            inputCopy = inputCopy.substring(idx + 1);
        }
        // Process the final element
        if (inputCopy.length() != 0) {
            File f = new File(inputCopy);
            if (!f.isAbsolute())
                f = new File(projectBaseDirectory + File.separator + inputCopy);
            if (validateFiles && !f.exists()) {
                invalidEntries.append(f + "\n"); //$NON-NLS-1$
            } else {
                fileSet.add(f);
            }

        }

        if (validateFiles && invalidEntries.length() != 0) {
            AJLog.log(AJLog.COMPILER, NLS.bind(CoreMessages.missingJarsWarning, invalidEntries.toString()));
        }
        return fileSet;
    }

    private void getProjectRelativePaths(IResource[] resource_list, List<String> allProjectFiles, CoreUtils.FilenameFilter filter,
            int trimSegments, IClasspathEntry sourceEntry) {
        try {
            for (int i = 0; i < resource_list.length; i++) {
                IResource ir = resource_list[i];
                // bug 161739: skip excluded resources
                char[][] inclusionPatterns = ((ClasspathEntry) sourceEntry).fullInclusionPatternChars();
                char[][] exclusionPatterns = ((ClasspathEntry) sourceEntry).fullExclusionPatternChars();
                if (!Util.isExcluded(ir, inclusionPatterns, exclusionPatterns)) {
                    if (ir instanceof IContainer) {
                        getProjectRelativePaths(((IContainer) ir).members(), allProjectFiles, filter, trimSegments, sourceEntry);
                    } else if (filter.accept(ir.getName())) {
                        String[] segments = ir.getProjectRelativePath().segments();
                        String path = ""; //$NON-NLS-1$
                        for (int j = trimSegments; j < segments.length; j++) {
                            path += segments[j];
                            if (j < segments.length - 1)
                                path += '/'; // matches Eclipse's separator
                        }
                        allProjectFiles.add(path);
                    }

                }
            }
        } catch (Exception e) {
        }
    }

    private ArrayList<IResource> getLinkedChildFolders(IResource resource) {
        ArrayList<IResource> resultList = new ArrayList<IResource>();

        if (resource instanceof IContainer) {
            try {
                IResource[] children = ((IContainer) resource).members();
                for (int i = 0; i < children.length; i++) {
                    if ((children[i] instanceof IFolder) && children[i].isLinked()) {
                        resultList.add(children[i]);
                    }
                }
            } catch (CoreException e) {
            }
        }
        return resultList;
    }

    private String getResourceFullPath(IResource srcContainer, String relPath, ArrayList<IResource> linkedFolders) {
        String result = null;
        if (relPath.lastIndexOf('/') != -1) {
            // Check to see if the relPath under scrutiny is
            // under a linked folder in this project.
            Iterator<IResource> it = linkedFolders.iterator();
            while (it.hasNext()) {
                IFolder folder = (IFolder) it.next();
                String linkedFolderName = folder.getName();
                if (relPath.indexOf(linkedFolderName + "/") == 0) { //$NON-NLS-1$
                    // Do the replacement ensuring that the result uses
                    // operating system separator characters.
                    result = folder.getLocation().toString() + relPath.substring(linkedFolderName.length());
                    result = result.replace('/', File.separatorChar);
                    break;
                }
            }
        }
        if (result == null) {
            result = srcContainer.getLocation().toOSString() + File.separator + relPath;
        }
        return result;
    }

    public void addModifiedFile(File changedFile) {
        AJLog.log(AJLog.BUILDER, "File: " + changedFile + " has changed.");
        if (modifiedFiles != null) {
            modifiedFiles.add(changedFile);
        } else {
            AJLog.log(AJLog.BUILDER, "    but, we don't have any state yet, so not recording the change.");
        }
    }
    
    /**
     * Flag this compiler configuration as having had a change.
     * This is reset after a call to {@link #configurationRead()}
     * @param changeFlag change flag from 
     * {@link CompilerConfigurationChangeFlags}
     */
    public void configurationChanged(int changeFlag) {
        configurationChanges |= changeFlag;
        logConfigurationChange(changeFlag);
    }

    private void logConfigurationChange(int changeFlag) {
        List<String> changeKind = new ArrayList<String>();
        if ((changeFlag & PROJECTSOURCEFILES_CHANGED) != NO_CHANGES) {
            changeKind.add("PROJECTSOURCEFILES_CHANGED");
        }
        if ((changeFlag & JAVAOPTIONS_CHANGED) != NO_CHANGES) {
            changeKind.add("JAVAOPTIONS_CHANGED");
        }
        if ((changeFlag & ASPECTPATH_CHANGED) != NO_CHANGES) {
            changeKind.add("ASPECTPATH_CHANGED");
        }
        if ((changeFlag & CLASSPATH_CHANGED) != NO_CHANGES) {
            changeKind.add("CLASSPATH_CHANGED");
        }
        if ((changeFlag & INPATH_CHANGED) != NO_CHANGES) {
            changeKind.add("INPATH_CHANGED");
        }
        if ((changeFlag & NONSTANDARDOPTIONS_CHANGED) != NO_CHANGES) {
            changeKind.add("NONSTANDARDOPTIONS_CHANGED");
        }
        if ((changeFlag & OUTJAR_CHANGED) != NO_CHANGES) {
            changeKind.add("OUTJAR_CHANGED");
        }
        if ((changeFlag & PROJECTSOURCERESOURCES_CHANGED) != NO_CHANGES) {
            changeKind.add("PROJECTSOURCERESOURCES_CHANGED");
        }
        if ((changeFlag & OUTPUTDESTINATIONS_CHANGED) != NO_CHANGES) {
            changeKind.add("OUTPUTDESTINATIONS_CHANGED");
        }
        // deprecated
        if ((changeFlag & INJARS_CHANGED) != NO_CHANGES) {
            changeKind.add("INJARS_CHANGED");
        }
        AJLog.log(AJLog.BUILDER, "CoreCompilerConfiguration for project " + project.getName() + " registered a configuration change: " + changeKind);
    }
    
    /**
     * converts the current configuration change list to a 
     * human readable string
     * @return human readable string denoting all configuration
     * changes since last read.
     */
    private String toConfigurationString() {
        List<String> changeKind = new ArrayList<String>();
        if ((configurationChanges & PROJECTSOURCEFILES_CHANGED) != NO_CHANGES) {
            changeKind.add("PROJECTSOURCEFILES_CHANGED");
        }
        if ((configurationChanges & JAVAOPTIONS_CHANGED) != NO_CHANGES) {
            changeKind.add("JAVAOPTIONS_CHANGED");
        }
        if ((configurationChanges & ASPECTPATH_CHANGED) != NO_CHANGES) {
            changeKind.add("ASPECTPATH_CHANGED");
        }
        if ((configurationChanges & CLASSPATH_CHANGED) != NO_CHANGES) {
            changeKind.add("CLASSPATH_CHANGED");
        }
        if ((configurationChanges & INPATH_CHANGED) != NO_CHANGES) {
            changeKind.add("INPATH_CHANGED");
        }
        if ((configurationChanges & NONSTANDARDOPTIONS_CHANGED) != NO_CHANGES) {
            changeKind.add("NONSTANDARDOPTIONS_CHANGED");
        }
        if ((configurationChanges & OUTJAR_CHANGED) != NO_CHANGES) {
            changeKind.add("OUTJAR_CHANGED");
        }
        if ((configurationChanges & PROJECTSOURCERESOURCES_CHANGED) != NO_CHANGES) {
            changeKind.add("PROJECTSOURCERESOURCES_CHANGED");
        }
        if ((configurationChanges & OUTPUTDESTINATIONS_CHANGED) != NO_CHANGES) {
            changeKind.add("OUTPUTDESTINATIONS_CHANGED");
        }
        // deprecated
        if ((configurationChanges & INJARS_CHANGED) != NO_CHANGES) {
            changeKind.add("INJARS_CHANGED");
        }
        return changeKind.toString();
    }

    /**
     * Callback method from AspectJ to tell us that it has processed the configuration information and is going to proceed with a
     * build.
     */
    public void configurationRead() {
        // we now know nothing has changed
        AJLog.log(AJLog.BUILDER, "Compiler configuration for project " + project.getName() + " has been read by compiler.  Resetting.");
        AJLog.log(AJLog.BUILDER, "     Configuration was " + toConfigurationString());
        
        // we are still not keeping track of some changes:
        // JAVAOPTIONS_CHANGED | NONSTANDARDOPTIONS_CHANGED | OUTJAR_CHANGED |
        // OUTPUTDESTINATIONS_CHANGED | INJARS_CHANGED
        configurationChanges = NO_CHANGES;
        resetModifiedList();
    }

    /**
     * Need to tell AspectJ what has changed in the configuration since the last build was done - the lazy answer (which causes it
     * to behave as it always used to) is EVERYTHING.
     * 
     * @see CompilerConfigurationChangeFlags
     * @see AspectJCorePreferences#isIncrementalCompilationOptimizationsEnabled
     */
    public int getConfigurationChanges() {
        // if the optimization flag is turned off, then return EVERYTHING
        if (!AspectJCorePreferences.isIncrementalCompilationOptimizationsEnabled()) {
            AJLog.log(AJLog.BUILDER, "Optimizations turned off, so assuming all parts of configuration have changed");
            return EVERYTHING;
        } else {
            AJLog.log(AJLog.BUILDER, "Sending the following configuration changes to the compiler: " + toConfigurationString());
            return AspectJCorePreferences.isIncrementalCompilationOptimizationsEnabled() ? configurationChanges : EVERYTHING;
        }
    }

    /**
     * If we know, tell AspectJ a List<File> that have changed since the last build. We should be able to work this out from
     * analysing delta changes. Returning null means we have no idea and will cause AspectJ to do the analysis to work it out.
     */
    public List<File> getProjectSourceFilesChanged() {
        if (!AspectJCorePreferences.isIncrementalCompilationOptimizationsEnabled()) {
            AJLog.log(AJLog.BUILDER, "Optimizations turned off, so assuming all source files have changed");
            return null;
        } else if (modifiedFiles == null) {
            // null means we dont know
            AJLog.log(AJLog.BUILDER, "We don't know what has changed since last build, so assuming all source files have changed");
            return null;
        } else {
            AJLog.log(AJLog.BUILDER, modifiedFiles.size() + " source file changes since last build");
            return modifiedFiles;
        }
    }

    public void resetModifiedList() {
        AJLog.log(AJLog.BUILDER, "Resetting list of modified source files.  Was " + 
                (modifiedFiles == null ? "null" : modifiedFiles.toString()));
        modifiedFiles = new ArrayList<File>();
    }
    
    public void resetClasspathElementsWithModifiedContents() {
        classpathElementsWithModifiedContents = null;
    }
    public void setClasspathElementsWithModifiedContents(List<String> modifiedContents) {
        AJLog.log(AJLog.BUILDER, "Setting list of classpath elements with modified contents:");
        AJLog.log(AJLog.BUILDER, "      " + (modifiedContents == null ? "NULL" : modifiedContents.toString()));
        classpathElementsWithModifiedContents = modifiedContents;
    }
    
    // must go through the classpath and look at projects we depend on that have been built before our
    // most recent last build
    public List<String> getClasspathElementsWithModifiedContents() {
        return classpathElementsWithModifiedContents;
    }

    
    /**
     * helper method that grabs the compiler configuration for a particular project
     * creates one if it does not exist
     * @param project
     * @return the project's compiler configuration
     */
    public static CoreCompilerConfiguration getCompilerConfigurationForProject(IProject project) {
        return (CoreCompilerConfiguration) AspectJPlugin.getDefault().getCompilerFactory().getCompilerForProject(project).getCompilerConfiguration();
    }
    
    public File[] getCompiledSourceFiles() {
        CoreOutputLocationManager coreOutputLocationManager = (CoreOutputLocationManager) getOutputLocationManager();
        File[] compiledSourceFiles = 
            coreOutputLocationManager.getCompiledSourceFiles();
        return compiledSourceFiles;
        
    }
    
    public List<String> getProjectXmlConfigFiles() {
        return new AopXmlPreferences(project).getAopXmlFilesAsListOfStrings();
    }

    public String getProjectEncoding() {
        try {
            String charset = project.getDefaultCharset(false);
            if (charset == null) {
                charset = ContentTypeManager.getInstance().findContentTypeFor("f.java").getDefaultCharset();
            }
            if (charset == null) {
                charset = ResourcesPlugin.getEncoding();
            }
            return charset;
        } catch (CoreException e) {
            return ResourcesPlugin.getEncoding();
        }
    }
    
    public FileURICache getFileCache() {
        return fileCache;
    }

	public String getProcessor() {
		return null;
	}

	public String getProcessorPath() {
		// Grab the factory entries from the Java Compiler annotation project properties page
        IJavaProject jp = JavaCore.create(project);
		FactoryPath fp =  FactoryPathUtil.getFactoryPath(jp);
		Map<FactoryContainer,FactoryPath.Attributes> containers = fp.getEnabledContainers();
		ArrayList<File> fileList = new ArrayList<File>( containers.size() );
		for (Map.Entry<FactoryContainer, FactoryPath.Attributes> entry : containers.entrySet()) {
			FactoryPath.Attributes attr = entry.getValue();
			FactoryContainer fc = entry.getKey();
			if (!attr.runInBatchMode() && fc instanceof JarFactoryContainer) {
				JarFactoryContainer jfc = (JarFactoryContainer)fc;
				fileList.add( jfc.getJarFile() );
			}
		}
		StringBuilder fcp = new StringBuilder();
		for (File f: fileList) {
			fcp.append(f.getAbsolutePath());
		}
		return fcp.toString();
    }
}