/*
 * Copyright (c) 2012, the Dart project authors.
 * 
 * Licensed under the Eclipse Public License v1.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.eclipse.org/legal/epl-v10.html
 * 
 * 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 com.google.dart.tools.core;

import com.google.common.collect.ImmutableList;
import com.google.common.collect.Lists;
import com.google.dart.engine.AnalysisEngine;
import com.google.dart.engine.error.ErrorCode;
import com.google.dart.engine.index.Index;
import com.google.dart.engine.index.IndexFactory;
import com.google.dart.engine.index.IndexStore;
import com.google.dart.engine.sdk.DirectoryBasedDartSdk;
import com.google.dart.engine.utilities.instrumentation.Instrumentation;
import com.google.dart.engine.utilities.instrumentation.InstrumentationBuilder;
import com.google.dart.engine.utilities.logging.Logger;
import com.google.dart.server.generated.AnalysisServer;
import com.google.dart.server.generated.types.RequestError;
import com.google.dart.server.generated.types.ServerService;
import com.google.dart.server.internal.remote.DebugPrintStream;
import com.google.dart.server.internal.remote.FileReadMode;
import com.google.dart.server.internal.remote.RemoteAnalysisServerImpl;
import com.google.dart.server.internal.remote.StdioServerSocket;
import com.google.dart.server.utilities.logging.Logging;
import com.google.dart.tools.core.analysis.model.AnalysisServerData;
import com.google.dart.tools.core.analysis.model.ProjectManager;
import com.google.dart.tools.core.analysis.model.PubFolder;
import com.google.dart.tools.core.internal.MessageConsoleImpl;
import com.google.dart.tools.core.internal.OptionManager;
import com.google.dart.tools.core.internal.analysis.model.AnalysisServerDataImpl;
import com.google.dart.tools.core.internal.analysis.model.DartProjectManager;
import com.google.dart.tools.core.internal.analysis.model.ProjectManagerImpl;
import com.google.dart.tools.core.internal.analysis.model.WorkspaceAnalysisServerListener;
import com.google.dart.tools.core.internal.builder.AnalysisMarkerManager;
import com.google.dart.tools.core.internal.model.DartIgnoreManager;
import com.google.dart.tools.core.internal.model.DartProjectNature;
import com.google.dart.tools.core.internal.util.Extensions;
import com.google.dart.tools.core.internal.util.ResourceUtil;
import com.google.dart.tools.core.internal.util.Util;
import com.google.dart.tools.core.jobs.CleanLibrariesJob;
import com.google.dart.tools.core.model.DartIgnoreListener;
import com.google.dart.tools.core.model.DartSdkListener;
import com.google.dart.tools.core.model.DartSdkManager;
import com.google.dart.tools.core.pub.PubCacheManager_NEW;
import com.google.dart.tools.core.utilities.general.StringUtilities;
import com.google.dart.tools.core.utilities.io.FileUtilities;
import com.google.dart.tools.core.utilities.performance.PerformanceManager;
import com.google.dart.tools.core.utilities.yaml.PubYamlUtils;

import org.apache.commons.lang3.ArrayUtils;
import org.apache.commons.lang3.StringUtils;
import org.eclipse.core.resources.IContainer;
import org.eclipse.core.resources.IFile;
import org.eclipse.core.resources.IFolder;
import org.eclipse.core.resources.IMarker;
import org.eclipse.core.resources.IProject;
import org.eclipse.core.resources.IResource;
import org.eclipse.core.resources.IResourceVisitor;
import org.eclipse.core.resources.IWorkspaceRoot;
import org.eclipse.core.resources.ProjectScope;
import org.eclipse.core.resources.ResourcesPlugin;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.ILog;
import org.eclipse.core.runtime.IPath;
import org.eclipse.core.runtime.IStatus;
import org.eclipse.core.runtime.Path;
import org.eclipse.core.runtime.Platform;
import org.eclipse.core.runtime.Plugin;
import org.eclipse.core.runtime.QualifiedName;
import org.eclipse.core.runtime.Status;
import org.eclipse.core.runtime.content.IContentType;
import org.eclipse.core.runtime.jobs.Job;
import org.eclipse.core.runtime.preferences.IEclipsePreferences;
import org.eclipse.core.runtime.preferences.InstanceScope;
import org.osgi.framework.BundleContext;
import org.osgi.framework.Version;
import org.osgi.service.prefs.BackingStoreException;

import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.io.PrintStream;
import java.io.PrintWriter;
import java.io.StringWriter;
import java.lang.management.ManagementFactory;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Date;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Hashtable;
import java.util.List;
import java.util.Properties;

/**
 * The class <code>DartCore</code> is used to access the elements modeling projects that have a Dart
 * nature.
 * 
 * @coverage dart.tools.core
 */
public class DartCore extends Plugin implements DartSdkListener {

  /**
   * The unique instance of this class.
   */
  private static DartCore PLUG_IN;

  /**
   * The log used by {@link #logError(String)} and other local methods for logging errors, warnings,
   * and information or <code>null</code> to use the default system log.
   */
  private static ILog PLUGIN_LOG;

  /**
   * Flag indicating whether instrumentation logging of errors is enabled
   */
  private static boolean instrumentationLogErrorEnabled = true;

  /**
   * The id of the plug-in that defines the Dart model.
   */
  public static final String PLUGIN_ID = DartCore.class.getPackage().getName();

  /**
   * Name of file containing user-defined properties.
   */
  public static final String EDITOR_PROPERTIES = "editor.properties";

  /**
   * The id of the project nature used for Dart projects.
   */
  public static final String DART_PROJECT_NATURE = PLUGIN_ID + ".dartNature";

  /**
   * The id of the builder used for Dart projects.
   */
  public static final String DART_BUILDER_ID = PLUGIN_ID + ".dartBuilder";

  /**
   * The id of the content type used to represent Dart compilation units.
   */
  public static final String DART_SOURCE_CONTENT_TYPE = PLUGIN_ID + ".dartSourceFile";

  /**
   * Eclipse problem marker type used to display Dart compilation errors.
   */
  public static final String DART_PROBLEM_MARKER_TYPE = PLUGIN_ID + ".problem";

  /**
   * Eclipse problem marker type used to display Dart hints.
   */
  public static final String DART_HINT_MARKER_TYPE = PLUGIN_ID + ".hint";

  /**
   * Eclipse problem marker type used to display todo markers.
   */
  public static final String DART_TASK_MARKER_TYPE = PLUGIN_ID + ".task";

  /**
   * Eclipse problem marker type used to Angular warning markers
   */
  public static final String ANGULAR_WARNING_MARKER_TYPE = PLUGIN_ID + ".angular_warning";

  /**
   * Correction marker attribute.
   */
  public static final String MARKER_ATTR_CORRECTION = "correction";

  /**
   * Extension for single unit compiled into JavaScript.
   */
  public static final String EXTENSION_JS = "js";

  /**
   * Preference for the automatically running pub.
   */
  public static final String PUB_AUTO_RUN_PREFERENCE = "pubAutoRun";

  /**
   * Preference for enabling hints.
   */
  public static final String ENABLE_HINTS_PREFERENCE = "enableHints";

  /**
   * Preference for enabling lints.
   */
  public static final String ENABLE_LINTS_PREFERENCE = "enableLints";

  /**
   * Preference for enabling dart2js related hints.
   */
  public static final String ENABLE_HINTS_DART2JS_PREFERENCE = "enableHints_dart2js";

  public static final String PROJECT_PREF_PACKAGE_ROOT = "projectPackageRoot";

  /**
   * Project package root for VM launches
   */
  public static final String PROJECT_PREF_VM_PACKAGE_ROOT = "projectVmPackageRoot";

  public static final String PREFS_DART2JS_FLAGS = "dart2jsFlags";

  /**
   * Preference for specifying location of the Dart SDK.
   */
  public static final String PREFS_SDK_LOCATION = "sdkLocation";

  /**
   * Preference for specifying location of Dartium
   */
  public static final String PREFS_DARTIUM_LOCATION = "dartiumLocation";

  /**
   * Preference to control if "not a member" warnings should be reported for inferred types.
   */
  public static final String TYPE_CHECKS_FOR_INFERRED_TYPES = "typeChecksForInferredTypes";

  public static final String PROJECT_PREF_DISABLE_DART_BASED_BUILDER = "disableDartBasedBuilder";

  /**
   * Preference for enabling usage collection
   */
  public static final String PREFS_ENABLE_ANALYTICS = "enableAnalytics";

  public static final String PREFS_SHOW_ANALYTICS_DIALOG = "showAnalyticsDialog";

  // white listed dirs that can be used for pub build
  public static final List<String> pubDirectories = Arrays.asList(
      "assest",
      "benchmark",
      "bin",
      "example",
      "test",
      "web");

  /**
   * Cached extensions for CSS files.
   */
  private static final String[] CSS_FILE_EXTENSIONS = {"css"};

  /**
   * Cached extensions for HTML files.
   */
  private static final String[] HTML_FILE_EXTENSIONS = {"html", "htm"};

  /**
   * Cached extensions for JS files.
   */
  private static final String[] JS_FILE_EXTENSIONS = {"js"};

  /**
   * Cached extensions for TXT files.
   */
  private static final String[] TXT_FILE_EXTENSIONS = {"txt"};

  /**
   * Cached extensions for files that are generated by the dartc compiler.
   */
  private static final String[] DART_GENERATED_FILE_EXTENSIONS = {"api", "deps", "js", "map"};

  /**
   * Cached extensions for image files.
   */
  public static final String[] IMAGE_FILE_EXTENSIONS = {
      "bmp", "gif", "jpeg", "jpg", "png", "raw", "thm", "tif", "tiff"};

  /**
   * Name of directory for packages installed by pub
   */
  public static final String PACKAGES_DIRECTORY_NAME = "packages";

  /**
   * Name of directory for build artifacts generated by pub
   */
  public static final String BUILD_DIRECTORY_NAME = "build";

  /**
   * Name of "lib" directory in package
   */
  public static final String LIB_DIRECTORY_NAME = "lib";

  /**
   * Path string for packages directory, uses "/" as path separator, equals "/packages/".
   */
  public static final String PACKAGES_DIRECTORY_PATH = "/" + PACKAGES_DIRECTORY_NAME + "/";

  /**
   * Path string for packages directory in a url.
   */
  public static final String PACKAGES_DIRECTORY_URL = "/" + PACKAGES_DIRECTORY_NAME + "/";

  public static final String PACKAGE_SCHEME_SPEC = "package:";

  /**
   * Path string for lib directory in a url.
   */
  public static final String LIB_URL_PATH = "/lib/";

  /**
   * Name of pubspec file
   */
  public static final String PUBSPEC_FILE_NAME = "pubspec.yaml";

  /**
   * Name of special pubspec lock file
   */
  public static final String PUBSPEC_LOCK_FILE_NAME = "pubspec.lock";

  /**
   * The name of the build.dart special file.
   */
  public static final String BUILD_DART_FILE_NAME = "build.dart";

  /**
   * Used by the {@link DartDebugUserAgentManager} to indicate whether the allow remote connection
   * dialog is open.
   */
  public static boolean allowConnectionDialogOpen = false;

  /**
   * The shared message console instance.
   */
  private static final MessageConsole CONSOLE = new MessageConsoleImpl();

  /**
   * The QualifiedName for a resource remapping (a.foo ==> a.bar).
   */
  private static final QualifiedName RESOURCE_REMAP_NAME = new QualifiedName(
      PLUGIN_ID,
      "resourceRemap");

  /**
   * The QualifiedName for the package version.
   */
  public static final QualifiedName PUB_PACKAGE_VERSION = new QualifiedName(
      DartCore.PLUGIN_ID,
      "pub.package.version");

  /**
   * The QualifiedName for library names.
   */
  public static final QualifiedName LIBRARY_NAME = new QualifiedName(
      DartCore.PLUGIN_ID,
      "libraryName");

  /**
   * The unique project manager used for analysis of anything in the workspace
   */
  private static ProjectManager projectManager;

  /**
   * Used to synchronize access to {@link #projectManager}.
   */
  private static final Object projectManagerLock = new Object();

  /**
   * The unique {@link AnalysisServer} used for analysis of anything in the workspace.
   */
  private static AnalysisServer analysisServer;

  /**
   * The unique {@link AnalysisServerDataImpl} instance.
   */
  private static AnalysisServerDataImpl analysisServerDataImpl = new AnalysisServerDataImpl();

  /**
   * The unique {@link WorkspaceAnalysisServerListener} instance.
   */
  private static WorkspaceAnalysisServerListener analysisServerListener;

  /**
   * Used to synchronize access to {@link #analysisServer}.
   */
  private static final Object analysisServerLock = new Object();

  /**
   * Add the given listener for dart ignore changes to the Dart Model. Has no effect if an identical
   * listener is already registered.
   * 
   * @param listener the listener to add
   */
  public static void addIgnoreListener(DartIgnoreListener listener) {
    getIgnoreManager().addListener(listener);
  }

  /**
   * Add the given resource to the set of ignored resources.
   * 
   * @param resource the resource to ignore
   * @throws IOException if there was an error accessing the ignore file
   * @throws CoreException if there was an error deleting markers
   */
  public static void addToIgnores(IResource resource) throws IOException, CoreException {
    getIgnoreManager().addToIgnores(resource);
  }

  /**
   * Remove any resource mapping for the given container.
   * 
   * @param resource
   */
  public static void clearResourceRemapping(IContainer container) {
    try {
      container.accept(new IResourceVisitor() {
        @Override
        public boolean visit(IResource resource) throws CoreException {
          if (resource instanceof IFile) {
            clearResourceRemapping((IFile) resource);

            return true;
          } else if (resource instanceof IContainer) {
            IContainer childContainer = (IContainer) resource;

            if (childContainer.getName().startsWith(".")) {
              return false;
            } else {
              return true;
            }
          } else {
            return false;
          }
        }
      });
    } catch (CoreException e) {
      DartCore.logError(e);
    }
  }

  /**
   * Remove any resource mapping for the given file.
   * 
   * @param resource
   */
  public static void clearResourceRemapping(IFile resource) {
    if (getResourceRemapping(resource) != null) {
      setResourceRemapping(resource, null);
    }
  }

  /**
   * Return true if directory contains a "packages" directory that is installed by pub
   */
  public static boolean containsPackagesDirectory(File file) {
    return new File(file, PACKAGES_DIRECTORY_NAME).isDirectory();
  }

  /**
   * Return <code>true</code> if the directory contains a "pubspec.yaml" file
   */
  public static boolean containsPubspecFile(File directory) {
    return new File(directory, PUBSPEC_FILE_NAME).isFile();
  }

  /**
   * Return an array of analysis server arguments
   * 
   * @return a non-null array of arguments
   */
  public static String[] getAdditionalAnalysisServerArguments() {
    String value = getUserDefinedProperty(ANALYSIS_SERVER_ARG_PROP_KEY);
    if (value == null) {
      return StringUtilities.EMPTY_ARRAY;
    }
    return value.split(",");
  }

  /**
   * Answer the unique {@link AnalysisServer} used for analysis of anything in the workspace.
   * 
   * @return the {@link AnalysisServer} (not {@code null})
   */
  public static AnalysisServer getAnalysisServer() {
    synchronized (analysisServerLock) {
      if (analysisServer == null) {
        DartSdkManager sdkManager = DartSdkManager.getManager();
        if (!sdkManager.hasSdk()) {
          DartCore.logError("Add the dart sdk (com.google.dart.sdk) as a JVM argument");
          System.exit(1);
        }

        boolean isRunningFromSource = false;
        String runtimePath = sdkManager.getSdk().getVmExecutable().getAbsolutePath();
        String analysisServerPath = DartCoreDebug.ANALYSIS_SERVER_PATH;
        if (StringUtils.isEmpty(analysisServerPath)) {
          String svnRoot = System.getProperty("com.google.dart.svnRoot");
          if (svnRoot == null) {
            File analysisServerSnapshot = new File(
                DartSdkManager.getManager().getSdk().getDirectory(),
                "bin/snapshots/analysis_server.dart.snapshot");
            analysisServerPath = analysisServerSnapshot.getAbsolutePath();
            if (!analysisServerSnapshot.exists()) {
              DartCore.logError("Analysis Server snapshot was not found in "
                  + analysisServerSnapshot.getAbsolutePath() + ", SDK is corrupt.");
              System.exit(1);
            }
          } else {
            analysisServerPath = svnRoot + "/pkg/analysis_server/bin/server.dart";
            isRunningFromSource = true;
          }
        } else {
          isRunningFromSource = true;
        }

        String packageRoot = System.getProperty("com.google.dart.packageRoot");
        if (packageRoot == null && isRunningFromSource) {
          DartCore.logError("To run analysis server from source, a package root must be "
              + "supplied using -Dcom.google.dart.packageRoot.");
          System.exit(1);
        }

        try {
          String[] additionalArguments = DartCore.getAdditionalAnalysisServerArguments();
          // prepare debug stream
          DebugPrintStream debugStream;
          {
            String logPath = DartCoreDebug.ANALYSIS_SERVER_LOG_FILE;
            if (StringUtils.isBlank(logPath)) {
              debugStream = null;
            } else if ("console".equals(logPath)) {
              debugStream = new DebugPrintStream() {
                @Override
                public void println(String s) {
                  if (s.length() > 1000) {
                    s = s.substring(0, 1000) + "...";
                  }
                  System.out.println(s);
                }
              };
            } else {
              @SuppressWarnings("resource")
              final PrintStream fileStream = new PrintStream(logPath);
              debugStream = new DebugPrintStream() {
                @Override
                public void println(String s) {
                  fileStream.println(s);
                }
              };
            }
          }
          // additional options
          if (DartCoreDebug.ANALYSIS_SERVER_INCREMENTAL_RESOLUTION_API) {
            additionalArguments = ArrayUtils.add(
                additionalArguments,
                "--enable-incremental-resolution-api");
          }
          if (DartCoreDebug.ANALYSIS_SERVER_NEW_TASK_MODEL) {
            additionalArguments = ArrayUtils.add(additionalArguments, "--enable-new-task-model");
          }
          {
            String log = DartCoreDebug.ANALYSIS_SERVER_INCREMENTAL_RESOLUTION_LOG;
            if (!StringUtils.isEmpty(log)) {
              additionalArguments = ArrayUtils.add(
                  additionalArguments,
                  "--incremental-resolution-log=" + log);
            }
          }
          if (DartCoreDebug.ANALYSIS_SERVER_INCREMENTAL_RESOLUTION_VALIDATION) {
            additionalArguments = ArrayUtils.add(
                additionalArguments,
                "--incremental-resolution-validation");
          }
          {
            String log = DartCoreDebug.ANALYSIS_SERVER_INSTRUMENTATION_LOG_FILE;
            if (!StringUtils.isEmpty(log)) {
              log = log.trim();
              if (log.length() > 0) {
                additionalArguments = ArrayUtils.add(
                    additionalArguments,
                    "--instrumentation-log-file=" + log);
              }
            }
          }
          if (DartCoreDebug.ANALYSIS_SERVER_PRINT_TO_CONSOLE) {
            additionalArguments = ArrayUtils.add(additionalArguments, "--internal-print-to-console");
          }
          // HTTP port
          int httpPort = 0;
          if (DartCoreDebug.ANALYSIS_SERVER_HTTP_PORT != null
              && !DartCoreDebug.ANALYSIS_SERVER_HTTP_PORT.isEmpty()) {
            try {
              httpPort = Integer.parseInt(DartCoreDebug.ANALYSIS_SERVER_HTTP_PORT);
            } catch (NumberFormatException e) {
              DartCore.logError("Analysis server HTTP port must be an integer.");
              System.exit(1);
            }
          }
          // create server, if "com.google.dart.svnRoot" flag was not set then use snapshot
          StdioServerSocket socket = new StdioServerSocket(
              runtimePath,
              analysisServerPath,
              packageRoot,
              debugStream,
              additionalArguments,
              DartCoreDebug.ANALYSIS_SERVER_DEBUG,
              DartCoreDebug.ANALYSIS_SERVER_PROFILE,
              httpPort,
              false,
              FileReadMode.AS_IS);
          if (isPluginsBuild()) {
            // plugin mode
            socket.setClientId("org.dartlang.dartplugin");
          } else {
            // editor mode
            socket.setClientId("org.dartlang.darteditor");
          }
          socket.setClientVersion(getVersion());
          // start server
          analysisServer = new RemoteAnalysisServerImpl(socket);
          analysisServerDataImpl.setServer(analysisServer);
          analysisServerListener = new WorkspaceAnalysisServerListener(
              analysisServerDataImpl,
              new DartProjectManager(
                  ResourcesPlugin.getWorkspace().getRoot(),
                  analysisServer,
                  DartIgnoreManager.getInstance()));
          analysisServer.addAnalysisServerListener(analysisServerListener);
          analysisServer.start();
          analysisServer.server_setSubscriptions(ImmutableList.of(ServerService.STATUS));
          analysisServerDataImpl.updateOptions();
        } catch (Throwable e) {
          DartCore.logError("Enable to start stdio server", e);
          System.exit(1);
        }
      }
    }
    return analysisServer;
  }

  /**
   * Answer the unique {@link AnalysisServerData} used to provide analysis information in the
   * workspace.
   * 
   * @return the {@link AnalysisServerData} (not {@code null})
   */
  public static AnalysisServerData getAnalysisServerData() {
    getAnalysisServer();
    return analysisServerDataImpl;
  }

  /**
   * Answer the application directory (a directory contains a "packages" directory and a
   * "pubspec.yaml" file) directly or indirectly containing the specified file or the file itself if
   * it is an application directory.
   * 
   * @param libFileOrDir the library file or directory
   * @return the context in which the specified library should be analyzed (not <code>null</code>)
   */
  public static File getApplicationDirectory(File file) {
    while (file != null) {
      if (isApplicationDirectory(file)) {
        return file;
      }
      file = file.getParentFile();
    }
    return null;
  }

  /**
   * Answer the application directory (a directory that contains a "packages" directory and a
   * "pubspec.yaml" file) directly or indirectly containing the specified resource or the resource
   * itself if it is an application directory.
   * 
   * @param resource the file or directory
   * @return the directory with the pubspec for the given file
   */
  public static IContainer getApplicationDirectory(IResource resource) {
    IContainer container;
    if (resource instanceof IFile) {
      container = resource.getParent();
    } else {
      container = (IContainer) resource;
    }
    while (container != null) {
      if (isApplicationDirectory(container)) {
        return container;
      }
      container = container.getParent();
    }
    return null;
  }

  /**
   * Returns the day (yyyy-MM-dd) the product was built.
   */
  public static String getBuildDate() {
    return "@BUILDDATE@";
  }

  /**
   * Returns the SVN revision number as a String.
   */
  public static String getBuildId() {
    return "@REVISION@";
  }

  /**
   * Return a unique token that can be used to determine whether cached data that changes only when
   * the version of the editor changes is still valid.
   * 
   * @return a token used to determine the validity of cached data
   */
  public static String getBuildIdOrDate() {
    String buildIdOrDate = getBuildId();
    if (buildIdOrDate.startsWith("@")) {
      buildIdOrDate = new SimpleDateFormat("yyyy-MM-dd").format(new Date());
    }
    return buildIdOrDate;
  }

  /**
   * Returns the shared message console. Unlike the log ({@link DartCore#getLog()}), the console is
   * intended for communication with the end-user.
   * 
   * @return the message console
   */
  public static MessageConsole getConsole() {
    return CONSOLE;
  }

  /**
   * Return the list of known Dart-like file extensions. Dart-like extensions are defined in the
   * {@link Platform.getContentManager() content type manager} for the
   * {@link #DART_SOURCE_CONTENT_TYPE}. Note that a Dart-like extension does not include the leading
   * dot, and that the "dart" extension is always defined as a Dart-like extension.
   * 
   * @return the list of known Dart-like file extensions
   */
  public static String[] getDartLikeExtensions() {
    IContentType dartContentType = Platform.getContentTypeManager().getContentType(
        DART_SOURCE_CONTENT_TYPE);
    HashSet<String> extensionSet = new HashSet<String>();
    for (IContentType contentType : Platform.getContentTypeManager().getAllContentTypes()) {
      if (contentType.isKindOf(dartContentType)) {
        for (String extension : contentType.getFileSpecs(IContentType.FILE_EXTENSION_SPEC)) {
          extensionSet.add(extension);
        }
      }
    }
    extensionSet.remove(Extensions.DART);
    ArrayList<String> extensionList = new ArrayList<String>(extensionSet);
    extensionList.add(0, Extensions.DART);
    return extensionList.toArray(new String[extensionList.size()]);
  }

  /**
   * Returns all existing and open workspace Dart projects.
   */
  public static IProject[] getDartProjects() {
    List<IProject> dartProjects = Lists.newArrayList();
    IProject[] projects = ResourcesPlugin.getWorkspace().getRoot().getProjects();
    for (IProject project : projects) {
      if (!project.isAccessible()) {
        continue;
      }
      if (!DartProjectNature.hasDartNature(project)) {
        continue;
      }
      if (PubCacheManager_NEW.isPubCacheProject(project)) {
        continue;
      }
      dartProjects.add(project);
    }
    return dartProjects.toArray(new IProject[dartProjects.size()]);
  }

  /**
   * Return a table of all known configurable options with their default values. These options allow
   * to configure the behavior of the underlying components. The client may safely use the result as
   * a template that they can modify and then pass to {@link #setOptions()}</code>.
   * <p>
   * Helper constants have been defined on DartPreferenceConstants for each of the option IDs
   * (categorized in Code assist option ID, Compiler option ID and Core option ID) and some of their
   * acceptable values (categorized in Option value). Some options accept open value sets beyond the
   * documented constant values.
   * <p>
   * Note: each release may add new options.
   * 
   * @return a table of all known configurable options with their default values
   */
  public static Hashtable<String, String> getDefaultOptions() {
    return null;
  }

  public static File getEclipseInstallationDirectory() {
    return new File(Platform.getInstallLocation().getURL().getFile());
  }

  /**
   * Return the workspace root default charset encoding.
   * 
   * @return the name of the default charset encoding for the workspace root
   */
  public static String getEncoding() {
    try {
      return ResourcesPlugin.getWorkspace().getRoot().getDefaultCharset();
    } catch (IllegalStateException exception) {
      // happen when there's no workspace (see bug
      // https://bugs.eclipse.org/bugs/show_bug.cgi?id=216817)
      // or when it is shutting down (see bug
      // https://bugs.eclipse.org/bugs/show_bug.cgi?id=60687)
      return System.getProperty("file.encoding"); //$NON-NLS-1$
    } catch (CoreException exception) {
      // fails silently and return plugin global encoding if core exception
      // occurs
    }
    return ResourcesPlugin.getEncoding();
  }

  /**
   * Extract {@link ErrorCode} form the given {@link IMarker}.
   * 
   * @return the {@link ErrorCode}, may be {@code null}.
   */
  public static ErrorCode getErrorCode(IMarker marker) {
    return AnalysisMarkerManager.getErrorCode(marker);
  }

  /**
   * Return the DartIgnoreManager
   */
  public static DartIgnoreManager getIgnoreManager() {
    if (DartCoreDebug.ENABLE_ANALYSIS_SERVER) {
      return DartIgnoreManager.getInstance();
    } else {
      return getProjectManager().getIgnoreManager();
    }
  }

  /**
   * Utility method for returning one option value only. Equivalent to
   * <code>DartCore.getOptions().get(optionName)</code> Note that it may answer <code>null</code> if
   * this option does not exist.
   * <p>
   * Helper constants have been defined on DartPreferenceConstants for each of the option IDs
   * (categorized in Code assist option ID, Compiler option ID and Core option ID) and some of their
   * acceptable values (categorized in Option value). Some options accept open value sets beyond the
   * documented constant values.
   * <p>
   * Note: each release may add new options.
   * 
   * @param optionName the name of the option whose value is to be returned
   * @return the value of a given option
   */
  public static String getOption(String optionName) {
    return OptionManager.getInstance().getOption(optionName);
  }

  /**
   * Return the table of the current options. Initially, all options have their default values, and
   * this method returns a table that includes all known options.
   * <p>
   * Helper constants have been defined on DartPreferenceConstants for each of the option IDs
   * (categorized in Code assist option ID, Compiler option ID and Core option ID) and some of their
   * acceptable values (categorized in Option value). Some options accept open value sets beyond the
   * documented constant values.
   * <p>
   * Note: each release may add new options.
   * <p>
   * Returns a default set of options even if the platform is not running.
   * </p>
   * 
   * @return table of current settings of all options (key type: <code>String</code>; value type:
   *         <code>String</code>)
   */
  public static HashMap<String, String> getOptions() {
    return OptionManager.getInstance().getOptions();
  }

  /**
   * Return the unique instance of this class.
   * 
   * @return the unique instance of this class
   */
  public static DartCore getPlugin() {
    return PLUG_IN;
  }

  /**
   * Answer the unique project manager used for analysis of anything in the workspace.
   * 
   * @return the manager (not {@code null})
   */
  public static ProjectManager getProjectManager() {
    synchronized (projectManagerLock) {
      if (projectManager == null) {
        // start index
        final Index index;
        {
          File stateDir = getPlugin().getStateLocation().toFile();
          File indexDir = new File(stateDir, "index");
          indexDir.mkdirs();
          IndexStore indexStore = IndexFactory.newFileIndexStore(indexDir);
          index = IndexFactory.newIndex(indexStore);
          Thread thread = new Thread() {
            @Override
            public void run() {
              index.run();
            }
          };
          thread.setName("Index Thread");
          thread.setDaemon(true);
          thread.start();
        }
        // create ProjectManagerImpl
        projectManager = new ProjectManagerImpl(
            ResourcesPlugin.getWorkspace().getRoot(),
            DartSdkManager.getManager().getSdk(),
            DartSdkManager.getManager().getSdkContextId(),
            index,
            DartIgnoreManager.getInstance());
      }
    }
    return projectManager;
  }

  /**
   * @return the mapping for the given resource, if any
   */
  public static String getResourceRemapping(IFile originalResource) {
    try {
      return originalResource.getPersistentProperty(RESOURCE_REMAP_NAME);
    } catch (CoreException e) {
      return null;
    }
  }

  /**
   * Returns the name of the directory in packages that is linked to the "lib" folder in the project
   * 
   * @param project
   * @return the name of the directory, <code>null</code> if there is no self linked packages folder
   */
  public static String getSelfLinkedPackageName(IResource resource) {
    String packageName = null;

    try {
      IContainer appFolder = getApplicationDirectory(resource);

      if (appFolder != null) {
        IResource pubspec = appFolder.findMember(DartCore.PUBSPEC_FILE_NAME);

        if (pubspec != null) {
          String contents = FileUtilities.getContents(pubspec.getLocation().toFile(), "UTF-8");

          if (contents != null) {
            String name = PubYamlUtils.getPubspecName(contents);

            if (name != null) {
              return name;
            }
          }
        }
      }
    } catch (Exception e) {

    }

    return packageName;
  }

  /**
   * Returns the path string for the default dart directory - user.home/dart
   * 
   * @return the name of the user.home/dart directory
   */
  public static String getUserDefaultDartFolder() {
    String defaultLocation = System.getProperty("user.home"); //$NON-NLS-1$
    return defaultLocation + File.separator + "dart" + File.separator; //$NON-NLS-1$
  }

  /**
   * Returns the current value of the string-valued user-defined property with the given name.
   * Returns <code>null</code> if there is no user-defined property with the given name.
   * <p>
   * User-defined properties are defined in the <code>editor.properties</code> file located in the
   * eclipse installation directory.
   * 
   * @see DartCore#getEclipseInstallationDirectory()
   * @param name the name of the property
   * @return the string-valued property
   */
  public static String getUserDefinedProperty(String key) {

    Properties properties = new Properties();

    File installDirectory = getEclipseInstallationDirectory();
    File file = new File(installDirectory, EDITOR_PROPERTIES);

    if (file.exists()) {
      try {
        properties.load(new FileReader(file));
      } catch (FileNotFoundException e) {
        logError(e);
      } catch (IOException e) {
        logError(e);
      }
    }

    return properties.getProperty(key);
  }

  /**
   * @return the version text for this plugin (i.e. 1.1.0)
   */
  public static String getVersion() {
    Version version = getPlugin().getBundle().getVersion();

    return version.getMajor() + "." + version.getMinor() + "." + version.getMicro();
  }

  public static boolean is32Bit() {
    return Platform.getOSArch().indexOf("64") == -1;
  }

  /**
   * Return <code>true</code> if the given resource should be analyzed. All resources are to be
   * analyzed unless they have been excluded.
   * 
   * @param resource the resource being tested
   * @return <code>true</code> if the given resource should be analyzed
   */
  public static boolean isAnalyzed(IResource resource) {
    return getIgnoreManager().isAnalyzed(resource);
  }

  /**
   * Return true if directory contains a "packages" directory and a "pubspec.yaml" file
   */
  public static boolean isApplicationDirectory(File directory) {
    return containsPubspecFile(directory);
  }

  /**
   * Return true if directory contains a "packages" directory and a "pubspec.yaml" file
   */
  public static boolean isApplicationDirectory(IContainer container) {
    if (container.getLocation() == null) {
      return false;
    }

    File directory = container.getLocation().toFile();

    return isApplicationDirectory(directory);
  }

  /**
   * Answer {@code true} if the specified resource is a build.dart file and exists either in a
   * project or in a folder containing a pubspec file.
   * 
   * @param file the file
   * @return {@code true} if the file is a build.dart file that will be run by the builder
   */
  public static boolean isBuildDart(IFile file) {
    if (file == null || !file.getName().equals(BUILD_DART_FILE_NAME) || !file.exists()) {
      return false;
    }

    IContainer container = file.getParent();

    // Always run build.dart in a project's root.
    if (container.getType() == IResource.PROJECT) {
      return true;
    }

    return container.getFile(new Path(PUBSPEC_FILE_NAME)).exists();
  }

  /**
   * Return true if directory is one that is generated by pub build
   * 
   * @param folder the folder to be checked
   * @return <code>true</code> if folder name matches and is sibling of pubspec.yaml
   */
  public static boolean isBuildDirectory(IFolder folder) {
    IPath location = folder.getLocation();
    if (location != null && folder.getName().equals(BUILD_DIRECTORY_NAME)) {
      if (folder.getParent().findMember(PUBSPEC_FILE_NAME) != null) {
        return true;
      }
    }
    return false;
  }

  /**
   * Return <code>true</code> if the given file is contained in the packages directory created by
   * pub
   * 
   * @param file the file that is to be checked
   * @return <code>true</code> if the given file is in packages
   */
  public static boolean isContainedInPackages(File file) {
    if (file.getAbsolutePath().contains(PACKAGES_DIRECTORY_NAME)) {
      return true;
    }
    return false;
  }

  /**
   * Return <code>true</code> if the given file is contained in the packages directory created by
   * pub
   * 
   * @param file the file that is to be checked
   * @return <code>true</code> if the given file is in packages
   */
  public static boolean isContainedInPackages(IFile file) {
    return file.getFullPath().toString().contains(DartCore.PACKAGES_DIRECTORY_PATH);
  }

  /**
   * Return <code>true</code> if the given file name's extension is an CSS-like extension.
   * 
   * @param fileName the file name being tested
   * @return <code>true</code> if the given file name's extension is an CSS-like extension
   */
  public static boolean isCssLikeFileName(String fileName) {
    return isLikeFileName(fileName, CSS_FILE_EXTENSIONS);
  }

  /**
   * Return <code>true</code> if the given file name's extension is a generated Dart like extension.
   * 
   * @return <code>true</code> if the given file name's extension is a generated Dart like extension
   */
  public static boolean isDartGeneratedFile(String fileName) {
    return isLikeFileName(fileName, DART_GENERATED_FILE_EXTENSIONS);
  }

  /**
   * Return <code>true</code> if the name of the given {@link IFile} has a Dart-like extension.
   * 
   * @param fileName the file name being tested
   * @return <code>true</code> if the name of the given {@link IFile} has a Dart-like extension
   */
  public static boolean isDartLikeFile(IFile file) {
    String fileName = file.getName();
    return isDartLikeFileName(fileName);
  }

  /**
   * Return <code>true</code> if the given file name's extension is a Dart-like extension.
   * 
   * @param fileName the file name being tested
   * @return <code>true</code> if the given file name's extension is a Dart-like extension
   */
  public static boolean isDartLikeFileName(String fileName) {
    return StringUtilities.endsWithIgnoreCase(fileName, ".dart");
  }

  /**
   * Return <code>true</code> if file is in the dart sdk lib directory
   * 
   * @param file
   * @return <code>true</code> if file is in dart-sdk/lib
   */
  public static boolean isDartSdkLibraryFile(File file) {
    File sdkLibrary = DartSdkManager.getManager().getSdk().getLibraryDirectory();
    File parentFile = file.getParentFile();
    while (parentFile != null) {
      if (parentFile.equals(sdkLibrary)) {
        return true;
      }
      parentFile = parentFile.getParentFile();
    }
    return false;
  }

  /**
   * Return <code>true</code> if the given file name's extension is an HTML-like extension.
   * 
   * @param fileName the file name being tested
   * @return <code>true</code> if the given file name's extension is an HTML-like extension
   */
  public static boolean isHtmlLikeFileName(String fileName) {
    return isLikeFileName(fileName, HTML_FILE_EXTENSIONS);
  }

  /**
   * Return <code>true</code> if the given file name's extension is an image-like extension.
   * 
   * @param fileName the file name being tested
   * @return <code>true</code> if the given file name's extension is an image-like extension
   */
  public static boolean isImageLikeFileName(String fileName) {
    return isLikeFileName(fileName, IMAGE_FILE_EXTENSIONS);
  }

  /**
   * Return true if directory is build directory created by pub
   * 
   * @param folder the folder to be checked
   * @return <code>true</code> if folder/parent name matches and is sibling of pubspec.yaml
   */
  public static boolean isInBuildDirectory(IContainer folder) {
    while (folder.getParent() != null) {
      if (folder.getName().equals(BUILD_DIRECTORY_NAME)
          && folder.getParent().getFile(new Path(PUBSPEC_FILE_NAME)).exists()) {
        return true;
      }
      folder = folder.getParent();
    }
    return false;
  }

  /**
   * Return true if is in build directory created by pub
   */
  public static boolean isInBuildDirectory(IResource resource) {
    if (resource == null) {
      return false;
    }
    if (!(resource instanceof IContainer)) {
      resource = resource.getParent();
    }
    return !(resource instanceof IProject || resource instanceof IWorkspaceRoot)
        && (isBuildDirectory((IFolder) resource) || isInBuildDirectory((IContainer) resource));

  }

  /**
   * @return {@code true} if the given resource is located in the top-level "packages" folder of its
   *         enclosing package.
   */
  public static boolean isInDuplicatePackageFolder(IResource resource) {
    if (resource == null) {
      return false;
    }
    // prepare "pub" folder
    PubFolder pubFolder = DartCore.getProjectManager().getPubFolder(resource);
    if (pubFolder == null) {
      return false;
    }
    IPath pubPath = pubFolder.getResource().getFullPath();
    // check if resource is in "packages"
    IPath resourcePath = resource.getFullPath();
    String[] segments = resourcePath.segments();
    for (int i = 1; i < segments.length - 1; i++) {
      String segment = segments[i];
      if (segment.equals(PACKAGES_DIRECTORY_NAME)) {
        return !resourcePath.uptoSegment(i).equals(pubPath);
      }
    }
    // not in "packages"
    return false;
  }

  /**
   * @return {@code true} if the given resource is located in the "packages" sub-folder that
   *         corresponds to the enclosing package.
   */
  public static boolean isInSelfLinkedPackageFolder(IResource resource) {
    if (resource == null) {
      return false;
    }
    try {
      // prepare "pub" folder
      PubFolder pubFolder = DartCore.getProjectManager().getPubFolder(resource);
      if (pubFolder == null) {
        return false;
      }
      // the name of the enclosing package
      String packageName = pubFolder.getPubspec().getName();
      // check if resource is in "packages" and references the enclosing package
      String[] segments = resource.getFullPath().segments();
      for (int i = 0; i < segments.length - 1; i++) {
        String segment = segments[i];
        if (segment.equals(PACKAGES_DIRECTORY_NAME) && segments[i + 1].equals(packageName)) {
          return true;
        }
      }
    } catch (Throwable e) {
      // pubFolder.getPubspec() may fail
      return false;
    }
    // not a self-reference
    return false;
  }

  /**
   * Return <code>true</code> if the given file name's extension is an HTML-like extension.
   * 
   * @param fileName the file name being tested
   * @return <code>true</code> if the given file name's extension is an HTML-like extension
   */
  public static boolean isJSLikeFileName(String fileName) {
    return isLikeFileName(fileName, JS_FILE_EXTENSIONS);
  }

  public static boolean isLinux() {
    return !isMac() && !isWindows();
  }

  public static boolean isMac() {
    // Look for the "Mac" OS name.
    return System.getProperty("os.name").toLowerCase().startsWith("mac");
  }

  /**
   * Return true if directory is one that is installed by pub
   * 
   * @param file the file to be checked
   * @return <code>true</code> if file name matches and is sibling of pubspec.yaml
   */
  public static boolean isPackagesDirectory(File file) {
    if (file.getName().equals(PACKAGES_DIRECTORY_NAME)) {
      return true;
    }
    return false;
  }

  /**
   * Return true if directory is one that is installed by pub
   * 
   * @param folder the folder to be checked
   * @return <code>true</code> if folder name matches and is sibling of pubspec.yaml
   */
  public static boolean isPackagesDirectory(IFolder folder) {
    IPath location = folder.getLocation();
    return location != null && isPackagesDirectory(location.toFile());
  }

  /**
   * Answer <code>true</code> if the string is a package spec
   */
  public static boolean isPackageSpec(String spec) {
    return spec != null && spec.startsWith(PACKAGE_SCHEME_SPEC);
  }

  /**
   * @return <code>true</code> if given {@link IResource} was installed by pub.
   */
  public static boolean isPackagesResource(IResource resource) {
    if (resource instanceof IFolder) {
      if (isPackagesDirectory((IFolder) resource)) {
        return true;
      }
    }
    if (resource != null && resource.getParent() instanceof IFolder) {
      IFolder parentFolder = (IFolder) resource.getParent();
      return isPackagesResource(parentFolder);
    }
    return false;
  }

  /**
   * Check if this URI denotes a patch file.
   */
  public static boolean isPatchfile(File file) {
    return file != null && file.getName().endsWith("_patch.dart");
  }

  /**
   * @return whether we're running in the context of the eclipse plugins build
   */
  public static boolean isPluginsBuild() {
    return Platform.getBundle("com.google.dart.eclipse.core") != null;
  }

  /**
   * Checks if the given linkedResource points to a file in the container. This is used to check for
   * the self link in the packages directory
   * 
   * @param resource
   * @param linkedResource
   * @return <code>true</code> if the linked resource points to a file/folder in the project
   */
  public static boolean isSelfLinkedResource(IContainer resource, IResource linkedResource) {

    try {
      //     if (linkedResource.getParent().getParent() == resource) {
      String resourcePath = resource.getLocation().toFile().getCanonicalPath();
      String linkPath = linkedResource.getLocation().toFile().getCanonicalPath();
      if (linkPath.startsWith(resourcePath)) {
        return true;
      }
      //     }
    } catch (IOException e) {
      return false;
    }
    return false;
  }

  /**
   * Return <code>true</code> if the given file name's extension is an HTML-like extension.
   * 
   * @param fileName the file name being tested
   * @return <code>true</code> if the given file name's extension is an HTML-like extension
   */
  public static boolean isTxtLikeFileName(String fileName) {
    return isLikeFileName(fileName, TXT_FILE_EXTENSIONS);
  }

  public static boolean isWindows() {
    // Look for the "Windows" OS name.
    return System.getProperty("os.name").toLowerCase().startsWith("win");
  }

  public static boolean isWindowsXp() {
    // Look for the "Windows XP" OS name.
    return System.getProperty("os.name").toLowerCase().equals("windows xp");
  }

  /**
   * Log the given message as an error.
   * 
   * @param message an explanation of why the error occurred or what it means
   */
  public static void logError(String message) {
    logErrorImpl(message, null);
    instrumentationLogErrorImpl(message, null);
  }

  /**
   * Log the given exception as one representing an error.
   * 
   * @param message an explanation of why the error occurred or what it means
   * @param exception the exception being logged
   */
  public static void logError(String message, Throwable exception) {
    logErrorImpl(message, exception);
    instrumentationLogErrorImpl(message, exception);
  }

  /**
   * Log the given exception as one representing an error.
   * 
   * @param exception the exception being logged
   */
  public static void logError(Throwable exception) {
    logErrorImpl(exception.getMessage(), exception);
    instrumentationLogErrorImpl(null, exception);
  }

  /**
   * Log the given informational message.
   * 
   * @param message an explanation of why the error occurred or what it means
   * @param exception the exception being logged
   */
  public static void logInformation(String message) {
    logInformation(message, null);
  }

  /**
   * Log the given exception as one representing an informational message.
   * 
   * @param message an explanation of why the error occurred or what it means
   * @param exception the exception being logged
   */
  public static void logInformation(String message, Throwable exception) {

    if (DartCoreDebug.VERBOSE) {
      ILog pluginLog = getPluginLog();
      if (pluginLog != null) {
        pluginLog.log(new Status(Status.INFO, PLUGIN_ID, "INFO: " + message, exception));
      }
    }

    instrumentationLogInfoImpl(message, exception);
  }

  /**
   * Log the given {@link RequestError}.
   */
  public static void logRequestError(RequestError requestError) {
    StringBuilder buf = new StringBuilder();
    buf.append("RequestError: ");
    buf.append(requestError.getCode());
    buf.append("\n");
    buf.append(requestError.getMessage());
    buf.append("\n");
    buf.append(requestError.getStackTrace());
    buf.append("\n");
    String str = buf.toString();
    DartCore.logError(str);
  }

  /**
   * This method exists as a convenient marker for methods that have not yet been fully implemented.
   * It should be deleted before this product ships.
   */
  public static void notYetImplemented() {
  }

  /**
   * Removes the file extension from the given file name, if it has a Dart-like file extension.
   * Otherwise the file name itself is returned. Note this removes the dot ('.') before the
   * extension as well.
   * 
   * @param fileName the name of a file
   * @return the fileName without the Dart-like extension
   */
  public static String removeDartLikeExtension(String fileName) {
    return Util.getNameWithoutDartLikeExtension(fileName);
  }

  /**
   * Remove the given resource (as a path) from the set of ignored resources.
   * 
   * @param resource the resource path to (un)ignore
   * @throws IOException if there was an error accessing the ignore file
   */
  public static void removeFromIgnores(IPath resource) throws IOException {
    getIgnoreManager().removeFromIgnores(resource);
  }

  /**
   * Remove the given resource from the set of ignored resources.
   * 
   * @param resource the resource to (un)ignore
   * @throws IOException if there was an error accessing the ignore file
   */
  public static void removeFromIgnores(IResource resource) throws IOException {
    getIgnoreManager().removeFromIgnores(resource);
  }

  /**
   * Remove the given listener for dart ignore changes from the Dart Model. Has no effect if an
   * identical listener is not registered.
   * 
   * @param listener the non-<code>null</code> listener to remove
   */
  public static void removeIgnoreListener(DartIgnoreListener listener) {
    getIgnoreManager().removeListener(listener);
  }

  public static void setOptions(HashMap<String, String> newOptions) {

  }

  /**
   * Sets the current table of options. All and only the options explicitly included in the given
   * table are remembered; all previous option settings are forgotten, including ones not explicitly
   * mentioned.
   * <p>
   * Helper constants have been defined on DartPreferenceConstants for each of the option IDs
   * (categorized in Code assist option ID, Compiler option ID and Core option ID) and some of their
   * acceptable values (categorized in Option value). Some options accept open value sets beyond the
   * documented constant values.
   * <p>
   * Note: each release may add new options.
   * 
   * @param newOptions the new options, or <code>null</code> to reset all options to their default
   *          values
   */
  public static void setOptions(Hashtable<String, String> newOptions) {

  }

  /**
   * TESTING ONLY: Set the log used by {@link #logError(String)} and other local methods for logging
   * errors, warnings, and information.
   * 
   * @param log the log or <code>null</code> to use the default system log
   * @return the log prior to calling this method or <code>null</code> for the default system log
   */
  public static ILog setPluginLog(ILog log) {
    ILog oldLog = PLUGIN_LOG;
    PLUGIN_LOG = log;
    return oldLog;
  }

  /**
   * Set a symbolic resource mapping from one resource to another. For some uses of the original
   * resource, like serving web content, the mapped resource should be substituted.
   * 
   * @param originalResource
   * @param newResource
   */
  public static void setResourceRemapping(IFile originalResource, IFile newResource) {
    try {
      String resourcePath = (newResource == null ? null
          : newResource.getFullPath().toPortableString());
      originalResource.setPersistentProperty(RESOURCE_REMAP_NAME, resourcePath);
    } catch (CoreException e) {
      DartCore.logError(e);
    }
  }

  /**
   * Sets the value of the string-valued user-defined property for the given key.
   * <p>
   * User-defined properties are defined in the <code>editor.properties</code> file located in the
   * eclipse installation directory.
   * 
   * @see DartCore#getEclipseInstallationDirectory()
   * @param key the name of the property
   * @param value the string-valued property
   */
  public static void setUserDefinedProperty(String key, String value) {

    Properties properties = new Properties();

    File installDirectory = getEclipseInstallationDirectory();
    File file = new File(installDirectory, EDITOR_PROPERTIES);

    try {
      if (!file.exists()) {
        file.createNewFile();
      }
      properties.load(new FileReader(file));
      properties.setProperty(key, value);
      properties.store(new FileWriter(file), null);
    } catch (FileNotFoundException e) {
      logError(e);
    } catch (IOException e) {
      logError(e);
    }

  }

  /**
   * Answer the log used by {@link #logError(String)} and other local methods for logging errors,
   * warnings, and information.
   * 
   * @return the {@link ILog} or {@code null} if not accessible (for example during platform
   *         shutdown)
   */
  private static ILog getPluginLog() {
    try {
      return PLUGIN_LOG != null ? PLUGIN_LOG : getPlugin().getLog();
    } catch (Throwable e) {
      return null;
    }
  }

  /**
   * Record an error
   */
  private static void instrumentationLogErrorImpl(String message, Throwable exception) {
    instrumentationLogImpl(message, exception, "LogError");
  }

  /**
   * Internal instrumentation message delivery implementation
   * 
   * @param message optional message to be delivered
   * @param exception optional exception to be delivered
   * @param messageType message type, common values LogError/LogMessage
   */
  private static void instrumentationLogImpl(String message, Throwable exception, String messageType) {
    if (instrumentationLogErrorEnabled) {
      InstrumentationBuilder instrumentation = Instrumentation.builder("DartCore." + messageType);
      try {
        instrumentation.data("Log_Message", message != null ? message : "null");
        instrumentation.data("Log_Exception", exception != null ? exception.toString() : "null");
        if (exception != null) {
          instrumentation.record(exception);
        }
      } catch (Exception e) {
        instrumentationLogErrorEnabled = false;
        logErrorImpl("Instrumentation failed to log error", exception);
      } finally {
        instrumentation.log();
      }

    }

  }

  /**
   * Record an 'informational exception'
   */
  private static void instrumentationLogInfoImpl(String message, Throwable exception) {

    instrumentationLogImpl(message, exception, "LogInfo");

  }

  /**
   * Return <code>true</code> if the given file name's extension matches one of the passed
   * extensions.
   * 
   * @param fileName the file name being tested
   * @param extensions an array of file extensions to test against
   * @return <code>true</code> if the given file name's extension matches one of the passed
   *         extensions
   */
  private static boolean isLikeFileName(String fileName, String[] extensions) {
    if (fileName == null || fileName.length() == 0) {
      return false;
    }
    for (String extension : extensions) {
      if (StringUtilities.endsWithIgnoreCase(fileName, '.' + extension)) {
        return true;
      }
    }
    return false;
  }

  private static void logErrorImpl(String message, Throwable exception) {
    ILog pluginLog = getPluginLog();
    if (pluginLog != null) {
      pluginLog.log(new Status(Status.ERROR, PLUGIN_ID, message, exception));
    }
  }

  private IEclipsePreferences prefs;

  /**
   * Property key for user-specified analysis server arguments.
   */
  public static final String ANALYSIS_SERVER_ARG_PROP_KEY = "com.dart.tools.server.args";

  /**
   * Initialize a newly created instance of this class.
   */
  public DartCore() {
    PLUG_IN = this;
  }

  /**
   * Use dart2js if the SDK is present.
   */
  public boolean getCompileWithDart2JS() {
    return DartSdkManager.getManager().hasSdk();
  }

  public String getDart2jsFlags() {
    return getPrefs().get(PREFS_DART2JS_FLAGS, "");
  }

  public String[] getDart2jsFlagsAsArray() {
    return StringUtilities.parseArgumentString(getDart2jsFlags());
  }

  public String getDartiumLocationPref() {
    return getPrefs().get(PREFS_DARTIUM_LOCATION, "");
  }

  public boolean getDisableDartBasedBuilder(IProject project) {
    return getProjectPreferences(project).getBoolean(PROJECT_PREF_DISABLE_DART_BASED_BUILDER, false);
  }

  public boolean getEnableAnalytics() {
    if (DartCoreDebug.ASK_FOR_USER_ANALYTICS) {
      return getPrefs().getBoolean(PREFS_ENABLE_ANALYTICS, false);
    }
    return false;
  }

  /**
   * Given an File, return the appropriate java.io.File representing a package root. This can be
   * null if a package root should not be used.
   * 
   * @param file the File
   * @return the File for the package root, or null if none
   */
  public File getPackageRoot(File file) {
    IResource resource = ResourceUtil.getResource(file);
    if (resource != null) {
      return getPackageRoot(resource.getProject());
    }
    return null;
  }

  /**
   * Given an IProject, return the appropriate java.io.File representing a package root. This can be
   * null if a package root should not be used.
   * 
   * @param project the IProject
   * @return the File for the package root, or null if none
   */
  public File getPackageRoot(IProject project) {
    if (project != null) {
      String setting = getProjectPreferences(project).get(PROJECT_PREF_PACKAGE_ROOT, "");

      if (setting != null && setting.length() > 0) {
        String[] paths = setting.split(File.pathSeparator);
        return new File(paths[0]);
      }
    }

    File[] roots = CmdLineOptions.getOptions().getPackageRoots();

    if (roots.length > 0) {
      return roots[0];
    }

    return null;
  }

  /**
   * Get the core plugin preferences. Use savePrefs() to save the preferences.
   */
  public IEclipsePreferences getPrefs() {
    if (prefs == null) {
      prefs = InstanceScope.INSTANCE.getNode(PLUGIN_ID);
    }

    return prefs;
  }

  public IEclipsePreferences getProjectPreferences(IProject project) {
    ProjectScope projectScope = new ProjectScope(project);

    return projectScope.getNode(PLUGIN_ID);
  }

  public String getSdkLocationPref() {
    return getPrefs().get(PREFS_SDK_LOCATION, "");
  }

  public boolean getShowAnalyticsDailog() {
    return getPrefs().getBoolean(PREFS_SHOW_ANALYTICS_DIALOG, true);
  }

  /**
   * Given an IProject, return string representing a package root to be used for all VM launches.
   * This can be null if a package root should not be used.
   * 
   * @param project the IProject
   * @return the String for the package root, or null if none
   */
  public String getVmPackageRoot(IProject project) {
    if (project != null) {
      String setting = getProjectPreferences(project).get(PROJECT_PREF_VM_PACKAGE_ROOT, "");
      if (!setting.isEmpty()) {
        return setting;
      }
    }
    return null;
  }

  public boolean isAutoRunPubEnabled() {
    return DartCore.getPlugin().getPrefs().getBoolean(PUB_AUTO_RUN_PREFERENCE, true);
  }

  public boolean isHintsDart2JSEnabled() {
    return DartCore.getPlugin().getPrefs().getBoolean(ENABLE_HINTS_DART2JS_PREFERENCE, true);
  }

  public boolean isHintsEnabled() {
    return DartCore.getPlugin().getPrefs().getBoolean(ENABLE_HINTS_PREFERENCE, true);
  }

  public boolean isLintsEnabled() {
    return DartCore.getPlugin().getPrefs().getBoolean(ENABLE_LINTS_PREFERENCE, false);
  }

  /**
   * Save the core plugin preferences
   * 
   * @throws CoreException
   */
  public void savePrefs() throws CoreException {
    try {
      getPrefs().flush();
    } catch (BackingStoreException e) {
      throw new CoreException(new Status(IStatus.ERROR, PLUGIN_ID, e.toString(), e));
    }
  }

  @Override
  public void sdkUpdated(DirectoryBasedDartSdk sdk) {
    Job job = new CleanLibrariesJob();

    job.schedule();
  }

  public void setDart2JsPreferences(String args) {
    IEclipsePreferences prefs = getPrefs();
    prefs.put(PREFS_DART2JS_FLAGS, args);

    try {
      getPrefs().flush();
    } catch (BackingStoreException exception) {
      logError(exception);
    }
  }

  public void setDisableDartBasedBuilder(IProject project, boolean value) throws CoreException {
    try {
      IEclipsePreferences prefs = getProjectPreferences(project);
      prefs.putBoolean(PROJECT_PREF_DISABLE_DART_BASED_BUILDER, value);
      prefs.flush();
    } catch (BackingStoreException ex) {
      throw new CoreException(new Status(IStatus.ERROR, PLUGIN_ID, ex.toString(), ex));
    }
  }

  public void setEnableAnalytics(boolean value) {
    if (DartCoreDebug.ASK_FOR_USER_ANALYTICS) {
      IEclipsePreferences prefs = getPrefs();
      prefs.putBoolean(PREFS_ENABLE_ANALYTICS, value);

      try {
        getPrefs().flush();
      } catch (BackingStoreException exception) {
        logError(exception);
      }
    }
  }

  public void setPackageRoot(IProject project, String packageRootPath) throws CoreException {
    try {
      IEclipsePreferences prefs = getProjectPreferences(project);
      prefs.put(PROJECT_PREF_PACKAGE_ROOT, packageRootPath);
      prefs.flush();
    } catch (BackingStoreException ex) {
      throw new CoreException(new Status(IStatus.ERROR, PLUGIN_ID, ex.toString(), ex));
    }
  }

  public void setShowAnalyticsDialogFalse() {
    IEclipsePreferences prefs = getPrefs();
    prefs.putBoolean(PREFS_SHOW_ANALYTICS_DIALOG, false);

    try {
      getPrefs().flush();
    } catch (BackingStoreException exception) {
      logError(exception);
    }
  }

  public void setVmPackageRoot(IProject project, String packageRootPath) throws CoreException {
    try {
      IEclipsePreferences prefs = getProjectPreferences(project);
      prefs.put(PROJECT_PREF_VM_PACKAGE_ROOT, packageRootPath);
      prefs.flush();
    } catch (BackingStoreException ex) {
      throw new CoreException(new Status(IStatus.ERROR, PLUGIN_ID, ex.toString(), ex));
    }
  }

  @Override
  public void start(BundleContext context) throws Exception {
    super.start(context);

    CmdLineOptions.setOptions(CmdLineOptions.parseCmdLine(Platform.getApplicationArgs()));
    CmdLineOptions.getOptions().printWarnings();

    if (DartCoreDebug.PERF_THREAD_CONTENTION_MONIOR) {
      try {
        java.lang.management.ThreadMXBean th = ManagementFactory.getThreadMXBean();
        th.setThreadContentionMonitoringEnabled(true);
      } catch (UnsupportedOperationException e) {
      }
    }

    AnalysisEngine analysisEngine = AnalysisEngine.getInstance();
    analysisEngine.setLogger(new Logger() {
      @Override
      public void logError(String message) {
        DartCore.logError(message);
      }

      @Override
      public void logError(String message, Throwable exception) {
        DartCore.logError(message, exception);
      }

      @Override
      public void logInformation(String message) {
        DartCore.logInformation(message);
      }

      @Override
      public void logInformation(String message, Throwable exception) {
        DartCore.logInformation(message, exception);
      }
    });
    Logging.setLogger(new com.google.dart.server.utilities.logging.Logger() {
      @Override
      public void logError(String message) {
        DartCore.logError(message);
      }

      @Override
      public void logError(String message, Throwable exception) {
        DartCore.logError(message, exception);
      }

      @Override
      public void logInformation(String message) {
        DartCore.logInformation(message);
      }

      @Override
      public void logInformation(String message, Throwable exception) {
        DartCore.logInformation(message, exception);
      }
    });

    DartSdkManager.getManager().addSdkListener(this);
    if (!DartCoreDebug.ENABLE_ANALYSIS_SERVER) {
      getProjectManager().hookListeners();
    } else {
      getAnalysisServer();
    }
  }

  @Override
  public void stop(BundleContext context) throws Exception {
    DartSdkManager.getManager().removeSdkListener(this);

    try {
      if (!DartCoreDebug.ENABLE_ANALYSIS_SERVER) {
        getProjectManager().stop();
      }

      synchronized (analysisServerLock) {
        if (analysisServer != null) {
          analysisServer.server_shutdown();
        }
      }

      if (DartCoreDebug.METRICS) {
        StringWriter writer = new StringWriter();
        PerformanceManager.getInstance().printMetrics(new PrintWriter(writer));
        String metricsInfo = writer.toString();
        if (metricsInfo.length() > 0) {
          getLog().log(new Status(Status.INFO, PLUGIN_ID, metricsInfo, null));
        }
      }
    } finally {
      super.stop(context);
    }
  }
}