# Copyright 2022 The Bazel Authors. All rights reserved.
#
# Licensed under the Apache License, Version 2.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.apache.org/licenses/LICENSE-2.0
#
# 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.

"""Auxiliary rule to create the deploy archives for java_binary"""

load("//java/common:java_semantics.bzl", "semantics")
load(":java_helper.bzl", "helper")

# copybara: default visibility

def _get_build_info(ctx, stamp):
    if helper.is_stamping_enabled(ctx, stamp):
        # Makes the target depend on BUILD_INFO_KEY, which helps to discover stamped targets
        # See b/326620485 for more details.
        ctx.version_file  # buildifier: disable=no-effect
        return ctx.attr._build_info_translator[OutputGroupInfo].non_redacted_build_info_files.to_list()
    else:
        return ctx.attr._build_info_translator[OutputGroupInfo].redacted_build_info_files.to_list()

def create_deploy_archives(
        ctx,
        java_attrs,
        launcher_info,
        main_class,
        coverage_main_class,
        strip_as_default,
        hermetic = False,
        add_exports = depset(),
        add_opens = depset(),
        one_version_level = "OFF",
        one_version_allowlist = None,
        extra_args = [],
        extra_manifest_lines = []):
    """ Registers actions for _deploy.jar and _deploy.jar.unstripped

    Args:
        ctx: (RuleContext) The rule context
        java_attrs: (Struct) Struct of (classpath_resources, runtime_jars, runtime_classpath_for_archive, resources)
        launcher_info: (Struct) Struct of (runtime_jars, launcher, unstripped_launcher)
        main_class: (String) FQN of the entry point for execution
        coverage_main_class: (String) FQN of the entry point for coverage collection
        strip_as_default: (bool) Whether to create unstripped deploy jar
        hermetic: (bool)
        add_exports: (depset)
        add_opens: (depset)
        one_version_level: (String) Optional one version check level, default OFF
        one_version_allowlist: (File) Optional allowlist for one version check
        extra_args: (list[Args]) Optional arguments for the deploy jar action
        extra_manifest_lines: (list[String]) Optional lines added to the jar manifest
    """
    classpath_resources = java_attrs.classpath_resources

    runtime_classpath = depset(
        direct = launcher_info.runtime_jars,
        transitive = [
            java_attrs.runtime_jars,
            java_attrs.runtime_classpath_for_archive,
        ],
        order = "preorder",
    )
    multi_release = ctx.fragments.java.multi_release_deploy_jars
    build_info_files = _get_build_info(ctx, ctx.attr.stamp)
    build_target = str(ctx.label)
    manifest_lines = ctx.attr.deploy_manifest_lines + extra_manifest_lines
    create_deploy_archive(
        ctx,
        launcher_info.launcher,
        main_class,
        coverage_main_class,
        java_attrs.resources,
        classpath_resources,
        runtime_classpath,
        manifest_lines,
        build_info_files,
        build_target,
        output = ctx.outputs.deployjar,
        one_version_level = one_version_level,
        one_version_allowlist = one_version_allowlist,
        multi_release = multi_release,
        hermetic = hermetic,
        add_exports = add_exports,
        add_opens = add_opens,
        extra_args = extra_args,
    )

    if strip_as_default:
        create_deploy_archive(
            ctx,
            launcher_info.unstripped_launcher,
            main_class,
            coverage_main_class,
            java_attrs.resources,
            classpath_resources,
            runtime_classpath,
            manifest_lines,
            build_info_files,
            build_target,
            output = ctx.outputs.unstrippeddeployjar,
            multi_release = multi_release,
            hermetic = hermetic,
            add_exports = add_exports,
            add_opens = add_opens,
            extra_args = extra_args,
        )
    else:
        ctx.actions.write(ctx.outputs.unstrippeddeployjar, "")

def create_deploy_archive(
        ctx,
        launcher,
        main_class,
        coverage_main_class,
        resources,
        classpath_resources,
        runtime_classpath,
        manifest_lines,
        build_info_files,
        build_target,
        output,
        one_version_level = "OFF",
        one_version_allowlist = None,
        multi_release = False,
        hermetic = False,
        add_exports = [],
        add_opens = [],
        extra_args = []):
    """ Creates a deploy jar

    Requires a Java runtime toolchain if and only if hermetic is True.

    Args:
        ctx: (RuleContext) The rule context
        launcher: (File) the launcher artifact
        main_class: (String) FQN of the entry point for execution
        coverage_main_class: (String) FQN of the entry point for coverage collection
        resources: (Depset) resource inputs
        classpath_resources: (Depset) classpath resource inputs
        runtime_classpath: (Depset) source files to add to the jar
        build_target: (String) Name of the build target for stamping
        manifest_lines: (list[String]) Optional lines added to the jar manifest
        build_info_files: (list[File]) build info files for stamping
        build_target: (String) the owner build target label name string
        output: (File) the output jar artifact
        one_version_level: (String) Optional one version check level, default OFF
        one_version_allowlist: (File) Optional allowlist for one version check
        multi_release: (bool)
        hermetic: (bool)
        add_exports: (depset)
        add_opens: (depset)
        extra_args: (list[Args]) Optional arguments for the deploy jar action
    """
    input_files = []
    input_files.extend(build_info_files)

    transitive_input_files = [
        resources,
        classpath_resources,
        runtime_classpath,
    ]

    single_jar = semantics.find_java_toolchain(ctx).single_jar

    manifest_lines = list(manifest_lines)
    if ctx.configuration.coverage_enabled:
        manifest_lines.append("Coverage-Main-Class: %s" % coverage_main_class)

    args = ctx.actions.args()
    args.set_param_file_format("shell").use_param_file("@%s", use_always = True)

    args.add("--output", output)
    args.add("--build_target", build_target)
    args.add("--normalize")
    args.add("--compression")
    if main_class:
        args.add("--main_class", main_class)
    args.add_all("--deploy_manifest_lines", manifest_lines)
    args.add_all(build_info_files, before_each = "--build_info_file")
    if launcher:
        input_files.append(launcher)
        args.add("--java_launcher", launcher)
    args.add_all("--classpath_resources", classpath_resources)
    args.add_all(
        "--sources",
        runtime_classpath,
        map_each = helper.jar_and_target_arg_mapper,
    )

    if one_version_level != "OFF" and one_version_allowlist:
        input_files.append(one_version_allowlist)
        args.add("--enforce_one_version")
        args.add("--one_version_allowlist", one_version_allowlist)
        if one_version_level == "WARNING":
            args.add("--succeed_on_found_violations")

    if multi_release:
        args.add("--multi_release")

    if hermetic:
        runtime = ctx.toolchains["@//tools/jdk/hermetic:hermetic_runtime_toolchain_type"].java_runtime
        if runtime.lib_modules != None:
            java_home = runtime.java_home
            lib_modules = runtime.lib_modules
            hermetic_files = runtime.hermetic_files
            default_cds = runtime.default_cds
            args.add("--hermetic_java_home", java_home)
            args.add("--jdk_lib_modules", lib_modules)
            args.add_all("--resources", hermetic_files)
            input_files.append(lib_modules)
            transitive_input_files.append(hermetic_files)
            if default_cds:
                input_files.append(default_cds)
                args.add("--cds_archive", default_cds)

    args.add_all("--add_exports", add_exports)
    args.add_all("--add_opens", add_opens)

    inputs = depset(input_files, transitive = transitive_input_files)

    ctx.actions.run(
        mnemonic = "JavaDeployJar",
        progress_message = "Building deploy jar %s" % output.short_path,
        executable = single_jar,
        inputs = inputs,
        tools = [single_jar],
        outputs = [output],
        arguments = [args] + extra_args,
        use_default_shell_env = True,
        toolchain = semantics.JAVA_TOOLCHAIN_TYPE,
    )