#!/usr/bin/env vpython3
# Copyright 2023 The Chromium Authors
# Use of this source code is governed by a BSD-style license that can be
# found in the LICENSE file.
"""Given a .build_config.json file, generates an Eclipse JDT project that can
be used with the "Language Support for Java™ by Red Hat" Visual Studio Code
extension. See //docs/vscode.md for details.
"""

import argparse
import logging
import json
import os
import re
import shutil
import sys
import xml.etree.ElementTree
import zipfile

sys.path.append(os.path.join(os.path.dirname(__file__), 'gyp'))
from util import build_utils

sys.path.append(os.path.join(os.path.dirname(__file__), os.pardir))
import gn_helpers


def _GetJavaReleaseVersion():
    """Read the --release value from compile_java.py."""
    compile_java_path = os.path.join(
        os.path.dirname(__file__), 'gyp', 'compile_java.py'
    )
    with open(compile_java_path) as f:
        contents = f.read()
    m = re.search(r"'--release',\s*'(\d+)'", contents)
    if m:
        return m.group(1)
    return '17'


def _WithoutSuffix(string, suffix):
    if not string.endswith(suffix):
        raise ValueError(f'{string!r} does not end with {suffix!r}')
    return string[: -len(suffix)]


def _GetJavaRoot(path):
    # The authoritative way to determine the Java root for a given source file is
    # to parse the source code and extract the package and class names, but let's
    # keep things simple and use some heuristics to try to guess the Java root
    # from the file path instead.
    while True:
        dirname, basename = os.path.split(path)
        if not basename:
            raise RuntimeError(
                f'Unable to determine the Java root for {path!r}'
            )
        if basename in ('java', 'src'):
            return path
        if basename in ('javax', 'org', 'com'):
            return dirname
        path = dirname


def _ProcessSourceFile(output_dir, source_file_path, source_dirs):
    source_file_path = os.path.normpath(
        os.path.join(output_dir, source_file_path)
    )
    java_root = _GetJavaRoot(source_file_path)
    # Refuse output_dir/ and output_dir/gen/ as source roots — JDT would scan
    # every sibling and the .classpath would be invalid.
    output_dir_norm = os.path.normpath(output_dir)
    if java_root in (
        output_dir_norm,
        os.path.normpath(os.path.join(output_dir_norm, 'gen')),
    ):
        logging.warning(
            'Skipping overly broad Java root `%s` for: %s',
            java_root,
            source_file_path,
        )
        return
    logging.debug(
        'Extracted java root `%s` from source file path `%s`',
        java_root,
        source_file_path,
    )
    source_dirs.add(java_root)


def _ProcessSourcesFile(output_dir, sources_file_path, source_dirs):
    for source_file_path in build_utils.ReadSourcesList(
        os.path.join(output_dir, sources_file_path)
    ):
        _ProcessSourceFile(output_dir, source_file_path, source_dirs)


def _FindCanonicalCompileResources(output_dir, build_config_path):
    """The __compile_resources.srcjar a root target owns, or None.

    Used to pick a single coherent R for the project; see _IsUsefulSrcJar.
    """
    params_json = build_config_path.replace(
        '.build_config.json', '.params.json'
    )
    with open(os.path.join(output_dir, params_json)) as f:
        params = json.load(f)
    for s in params.get('bundled_srcjars', []):
        if s.endswith('__compile_resources.srcjar'):
            return s
    return None


def _IsUsefulSrcJar(srcjar_path, canonical_compile_resources):
    """Drop bundled srcjars that would surface duplicate types in JDT.

    The wrapper-srcjar filters (BuildConfig/NativeLibraries/ProductConfig) hide
    per-apk variants whose classes are already fed via input_srcjars. Resource
    srcjars are pinned to the root target's own to avoid R conflicts across
    libs. Mirrors build/android/chromiumide_api.py:_is_useful_source_jar.
    """
    if srcjar_path.endswith('_placeholder.srcjar'):
        return False
    if srcjar_path.endswith(
        (
            '__build_config_srcjar.srcjar',
            '__native_libraries.srcjar',
            '__product_config_srcjar.srcjar',
        )
    ):
        return False
    if srcjar_path.endswith('__compile_resources.srcjar'):
        return srcjar_path in canonical_compile_resources
    return True


def _ExtractBundledSrcJar(output_dir, srcjar_path, source_dirs):
    """Extract a bundled .srcjar to a cache dir so JDT can index its sources.

    Returns True if a source root was added (False for empty extracts).
    Mirrors build/android/chromiumide_api.py:_extract_source_jar.
    """
    abs_srcjar = os.path.normpath(os.path.join(output_dir, srcjar_path))
    if not os.path.exists(abs_srcjar):
        return False
    extract_dir = os.path.normpath(
        os.path.join(
            output_dir,
            'extracted_srcjars',
            _WithoutSuffix(srcjar_path, '.srcjar'),
        )
    )
    # Sibling stamp = "extract finished cleanly". Missing/stale stamp triggers
    # re-extract, so a mid-extract crash recovers on the next run.
    stamp = extract_dir + '.stamp'
    if not os.path.exists(stamp) or os.path.getmtime(stamp) < os.path.getmtime(
        abs_srcjar
    ):
        if os.path.exists(extract_dir):
            shutil.rmtree(extract_dir)
        os.makedirs(extract_dir)
        with zipfile.ZipFile(abs_srcjar) as zf:
            zf.extractall(extract_dir)
        # Strip placeholder GEN_JNI; every *_jni.srcjar ships one and they collide.
        jni_zero_dir = os.path.join(extract_dir, 'org', 'jni_zero')
        if os.path.exists(jni_zero_dir):
            shutil.rmtree(jni_zero_dir)
        with open(stamp, 'wb'):
            pass
    has_java = any(
        f.endswith('.java')
        for _, _, files in os.walk(extract_dir)
        for f in files
    )
    if has_java:
        source_dirs.add(extract_dir)
    return has_java


def _AddTargetOutput(
    output_dir,
    params_json,
    build_config,
    has_sources_file,
    canonical_compile_resources,
    source_dirs,
    libs,
):
    """Resolve a target's generated/compiled output into source roots and libs.

    Source priority (first match wins; alternatives would dup-type in JDT):
    input_srcjars/ → bundled_srcjars (extracted). The compiled jar is added as
    a classpath lib only for aggregating roots (apk/bundle/robolectric — they
    carry final R/GEN_JNI/BuildConfig classes per
    build/android/docs/java_toolchain.md) or true prebuilts.
    """
    input_srcjars = os.path.join(
        output_dir,
        _WithoutSuffix(params_json, '.params.json'),
        'generated_java',
        'input_srcjars',
    )
    has_source_repr = False
    if os.path.exists(input_srcjars):
        source_dirs.add(input_srcjars)
        has_source_repr = True
    else:
        # Require srcjars to exist on disk so a stale/partial build doesn't
        # suppress the prebuilt fallback below.
        useful_bundled_srcjars = [
            s
            for s in build_config.get('bundled_srcjars', [])
            if s.startswith('gen/')
            and _IsUsefulSrcJar(s, canonical_compile_resources)
            and os.path.exists(os.path.join(output_dir, s))
        ]
        for srcjar in useful_bundled_srcjars:
            if _ExtractBundledSrcJar(output_dir, srcjar, source_dirs):
                has_source_repr = True

    unprocessed_jar_path = build_config.get('unprocessed_jar_path')
    if unprocessed_jar_path is None:
        return
    is_aggregating = build_config.get('type') in (
        'android_apk',
        'android_app_bundle_module',
        'robolectric_binary',
    )
    if is_aggregating or (not has_source_repr and not has_sources_file):
        lib_path = os.path.normpath(
            os.path.join(output_dir, unprocessed_jar_path)
        )
        logging.debug('Found lib `%s`', lib_path)
        libs.add(lib_path)


def _ProcessBuildConfigFile(
    output_dir,
    build_config_path,
    source_dirs,
    libs,
    already_processed_build_config_files,
    android_sdk_build_tools_version,
    canonical_compile_resources,
):
    if build_config_path in already_processed_build_config_files:
        return
    already_processed_build_config_files.add(build_config_path)

    logging.info('Processing build config: %s', build_config_path)

    # deps_configs (needed to walk the dependency tree) lives in
    # .params.json rather than .build_config.json. Read both and merge.
    params_json = build_config_path.replace(
        '.build_config.json', '.params.json'
    )
    with open(os.path.join(output_dir, params_json)) as f:
        build_config = json.load(f)
    build_config_file = os.path.join(output_dir, build_config_path)
    if os.path.exists(build_config_file):
        with open(build_config_file) as f:
            build_config.update(json.load(f))

    target_sources_file = build_config.get('target_sources_file')
    if target_sources_file is not None:
        _ProcessSourcesFile(output_dir, target_sources_file, source_dirs)

    # Add pre-built JARs that are compile-time dependencies (e.g., SDK JARs).
    for jar_path in build_config.get('input_jars_paths', []):
        lib_path = os.path.normpath(os.path.join(output_dir, jar_path))
        if os.path.exists(lib_path):
            logging.debug('Found input jar `%s`', lib_path)
            libs.add(lib_path)

    _AddTargetOutput(
        output_dir,
        params_json,
        build_config,
        target_sources_file is not None,
        canonical_compile_resources,
        source_dirs,
        libs,
    )

    # Add core-lambda-stubs.jar so that JDT can resolve LambdaMetafactory.
    # d8 normally strips these refs, but JDT doesn't run d8. See:
    #   https://jakewharton.com/androids-java-8-support/#native-lambdas
    lambda_stubs_jar = os.path.join(
        'third_party',
        'android_sdk',
        'public',
        'build-tools',
        android_sdk_build_tools_version,
        'core-lambda-stubs.jar',
    )
    if os.path.exists(lambda_stubs_jar):
        libs.add(os.path.normpath(lambda_stubs_jar))

    for dep_config in build_config.get('deps_configs', []):
        _ProcessBuildConfigFile(
            output_dir,
            dep_config,
            source_dirs,
            libs,
            already_processed_build_config_files,
            android_sdk_build_tools_version,
            canonical_compile_resources,
        )
    # Also walk public_deps_configs to pick up transitive dependencies
    # exposed via public_deps (e.g., chrome_public_apk's full dep tree).
    for dep_config in build_config.get('public_deps_configs', []):
        _ProcessBuildConfigFile(
            output_dir,
            dep_config,
            source_dirs,
            libs,
            already_processed_build_config_files,
            android_sdk_build_tools_version,
            canonical_compile_resources,
        )


def _GenerateClasspathEntry(kind, path, excluding=None):
    classpathentry = xml.etree.ElementTree.Element('classpathentry')
    classpathentry.set('kind', kind)
    classpathentry.set('path', path)
    if excluding:
        classpathentry.set('excluding', excluding)
    return classpathentry


def _GenerateProject(source_dirs, libs, output_dir):
    # Find source dirs that are ancestors of other source dirs. Eclipse JDT
    # does not allow nesting, but supports exclusion patterns to carve out
    # subdirectories that have their own source entries.
    sorted_dirs = sorted(source_dirs)
    # Map parent -> list of nested children (relative to parent)
    nested_children = {}
    for i, d in enumerate(sorted_dirs):
        for other in sorted_dirs[i + 1 :]:
            if other.startswith(d + '/'):
                nested_children.setdefault(d, []).append(
                    other[len(d) + 1 :] + '/'
                )
            elif not other.startswith(d):
                break

    classpath = xml.etree.ElementTree.Element('classpath')
    for source_dir in sorted(source_dirs):
        children = nested_children.get(source_dir)
        if children:
            classpath.append(
                _GenerateClasspathEntry(
                    'src', source_dir, excluding='|'.join(children)
                )
            )
        else:
            classpath.append(_GenerateClasspathEntry('src', source_dir))
    for lib in sorted(libs):
        classpath.append(_GenerateClasspathEntry('lib', lib))
    classpath.append(
        _GenerateClasspathEntry(
            'output', os.path.join(output_dir, 'jdt_output')
        )
    )

    xml.etree.ElementTree.ElementTree(classpath).write(
        '.classpath', encoding='unicode'
    )
    print('Generated .classpath', file=sys.stderr)

    with open('.project', 'w') as f:
        f.write("""<?xml version="1.0" encoding="UTF-8"?>
<projectDescription>
  <name>chromium</name>
  <buildSpec>
    <buildCommand>
      <name>org.eclipse.jdt.core.javabuilder</name>
      <arguments />
    </buildCommand>
  </buildSpec>
  <natures><nature>org.eclipse.jdt.core.javanature</nature></natures>
</projectDescription>
""")
    print('Generated .project', file=sys.stderr)

    # Tell the Eclipse compiler not to use java.lang.invoke.StringConcatFactory
    # in the generated bytecodes as the class is unavailable in Android.
    # Set compiler compliance to match Chromium's javac --release value
    # (read from compile_java.py).
    java_release = _GetJavaReleaseVersion()
    os.makedirs('.settings', exist_ok=True)
    with open('.settings/org.eclipse.jdt.core.prefs', 'w') as f:
        f.write(f"""eclipse.preferences.version=1
org.eclipse.jdt.core.compiler.codegen.useStringConcatFactory=disabled
org.eclipse.jdt.core.compiler.source={java_release}
org.eclipse.jdt.core.compiler.compliance={java_release}
org.eclipse.jdt.core.compiler.codegen.targetPlatform={java_release}
""")
    print('Generated .settings', file=sys.stderr)


def _ParseArguments(argv):
    parser = argparse.ArgumentParser(
        description='Given Chromium Java build config files, generates an Eclipse JDT '
        'project that can be used with the "Language Support for Java™ by '
        'Red Hat" Visual Studio Code extension. See //docs/vscode.md '
        'for details.'
    )
    parser.add_argument(
        '--output-dir',
        required=True,
        help='Relative path to the output directory, e.g. "out/Debug"',
    )
    parser.add_argument(
        '--build-config',
        action='append',
        required=True,
        help='Path to the .build_config.json file to use as input, relative to '
        '`--output-dir`. May be repeated.',
    )
    return parser.parse_args(argv)


def main(argv):
    build_utils.InitLogging('GENERATE_VSCODE_CLASSPATH_DEBUG')

    assert os.path.exists('.gn'), (
        'This script must be run from the src directory'
    )

    args = _ParseArguments(argv)
    output_dir = args.output_dir

    build_vars = gn_helpers.ReadBuildVars(output_dir)

    # Pin R aggregation to root targets; other __compile_resources.srcjars in
    # the dep tree are partial duplicates that surface R conflicts in JDT.
    canonical_compile_resources = set()
    for build_config_path in args.build_config:
        found = _FindCanonicalCompileResources(output_dir, build_config_path)
        if found is not None:
            canonical_compile_resources.add(found)

    source_dirs = set()
    libs = set()
    already_processed_build_config_files = set()
    for build_config_path in args.build_config:
        _ProcessBuildConfigFile(
            output_dir,
            build_config_path,
            source_dirs,
            libs,
            already_processed_build_config_files,
            build_vars['android_sdk_build_tools_version'],
            canonical_compile_resources,
        )

    logging.info(
        'Done processing %d build config files',
        len(already_processed_build_config_files),
    )

    _GenerateProject(source_dirs, libs, output_dir)


if __name__ == '__main__':
    sys.exit(main(sys.argv[1:]))