package org.checkerframework.framework.stub;

import com.sun.source.tree.CompilationUnitTree;
import io.github.classgraph.ClassGraph;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.net.JarURLConnection;
import java.net.URI;
import java.net.URISyntaxException;
import java.net.URL;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.Enumeration;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.StringJoiner;
import java.util.jar.JarEntry;
import java.util.jar.JarFile;
import java.util.stream.Collectors;
import java.util.stream.Stream;
import javax.annotation.processing.ProcessingEnvironment;
import javax.lang.model.element.AnnotationMirror;
import javax.lang.model.element.Element;
import javax.lang.model.element.ElementKind;
import javax.lang.model.element.ExecutableElement;
import javax.lang.model.element.TypeElement;
import javax.lang.model.type.TypeKind;
import javax.lang.model.type.TypeMirror;
import javax.tools.Diagnostic.Kind;
import org.checkerframework.checker.nullness.qual.Nullable;
import org.checkerframework.checker.signature.qual.CanonicalNameOrEmpty;
import org.checkerframework.common.basetype.BaseTypeChecker;
import org.checkerframework.framework.qual.StubFiles;
import org.checkerframework.framework.source.SourceChecker;
import org.checkerframework.framework.stub.AnnotationFileParser.AnnotationFileAnnotations;
import org.checkerframework.framework.stub.AnnotationFileUtil.AnnotationFileType;
import org.checkerframework.framework.type.AnnotatedTypeFactory;
import org.checkerframework.framework.type.AnnotatedTypeMirror;
import org.checkerframework.framework.type.AnnotatedTypeMirror.AnnotatedExecutableType;
import org.checkerframework.javacutil.BugInCF;
import org.checkerframework.javacutil.ElementUtils;
import org.checkerframework.javacutil.Pair;
import org.checkerframework.javacutil.SystemUtil;
import org.checkerframework.javacutil.TypesUtils;

/**
 * Holds information about types parsed from annotation files (stub files or ajava files). When
 * using an ajava file, only holds information on public elements as with stub files.
 */
public class AnnotationFileElementTypes {
  /** Annotations from annotation files (but not from annotated JDK files). */
  private final AnnotationFileAnnotations annotationFileAnnos;

  /**
   * Whether or not a file is currently being parsed. (If one is being parsed, don't try to parse
   * another.)
   */
  private boolean parsing;

  /** AnnotatedTypeFactory. */
  private final AnnotatedTypeFactory factory;

  /**
   * Mapping from fully-qualified class name to corresponding JDK stub file from the file system. By
   * contrast, {@link #jdkStubFilesJar} contains JDK stub files from checker.jar.
   */
  private final Map<String, Path> jdkStubFiles = new HashMap<>();

  /**
   * Mapping from fully-qualified class name to corresponding JDK stub files from checker.jar. By
   * contrast, {@link #jdkStubFiles} contains JDK stub files from the file system.
   */
  private final Map<String, String> jdkStubFilesJar = new HashMap<>();

  /** Which version number of the annotated JDK should be used? */
  private final String annotatedJdkVersion;

  /** Should the JDK be parsed? */
  private final boolean shouldParseJdk;

  /** Parse all JDK files at startup rather than as needed. */
  private final boolean parseAllJdkFiles;

  /**
   * Creates an empty annotation source.
   *
   * @param factory AnnotatedTypeFactory
   */
  public AnnotationFileElementTypes(AnnotatedTypeFactory factory) {
    this.factory = factory;
    this.annotationFileAnnos = new AnnotationFileAnnotations();
    this.parsing = false;
    String release = SystemUtil.getReleaseValue(factory.getProcessingEnv());
    this.annotatedJdkVersion =
        release != null ? release : String.valueOf(SystemUtil.getJreVersion());

    this.shouldParseJdk = !factory.getChecker().hasOption("ignorejdkastub");
    this.parseAllJdkFiles = factory.getChecker().hasOption("parseAllJdk");
  }

  /**
   * Returns true if files are currently being parsed; otherwise, false.
   *
   * @return true if files are currently being parsed; otherwise, false
   */
  public boolean isParsing() {
    return parsing;
  }

  /**
   * Parses the stub files in the following order:
   *
   * <ol>
   *   <li>jdk.astub in the same directory as the checker, if it exists and ignorejdkastub option is
   *       not supplied
   *   <li>If parsing annotated JDK as stub files, all package-info.java files under the jdk/
   *       directory
   *   <li>Stub files listed in @StubFiles annotation on the checker; must be in same directory as
   *       the checker
   *   <li>Stub files returned by {@link BaseTypeChecker#getExtraStubFiles} (treated like those
   *       listed in @StubFiles annotation)
   *   <li>Stub files provided via {@code -Astubs} compiler option
   * </ol>
   *
   * <p>If a type is annotated with a qualifier from the same hierarchy in more than one stub file,
   * the qualifier in the last stub file is applied.
   *
   * <p>If using JDK 11, then the JDK stub files are only parsed if a type or declaration annotation
   * is requested from a class in that file.
   */
  public void parseStubFiles() {
    parsing = true;
    BaseTypeChecker checker = factory.getChecker();
    ProcessingEnvironment processingEnv = factory.getProcessingEnv();
    // 1. jdk.astub
    // Only look in .jar files, and parse it right away.
    if (!checker.hasOption("ignorejdkastub")) {
      InputStream jdkStubIn = checker.getClass().getResourceAsStream("jdk.astub");
      if (jdkStubIn != null) {
        AnnotationFileParser.parseStubFile(
            checker.getClass().getResource("jdk.astub").toString(),
            jdkStubIn,
            factory,
            processingEnv,
            annotationFileAnnos,
            AnnotationFileType.BUILTIN_STUB);
      }
      String jdkVersionStub = "jdk" + annotatedJdkVersion + ".astub";
      InputStream jdkVersionStubIn = checker.getClass().getResourceAsStream(jdkVersionStub);
      if (jdkVersionStubIn != null) {
        AnnotationFileParser.parseStubFile(
            checker.getClass().getResource(jdkVersionStub).toString(),
            jdkVersionStubIn,
            factory,
            processingEnv,
            annotationFileAnnos,
            AnnotationFileType.BUILTIN_STUB);
      }

      // 2. Annotated JDK
      // This preps but does not parse the JDK files (except package-info.java files).
      // The JDK source code files will be parsed later, on demand.
      prepJdkStubs();
      // prepping the JDK parses all package-info.java files, which sets the `parsing` field to
      // false, so re-set it to true.
      parsing = true;
    }

    // 3. Stub files listed in @StubFiles annotation on the checker
    StubFiles stubFilesAnnotation = checker.getClass().getAnnotation(StubFiles.class);
    if (stubFilesAnnotation != null) {
      parseAnnotationFiles(
          Arrays.asList(stubFilesAnnotation.value()), AnnotationFileType.BUILTIN_STUB);
    }

    // 4. Stub files returned by the `getExtraStubFiles()` method
    parseAnnotationFiles(checker.getExtraStubFiles(), AnnotationFileType.BUILTIN_STUB);

    // 5. Stub files provided via -Astubs command-line option
    String stubsOption = checker.getOption("stubs");
    if (stubsOption != null) {
      parseAnnotationFiles(
          Arrays.asList(stubsOption.split(File.pathSeparator)),
          AnnotationFileType.COMMAND_LINE_STUB);
    }

    parsing = false;
  }

  /** Parses the ajava files passed through the -Aajava command-line option. */
  public void parseAjavaFiles() {
    parsing = true;
    // TODO: Error if this is called more than once?
    SourceChecker checker = factory.getChecker();
    List<String> ajavaFiles = new ArrayList<>();
    String ajavaOption = checker.getOption("ajava");
    if (ajavaOption != null) {
      Collections.addAll(ajavaFiles, ajavaOption.split(File.pathSeparator));
    }

    parseAnnotationFiles(ajavaFiles, AnnotationFileType.AJAVA);
    parsing = false;
  }

  /**
   * Parses the ajava file at {@code ajavaPath} assuming {@code root} represents the compilation
   * unit of that file. Uses {@code root} to get information from javac on specific elements of
   * {@code ajavaPath}, enabling storage of more detailed annotation information than with just the
   * ajava file.
   *
   * @param ajavaPath path to an ajava file
   * @param root javac tree for the compilation unit stored in {@code ajavaFile}
   */
  public void parseAjavaFileWithTree(String ajavaPath, CompilationUnitTree root) {
    parsing = true;
    SourceChecker checker = factory.getChecker();
    ProcessingEnvironment processingEnv = factory.getProcessingEnv();
    try {
      InputStream in = new FileInputStream(ajavaPath);
      AnnotationFileParser.parseAjavaFile(
          ajavaPath, in, root, factory, processingEnv, annotationFileAnnos);
    } catch (IOException e) {
      checker.message(Kind.NOTE, "Could not read ajava file: " + ajavaPath);
    }

    parsing = false;
  }

  /**
   * Parses the files in {@code annotationFiles} of the given file type. This includes files listed
   * directly in {@code annotationFiles} and for each listed directory, also includes all files
   * located in that directory (recursively).
   *
   * @param annotationFiles list of files and directories to parse
   * @param fileType the file type of files to parse
   */
  private void parseAnnotationFiles(List<String> annotationFiles, AnnotationFileType fileType) {
    SourceChecker checker = factory.getChecker();
    ProcessingEnvironment processingEnv = factory.getProcessingEnv();
    for (String path : annotationFiles) {
      // Special case when running in jtreg.
      String base = System.getProperty("test.src");
      String fullPath = (base == null) ? path : base + "/" + path;

      List<AnnotationFileResource> allFiles =
          AnnotationFileUtil.allAnnotationFiles(fullPath, fileType);
      if (allFiles != null) {
        for (AnnotationFileResource resource : allFiles) {
          InputStream annotationFileStream;
          try {
            annotationFileStream = resource.getInputStream();
          } catch (IOException e) {
            checker.message(
                Kind.NOTE, "Could not read annotation resource: " + resource.getDescription());
            continue;
          }
          // We use parseStubFile here even for ajava files because at this stage ajava
          // files are parsed as stub files. The extra annotation data in an ajava file is
          // parsed when type-checking the ajava file's corresponding Java file.
          AnnotationFileParser.parseStubFile(
              resource.getDescription(),
              annotationFileStream,
              factory,
              processingEnv,
              annotationFileAnnos,
              fileType == AnnotationFileType.AJAVA ? AnnotationFileType.AJAVA_AS_STUB : fileType);
        }
      } else {
        // We didn't find the files.
        // If the file has a prefix of "checker.jar/" then look for the file in the top
        // level directory of the jar that contains the checker.
        if (path.startsWith("checker.jar/")) {
          path = path.substring("checker.jar/".length());
        }
        InputStream in = checker.getClass().getResourceAsStream(path);
        if (in != null) {
          AnnotationFileParser.parseStubFile(
              path, in, factory, processingEnv, annotationFileAnnos, fileType);
        } else {
          // Didn't find the file.  Issue a warning.

          // When using a compound checker, the target file may be found by the
          // current checker's parent checkers. Also check this to avoid a false
          // warning. Currently, only the original checker will try to parse the target
          // file, the parent checkers are only used to reduce false warnings.
          SourceChecker currentChecker = checker;
          boolean findByParentCheckers = false;
          while (currentChecker != null) {
            URL topLevelResource = currentChecker.getClass().getResource("/" + path);
            if (topLevelResource != null) {
              currentChecker.message(
                  Kind.WARNING,
                  path
                      + " should be in the same directory as "
                      + currentChecker.getClass().getSimpleName()
                      + ".class, but is at the top level of a jar file: "
                      + topLevelResource);
              findByParentCheckers = true;
              break;
            } else {
              currentChecker = currentChecker.getParentChecker();
            }
          }
          // If there exists one parent checker that can find this file, don't report a warning.
          if (!findByParentCheckers) {
            File parentPath = new File(path).getParentFile();
            String parentPathDescription =
                (parentPath == null
                    ? "current directory"
                    : "directory " + parentPath.getAbsolutePath());
            String msg =
                checker.getClass().getSimpleName()
                    + " did not find annotation file or directory "
                    + path
                    + " on classpath or within "
                    + parentPathDescription
                    + (fullPath.equals(path) ? "" : (" or at " + fullPath));
            StringJoiner sj = new StringJoiner(System.lineSeparator() + "  ");
            sj.add(msg);
            sj.add("Classpath:");
            for (URI uri : new ClassGraph().getClasspathURIs()) {
              sj.add(uri.toString());
            }
            checker.message(Kind.WARNING, sj.toString());
          }
        }
      }
    }
  }

  /**
   * Returns the annotated type for {@code e} containing only annotations explicitly written in an
   * annotation file or {@code null} if {@code e} does not appear in an annotation file.
   *
   * @param e an Element whose type is returned
   * @return an AnnotatedTypeMirror for {@code e} containing only annotations explicitly written in
   *     the annotation file and in the element. {@code null} is returned if {@code element} does
   *     not appear in an annotation file.
   */
  public AnnotatedTypeMirror getAnnotatedTypeMirror(Element e) {
    if (parsing) {
      return null;
    }
    parseEnclosingClass(e);
    AnnotatedTypeMirror type = annotationFileAnnos.atypes.get(e);
    return type == null ? null : type.deepCopy();
  }

  /**
   * Returns the set of declaration annotations for {@code e} containing only annotations explicitly
   * written in an annotation file or the empty set if {@code e} does not appear in an annotation
   * file.
   *
   * @param elt element for which annotations are returned
   * @return an AnnotatedTypeMirror for {@code e} containing only annotations explicitly written in
   *     the annotation file and in the element. {@code null} is returned if {@code element} does
   *     not appear in an annotation file.
   */
  public Set<AnnotationMirror> getDeclAnnotation(Element elt) {
    if (parsing) {
      return Collections.emptySet();
    }

    parseEnclosingClass(elt);
    String eltName = ElementUtils.getQualifiedName(elt);
    if (annotationFileAnnos.declAnnos.containsKey(eltName)) {
      return annotationFileAnnos.declAnnos.get(eltName);
    }
    return Collections.emptySet();
  }

  /**
   * Returns the method type of the most specific fake override for the given element, when used as
   * a member of the given type.
   *
   * @param elt element for which annotations are returned
   * @param receiverType the type of the class that contains member (or a subtype of it)
   * @return the most specific AnnotatedTypeMirror for {@code elt} that is a fake override, or null
   *     if there are no fake overrides
   */
  public @Nullable AnnotatedTypeMirror getFakeOverride(
      Element elt, AnnotatedTypeMirror receiverType) {
    if (parsing) {
      throw new BugInCF("parsing while calling getFakeOverride");
    }

    if (elt.getKind() != ElementKind.METHOD) {
      return null;
    }

    ExecutableElement method = (ExecutableElement) elt;

    TypeMirror methodReceiverType = method.getReceiverType();
    if (methodReceiverType != null && methodReceiverType.getKind() == TypeKind.NONE) {
      return null;
    }

    // This is a list of pairs of (where defined, method type) for fake overrides.  The second
    // element of each pair is currently always an AnnotatedExecutableType.
    List<Pair<TypeMirror, AnnotatedTypeMirror>> candidates =
        annotationFileAnnos.fakeOverrides.get(elt);

    if (candidates == null || candidates.isEmpty()) {
      return null;
    }

    TypeMirror receiverTypeMirror = receiverType.getUnderlyingType();

    // A list of fake receiver types.
    List<TypeMirror> applicableClasses = new ArrayList<>();
    List<TypeMirror> applicableInterfaces = new ArrayList<>();
    for (Pair<TypeMirror, AnnotatedTypeMirror> candidatePair : candidates) {
      TypeMirror fakeLocation = candidatePair.first;
      AnnotatedExecutableType candidate = (AnnotatedExecutableType) candidatePair.second;
      if (factory.types.isSameType(receiverTypeMirror, fakeLocation)) {
        return candidate;
      } else if (factory.types.isSubtype(receiverTypeMirror, fakeLocation)) {
        TypeElement fakeElement = TypesUtils.getTypeElement(fakeLocation);
        switch (fakeElement.getKind()) {
          case CLASS:
          case ENUM:
            applicableClasses.add(fakeLocation);
            break;
          case INTERFACE:
          case ANNOTATION_TYPE:
            applicableInterfaces.add(fakeLocation);
            break;
          default:
            throw new BugInCF(
                "What type? %s %s %s", fakeElement.getKind(), fakeElement.getClass(), fakeElement);
        }
      }
    }

    if (applicableClasses.isEmpty() && applicableInterfaces.isEmpty()) {
      return null;
    }
    TypeMirror fakeReceiverType =
        TypesUtils.mostSpecific(
            !applicableClasses.isEmpty() ? applicableClasses : applicableInterfaces,
            factory.getProcessingEnv());
    if (fakeReceiverType == null) {
      StringJoiner message = new StringJoiner(System.lineSeparator());
      message.add(
          String.format(
              "No most specific fake override found for %s with receiver %s."
                  + " These fake overrides are applicable:",
              elt, receiverTypeMirror));
      for (TypeMirror candidate : applicableClasses) {
        message.add("  class candidate: " + candidate);
      }
      for (TypeMirror candidate : applicableInterfaces) {
        message.add("  interface candidate: " + candidate);
      }
      throw new BugInCF(message.toString());
    }

    for (Pair<TypeMirror, AnnotatedTypeMirror> candidatePair : candidates) {
      TypeMirror candidateReceiverType = candidatePair.first;
      if (factory.types.isSameType(fakeReceiverType, candidateReceiverType)) {
        return (AnnotatedExecutableType) candidatePair.second;
      }
    }

    throw new BugInCF(
        "No match for %s in %s %s %s",
        fakeReceiverType, candidates, applicableClasses, applicableInterfaces);
  }

  ///
  /// End of public methods, private helper methods follow
  ///

  /**
   * Parses the outermost enclosing class of {@code e} if there exists an annotation file for it and
   * it has not already been parsed.
   *
   * @param e element whose outermost enclosing class will be parsed
   */
  private void parseEnclosingClass(Element e) {
    if (!shouldParseJdk) {
      return;
    }
    String className = getOutermostEnclosingClass(e);
    if (className == null || className.isEmpty()) {
      return;
    }
    if (jdkStubFiles.containsKey(className)) {
      parseJdkStubFile(jdkStubFiles.get(className));
      jdkStubFiles.remove(className);
    } else if (jdkStubFilesJar.containsKey(className)) {
      parseJdkJarEntry(jdkStubFilesJar.get(className));
      jdkStubFilesJar.remove(className);
    }
  }

  /**
   * Returns the fully qualified name of the outermost enclosing class of {@code e} or {@code null}
   * if no such class exists for {@code e}.
   *
   * @param e an element whose outermost enclosing class to return
   * @return the canonical name of the outermost enclosing class of {@code e} or {@code null} if no
   *     class encloses {@code e}
   */
  private @CanonicalNameOrEmpty String getOutermostEnclosingClass(Element e) {
    TypeElement enclosingClass = ElementUtils.enclosingTypeElement(e);
    if (enclosingClass == null) {
      return null;
    }
    while (true) {
      Element element = enclosingClass.getEnclosingElement();
      if (element == null || element.getKind() == ElementKind.PACKAGE) {
        break;
      }
      TypeElement t = ElementUtils.enclosingTypeElement(element);
      if (t == null) {
        break;
      }
      enclosingClass = t;
    }
    @SuppressWarnings("signature:assignment" // https://tinyurl.com/cfissue/658:
    // Name.toString should be @PolySignature
    )
    @CanonicalNameOrEmpty String result = enclosingClass.getQualifiedName().toString();
    return result;
  }

  /**
   * Parses the stub file in {@code path}.
   *
   * @param path path to file to parse
   */
  private void parseJdkStubFile(Path path) {
    parsing = true;
    try (FileInputStream jdkStub = new FileInputStream(path.toFile())) {
      AnnotationFileParser.parseJdkFileAsStub(
          path.toFile().getName(),
          jdkStub,
          factory,
          factory.getProcessingEnv(),
          annotationFileAnnos);
    } catch (IOException e) {
      throw new BugInCF("cannot open the jdk stub file " + path, e);
    } finally {
      parsing = false;
    }
  }

  /**
   * Parses the stub file in the given jar entry.
   *
   * @param jarEntryName name of the jar entry to parse
   */
  private void parseJdkJarEntry(String jarEntryName) {
    JarURLConnection connection = getJarURLConnectionToJdk();
    parsing = true;
    try (JarFile jarFile = connection.getJarFile()) {
      InputStream jdkStub;
      try {
        jdkStub = jarFile.getInputStream(jarFile.getJarEntry(jarEntryName));
      } catch (IOException e) {
        throw new BugInCF("cannot open the jdk stub file " + jarEntryName, e);
      }
      AnnotationFileParser.parseJdkFileAsStub(
          jarEntryName, jdkStub, factory, factory.getProcessingEnv(), annotationFileAnnos);
    } catch (IOException e) {
      throw new BugInCF("cannot open the Jar file " + connection.getEntryName(), e);
    } catch (BugInCF e) {
      throw new BugInCF("Exception while parsing " + jarEntryName + ": " + e.getMessage(), e);
    } finally {
      parsing = false;
    }
  }

  /**
   * Returns a JarURLConnection to "/jdk*".
   *
   * @return a JarURLConnection to "/jdk*"
   */
  private JarURLConnection getJarURLConnectionToJdk() {
    URL resourceURL = factory.getClass().getResource("/annotated-jdk");
    JarURLConnection connection;
    try {
      connection = (JarURLConnection) resourceURL.openConnection();

      // disable caching / connection sharing of the low level URLConnection to the Jarfile
      connection.setDefaultUseCaches(false);
      connection.setUseCaches(false);

      connection.connect();
    } catch (IOException e) {
      throw new BugInCF("cannot open a connection to the Jar file " + resourceURL.getFile(), e);
    }
    return connection;
  }

  /**
   * Walk through the jdk directory and create a mapping, {@link #jdkStubFiles}, from file name to
   * the class contained with in it. Also, parses all package-info.java files.
   */
  private void prepJdkStubs() {
    if (!shouldParseJdk) {
      return;
    }
    URL resourceURL = factory.getClass().getResource("/annotated-jdk");
    if (resourceURL == null) {
      if (factory.getChecker().hasOption("permitMissingJdk")
          // temporary, for backward compatibility
          || factory.getChecker().hasOption("nocheckjdk")) {
        return;
      }
      throw new BugInCF("JDK not found");
    } else if (resourceURL.getProtocol().contentEquals("jar")) {
      prepJdkFromJar(resourceURL);
    } else if (resourceURL.getProtocol().contentEquals("file")) {
      prepJdkFromFile(resourceURL);
    } else {
      if (factory.getChecker().hasOption("permitMissingJdk")
          // temporary, for backward compatibility
          || factory.getChecker().hasOption("nocheckjdk")) {
        return;
      }
      throw new BugInCF("JDK not found");
    }
  }

  /**
   * Walk through the JDK directory and create a mapping, {@link #jdkStubFiles}, from file name to
   * the class contained with in it. Also, parses all package-info.java files.
   *
   * @param resourceURL the URL pointing to the JDK directory
   */
  private void prepJdkFromFile(URL resourceURL) {
    Path root;
    try {
      root = Paths.get(resourceURL.toURI());
    } catch (URISyntaxException e) {
      throw new BugInCF("Can parse URL: " + resourceURL.toString(), e);
    }

    try (Stream<Path> walk = Files.walk(root)) {
      List<Path> paths =
          walk.filter(p -> Files.isRegularFile(p) && p.toString().endsWith(".java"))
              .collect(Collectors.toList());
      for (Path path : paths) {
        if (path.getFileName().toString().equals("package-info.java")) {
          parseJdkStubFile(path);
          continue;
        }
        if (path.getFileName().toString().equals("module-info.java")) {
          // JavaParser can't parse module-info files, so skip them.
          continue;
        }
        if (parseAllJdkFiles) {
          parseJdkStubFile(path);
          continue;
        }
        Path relativePath = root.relativize(path);
        // 4: /src/<module>/share/classes
        Path savepath = relativePath.subpath(4, relativePath.getNameCount());
        String s = savepath.toString().replace(".java", "").replace(File.separatorChar, '.');
        jdkStubFiles.put(s, path);
      }
    } catch (IOException e) {
      throw new BugInCF("prepJdkFromFile(" + resourceURL + ")", e);
    }
  }

  /**
   * Walk through the JDK directory and create a mapping, {@link #jdkStubFilesJar}, from file name
   * to the class contained with in it. Also, parses all package-info.java files.
   *
   * @param resourceURL the URL pointing to the JDK directory
   */
  private void prepJdkFromJar(URL resourceURL) {
    JarURLConnection connection = getJarURLConnectionToJdk();

    try (JarFile jarFile = connection.getJarFile()) {
      for (Enumeration<JarEntry> e = jarFile.entries(); e.hasMoreElements(); ) {
        JarEntry jarEntry = e.nextElement();
        // filter out directories and non-class files
        if (!jarEntry.isDirectory()
            && jarEntry.getName().endsWith(".java")
            && jarEntry.getName().startsWith("annotated-jdk")
            // JavaParser can't parse module-info files, so skip them.
            && !jarEntry.getName().contains("module-info")) {
          String jarEntryName = jarEntry.getName();
          if (parseAllJdkFiles) {
            parseJdkJarEntry(jarEntryName);
            continue;
          }
          int index = jarEntry.getName().indexOf("/share/classes/");
          String shortName =
              jarEntryName
                  .substring(index + "/share/classes/".length())
                  .replace(".java", "")
                  .replace('/', '.');
          jdkStubFilesJar.put(shortName, jarEntryName);
          if (jarEntryName.endsWith("package-info.java")) {
            parseJdkJarEntry(jarEntryName);
          }
        }
      }
    } catch (IOException e) {
      throw new BugInCF("cannot open the Jar file " + resourceURL.getFile(), e);
    }
  }
}