# Copyright 2014 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.

java_filetype = FileType([".java"])
jar_filetype = FileType([".jar"])
srcjar_filetype = FileType([".jar", ".srcjar"])

# This is a quick and dirty rule to make Bazel compile itself. It's not
# production ready.

def java_library_impl(ctx):
    javac_options = ctx.fragments.java.default_javac_flags
    class_jar = ctx.outputs.class_jar
    compile_time_jars = depset(order = "topological")
    runtime_jars = depset(order = "topological")
    for dep in ctx.attr.deps:
        compile_time_jars += dep.compile_time_jars
        runtime_jars += dep.runtime_jars

    jars = jar_filetype.filter(ctx.files.jars)
    neverlink_jars = jar_filetype.filter(ctx.files.neverlink_jars)
    compile_time_jars += jars + neverlink_jars
    runtime_jars += jars
    compile_time_jars_list = list(compile_time_jars)  # TODO: This is weird.

    build_output = class_jar.path + ".build_output"
    java_output = class_jar.path + ".build_java"
    javalist_output = class_jar.path + ".build_java_list"
    sources = ctx.files.srcs

    sources_param_file = ctx.new_file(ctx.bin_dir, class_jar, "-2.params")
    ctx.file_action(
        output = sources_param_file,
        content = cmd_helper.join_paths("\n", depset(sources)),
        executable = False,
    )

    # Cleaning build output directory
    cmd = "set -e;rm -rf " + build_output + " " + java_output + " " + javalist_output + "\n"
    cmd += "mkdir " + build_output + " " + java_output + "\n"
    files = " @" + sources_param_file.path

    if ctx.files.srcjars:
        files += " @" + javalist_output
        for file in ctx.files.srcjars:
            cmd += "%s tf %s | grep '\.java$' | sed 's|^|%s/|' >> %s\n" % (ctx.file._jar.path, file.path, java_output, javalist_output)
            cmd += "unzip %s -d %s >/dev/null\n" % (file.path, java_output)

    if ctx.files.srcs or ctx.files.srcjars:
        cmd += ctx.file._javac.path
        cmd += " " + " ".join(javac_options)
        if compile_time_jars:
            cmd += " -classpath '" + cmd_helper.join_paths(ctx.configuration.host_path_separator, compile_time_jars) + "'"
        cmd += " -d " + build_output + files + "\n"

    # We haven't got a good story for where these should end up, so
    # stick them in the root of the jar.
    for r in ctx.files.resources:
        cmd += "cp %s %s\n" % (r.path, build_output)
    cmd += (ctx.file._jar.path + " cf " + class_jar.path + " -C " + build_output + " .\n" +
            "touch " + build_output + "\n")
    ctx.action(
        inputs = (sources + compile_time_jars_list + [sources_param_file] +
                  [ctx.file._jar] + ctx.files._jdk + ctx.files.resources + ctx.files.srcjars),
        outputs = [class_jar],
        mnemonic = "JavacBootstrap",
        command = cmd,
        use_default_shell_env = True,
    )

    runfiles = ctx.runfiles(collect_data = True)

    return struct(
        files = depset([class_jar]),
        compile_time_jars = compile_time_jars + [class_jar],
        runtime_jars = runtime_jars + [class_jar],
        runfiles = runfiles,
    )

def java_binary_impl(ctx):
    library_result = java_library_impl(ctx)

    deploy_jar = ctx.outputs.deploy_jar
    manifest = ctx.outputs.manifest
    build_output = deploy_jar.path + ".build_output"
    main_class = ctx.attr.main_class
    ctx.file_action(
        output = manifest,
        content = "Main-Class: " + main_class + "\n",
        executable = False,
    )

    # Cleaning build output directory
    cmd = "set -e;rm -rf " + build_output + ";mkdir " + build_output + "\n"
    for jar in library_result.runtime_jars:
        cmd += "unzip -qn " + jar.path + " -d " + build_output + "\n"
    cmd += (ctx.file._jar.path + " cmf " + manifest.path + " " +
            deploy_jar.path + " -C " + build_output + " .\n" +
            "touch " + build_output + "\n")

    ctx.action(
        inputs = list(library_result.runtime_jars) + [manifest] + ctx.files._jdk,
        outputs = [deploy_jar],
        mnemonic = "Deployjar",
        command = cmd,
        use_default_shell_env = True,
    )

    # Write the wrapper.
    executable = ctx.outputs.executable
    ctx.file_action(
        output = executable,
        content = "\n".join([
            "#!/bin/bash",
            "# autogenerated - do not edit.",
            "case \"$0\" in",
            "/*) self=\"$0\" ;;",
            "*)  self=\"$PWD/$0\";;",
            "esac",
            "",
            "if [[ -z \"$JAVA_RUNFILES\" ]]; then",
            "  if [[ -e \"${self}.runfiles\" ]]; then",
            "    export JAVA_RUNFILES=\"${self}.runfiles\"",
            "  fi",
            "  if [[ -n \"$JAVA_RUNFILES\" ]]; then",
            "    export TEST_SRCDIR=${TEST_SRCDIR:-$JAVA_RUNFILES}",
            "  fi",
            "fi",
            "",
            "jvm_bin=%s" % (ctx.file._java.path),
            "if [[ ! -x ${jvm_bin} ]]; then",
            "  jvm_bin=$(which java)",
            "fi",

            # We extract the .so into a temp dir. If only we could mmap
            # directly from the zip file.
            "DEPLOY=$(dirname $self)/$(basename %s)" % deploy_jar.path,

            # This works both on Darwin and Linux, with the darwin path
            # looking like tmp.XXXXXXXX.{random}
            "SO_DIR=$(mktemp -d -t tmp.XXXXXXXXX)",
            "function cleanup() {",
            "  rm -rf ${SO_DIR}",
            "}",
            "trap cleanup EXIT",
            "unzip -q -d ${SO_DIR} ${DEPLOY} \"*.so\" \"*.dll\" \"*.dylib\" >& /dev/null",
            ("${jvm_bin} -Djava.library.path=${SO_DIR} %s -jar $DEPLOY \"$@\"" %
             " ".join(ctx.attr.jvm_flags)),
            "",
        ]),
        executable = True,
    )

    runfiles = ctx.runfiles(files = [deploy_jar, executable] + ctx.files._jdk, collect_data = True)
    files_to_build = depset([deploy_jar, manifest, executable])
    files_to_build += library_result.files

    return struct(files = files_to_build, runfiles = runfiles)

def java_import_impl(ctx):
    # TODO(bazel-team): Why do we need to filter here? The attribute
    # already says only jars are allowed.
    jars = depset(jar_filetype.filter(ctx.files.jars))
    neverlink_jars = depset(jar_filetype.filter(ctx.files.neverlink_jars))
    runfiles = ctx.runfiles(collect_data = True)
    return struct(
        files = jars,
        compile_time_jars = jars + neverlink_jars,
        runtime_jars = jars,
        runfiles = runfiles,
    )

java_library_attrs = {
    "_java": attr.label(default = Label("//tools/jdk:java"), single_file = True),
    "_javac": attr.label(default = Label("//tools/jdk:javac"), single_file = True),
    "_jar": attr.label(default = Label("//tools/jdk:jar"), single_file = True),
    "_jdk": attr.label(default = Label("//tools/jdk:jdk"), allow_files = True),
    "data": attr.label_list(allow_files = True, cfg = "data"),
    "resources": attr.label_list(allow_files = True),
    "srcs": attr.label_list(allow_files = java_filetype),
    "jars": attr.label_list(allow_files = jar_filetype),
    "neverlink_jars": attr.label_list(allow_files = jar_filetype),
    "srcjars": attr.label_list(allow_files = srcjar_filetype),
    "deps": attr.label_list(
        allow_files = False,
        providers = ["compile_time_jars", "runtime_jars"],
    ),
}

java_library = rule(
    java_library_impl,
    attrs = java_library_attrs,
    outputs = {
        "class_jar": "lib%{name}.jar",
    },
    fragments = ["java", "cpp"],
)

# A copy to avoid conflict with native rule.
bootstrap_java_library = rule(
    java_library_impl,
    attrs = java_library_attrs,
    outputs = {
        "class_jar": "lib%{name}.jar",
    },
    fragments = ["java"],
)

java_binary_attrs_common = dict(java_library_attrs)
java_binary_attrs_common.update({
    "jvm_flags": attr.string_list(),
    "jvm": attr.label(default = Label("//tools/jdk:jdk"), allow_files = True),
})

java_binary_attrs = dict(java_binary_attrs_common)
java_binary_attrs["main_class"] = attr.string(mandatory = True)

java_binary_outputs = {
    "class_jar": "lib%{name}.jar",
    "deploy_jar": "%{name}_deploy.jar",
    "manifest": "%{name}_MANIFEST.MF",
}

java_binary = rule(
    java_binary_impl,
    executable = True,
    attrs = java_binary_attrs,
    outputs = java_binary_outputs,
    fragments = ["java", "cpp"],
)

# A copy to avoid conflict with native rule
bootstrap_java_binary = rule(
    java_binary_impl,
    executable = True,
    attrs = java_binary_attrs,
    outputs = java_binary_outputs,
    fragments = ["java"],
)

java_test = rule(
    java_binary_impl,
    executable = True,
    attrs = dict(java_binary_attrs_common.items() + [
        ("main_class", attr.string(default = "org.junit.runner.JUnitCore")),
        # TODO(bazel-team): it would be better if we could offer a
        # test_class attribute, but the "args" attribute is hard
        # coded in the bazel infrastructure.
    ]),
    outputs = java_binary_outputs,
    test = True,
    fragments = ["java", "cpp"],
)

java_import = rule(
    java_import_impl,
    attrs = {
        "jars": attr.label_list(allow_files = jar_filetype),
        "srcjar": attr.label(allow_files = srcjar_filetype),
        "neverlink_jars": attr.label_list(allow_files = jar_filetype, default = []),
    },
)