load("@bazel_tools//tools/cpp:cc_toolchain_config_lib.bzl", "feature", "flag_group", "flag_set", "tool_path", "with_feature_set")
load("@bazel_tools//tools/build_defs/cc:action_names.bzl", "ACTION_NAMES")
load("@soong_injection//cc_toolchain:constants.bzl", "constants")

# Clang-specific configuration.
_ClangVersionInfo = provider(fields = ["directory", "includes"])

def _clang_version_impl(ctx):
    directory = ctx.file.directory
    provider = _ClangVersionInfo(
        directory = directory,
        includes = [directory.short_path + "/" + d for d in ctx.attr.includes],
    )
    return [provider]

clang_version = rule(
    implementation = _clang_version_impl,
    attrs = {
        "directory": attr.label(allow_single_file = True, mandatory = True),
        "includes": attr.string_list(default = []),
    },
)

# These defines should only apply to targets which are not under
# @external/. This can be controlled by adding "-non_external_compiler_flags"
# to the features list for external/ packages.
# This corresponds to special-casing in Soong (see "external/" in build/soong/cc/compiler.go).
NON_EXTERNAL_DEFINES = [
    "-DANDROID_STRICT",
]

COMPILER_FLAGS = [
    "-fPIC",
]
ASM_COMPILER_FLAGS = [
    "-D__ASSEMBLY__",
]
# CStdVersion in cc/config/global.go
C_COMPILER_FLAGS = [
    "-std=gnu99",
]
# CppStdVersion in cc/config/global.go
CC_COMPILER_STANDARD_STD_FLAGS = [
    "-std=gnu++17",
]

# Should be toggled instead of CC_COMPILER_STANDARD_STD_FLAGS if
# the soong module has "cpp_std: 'experimental'". In bazel, tied
# to the feature "cpp_std_experimental".
CC_COMPILER_EXPERIMENTAL_STD_FLAGS = [
    "-std=gnu++2a",
]

# These are the linker flags for OSes that use Bionic: LinuxBionic, Android
BIONIC_LINKER_FLAGS = [
    "-nostdlib",
    "-Wl,--no-undefined",
    "-Wl,--hash-style=gnu",
    "-Wl,--gc-sections",
]
STATIC_LINKER_FLAGS = [
    "-static",
]
DYNAMIC_LINKER_FLAGS = [
    "-shared",
]

# The set of C and C++ actions used in the Android build. There are other types
# of compile actions available in ACTION_NAMES, but those are not used in
# Android yet.
ALL_COMPILE_ACTIONS = [
    ACTION_NAMES.c_compile,
    ACTION_NAMES.cpp_compile,
    ACTION_NAMES.assemble,
    ACTION_NAMES.preprocess_assemble,
]

# Assembler actions for .s and .S files.
ALL_ASSEMBLE_ACTIONS = [
    ACTION_NAMES.assemble,
    ACTION_NAMES.preprocess_assemble,
]

ALL_LINK_ACTIONS = [
    ACTION_NAMES.cpp_link_executable,
    ACTION_NAMES.cpp_link_dynamic_library,
    ACTION_NAMES.cpp_link_nodeps_dynamic_library,
]

def _tool_paths(clang_version_info):
    return [
        tool_path(
            name = "gcc",
            path = clang_version_info.directory.basename + "/bin/clang",
        ),
        tool_path(
            name = "ld",
            path = clang_version_info.directory.basename + "/bin/ld.lld",
        ),
        tool_path(
            name = "ar",
            path = clang_version_info.directory.basename + "/bin/llvm-ar",
        ),
        tool_path(
            name = "cpp",
            path = "/bin/false",
        ),
        tool_path(
            name = "gcov",
            path = "/bin/false",
        ),
        tool_path(
            name = "nm",
            path = clang_version_info.directory.basename + "/bin/llvm-nm",
        ),
        tool_path(
            name = "objdump",
            path = clang_version_info.directory.basename + "/bin/llvm-objdump",
        ),
        # Soong has a wrapper around strip.
        # https://cs.android.com/android/platform/superproject/+/master:build/soong/cc/strip.go;l=62;drc=master
        # https://cs.android.com/android/platform/superproject/+/master:build/soong/cc/builder.go;l=991-1025;drc=master
        tool_path(
            name = "strip",
            path = clang_version_info.directory.basename + "/bin/llvm-strip",
        ),
    ]

def _compiler_flag_features(flags = [], os_is_device = False):

    # Combine the toolchain's provided flags with the default ones.
    flags = flags + COMPILER_FLAGS + constants.CommonClangGlobalCflags

    if os_is_device:
        flags += constants.DeviceClangGlobalCflags
    else:
        flags += constants.HostClangGlobalCflags

    # Default assembler flags.
    asm_only_flags = ASM_COMPILER_FLAGS

    # Default C++ compile action only flags (No C)
    cpp_only_flags = []
    cpp_only_flags += constants.CommonClangGlobalCppflags
    if os_is_device:
        cpp_only_flags += constants.DeviceGlobalCppflags
    else:
        cpp_only_flags += constants.HostGlobalCppflags

    # Default C compile action only flags (No C++)
    c_only_flags = C_COMPILER_FLAGS + constants.CommonGlobalConlyflags

    # Flags that only apply in the external/ directory.
    non_external_flags = NON_EXTERNAL_DEFINES

    features = []

    features.append(feature(
        name = "non_external_compiler_flags",
        enabled = True,
        flag_sets = [
            flag_set(
                actions = ALL_COMPILE_ACTIONS,
                flag_groups = [
                    flag_group(
                        flags = non_external_flags,
                    ),
                ],
            ),
        ],
    ))
    features.append(feature(
        name = "common_compiler_flags",
        enabled = True,
        flag_sets = [
            flag_set(
                actions = ALL_COMPILE_ACTIONS,
                flag_groups = [
                    flag_group(
                        flags = flags,
                    ),
                ],
            ),
        ],
    ))
    features.append(feature(
        name = "asm_compiler_flags",
        enabled = True,
        flag_sets = [
            flag_set(
                actions = ALL_ASSEMBLE_ACTIONS,
                flag_groups = [
                    flag_group(
                        flags = asm_only_flags,
                    ),
                ],
            ),
        ],
    ))
    features.append(feature(
        name = "cpp_compiler_flags",
        enabled = True,
        flag_sets = [
            flag_set(
                actions = [ACTION_NAMES.cpp_compile] + ALL_ASSEMBLE_ACTIONS,
                flag_groups = [
                    flag_group(
                        flags = cpp_only_flags,
                    ),
                ],
            ),
        ],
    ))
    features.append(feature(
        name = "c_compiler_flags",
        enabled = True,
        flag_sets = [
            flag_set(
                actions = [ACTION_NAMES.c_compile] + ALL_ASSEMBLE_ACTIONS,
                flag_groups = [
                    flag_group(
                        flags = c_only_flags,
                    ),
                ],
            ),
        ],
    ))
    features.append(feature(
        name = "cpp_std_experimental",
        flag_sets = [
            flag_set(
                actions = [
                    ACTION_NAMES.cpp_compile,
                ],
                flag_groups = [
                    flag_group(
                        flags = CC_COMPILER_EXPERIMENTAL_STD_FLAGS,
                    ),
                ],
            ),
        ],
    ))
    features.append(feature(
        name = "cpp_std_standard",
        enabled = True,
        flag_sets = [
            flag_set(
                actions = [
                    ACTION_NAMES.cpp_compile,
                ],
                with_features = [
                    with_feature_set(not_features = ["cpp_std_experimental"]),
                ],
                flag_groups = [
                    flag_group(
                        flags = CC_COMPILER_STANDARD_STD_FLAGS,
                    ),
                ],
            ),
        ],
    ))

    # The user_compile_flags feature is used by Bazel to add --copt, --conlyopt,
    # and --cxxopt values. Any features added above this call will thus appear
    # earlier in the commandline than the user opts (so users could override
    # flags set by earlier features). Anything after the user options are
    # effectively non-overridable by users.
    features.append(feature(
        name = "user_compile_flags",
        enabled = True,
        flag_sets = [
            flag_set(
                actions = ALL_COMPILE_ACTIONS,
                flag_groups = [
                    flag_group(
                        expand_if_available = "user_compile_flags",
                        flags = ["%{user_compile_flags}"],
                        iterate_over = "user_compile_flags",
                    ),
                ],
            ),
        ],
    ))

    # These cannot be overriden by the user.
    features.append(feature(
        name = "no_override_clang_global_copts",
        enabled = True,
        flag_sets = [
            flag_set(
                actions = ALL_COMPILE_ACTIONS,
                flag_groups = [
                    flag_group(
                        flags = constants.NoOverrideClangGlobalCflags,
                    ),
                ],
            ),
        ],
    ))


    return features

def _rtti_features():
    rtti_flag_feature = feature(
        name = "rtti_flag",
        flag_sets = [
            flag_set(
                actions = [
                    ACTION_NAMES.cpp_compile,
                ],
                flag_groups = [
                    flag_group(
                        flags = ["-frtti"],
                    ),
                ],
                with_features = [
                    with_feature_set(features = ["rtti"]),
                ],
            ),
            flag_set(
                actions = [
                    ACTION_NAMES.cpp_compile,
                ],
                flag_groups = [
                    flag_group(
                        flags = ["-fno-rtti"],
                    ),
                ],
                with_features = [
                    with_feature_set(not_features = ["rtti"]),
                ],
            ),
        ],
        enabled = True,
    )
    rtti_feature  = feature(
        name = "rtti",
        enabled = False,
    )
    return [rtti_flag_feature, rtti_feature]

def _rpath_features():
    runtime_library_search_directories_feature = feature(
        name = "runtime_library_search_directories",
        flag_sets = [
            flag_set(
                actions = ALL_LINK_ACTIONS,
                flag_groups = [
                    flag_group(
                        iterate_over = "runtime_library_search_directories",
                        flag_groups = [
                            flag_group(
                                flags = [
                                    "-Wl,-rpath,$EXEC_ORIGIN/%{runtime_library_search_directories}",
                                ],
                                expand_if_true = "is_cc_test",
                            ),
                            flag_group(
                                flags = [
                                    "-Wl,-rpath,$ORIGIN/%{runtime_library_search_directories}",
                                ],
                                expand_if_false = "is_cc_test",
                            ),
                        ],
                        expand_if_available =
                            "runtime_library_search_directories",
                    ),
                ],
                with_features = [
                    with_feature_set(features = ["static_link_cpp_runtimes"]),
                ],
            ),
            flag_set(
                actions = ALL_LINK_ACTIONS,
                flag_groups = [
                    flag_group(
                        iterate_over = "runtime_library_search_directories",
                        flag_groups = [
                            flag_group(
                                flags = [
                                    "-Wl,-rpath,$ORIGIN/%{runtime_library_search_directories}",
                                ],
                            ),
                        ],
                        expand_if_available =
                            "runtime_library_search_directories",
                    ),
                ],
                with_features = [
                    with_feature_set(
                        not_features = ["static_link_cpp_runtimes", "disable_rpath"],
                    ),
                ],
            ),
        ],
    )
    disable_rpath_feature = feature(
        name = "disable_rpath",
        enabled = False,
    )
    return [runtime_library_search_directories_feature, disable_rpath_feature]

def _use_libcrt_feature(path):
    if not path:
        return None
    return feature(
        name = "use_libcrt",
        enabled = True,
        flag_sets = [
            # TODO(b/190383809): binaries need to be linked with late static libs grouped
            flag_set(
                actions = [
                    ACTION_NAMES.cpp_link_dynamic_library,
                ],
                flag_groups = [
                    flag_group(
                        flags = [path.path],
                    ),
                ],
            ),
        ],
    )

def _linker_flag_feature(name, flags = [], additional_static_flags = [], additional_dynamic_flags = []):
    if not flags:
        return None
    return feature(
        name = name,
        enabled = True,
        flag_sets = [
            flag_set(
                actions = [
                    ACTION_NAMES.cpp_link_executable,
                ],
                flag_groups = [
                    flag_group(
                        flags = flags + additional_static_flags,
                    ),
                ],
            ),
            flag_set(
                actions = [
                    ACTION_NAMES.cpp_link_dynamic_library,
                ],
                flag_groups = [
                    flag_group(
                        flags = flags + additional_dynamic_flags,
                    ),
                ],
            ),
        ],
    )

def _toolchain_include_feature(system_includes = []):
    flags = []
    for include in system_includes:
        flags.append("-isystem")
        flags.append(include)
    if not flags:
        return None
    return feature(
        name = "toolchain_include_directories",
        enabled = True,
        flag_sets = [
            flag_set(
                actions = ALL_COMPILE_ACTIONS,
                flag_groups = [
                    flag_group(
                        flags = flags,
                    ),
                ],
            ),
        ],
    )

def is_target_os_device(ctx):
    if "_host" in ctx.attr.toolchain_identifier:
        return False
    else:
        return True

def _cc_toolchain_config_impl(ctx):
    clang_version_info = ctx.attr.clang_version[_ClangVersionInfo]
    os_is_device = is_target_os_device(ctx)

    builtin_include_dirs = []
    # This is so that Bazel doesn't validate .d files against the set of headers
    # declared in BUILD files (Blueprint files don't contain that data)
    builtin_include_dirs.extend(["/"])
    builtin_include_dirs.extend(clang_version_info.includes)
    # b/186035856: Do not add anything to this list.
    builtin_include_dirs.extend(constants.CommonGlobalIncludes)

    # Compiler action features
    compiler_flag_features = _compiler_flag_features(ctx.attr.target_flags, os_is_device)

    # Linker action features
    linker_target_flag_feature = _linker_flag_feature(
        "linker_target_flags",
        flags = ctx.attr.target_flags,
    )

    linker_flags = []
    linker_flags += ctx.attr.linker_flags
    if os_is_device:
        linker_flags += constants.DeviceGlobalLldflags
        linker_flags += BIONIC_LINKER_FLAGS
    else:
        linker_flags += constants.HostGlobalLldflags
    linker_flag_feature = _linker_flag_feature(
        "linker_flags",
        flags = linker_flags,
        additional_static_flags = STATIC_LINKER_FLAGS,
        additional_dynamic_flags = DYNAMIC_LINKER_FLAGS,
    )

    # System include directories features
    toolchain_include_directories_feature = _toolchain_include_feature(
        system_includes = builtin_include_dirs,
    )

    # Aggregate all features
    features = compiler_flag_features + \
        _rpath_features() + _rtti_features() + \
        [
            _use_libcrt_feature(ctx.file.libclang_rt_builtin),
            linker_target_flag_feature,
            linker_flag_feature,
            toolchain_include_directories_feature,
        ]
    features = [feature for feature in features if feature != None]

    return cc_common.create_cc_toolchain_config_info(
        ctx = ctx,
        toolchain_identifier = ctx.attr.toolchain_identifier,
        host_system_name = "i686-unknown-linux-gnu",
        # TODO: replace the following placeholders with the real target values,
        # preferably declared at the toolchain.
        target_system_name = "x86_64-unknown-unknown",
        target_cpu = "x86_64",
        target_libc = "unknown",
        compiler = "clang",
        abi_version = "unknown",
        abi_libc_version = "unknown",
        tool_paths = _tool_paths(clang_version_info),
        features = features,
        cxx_builtin_include_directories = builtin_include_dirs,
    )

_cc_toolchain_config = rule(
    implementation = _cc_toolchain_config_impl,
    attrs = {
        "toolchain_identifier": attr.string(mandatory = True),
        "clang_version": attr.label(mandatory = True, providers = [_ClangVersionInfo]),
        "target_flags": attr.string_list(default = []),
        "linker_flags": attr.string_list(default = []),
        "libclang_rt_builtin": attr.label(allow_single_file=True),
    },
    provides = [CcToolchainConfigInfo],
)

# Macro to set up both the toolchain and the config.
def android_cc_toolchain(
        name,
        clang_version = None,
        # This should come from the clang_version provider.
        # Instead, it's hard-coded because this is a macro, not a rule.
        clang_version_directory = None,
        libclang_rt_builtin = None,
        target_flags = [],
        linker_flags = [],
        toolchain_identifier = None):
    extra_linker_paths = []
    libclang_rt_path = None
    if libclang_rt_builtin:
        libclang_rt_path = libclang_rt_builtin
        extra_linker_paths.append(":"+libclang_rt_path)

    # Write the toolchain config.
    _cc_toolchain_config(
        name = "%s_config" % name,
        clang_version = clang_version,
        libclang_rt_builtin= libclang_rt_path,
        target_flags = target_flags,
        linker_flags = linker_flags,
        toolchain_identifier = toolchain_identifier,
    )

    # Create the filegroups needed for sandboxing toolchain inputs to C++ actions.
    native.filegroup(
        name = "%s_compiler_clang_includes" % name,
        srcs =
            native.glob([clang_version_directory + "/lib64/clang/*/include/**"]),
    )

    native.filegroup(
        name = "%s_compiler_binaries" % name,
        srcs = native.glob([
            clang_version_directory + "/bin/clang*",
        ]),
    )

    native.filegroup(
        name = "%s_linker_binaries" % name,
        srcs = native.glob([
            # Linking shared libraries uses clang.
            clang_version_directory + "/bin/clang*",
        ]) + [
            clang_version_directory + "/bin/lld",
            clang_version_directory + "/bin/ld.lld",
        ],
    )

    native.filegroup(
        name = "%s_ar_files" % name,
        srcs = [clang_version_directory + "/bin/llvm-ar"],
    )

    native.filegroup(
        name = "%s_compiler_files" % name,
        srcs = [
            "%s_compiler_binaries" % name,
            "%s_compiler_clang_includes" % name,
        ],
    )
    native.filegroup(
        name = "%s_linker_files" % name,
        srcs = [
            "%s_linker_binaries" % name,
        ] + extra_linker_paths,
    )
    native.filegroup(
        name = "%s_all_files" % name,
        srcs = [
            "%s_compiler_files" % name,
            "%s_linker_files" % name,
            "%s_ar_files" % name,
        ],
    )

    # Create the actual cc_toolchain.
    # The dependency on //:empty is intentional; it's necessary so that Bazel
    # can parse .d files correctly (see the comment in $TOP/BUILD)
    native.cc_toolchain(
        name = name,
        all_files = "%s_all_files" % name,
        as_files = "//:empty",  # Note the "//" prefix, see comment above
        ar_files = "%s_ar_files" % name,
        compiler_files = "%s_compiler_files" % name,
        dwp_files = ":empty",
        linker_files = "%s_linker_files" % name,
        objcopy_files = ":empty",
        strip_files = ":empty",
        supports_param_files = 0,
        toolchain_config = ":%s_config" % name,
        toolchain_identifier = toolchain_identifier,
    )