load("@rules_pkg//:mappings.bzl", "pkg_filegroup", "pkg_files")
load("@rules_pkg//pkg:zip.bzl", "pkg_zip")
load("//shared/bazel/rules:publishing.bzl", "architectures_pkg_zip", "platform_prefix", "wpilib_maven_export")

def _headers_impl(ctx):
    # Get the CcInfo provider from the dependency.
    # We only expect one dependency, so we take the first from the list.
    target_cc_info = ctx.attr.dep[CcInfo]

    # Extract the set of public headers from the compilation context.
    headers = target_cc_info.compilation_context.headers

    # Return the generated archive as a default output.
    return [DefaultInfo(files = headers)]

_headers = rule(
    implementation = _headers_impl,
    attrs = {
        "dep": attr.label(
            providers = [CcInfo],
            mandatory = True,
            doc = "The cc_library target whose headers should be extracted.",
        ),
    },
    doc = "Extracts the public headers of a C/C++ library.",
)

def pkg_files_headers(name, dep):
    """Makes a pkg_files out of the headers of a cc_library target."""
    _headers(name = name + "-headers", dep = dep)
    pkg_files(
        name = name,
        srcs = [
            ":" + name + "-headers",
        ],
        strip_prefix = "",
    )

def pkg_java_src_files(name):
    pkg_files(
        name = name + "-java-srcs",
        srcs = native.glob(["src/main/java/**"]),
        strip_prefix = "src/main/java",
    )

    pkg_files(
        name = name + "-generated-java-srcs",
        srcs = native.glob(["src/generated/main/java/**/*.java"], allow_empty = True),
        strip_prefix = "src/generated/main/java",
    )

    pkg_files(
        name = name + "-proto-srcs",
        srcs = native.glob(["src/main/proto/**"], allow_empty = True),
        strip_prefix = "src/main/proto",
    )

    pkg_filegroup(
        name = name,
        srcs = [
            name + "-java-srcs",
            name + "-proto-srcs",
            name + "-generated-java-srcs",
            "//shared/bazel/rules:src_jar_dummy_manifest",
        ],
    )

def zip_java_srcs(name, extra_pkgs = []):
    pkg_java_src_files("{}-sources.pkg".format(name))

    pkg_zip(
        name = "lib{}-java-sources".format(name),
        srcs = ["{}-sources.pkg".format(name)] + extra_pkgs,
        out = "lib{}-sources.jar".format(name),
        tags = ["manual"],
    )

_platform_mapping = {
    "linux-x86-64": "linuxx86-64",
    "osxuniversal": "osxuniversal",
    "systemcore": "linuxsystemcore",
    "windows-arm64": "windowsarm64",
    "windows-x86-64": "windowsx86-64",
}

def _filter_artifacts(architectures, artifacts):
    if architectures == None:
        return artifacts

    result = {}
    for ak, av in artifacts.items():
        if ak == "sources" or ak == "headers":
            result[ak] = av
            continue

        for k, v in architectures.items():
            if ak.startswith(_platform_mapping[v]):
                result[ak] = av
                break

    return result

def package_default_jni_project(
        name,
        maven_group_id,
        maven_artifact_name,
        architectures = None):
    """Packages the C++ shared and static libraries for a project which has a JNI component.

    This assumes that shared and static libraries exist for the project, and
    that they are compatible with the relevant architectures.  This triggers the
    transitions, packages them up, and deploys them for all native platforms
    plus systemcore.
    """
    pkg_files(
        name = "{}-static-files".format(name),
        srcs = [
            ":static/{}".format(name),
        ],
        prefix = platform_prefix("static"),
        strip_prefix = "static",
    )

    pkg_filegroup(
        name = "{}-shared-files".format(name),
        srcs = [
            ":shared/lib{}-shared-files".format(name),
            ":shared/lib{}jni-shared-files".format(name),
        ],
        prefix = platform_prefix("shared"),
    )

    architectures_pkg_zip(
        name = "{}_static_zip".format(name),
        srcs = [
            ":{}-static-files".format(name),
            "//:license_pkg_files",
        ],
        architectures = architectures,
    )

    architectures_pkg_zip(
        name = "{}_shared_zip".format(name),
        srcs = [
            ":{}-shared-files".format(name),
            "//:license_pkg_files",
        ],
        architectures = architectures,
    )

    _wpilib_maven_export_shared_static(
        name = "{}-cpp_publish".format(name),
        target_name = name,
        maven_group_id = maven_group_id,
        maven_artifact_name = maven_artifact_name,
        architectures = architectures,
    )

def package_default_cc_project(
        name,
        maven_group_id,
        maven_artifact_name,
        architectures = None):
    """Packages the C++ shared and static libraries for a project.

    This assumes that shared and static libraries exist for the project, and
    that they are compatible with the relevant architectures.  This triggers the
    transitions, packages them up, and deploys them for all native platforms
    plus systemcore.
    """
    pkg_files(
        name = "{}-static-files".format(name),
        srcs = [
            ":static/{}".format(name),
        ],
        prefix = platform_prefix("static"),
        strip_prefix = "static",
    )

    pkg_filegroup(
        name = "{}-shared-files".format(name),
        srcs = [
            ":shared/lib{}-shared-files".format(name),
        ],
        prefix = platform_prefix("shared"),
    )

    architectures_pkg_zip(
        name = "{}_static_zip".format(name),
        srcs = [
            ":{}-static-files".format(name),
            "//:license_pkg_files",
        ],
        architectures = architectures,
    )

    architectures_pkg_zip(
        name = "{}_shared_zip".format(name),
        srcs = [
            ":{}-shared-files".format(name),
            "//:license_pkg_files",
        ],
        architectures = architectures,
    )
    _wpilib_maven_export_shared_static(
        name = "{}-cpp_publish".format(name),
        target_name = name,
        maven_group_id = maven_group_id,
        maven_artifact_name = maven_artifact_name,
        architectures = architectures,
    )

def _wpilib_maven_export_shared_static(
        name,
        target_name,
        maven_group_id,
        maven_artifact_name,
        architectures = None):
    wpilib_maven_export(
        name = name,
        maven_coordinates = "{}:{}:$(WPILIB_VERSION)".format(maven_group_id, maven_artifact_name),
        classifier_artifacts = _filter_artifacts(architectures, {
            "headers": ":{}-hdrs-zip".format(target_name),
            "linuxsystemcore": ":{}_shared_zip-opt-systemcore".format(target_name),
            "linuxsystemcoredebug": ":{}_shared_zip-dbg-systemcore".format(target_name),
            "linuxsystemcorestatic": ":{}_static_zip-opt-systemcore".format(target_name),
            "linuxsystemcorestaticdebug": ":{}_static_zip-dbg-systemcore".format(target_name),
            "sources": ":{}-srcs-zip".format(target_name),
        }),
        linux_artifacts = _filter_artifacts(architectures, {
            "linuxx86-64": ":{}_shared_zip-opt-linux-x86-64".format(target_name),
            "linuxx86-64debug": ":{}_shared_zip-dbg-linux-x86-64".format(target_name),
            "linuxx86-64static": ":{}_static_zip-opt-linux-x86-64".format(target_name),
            "linuxx86-64staticdebug": ":{}_static_zip-dbg-linux-x86-64".format(target_name),
        }),
        osx_artifacts = _filter_artifacts(architectures, {
            "osxuniversal": ":{}_shared_zip-opt-osxuniversal".format(target_name),
            "osxuniversaldebug": ":{}_shared_zip-dbg-osxuniversal".format(target_name),
            "osxuniversalstatic": ":{}_static_zip-opt-osxuniversal".format(target_name),
            "osxuniversalstaticdebug": ":{}_static_zip-dbg-osxuniversal".format(target_name),
        }),
        visibility = ["//visibility:public"],
        windows_artifacts = _filter_artifacts(architectures, {
            "windowsarm64": ":{}_shared_zip-opt-windows-arm64".format(target_name),
            "windowsarm64debug": ":{}_shared_zip-dbg-windows-arm64".format(target_name),
            "windowsarm64static": ":{}_static_zip-opt-windows-arm64".format(target_name),
            "windowsarm64staticdebug": ":{}_static_zip-dbg-windows-arm64".format(target_name),
            "windowsx86-64": ":{}_shared_zip-opt-windows-x86-64".format(target_name),
            "windowsx86-64debug": ":{}_shared_zip-dbg-windows-x86-64".format(target_name),
            "windowsx86-64static": ":{}_static_zip-opt-windows-x86-64".format(target_name),
            "windowsx86-64staticdebug": ":{}_static_zip-dbg-windows-x86-64".format(target_name),
        }),
    )

def package_minimal_cc_project(
        name,
        maven_group_id,
        maven_artifact_name,
        architectures = None):
    wpilib_maven_export(
        name = "{}-cpp_publish".format(name),
        classifier_artifacts = _filter_artifacts(architectures, {
            "headers": ":{}-hdrs-zip".format(name),
            "sources": ":{}-srcs-zip".format(name),
        }),
        linux_artifacts = {},
        maven_coordinates = "{}:{}:$(WPILIB_VERSION)".format(maven_group_id, maven_artifact_name),
        osx_artifacts = {},
        visibility = ["//visibility:public"],
        windows_artifacts = {},
    )

package_minimal_jni_project = package_minimal_cc_project

def package_shared_cc_project(
        name,
        maven_group_id,
        maven_artifact_name,
        architectures = None):
    """Packages the C++ shared libraries for a project.

    This assumes that shared libraries exist for the project, and that they
    are compatible with the relevant architectures.  This triggers the
    transitions, packages them up, and deploys them for all native platforms
    plus systemcore.
    """
    pkg_filegroup(
        name = "{}-shared-files".format(name),
        srcs = [
            ":shared/lib{}-shared-files".format(name),
        ],
        prefix = platform_prefix("shared"),
    )

    architectures_pkg_zip(
        name = "{}_shared_zip".format(name),
        srcs = [
            ":{}-shared-files".format(name),
            "//:license_pkg_files",
        ],
        architectures = architectures,
    )

    wpilib_maven_export(
        name = "{}-cpp_publish".format(name),
        classifier_artifacts = _filter_artifacts(architectures, {
            "headers": ":{}-hdrs-zip".format(name),
            "linuxsystemcore": ":{}_shared_zip-opt-systemcore".format(name),
            "linuxsystemcoredebug": ":{}_shared_zip-dbg-systemcore".format(name),
            "sources": ":{}-srcs-zip".format(name),
        }),
        linux_artifacts = _filter_artifacts(architectures, {
            "linuxx86-64": ":{}_shared_zip-opt-linux-x86-64".format(name),
            "linuxx86-64debug": ":{}_shared_zip-dbg-linux-x86-64".format(name),
        }),
        maven_coordinates = "{}:{}:$(WPILIB_VERSION)".format(maven_group_id, maven_artifact_name),
        osx_artifacts = _filter_artifacts(architectures, {
            "osxuniversal": ":{}_shared_zip-opt-osxuniversal".format(name),
            "osxuniversaldebug": ":{}_shared_zip-dbg-osxuniversal".format(name),
        }),
        visibility = ["//visibility:public"],
        windows_artifacts = _filter_artifacts(architectures, {
            "windowsarm64": ":{}_shared_zip-opt-windows-arm64".format(name),
            "windowsarm64debug": ":{}_shared_zip-dbg-windows-arm64".format(name),
            "windowsx86-64": ":{}_shared_zip-opt-windows-x86-64".format(name),
            "windowsx86-64debug": ":{}_shared_zip-dbg-windows-x86-64".format(name),
        }),
    )

def package_static_cc_project(
        name,
        maven_group_id,
        maven_artifact_name,
        architectures = None):
    """Packages the C++ static libraries for a project.

    This assumes that static libraries exist for the project, and that they
    are compatible with the relevant architectures.  This triggers the
    transitions, packages them up, and deploys them for all native platforms
    plus systemcore.
    """
    pkg_files(
        name = "{}-static-files".format(name),
        srcs = [
            ":static/{}".format(name),
        ],
        prefix = platform_prefix("static"),
        strip_prefix = "static",
    )

    architectures_pkg_zip(
        name = "{}_static_zip".format(name),
        srcs = [
            ":{}-static-files".format(name),
            "//:license_pkg_files",
        ],
        architectures = architectures,
    )

    wpilib_maven_export(
        name = "{}-cpp_publish".format(name),
        maven_coordinates = "{}:{}:$(WPILIB_VERSION)".format(maven_group_id, maven_artifact_name),
        classifier_artifacts = _filter_artifacts(architectures, {
            "headers": ":{}-hdrs-zip".format(name),
            "linuxsystemcorestatic": ":{}_static_zip-opt-systemcore".format(name),
            "linuxsystemcorestaticdebug": ":{}_static_zip-dbg-systemcore".format(name),
            "sources": ":{}-srcs-zip".format(name),
        }),
        linux_artifacts = _filter_artifacts(architectures, {
            "linuxx86-64static": ":{}_static_zip-opt-linux-x86-64".format(name),
            "linuxx86-64staticdebug": ":{}_static_zip-dbg-linux-x86-64".format(name),
        }),
        osx_artifacts = _filter_artifacts(architectures, {
            "osxuniversalstatic": ":{}_static_zip-opt-osxuniversal".format(name),
            "osxuniversalstaticdebug": ":{}_static_zip-dbg-osxuniversal".format(name),
        }),
        visibility = ["//visibility:public"],
        windows_artifacts = _filter_artifacts(architectures, {
            "windowsarm64static": ":{}_static_zip-opt-windows-arm64".format(name),
            "windowsarm64staticdebug": ":{}_static_zip-dbg-windows-arm64".format(name),
            "windowsx86-64static": ":{}_static_zip-opt-windows-x86-64".format(name),
            "windowsx86-64staticdebug": ":{}_static_zip-dbg-windows-x86-64".format(name),
        }),
    )

def package_binary_cc_project(
        name,
        maven_group_id,
        maven_artifact_name,
        extra_files = [],
        architectures = None,
        renames = None):
    """Packages the C++ binary targets for a project.

    This assumes that static libraries exist for the project, and that they
    are compatible with the relevant architectures.  This triggers the
    transitions, packages them up, and deploys them for just the native
    platforms.
    """
    pkg_files(
        name = "{}-files".format(name),
        srcs = [name],
        prefix = platform_prefix(""),
        renames = renames,
    )

    architectures_pkg_zip(
        name = "{}_zip".format(name),
        srcs = [
            ":{}-files".format(name),
            "//:license_pkg_files",
        ] + extra_files,
        architectures = architectures,
    )

    wpilib_maven_export(
        name = "{}_publish".format(name),
        maven_coordinates = "{}:{}:$(WPILIB_VERSION)".format(maven_group_id, maven_artifact_name),
        classifier_artifacts = {},
        linux_artifacts = _filter_artifacts(architectures, {
            "linuxx86-64": ":{}_zip-opt-linux-x86-64".format(name),
        }),
        osx_artifacts = _filter_artifacts(architectures, {
            "osxuniversalstatic": ":{}_zip-opt-osxuniversal".format(name),
        }),
        visibility = ["//visibility:public"],
        windows_artifacts = _filter_artifacts(architectures, {
            "windowsarm64static": ":{}_zip-opt-windows-arm64".format(name),
            "windowsx86-64static": ":{}_zip-opt-windows-x86-64".format(name),
        }),
    )