/*******************************************************************************
 * Copyright (c) 2010 BSI Business Systems Integration AG.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     BSI Business Systems Integration AG - initial API and implementation
 ******************************************************************************/
package org.eclipse.scout.sdk.util;

import java.util.HashMap;
import java.util.List;
import java.util.Set;
import java.util.TreeSet;
import java.util.regex.Pattern;

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.IResourceProxy;
import org.eclipse.core.resources.IResourceProxyVisitor;
import org.eclipse.core.resources.ResourcesPlugin;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IPath;
import org.eclipse.core.runtime.IStatus;
import org.eclipse.core.runtime.Platform;
import org.eclipse.core.runtime.Status;
import org.eclipse.jdt.core.ICompilationUnit;
import org.eclipse.jdt.core.IJavaElement;
import org.eclipse.jdt.core.IJavaProject;
import org.eclipse.jdt.core.IMethod;
import org.eclipse.jdt.core.IPackageFragment;
import org.eclipse.jdt.core.IPackageFragmentRoot;
import org.eclipse.jdt.core.IType;
import org.eclipse.jdt.core.JavaModelException;
import org.eclipse.jdt.core.Signature;
import org.eclipse.jface.text.Document;
import org.eclipse.scout.commons.StringUtility;
import org.eclipse.scout.commons.holders.BooleanHolder;
import org.eclipse.scout.commons.holders.Holder;
import org.eclipse.scout.nls.sdk.model.INlsEntry;
import org.eclipse.scout.nls.sdk.model.workspace.project.INlsProject;
import org.eclipse.scout.sdk.ScoutSdkCore;
import org.eclipse.scout.sdk.Texts;
import org.eclipse.scout.sdk.extensions.runtime.bundles.RuntimeBundles;
import org.eclipse.scout.sdk.extensions.runtime.classes.IRuntimeClasses;
import org.eclipse.scout.sdk.internal.ScoutSdk;
import org.eclipse.scout.sdk.operation.service.ServiceRegistrationDescription;
import org.eclipse.scout.sdk.util.log.ScoutStatus;
import org.eclipse.scout.sdk.util.method.AstMethodReturnValueParser;
import org.eclipse.scout.sdk.util.method.IMethodReturnValueParser;
import org.eclipse.scout.sdk.util.method.MethodReturnExpression;
import org.eclipse.scout.sdk.util.method.SimpleMethodReturnValueParser;
import org.eclipse.scout.sdk.util.pde.PluginModelHelper;
import org.eclipse.scout.sdk.util.pde.ProductFileModelHelper;
import org.eclipse.scout.sdk.util.resources.ResourceUtility;
import org.eclipse.scout.sdk.util.signature.IImportValidator;
import org.eclipse.scout.sdk.util.type.MethodFilters;
import org.eclipse.scout.sdk.util.type.TypeFilters;
import org.eclipse.scout.sdk.util.type.TypeUtility;
import org.eclipse.scout.sdk.workspace.IScoutBundle;
import org.eclipse.scout.sdk.workspace.IScoutBundleFilter;
import org.eclipse.scout.sdk.workspace.IScoutBundleGraphVisitor;
import org.eclipse.scout.sdk.workspace.ScoutBundleFilters;
import org.eclipse.scout.sdk.workspace.type.ScoutTypeUtility;
import org.eclipse.scout.sdk.workspace.type.config.PropertyMethodSourceUtility;

/**
 * <h3>ScoutUtility</h3>Contains scout specific utility methods.
 */
public final class ScoutUtility {

  private static final Pattern REGEX_LINE_SEP_CLEAN = Pattern.compile("(\\n)\\r");
  private static final Pattern REGEX_LINE_SEP_CLEAN2 = Pattern.compile("\\r(\\n)");
  private static final Pattern REGEX_LINE_SET_CLEAN3 = Pattern.compile("\\n+$");
  private static final Pattern REGEX_LINE_SET_CLEAN4 = Pattern.compile("\\n");
  private static final Pattern REGEX_PACKAGE_NAME = Pattern.compile("^[0-9a-zA-Z\\.\\_]*$");
  private static final Pattern REGEX_PACKAGE_NAME_START = Pattern.compile("[a-zA-Z]{1}.*$");
  private static final Pattern REGEX_PACKAGE_NAME_END = Pattern.compile("^.*[a-zA-Z]{1}$");
  private static final Pattern REGEX_CONTAINS_UPPER_CASE = Pattern.compile(".*[A-Z].*");
  private static final Pattern REGEX_COMMENT_REMOVE_1 = Pattern.compile("\\/\\/.*?\\\r\\\n");
  private static final Pattern REGEX_COMMENT_REMOVE_2 = Pattern.compile("\\/\\/.*?\\\n");
  private static final Pattern REGEX_COMMENT_REMOVE_3 = Pattern.compile("(?s)\\/\\*.*?\\*\\/");

  private static final ThreadLocal<String> CURRENT_USER_NAME = new ThreadLocal<String>();

  private static final IMethodReturnValueParser[] METHOD_RETURN_VALUE_PARSERS = new IMethodReturnValueParser[]{
    SimpleMethodReturnValueParser.INSTANCE,
    AstMethodReturnValueParser.INSTANCE
  };

  private ScoutUtility() {
  }

  public static String getCommentBlock(String content) {
    StringBuilder builder = new StringBuilder();
    builder.append("// TODO ");
    String username = getUsername();
    if (!StringUtility.isNullOrEmpty(username)) {
      builder.append("[" + username + "] ");
    }
    builder.append(content);
    return builder.toString();
  }

  /**
   * Returns the user name of the current thread. If the current thread has no user name set, the system property is
   * returned.<br>
   * Use {@link ScoutUtility#setUsernameForThread(String)} to define the user name for the current thread.
   *
   * @return The user name of the thread or the system if no user name is defined on the thread.
   */
  public static String getUsername() {
    String name = CURRENT_USER_NAME.get();
    if (name == null) {
      name = System.getProperty("user.name");
    }
    return name;
  }

  /**
   * Sets the user name that should be returned by {@link ScoutUtility#getUsername()} for the current thread.
   *
   * @param newUsernameForCurrentThread
   *          the new user name
   */
  public static void setUsernameForThread(String newUsernameForCurrentThread) {
    CURRENT_USER_NAME.set(newUsernameForCurrentThread);
  }

  public static String getCommentAutoGeneratedMethodStub() {
    return getCommentBlock("Auto-generated method stub.");
  }

  /**
   * strips a (IMethod) method body from its comments
   * this is needed in order to avoid wrong method property
   * assignments.
   *
   * @param methodBody
   * @return
   */
  public static String removeComments(String methodBody) {
    if (methodBody == null) {
      return null;
    }
    String retVal = methodBody;
    retVal = REGEX_COMMENT_REMOVE_1.matcher(retVal).replaceAll("");
    retVal = REGEX_COMMENT_REMOVE_2.matcher(retVal).replaceAll("");
    retVal = REGEX_COMMENT_REMOVE_3.matcher(retVal).replaceAll("");
    return retVal;
  }

  public static String cleanLineSeparator(String buffer, ICompilationUnit icu) {
    return cleanLineSeparator(buffer, ResourceUtility.getLineSeparator(icu));
  }

  public static String cleanLineSeparator(String buffer, Document doc) {
    return cleanLineSeparator(buffer, ResourceUtility.getLineSeparator(doc));
  }

  public static String cleanLineSeparator(String buffer, String separator) {
    buffer = REGEX_LINE_SEP_CLEAN.matcher(buffer).replaceAll("$1");
    buffer = REGEX_LINE_SEP_CLEAN2.matcher(buffer).replaceAll("$1");
    // max 1 newline at the end
    buffer = REGEX_LINE_SET_CLEAN3.matcher(buffer).replaceAll("\n");
    return REGEX_LINE_SET_CLEAN4.matcher(buffer).replaceAll(separator);
  }

  public static String getIndent(IType type) {
    StringBuilder indent = new StringBuilder("");
    if (type.getDeclaringType() != null) {
      IType decType = type.getDeclaringType();
      while (decType != null) {
        decType = decType.getDeclaringType();
        indent.append(SdkProperties.TAB);
      }
    }
    return indent.toString();
  }

  public static void registerServiceClass(String extensionPoint, String elemType, String serviceClass, ServiceRegistrationDescription desc) throws CoreException {
    PluginModelHelper h = new PluginModelHelper(desc.targetProject.getProject());
    HashMap<String, String> attributes = new HashMap<String, String>(3);
    attributes.put("class", serviceClass);
    if (desc.session != null) {
      attributes.put("session", desc.session);
    }
    if (desc.serviceFactory != null) {
      attributes.put("factory", desc.serviceFactory);
    }
    if (!h.PluginXml.existsSimpleExtension(extensionPoint, elemType, attributes)) {
      h.PluginXml.addSimpleExtension(extensionPoint, elemType, attributes);
      h.save();
    }
  }

  public static void unregisterServiceProxy(IType interfaceType) throws CoreException {
    IScoutBundle interfaceBundle = ScoutTypeUtility.getScoutBundle(interfaceType);
    for (IScoutBundle clientBundle : interfaceBundle.getChildBundles(
        ScoutBundleFilters.getMultiFilterAnd(ScoutBundleFilters.getWorkspaceBundlesFilter(), ScoutBundleFilters.getBundlesOfTypeFilter(IScoutBundle.TYPE_CLIENT)), true)) {
      unregisterServiceClass(clientBundle.getProject(), IRuntimeClasses.EXTENSION_POINT_CLIENT_SERVICE_PROXIES, IRuntimeClasses.EXTENSION_ELEMENT_CLIENT_SERVICE_PROXY, interfaceType.getFullyQualifiedName());
    }
  }

  public static void unregisterServiceImplementation(IType serviceType) throws CoreException {
    IScoutBundle implementationBundle = ScoutTypeUtility.getScoutBundle(serviceType);
    // do not limit filter to a scout-bundle-type because every scout-bundle type can hold service implementations (e.g. text services in the shared bundle).
    for (IScoutBundle bundle : implementationBundle.getChildBundles(ScoutBundleFilters.getWorkspaceBundlesFilter(), true)) {
      unregisterServiceClass(bundle.getProject(), IRuntimeClasses.EXTENSION_POINT_SERVICES, IRuntimeClasses.EXTENSION_ELEMENT_SERVICE, serviceType.getFullyQualifiedName());
    }
  }

  public static void unregisterServiceClass(IProject project, String extensionPoint, String elemType, String className) throws CoreException {
    PluginModelHelper h = new PluginModelHelper(project);
    HashMap<String, String> attributes = new HashMap<String, String>(1);
    attributes.put("class", className);
    h.PluginXml.removeSimpleExtension(extensionPoint, elemType, attributes);
    h.save();
  }

  public static String getDefaultValueOf(String parameter) {
    if (parameter.length() == 1) {
      switch (parameter.charAt(0)) {
        case Signature.C_BOOLEAN:
          return "true";
        case Signature.C_BYTE:
          return "0";
        case Signature.C_CHAR:
          return "0";
        case Signature.C_DOUBLE:
          return "0";
        case Signature.C_FLOAT:
          return "0.0f";
        case Signature.C_INT:
          return "0";
        case Signature.C_LONG:
          return "0";
        case Signature.C_SHORT:
          return "0";
        case Signature.C_VOID:
          return null;
      }
    }
    return "null";
  }

  /**
   * Returns true if the package fragment has class files in it.
   *
   * @param packageFragment
   * @param includeSubpackages
   *          to include all sub packages
   * @return true is there are existing class files found.
   * @throws JavaModelException
   */
  public static boolean hasExistingChildren(IPackageFragment packageFragment, boolean includeSubpackages) throws JavaModelException {
    for (IJavaElement element : packageFragment.getChildren()) {
      if (element instanceof IPackageFragment && includeSubpackages) {
        return hasExistingChildren((IPackageFragment) element, includeSubpackages);
      }
      else if (element.exists()) {
        return true;
      }
    }
    return false;
  }

  /**
   * Gets the bundle type for the given product file. This is the type of first type-defining-bundle that is found in
   * the dependencies of the given project.
   *
   * @param productFile
   *          The product file.
   * @return The type of the type-defining bundle with the lowest (first) order number. If no type-defining-bundle is in
   *         the dependencies of the given product, this method returns null. Types can be added using the
   *         <code>org.eclipse.scout.sdk.runtimeBundles</code> extension point. The predefined types are available in
   *         the {@link IScoutBundle}.TYPE* constants.
   * @throws CoreException
   */
  public static String getProductFileType(IFile productFile) throws CoreException {
    ProductFileModelHelper pfmh = new ProductFileModelHelper(productFile);
    List<String> symbolicNames = pfmh.ProductFile.getPluginSymbolicNames();
    return RuntimeBundles.getBundleType(symbolicNames);
  }

  public static IJavaProject getJavaProject(IScoutBundle bundle) {
    if (bundle != null) {
      return bundle.getJavaProject();
    }
    return null;
  }

  public static Set<String> getEntities(IScoutBundle p) throws JavaModelException {
    Set<String> ret = new TreeSet<String>();
    Set<? extends IScoutBundle> roots = p.getParentBundles(ScoutBundleFilters.getRootBundlesFilter(), true);
    IScoutBundleFilter workspaceClientSharedServerFilter = ScoutBundleFilters.getMultiFilterAnd(ScoutBundleFilters.getWorkspaceBundlesFilter(),
        ScoutBundleFilters.getBundlesOfTypeFilter(IScoutBundle.TYPE_CLIENT, IScoutBundle.TYPE_SERVER, IScoutBundle.TYPE_SHARED));
    for (IScoutBundle root : roots) {
      for (IScoutBundle b : root.getChildBundles(workspaceClientSharedServerFilter, true)) {
        for (IPackageFragmentRoot r : b.getJavaProject().getPackageFragmentRoots()) {
          String bundleName = null;
          if (r.isExternal()) {
            bundleName = r.getElementName();
            int versionPos = bundleName.indexOf('_');
            if (versionPos > 0) {
              bundleName = bundleName.substring(0, versionPos);
            }
            if (ScoutSdkCore.getScoutWorkspace().getBundleGraph().getBundle(bundleName) == null) {
              // not a scout bundle. we are not interested
              bundleName = null;
            }
          }
          else {
            // its me
            bundleName = b.getSymbolicName();
          }
          if (bundleName != null) {
            int bundleNameMin = bundleName.length() + 1;
            for (IJavaElement je : r.getChildren()) {
              if (je instanceof IPackageFragment) {
                String pckName = je.getElementName();
                if (pckName.startsWith(bundleName) && pckName.length() > bundleNameMin) {
                  ret.add(pckName.substring(bundleNameMin));
                }
              }
            }
          }
        }
      }
    }
    return ret;
  }

  public static String removeFieldSuffix(String fieldName) {
    if (fieldName.endsWith(SdkProperties.SUFFIX_FORM_FIELD)) {
      fieldName = fieldName.replaceAll(SdkProperties.SUFFIX_FORM_FIELD + "$", "");
    }
    else if (fieldName.endsWith(SdkProperties.SUFFIX_BUTTON)) {
      fieldName = fieldName.replaceAll(SdkProperties.SUFFIX_BUTTON + "$", "");
    }
    else if (fieldName.endsWith(SdkProperties.SUFFIX_TABLE_COLUMN)) {
      fieldName = fieldName.replaceAll(SdkProperties.SUFFIX_TABLE_COLUMN + "$", "");
    }
    else if (fieldName.endsWith(SdkProperties.SUFFIX_OUTLINE_PAGE)) {
      fieldName = fieldName.replaceAll(SdkProperties.SUFFIX_OUTLINE_PAGE + "$", "");
    }
    return fieldName;
  }

  public static IStatus validatePackageName(String pckName) {
    if (StringUtility.isNullOrEmpty(pckName)) {
      return new Status(IStatus.WARNING, ScoutSdk.PLUGIN_ID, Texts.get("DefaultPackageIsDiscouraged"));
    }
    // no double points
    if (pckName.contains("..")) {
      return new Status(IStatus.ERROR, ScoutSdk.PLUGIN_ID, Texts.get("PackageNameNotValid"));
    }
    // invalid characters
    if (!REGEX_PACKAGE_NAME.matcher(pckName).matches()) {
      return new Status(IStatus.ERROR, ScoutSdk.PLUGIN_ID, Texts.get("PackageNameNotValid"));
    }
    // no start and end with number or special characters
    if (!REGEX_PACKAGE_NAME_START.matcher(pckName).matches() || !REGEX_PACKAGE_NAME_END.matcher(pckName).matches()) {
      return new Status(IStatus.ERROR, ScoutSdk.PLUGIN_ID, Texts.get("PackageNameNotValid"));
    }
    // reserved java keywords
    String jkw = getContainingJavaKeyWord(pckName);
    if (jkw != null) {
      return new Status(IStatus.ERROR, ScoutSdk.PLUGIN_ID, Texts.get("PackageNotContainJavaKeyword", jkw));
    }
    // warn containing upper case characters
    if (REGEX_CONTAINS_UPPER_CASE.matcher(pckName).matches()) {
      return new Status(IStatus.WARNING, ScoutSdk.PLUGIN_ID, Texts.get("PackageOnlyLowerCase"));
    }
    return Status.OK_STATUS;
  }

  public static IStatus validateNewBundleName(String bundleName) {
    // validate name
    if (StringUtility.isNullOrEmpty(bundleName)) {
      return new Status(IStatus.ERROR, ScoutSdk.PLUGIN_ID, Texts.get("ProjectNameMissing"));
    }
    // no double points
    if (bundleName.contains("..")) {
      return new Status(IStatus.ERROR, ScoutSdk.PLUGIN_ID, Texts.get("ProjectNameIsNotValid"));
    }
    // invalid characters
    if (!REGEX_PACKAGE_NAME.matcher(bundleName).matches()) {
      return new Status(IStatus.ERROR, ScoutSdk.PLUGIN_ID, Texts.get("TheBundleNameContainsInvalidCharacters"));
    }
    // no start and end with number or special characters
    if (!REGEX_PACKAGE_NAME_START.matcher(bundleName).matches() || !REGEX_PACKAGE_NAME_END.matcher(bundleName).matches()) {
      return new Status(IStatus.ERROR, ScoutSdk.PLUGIN_ID, Texts.get("BundleNameCanNotStartOrEndWithSpecialCharactersOrDigits"));
    }
    // reserved java keywords
    String jkw = getContainingJavaKeyWord(bundleName);
    if (jkw != null) {
      return new Status(IStatus.ERROR, ScoutSdk.PLUGIN_ID, Texts.get("TheProjectNameMayNotContainAReservedJavaKeyword", jkw));
    }
    // already existing bundle name
    if (Platform.getBundle(bundleName) != null) {
      return new Status(IStatus.ERROR, ScoutSdk.PLUGIN_ID, Texts.get("BundleAlreadyExists", bundleName));
    }
    if (ResourcesPlugin.getWorkspace().getRoot().getProject(bundleName).exists()) {
      return new Status(IStatus.ERROR, ScoutSdk.PLUGIN_ID, Texts.get("BundleAlreadyExists", bundleName));
    }
    // warn containing upper case characters
    if (REGEX_CONTAINS_UPPER_CASE.matcher(bundleName).matches()) {
      return new Status(IStatus.WARNING, ScoutSdk.PLUGIN_ID, Texts.get("ProjectNameShouldContainOnlyLowerCaseCharacters"));
    }
    return Status.OK_STATUS;
  }

  private static String getContainingJavaKeyWord(String s) {
    for (String keyWord : NamingUtility.getJavaKeyWords()) {
      if (s.startsWith(keyWord + ".") || s.endsWith("." + keyWord) || s.contains("." + keyWord + ".")) {
        return keyWord;
      }
    }
    return null;
  }

  public static String getMethodReturnValue(IMethod method, IImportValidator validator) {
    return getMethodReturnExpression(method).getReturnStatement(validator);
  }

  public static String getMethodReturnValue(IMethod method) {
    return getMethodReturnExpression(method).getReturnStatement();
  }

  public static MethodReturnExpression getMethodReturnExpression(IMethod method) {
    for (IMethodReturnValueParser parser : METHOD_RETURN_VALUE_PARSERS) {
      MethodReturnExpression returnExpression = parser.parse(method);
      if (returnExpression != null) {
        return returnExpression;
      }
    }
    return null; // no parser was able to calculate a value
  }

  public static INlsEntry getReturnNlsEntry(IMethod method) throws CoreException {
    String key = PropertyMethodSourceUtility.parseReturnParameterNlsKey(getMethodReturnValue(method));
    if (!StringUtility.isNullOrEmpty(key)) {
      INlsProject nlsProject = ScoutTypeUtility.findNlsProject(method);
      if (nlsProject == null) {
        ScoutSdk.logWarning("could not find nls project for method '" + method.getElementName() + "' in type '" + method.getDeclaringType().getFullyQualifiedName() + "'");
      }
      else {
        return nlsProject.getEntry(key);
      }
    }
    return null;
  }

  /**
   * Gets the status of the given java name. Checks if a name that differs from the suffix is entered and that the name
   * is a valid java name.
   *
   * @param name
   *          The name to check
   * @param suffix
   *          The suffix to compare against.
   * @return A status that describes the state of the given name
   */
  public static IStatus validateJavaName(String name, String suffix) {
    if (!StringUtility.hasText(name) || name.equals(suffix)) {
      return new Status(IStatus.ERROR, ScoutSdk.PLUGIN_ID, Texts.get("Error_className"));
    }
    if (IRegEx.WELLFORMD_JAVAFIELD.matcher(name).matches()) {
      return Status.OK_STATUS;
    }
    else if (IRegEx.JAVAFIELD.matcher(name).matches()) {
      return new Status(IStatus.WARNING, ScoutSdk.PLUGIN_ID, Texts.get("Warning_notWellformedJavaName"));
    }
    else {
      return new Status(IStatus.ERROR, ScoutSdk.PLUGIN_ID, Texts.get("NameNotValid"));
    }
  }

  /**
   * Gets the status of a form field to be created.
   *
   * @param name
   *          The name of the field
   * @param suffix
   *          The suffix of the name to be used.
   * @param declaringType
   *          The type in which the field should be created.
   * @return A status that describes the state of such a form field in the given context.
   */
  public static IStatus validateFormFieldName(String name, String suffix, IType declaringType) {
    IStatus javaFieldNameStatus = ScoutUtility.validateJavaName(name, suffix);
    if (javaFieldNameStatus.getSeverity() > IStatus.WARNING) {
      return javaFieldNameStatus;
    }

    try {
      List<IType> allTypesWithSameSimpleName = TypeUtility.getAllTypes(declaringType.getCompilationUnit(), TypeFilters.getElementNameFilter(name, false));
      if (allTypesWithSameSimpleName.size() > 0) {
        return new Status(IStatus.ERROR, ScoutSdk.PLUGIN_ID, Texts.get("Error_nameAlreadyUsed"));
      }
    }
    catch (JavaModelException e) {
      ScoutSdk.logError("unable to get all types in '" + declaringType.getCompilationUnit().getElementName() + "'.", e);
      return new Status(IStatus.ERROR, ScoutSdk.PLUGIN_ID, "Fatal: " + e.getMessage());
    }
    IType formType = TypeUtility.getPrimaryType(declaringType);
    String plainName = removeFieldSuffix(name);
    String pat = "(?:get|is)(?:" + name + "|" + plainName + ")";
    Set<IMethod> existingMethods = TypeUtility.getMethods(formType, MethodFilters.getNameRegexFilter(Pattern.compile(pat)));
    if (existingMethods.size() > 0) {
      return new Status(IStatus.ERROR, ScoutSdk.PLUGIN_ID, Texts.get("Error_nameAlreadyUsed"));
    }
    return javaFieldNameStatus;
  }

  /**
   * Gets the validation status for a potential new class in the given bundle, below the given package suffix with given
   * name.<br>
   * The method does no check for java classes, but checks if there exists a resource with the target name already.
   *
   * @param container
   *          The bundle in which the type would be created.
   * @param packageSuffix
   *          The suffix under which the type would be created.
   * @param typeName
   *          the name of the potential type.
   * @return the ok status if no file exists at the target location with the given name. An error status otherwise.
   */
  public static IStatus validateTypeNotExisting(IScoutBundle container, String packageSuffix, String typeName) {
    if (typeName == null) {
      return Status.OK_STATUS;
    }
    String pck = container.getPackageName(packageSuffix);
    StringBuilder pathBuilder = new StringBuilder(TypeUtility.DEFAULT_SOURCE_FOLDER_NAME);
    pathBuilder.append(IPath.SEPARATOR).append(pck.replace('.', IPath.SEPARATOR));

    final BooleanHolder elementFound = new BooleanHolder(false);
    final String typeNameComplete = typeName + ".java";
    final IFolder folder = container.getProject().getFolder(pathBuilder.toString());

    if (folder.exists()) {
      try {
        folder.accept(new IResourceProxyVisitor() {
          boolean selfVisited = false;

          @Override
          public boolean visit(IResourceProxy proxy) throws CoreException {
            if (proxy.getType() == IResource.FOLDER) {
              if (!selfVisited) {
                selfVisited = true;
                return true;
              }
              return false;
            }
            else if (proxy.getType() == IResource.FILE && typeNameComplete.equalsIgnoreCase(proxy.getName())) {
              elementFound.setValue(true);
            }
            return false;
          }
        }, IResource.NONE);
      }
      catch (CoreException e) {
        return new ScoutStatus("Unable to check if the type '" + typeName + "' already exists.", e);
      }
    }

    if (elementFound.getValue()) {
      return new Status(IStatus.ERROR, ScoutSdk.PLUGIN_ID, Texts.get("NameXAlreadyUsed", typeName));
    }
    return Status.OK_STATUS;
  }

  /**
   * Gets the one type from the given candidate types that is contained in the closest (nearest) parent bundle
   * (=dependencies) of the given reference bundle.<br>
   * <br>
   * Types that are not found in any of the parent bundles (=dependencies) are ignored.
   *
   * @param candidates
   *          The list of types.
   * @param reference
   *          The reference bundle. Must not be null.
   * @return The one (from the given candidates) whose surrounding scout bundle has the lowest distance to the reference
   *         bundle. Or null if the candidates do not contain any types or all of them cannot be found in the
   *         dependencies of the reference bundle.
   */
  public static IType getNearestType(Set<IType> candidates, IScoutBundle reference) {
    if (candidates == null || candidates.size() < 1) {
      return null;
    }
    final Holder<IType> result = new Holder<IType>(IType.class, null);
    final Holder<Integer> minDistance = new Holder<Integer>(Integer.class, Integer.valueOf(Integer.MAX_VALUE));
    for (IType c : candidates) {
      final IType candidate = c;
      reference.visit(new IScoutBundleGraphVisitor() {
        @Override
        public boolean visit(IScoutBundle bundle, int traversalLevel) {
          if (bundle.contains(candidate)) {
            if (traversalLevel < minDistance.getValue().intValue()) {
              minDistance.setValue(Integer.valueOf(traversalLevel));
              result.setValue(candidate);
            }
            return false;
          }
          return true;
        }
      }, true, true);
    }
    return result.getValue();
  }
}