"""Aspects to build and collect project dependencies."""

# Load external dependencies of this aspect. These are loaded in a separate file and re-exported as necessary
# to make supporting other versions of bazel easier, by replacing build_dependencies_deps.bzl.
load(
    ":build_dependencies_deps.bzl",
    "ZIP_TOOL_LABEL",
    _ide_android_not_validated = "IDE_ANDROID",
    _ide_cc_not_validated = "IDE_CC",
    _ide_java_not_validated = "IDE_JAVA",
    _ide_java_proto_not_validated = "IDE_JAVA_PROTO",
    _ide_kotlin_not_validated = "IDE_KOTLIN",
)

def _rule_function(
        rule):  # @unused
    return []

def _target_rule_function(
        target,  # @unused
        rule):  # @unused
    return []

def _unique(values):
    return {k: None for k in values}.keys()

def _validate_ide(unvalidated, template):
    "Basic validation that a provided implementation conforms to a given template"
    for a in dir(template):
        if not hasattr(unvalidated, a):
            fail("attribute missing: ", a, unvalidated)
        elif type(getattr(unvalidated, a)) != type(getattr(template, a)):
            fail("attribute type mismatch: ", a, type(getattr(unvalidated, a)), type(getattr(template, a)))
    return struct(**{a: getattr(unvalidated, a) for a in dir(template) if a not in dir(struct())})

IDE_JAVA = _validate_ide(
    _ide_java_not_validated,
    template = struct(
        srcs_attributes = [],  # Additional srcs like attributes.
        get_java_info = _target_rule_function,  # A function that takes a rule and returns a JavaInfo like structure (or the provider itself).
    ),
)

IDE_ANDROID = _validate_ide(
    _ide_android_not_validated,
    template = struct(
        get_android_info = _target_rule_function,  # A function that takes a rule and returns a JavaInfo like structure (or the provider itself).
    ),
)

IDE_KOTLIN = _validate_ide(
    _ide_kotlin_not_validated,
    template = struct(
        srcs_attributes = [],  # Additional srcs like attributes.
        follow_attributes = [],  # Additional attributes for the aspect to follow and request DependenciesInfo provider.
        follow_additional_attributes = [],  # Additional attributes for the aspect to follow without requesting DependenciesInfo provider.
        followed_dependencies = _rule_function,  # A function that takes a rule and returns a list of dependencies (targets or toolchain containers).
        toolchains_aspects = [],  # Toolchain types for the aspect to follow.
        get_kotlin_info = _target_rule_function,  # A function that takes a rule and returns a marker struct if the target
        # was recognised as a Kotlin related target and `followed_dependenices` must be called.
    ),
)

IDE_JAVA_PROTO = _validate_ide(
    _ide_java_proto_not_validated,
    template = struct(
        get_java_proto_info = _target_rule_function,  # A function that takes a rule and returns a marker structure (empty for now).
        srcs_attributes = [],  # Additional srcs like attributes.
        follow_attributes = [],  # Additional attributes for the aspect to follow and request DependenciesInfo provider.
        followed_dependencies = _rule_function,  # A function that takes a rule and returns a list of dependencies (targets or toolchain containers).
        toolchains_aspects = [],  # Toolchain types for the aspect to follow.
    ),
)

IDE_CC = _validate_ide(
    _ide_cc_not_validated,
    template = struct(
        follow_attributes = ["_cc_toolchain"],  # Additional attributes for the aspect to follow and request DependenciesInfo provider.
        toolchains_aspects = [],  # Toolchain types for the aspect to follow.
        toolchain_target = _rule_function,  # A function that takes a rule and returns a toolchain target (or a toolchain container).
        compilation_context = _rule_function,  # A function that takes a target and returns compilation_context of target.
        cc_toolchain_info = _rule_function,  # A function that takes a target and ctx, returns a struct that contains cc toolchain info.
    ),
)

JVM_SRC_ATTRS = _unique(["srcs"] + IDE_JAVA.srcs_attributes + IDE_JAVA_PROTO.srcs_attributes + IDE_KOTLIN.srcs_attributes)

def _noneToEmpty(d):
    return d if d else depset()

def _package_dependencies_impl(target, ctx):
    dep_info = target[DependenciesInfo]
    java_info = IDE_JAVA.get_java_info(target, ctx.rule)

    java_info_files = _noneToEmpty(dep_info.java_info_files)
    cc_info_files = _noneToEmpty(dep_info.cc_info_files)

    return [OutputGroupInfo(
        qs_jars = _noneToEmpty(dep_info.compile_time_jars),
        qs_transitive_runtime_jars = java_info.transitive_runtime_jars_depset if java_info else depset(),
        qs_info = java_info_files,
        qs_jdeps = _noneToEmpty(dep_info.compile_jdeps),
        qs_aars = _noneToEmpty(dep_info.aars),
        qs_gensrcs = _noneToEmpty(dep_info.gensrcs),
        qs_cc_headers = _noneToEmpty(dep_info.cc_headers),
        qs_cc_info = cc_info_files,
    )]

def _write_java_target_info(ctx, label, target_info):
    """Write java target info to a file in proto format.

    The proto format used is defined by proto bazel.intellij.JavaArtifacts.
    """
    file_name = label.name + ".java-info.txt"
    artifact_info_file = ctx.actions.declare_file(file_name)
    ctx.actions.write(
        artifact_info_file,
        _encode_target_info_proto(target_info),
    )
    return artifact_info_file

def _write_cc_target_info(label, cc_compilation_info, ctx):
    """Write CC target info to a file in proto format.

    The proto format used defined by proto bazel.intellij.CcCompilationInfo.
    """
    cc_info_file_name = label.name + ".cc-info.txt"
    cc_info_file = ctx.actions.declare_file(cc_info_file_name)
    ctx.actions.write(
        cc_info_file,
        _encode_cc_compilation_info_proto(label, cc_compilation_info),
    )
    return cc_info_file

DependenciesInfo = provider(
    "The out-of-project dependencies",
    fields = {
        "label": "the label of a target it describes",
        "java_info_file": "a file containing java related info",
        "java_info_files": "a list of java info files",
        "compile_time_jars": "a list of jars generated by targets",
        "compile_jdeps": "a list of jdeps files desribing targets",
        "aars": "a list of aars with resource files",
        "gensrcs": "a list of sources generated by project targets",
        "expand_sources": "boolean, true if the sources for this target should be expanded when it appears inside another rules srcs list",
        "cc_info_files": "a list of cc info files",
        "cc_compilation_info": "a structure containing info required to compile cc sources",
        "cc_headers": "a depset of generated headers required to compile cc sources",
        "cc_toolchain_info": "struct containing cc toolchain info, with keys file (the output file) and id (unique ID for the toolchain info, referred to from elsewhere)",
    },
)

def create_dependencies_info(
        label,
        java_info_file = None,
        java_info_files = depset(),
        compile_time_jars = depset(),
        compile_jdeps = depset(),
        aars = depset(),
        gensrcs = depset(),
        expand_sources = False,
        cc_info_files = depset(),
        cc_compilation_info = None,
        cc_headers = depset(),
        cc_toolchain_info = None):
    """A helper function to create a DependenciesInfo provider instance."""
    return DependenciesInfo(
        label = label,
        java_info_file = java_info_file,
        java_info_files = java_info_files,
        compile_time_jars = compile_time_jars,
        compile_jdeps = compile_jdeps,
        aars = aars,
        gensrcs = gensrcs,
        expand_sources = expand_sources,
        cc_info_files = cc_info_files,
        cc_compilation_info = cc_compilation_info,
        cc_headers = cc_headers,
        cc_toolchain_info = cc_toolchain_info,
    )

def create_java_dependencies_info(
        info_file,
        info_files,
        compile_time_jars,
        compile_jdeps,
        aars,
        gensrcs,
        expand_sources):
    """A helper function to create a DependenciesInfo provider instance."""
    return struct(
        info_file = info_file,
        info_files = info_files,
        compile_time_jars = compile_time_jars,
        compile_jdeps = compile_jdeps,
        aars = aars,
        gensrcs = gensrcs,
        expand_sources = expand_sources,
    )

def create_cc_dependencies_info(
        cc_info_files = depset(),
        cc_compilation_info = None,
        cc_headers = depset(),
        cc_toolchain_info = None):
    """A helper function to create a DependenciesInfo provider instance."""
    return struct(
        cc_info_files = cc_info_files,
        cc_compilation_info = cc_compilation_info,
        cc_headers = cc_headers,
        cc_toolchain_info = cc_toolchain_info,
    )

def create_cc_toolchain_info(
        cc_toolchain_info = None):
    """A helper function to create a DependenciesInfo provider instance."""
    return struct(
        cc_toolchain_info = cc_toolchain_info,
    )

def merge_dependencies_info(
        target,
        ctx,  # @unused
        java_dep_info,
        cc_dep_info,
        cc_toolchain_dep_info):
    """Merge multiple DependenciesInfo providers into one.

    Depsets and dicts are merged. For members such as `cc_compilation_info`, we require that at most one of the
    DependenciesInfo's defines this which should always be the case.

    Args:
      target: the target.
      ctx: the context which is ignored in this function.
      java_dep_info: java dep info.
      cc_dep_info: cc dep info.
      cc_toolchain_dep_info: cc toolchain dep info.
    Returns:
      Merged dependencies info.
    """

    if not java_dep_info and not cc_dep_info and not cc_toolchain_dep_info:
        return create_dependencies_info(label = target.label)

    merged = create_dependencies_info(
        label = target.label,
        java_info_file = java_dep_info.info_file if java_dep_info else None,
        java_info_files = java_dep_info.info_files if java_dep_info else None,
        compile_time_jars = java_dep_info.compile_time_jars if java_dep_info else None,
        compile_jdeps = java_dep_info.compile_jdeps if java_dep_info else None,
        aars = java_dep_info.aars if java_dep_info else None,
        gensrcs = java_dep_info.gensrcs if java_dep_info else None,
        expand_sources = java_dep_info.expand_sources if java_dep_info else None,
        cc_info_files = cc_dep_info.cc_info_files if cc_dep_info else None,
        cc_compilation_info = cc_dep_info.cc_compilation_info if cc_dep_info else None,
        cc_headers = cc_dep_info.cc_headers if cc_dep_info else None,
        cc_toolchain_info = cc_toolchain_dep_info.cc_toolchain_info if cc_toolchain_dep_info else None,
    )
    return merged

def one_of(a, b):
    """
    Returns whichever of a or b is not None, None if both are, or fails if neither are.

    Args:
      a: maybe None argument.
      b: maybe None argument.
    Returns:
      Whichever of a or b is not None, None if both are, or fails if neither are.
    """
    if a == None:
        return b
    if b == None:
        return a
    fail("Expected at most one, but got both", a, b)

def _encode_target_info_proto(target_info):
    contents = struct(
        target = target_info.target,
        is_external_dependency = target_info.is_external_dependency,
        dep_java_info_files = _encode_file_list(target_info.dep_java_info_files),
        jars = _encode_file_list(target_info.jars),
        compile_jdeps = _encode_file_list(target_info.compile_jdeps),
        output_jars = _encode_file_list(target_info.output_jars),
        ide_aars = _encode_file_list(target_info.ide_aars),
        gen_srcs = _encode_file_list(target_info.gen_srcs),
        srcs = target_info.srcs,
        srcjars = target_info.srcjars,
        android_resources_package = target_info.android_resources_package,
    )
    return proto.encode_text(contents)

def _encode_file_list(files):
    """Encodes a list of files as a struct.

    Returns:
      A list fo structs matching the bazel.intellij.OutputArtifact proto message.
    """
    r = []
    for f in files:
        if f.is_directory:
            r.append(struct(directory = f.path))
        else:
            r.append(struct(file = f.path))
    return r

def _encode_cc_compilation_info_proto(label, cc_compilation_info):
    return proto.encode_text(
        struct(targets = [
            struct(
                label = str(label),
                defines = cc_compilation_info.transitive_defines,
                include_directories = cc_compilation_info.transitive_include_directory,
                quote_include_directories = cc_compilation_info.transitive_quote_include_directory,
                system_include_directories = cc_compilation_info.transitive_system_include_directory,
                framework_include_directories = cc_compilation_info.framework_include_directory,
                gen_hdrs = _encode_file_list(cc_compilation_info.gen_headers),
                toolchain_id = cc_compilation_info.toolchain_id,
            ),
        ]),
    )

# Do not remove parameters. They may be used to configure experiment values.
#buildifier: disable=unused_parameters
def package_dependencies(unused_parameters):
    return aspect(
        implementation = _package_dependencies_impl,
        required_aspect_providers = [[DependenciesInfo]],
    )

def declares_android_resources(target, ctx):
    """
    Returns true if the target has resource files and an android provider.

    The IDE needs aars from targets that declare resources. AndroidIdeInfo
    has a defined_android_resources flag, but this returns true for additional
    cases (aidl files, etc), so we check if the target has resource files.

    Args:
      target: the target.
      ctx: the context.
    Returns:
      True if the target has resource files and an android provider.
    """
    if IDE_ANDROID.get_android_info(target, ctx.rule) == None:
        return False
    return hasattr(ctx.rule.attr, "resource_files") and len(ctx.rule.attr.resource_files) > 0

def declares_aar_import(ctx):
    """
    Returns true if the target has aar and is aar_import rule.

    Args:
      ctx: the context.
    Returns:
      True if the target has aar and is aar_import rule.
    """
    return ctx.rule.kind == "aar_import" and hasattr(ctx.rule.attr, "aar")

def _collect_dependencies_impl(target, ctx, params):
    return _collect_dependencies_core_impl(
        target,
        ctx,
        params,
    )

def _package_prefix_match(package, prefix):
    if (package == prefix):
        return True
    if package.startswith(prefix) and package[len(prefix)] == "/":
        return True
    return False

def _get_repo_name(label):
    # The API to get the repo name changed between bazel versions. Use whichever exists:
    return label.repo_name if "repo_name" in dir(label) else label.workspace_name

def _target_within_project_scope(label, include, exclude):
    repo = _get_repo_name(label)
    package = label.package
    result = False
    if include:
        if len(include) == 1 and include[0] == "//":
            # when workspace root is included
            result = True
        else:
            for inc in [Label(i) for i in include]:
                if _get_repo_name(inc) == repo and _package_prefix_match(package, inc.package):
                    result = True
                    break
    if result and len(exclude) > 0:
        for exc in [Label(i) for i in exclude]:
            if _get_repo_name(exc) == repo and _package_prefix_match(package, exc.package):
                result = False
                break
    return result

def _get_dependency_attribute(rule, attr):
    if hasattr(rule.attr, attr):
        to_add = getattr(rule.attr, attr)
        if type(to_add) == "list":
            return [t for t in to_add if type(t) == "Target"]
        elif type(to_add) == "Target":
            return [to_add]
    return []

def _get_followed_java_dependency_infos(
        label,  # @unused
        rule):
    deps = []
    for attr in FOLLOW_JAVA_ATTRIBUTES:
        deps.extend(_get_dependency_attribute(rule, attr))

    deps.extend(IDE_JAVA_PROTO.followed_dependencies(rule))
    deps.extend(IDE_KOTLIN.followed_dependencies(rule))

    return {
        str(dep[DependenciesInfo].label): dep[DependenciesInfo]  # NOTE: This handles duplicates.
        for dep in deps
        if DependenciesInfo in dep and dep[DependenciesInfo].java_info_files
    }

def _collect_own_java_artifacts(
        target,
        ctx,
        always_build_rules,
        generate_aidl_classes,
        use_generated_srcjars,
        target_is_within_project_scope):
    rule = ctx.rule

    must_build_main_artifacts = (
        not target_is_within_project_scope or rule.kind in always_build_rules
    )

    own_jar_files = []
    own_jar_depsets = []
    own_compile_jdeps_files = []
    own_output_jar_files = []
    own_ide_aar_files = []
    own_gensrc_files = []
    own_src_file_paths = []
    own_srcjar_file_paths = []
    resource_package = ""

    java_info = IDE_JAVA.get_java_info(target, ctx.rule)
    kotlin_info = IDE_KOTLIN.get_kotlin_info(target, ctx.rule)

    # Targets recognised as java_proto_info can have java_info dependencies.
    java_proto_info = IDE_JAVA_PROTO.get_java_proto_info(target, ctx.rule)
    android_info = IDE_ANDROID.get_android_info(target, ctx.rule)

    if must_build_main_artifacts:
        # For rules that we do not follow dependencies of (either because they don't
        # have further dependencies with JavaInfo or do so in attributes we don't care)
        # we gather all their transitive dependencies. If they have dependencies, we
        # only gather their own compile jars and continue down the tree.
        # This is done primarily for rules like proto, whose toolchain classes
        # are collected via attribute traversal, but still requires jars for any
        # proto deps of the underlying proto_library.
        if java_info:
            for generated_output in java_info.generated_outputs:
                if generated_output.compile_jdeps:
                    own_compile_jdeps_files.append(generated_output.compile_jdeps)
            own_jar_depsets.append(java_info.compile_jars_depset)
            own_output_jar_files = java_info.java_output_compile_jars

        if declares_android_resources(target, ctx):
            ide_aar = _get_ide_aar_file(target, ctx)
            if ide_aar:
                # TODO(mathewi) - handle source aars
                if not ide_aar.is_source:
                    own_ide_aar_files.append(ide_aar)
        elif declares_aar_import(ctx):
            ide_aar = rule.attr.aar.files.to_list()[0]

            # TODO(mathewi) - handle source aars
            if not ide_aar.is_source:
                own_ide_aar_files.append(ide_aar)

    else:
        if android_info != None:
            resource_package = android_info.java_package

            if generate_aidl_classes:
                add_base_idl_jar = False
                idl_jar = android_info.idl_class_jar
                if idl_jar != None:
                    own_jar_files.append(idl_jar)
                    add_base_idl_jar = True

                generated_java_files = android_info.idl_generated_java_files
                if generated_java_files:
                    own_gensrc_files += generated_java_files
                    add_base_idl_jar = True

                # An AIDL base jar needed for resolving base classes for aidl generated stubs.
                if add_base_idl_jar:
                    if hasattr(rule.attr, "_aidl_lib"):
                        own_jar_depsets.append(rule.attr._aidl_lib.files)
                    elif hasattr(rule.attr, "_android_sdk") and hasattr(android_common, "AndroidSdkInfo"):
                        android_sdk_info = getattr(rule.attr, "_android_sdk")[android_common.AndroidSdkInfo]
                        own_jar_depsets.append(android_sdk_info.aidl_lib.files)

        # Add generated java_outputs (e.g. from annotation processing)
        generated_class_jars = []
        if java_info:
            for generated_output in java_info.generated_outputs:
                # Prefer source jars if they exist and are requested:
                if use_generated_srcjars and generated_output.generated_source_jar:
                    own_gensrc_files.append(generated_output.generated_source_jar)
                elif generated_output.generated_class_jar:
                    generated_class_jars.append(generated_output.generated_class_jar)

        if generated_class_jars:
            own_jar_files += generated_class_jars

        # Add generated sources for included targets
        for src_attr in JVM_SRC_ATTRS:
            if hasattr(rule.attr, src_attr):
                for src in getattr(rule.attr, src_attr):
                    # If the target that generates this source specifies that
                    # the sources should be expanded, we ignore the generated
                    # sources - the IDE will substitute the target sources
                    # themselves instead.
                    if not (DependenciesInfo in src and src[DependenciesInfo].expand_sources):
                        for file in src.files.to_list():
                            if not file.is_source:
                                own_gensrc_files.append(file)

    if not target_is_within_project_scope:
        for src_attr in JVM_SRC_ATTRS:
            if hasattr(rule.attr, src_attr):
                for src in getattr(rule.attr, src_attr):
                    for file in src.files.to_list():
                        if file.is_source:
                            own_src_file_paths.append(file.path)
                        else:
                            own_gensrc_files.append(file)
        if hasattr(rule.attr, "srcjar"):
            if rule.attr.srcjar and type(rule.attr.srcjar) == "Target":
                for file in rule.attr.srcjar.files.to_list():
                    if file.is_source:
                        own_srcjar_file_paths.append(file.path)
                    else:
                        own_gensrc_files.append(file)

    if not (java_info or kotlin_info or android_info or java_proto_info or own_gensrc_files or own_src_file_paths or own_srcjar_file_paths):
        return None
    if own_jar_files or len(own_jar_depsets) > 1:
        own_jar_depset = depset(own_jar_files, transitive = own_jar_depsets)
        # here two cases left: own_jar_files is None/[] and own_jar_depsets is None/[] or a singleton.

    elif not own_jar_depsets:
        own_jar_depset = depset()
    elif len(own_jar_depsets) == 1:
        own_jar_depset = own_jar_depsets[0]
    else:
        # See the comment above.
        fail("Unexpected: " + str(own_jar_files) + " " + str(own_jar_depsets))

    return struct(
        is_external_dependency = must_build_main_artifacts,
        jar_depset = own_jar_depset,
        compile_jdeps_depset = depset(own_compile_jdeps_files),
        output_jar_depset = depset(own_output_jar_files),
        ide_aar_depset = depset(own_ide_aar_files),
        gensrc_depset = depset(own_gensrc_files),
        src_file_paths = own_src_file_paths,
        srcjar_file_paths = own_srcjar_file_paths,
        android_resources_package = resource_package,
    )

def _target_to_artifact_entry(
        label = "",
        is_external_dependency = False,
        dep_java_info_files = [],
        jars = [],
        compile_jdeps = [],
        output_jars = [],
        ide_aars = [],
        gen_srcs = [],
        srcs = [],
        srcjars = [],
        android_resources_package = ""):
    return struct(
        target = label,
        is_external_dependency = is_external_dependency,
        dep_java_info_files = dep_java_info_files,
        jars = jars,
        compile_jdeps = compile_jdeps,
        output_jars = output_jars,
        ide_aars = ide_aars,
        gen_srcs = gen_srcs,
        srcs = srcs,
        srcjars = srcjars,
        android_resources_package = android_resources_package,
    )

# Collects artifacts exposed by this java-like (i.e. java, android or proto-for-java) target and its dependencies if it is such a target.
# For non-Java targets only generated sources are collected without recursing to its dependencies. Therefore, for example, if there are
# generated proto files they won't be collected and this use case will need to be supported explicitly. Not following non-Java dependencies
# while collecting Java info files substantially reduces the number of generated and fetched info files.
def _collect_own_and_dependency_java_artifacts(
        target,
        ctx,
        dependency_infos,
        always_build_rules,
        generate_aidl_classes,
        use_generated_srcjars,
        target_is_within_project_scope):
    own_files = _collect_own_java_artifacts(
        target,
        ctx,
        always_build_rules,
        generate_aidl_classes,
        use_generated_srcjars,
        target_is_within_project_scope,
    )

    if not own_files:
        # Any target recognized as a java related target gets at least
        # an empty own_files structure.
        return None

    target_to_artifacts = {}

    # Flattening is fine here as these are files from a single target (maybe some are re-exported from a few of its depende3ncies).
    dep_java_info_files = [info.java_info_file for info in dependency_infos.values() if info.java_info_file]
    jars = own_files.jar_depset.to_list()
    compile_jdeps = own_files.compile_jdeps_depset.to_list()
    output_jars = own_files.output_jar_depset.to_list()
    ide_aars = own_files.ide_aar_depset.to_list()
    gen_srcs = own_files.gensrc_depset.to_list()  # Flattening is fine here (these are files from one target)
    java_info_file = _write_java_target_info(ctx, target.label, _target_to_artifact_entry(
        label = str(target.label),
        is_external_dependency = own_files.is_external_dependency,
        dep_java_info_files = dep_java_info_files,  # No flattening here. This is a list of direct dependencies only.
        jars = jars,
        compile_jdeps = compile_jdeps,
        output_jars = output_jars,
        ide_aars = ide_aars,
        gen_srcs = gen_srcs,
        srcs = own_files.src_file_paths,
        srcjars = own_files.srcjar_file_paths,
        android_resources_package = own_files.android_resources_package,
    ))

    own_and_transitive_compile_jdeps_depsets = [own_files.compile_jdeps_depset]
    own_and_transitive_jar_depsets = [own_files.jar_depset, own_files.output_jar_depset]  # Copy to prevent changes to own_files.jar_depset.
    own_and_transitive_ide_aar_depsets = []
    own_and_transitive_gensrc_depsets = []

    for info in dependency_infos.values():
        own_and_transitive_jar_depsets.append(info.compile_time_jars)
        own_and_transitive_compile_jdeps_depsets.append(info.compile_jdeps)
        own_and_transitive_ide_aar_depsets.append(info.aars)
        own_and_transitive_gensrc_depsets.append(info.gensrcs)

    return struct(
        java_info_file = java_info_file,
        compile_jars = depset(transitive = own_and_transitive_jar_depsets),
        compile_jdeps = depset(transitive = own_and_transitive_compile_jdeps_depsets),
        aars = depset(ide_aars, transitive = own_and_transitive_ide_aar_depsets),
        gensrcs = depset(gen_srcs, transitive = own_and_transitive_gensrc_depsets),
    )

def _get_cc_toolchain_dependency_info(rule):
    cc_toolchain_target = IDE_CC.toolchain_target(rule)
    if cc_toolchain_target and DependenciesInfo in cc_toolchain_target:
        return cc_toolchain_target[DependenciesInfo]
    return None

def _collect_own_and_dependency_cc_info(target, rule):
    dependency_info = _get_cc_toolchain_dependency_info(rule)
    compilation_context = IDE_CC.compilation_context(target)
    cc_toolchain_info = None
    if dependency_info:
        cc_toolchain_info = dependency_info.cc_toolchain_info

    gen_headers = depset()
    compilation_info = None
    if compilation_context:
        gen_headers = depset([f for f in compilation_context.headers.to_list() if not f.is_source])

        compilation_info = struct(
            transitive_defines = compilation_context.defines.to_list(),
            transitive_include_directory = compilation_context.includes.to_list(),
            transitive_quote_include_directory = compilation_context.quote_includes.to_list(),
            transitive_system_include_directory = (
                compilation_context.system_includes.to_list() + (
                    # external_includes was added in newer versions of bazel
                    compilation_context.external_includes.to_list() if hasattr(compilation_context, "external_includes") else []
                )
            ),
            framework_include_directory = compilation_context.framework_includes.to_list(),
            gen_headers = gen_headers.to_list(),
            toolchain_id = cc_toolchain_info.id if cc_toolchain_info else None,
        )
    if not compilation_info and not cc_toolchain_info:
        return None
    return struct(
        compilation_info = compilation_info,
        gen_headers = gen_headers,
        cc_toolchain_info = cc_toolchain_info,
    )

def _collect_dependencies_core_impl(
        target,
        ctx,
        params):
    if hasattr(ctx.rule.attr, "tags"):
        if "no-ide" in ctx.rule.attr.tags:
            return create_dependencies_info(label = target.label)

    java_dep_info = _collect_java_dependencies_core_impl(
        target,
        ctx,
        params,
    )
    cc_dep_info = _collect_cc_dependencies_core_impl(target, ctx)
    cc_toolchain_dep_info = _collect_cc_toolchain_info(target, ctx)
    return merge_dependencies_info(target, ctx, java_dep_info, cc_dep_info, cc_toolchain_dep_info)

def _collect_java_dependencies_core_impl(
        target,
        ctx,
        params):
    target_is_within_project_scope = _target_within_project_scope(target.label, params.include, params.exclude)
    dependency_infos = _get_followed_java_dependency_infos(target.label, ctx.rule)

    own_and_dependencies = _collect_own_and_dependency_java_artifacts(
        target,
        ctx,
        dependency_infos,
        params.always_build_rules,
        params.generate_aidl_classes,
        params.use_generated_srcjars,
        target_is_within_project_scope,
    )

    if own_and_dependencies == None:
        return None

    java_info_file = own_and_dependencies.java_info_file
    compile_jars = own_and_dependencies.compile_jars
    compile_jdeps = own_and_dependencies.compile_jdeps
    aars = own_and_dependencies.aars
    gensrcs = own_and_dependencies.gensrcs

    expand_sources = False
    if hasattr(ctx.rule.attr, "tags"):
        if "ij-ignore-source-transform" in ctx.rule.attr.tags:
            expand_sources = True

    return create_java_dependencies_info(
        info_file = java_info_file,
        info_files = depset([java_info_file], transitive = [d.java_info_files for d in dependency_infos.values()]),
        compile_time_jars = compile_jars,
        compile_jdeps = compile_jdeps,
        aars = aars,
        gensrcs = gensrcs,
        expand_sources = expand_sources,
    )

def _collect_cc_dependencies_core_impl(target, ctx):
    cc_info = _collect_own_and_dependency_cc_info(target, ctx.rule)
    if not cc_info:
        return None
    cc_info_files = []
    cc_info_files = ([_write_cc_target_info(target.label, cc_info.compilation_info, ctx)] if cc_info.compilation_info else []) + \
                    ([cc_info.cc_toolchain_info.file] if cc_info.cc_toolchain_info else [])

    return create_cc_dependencies_info(
        cc_info_files = depset(cc_info_files),
        cc_compilation_info = cc_info.compilation_info,
        cc_headers = cc_info.gen_headers,
        cc_toolchain_info = cc_info.cc_toolchain_info,
    )

def _collect_cc_toolchain_info(target, ctx):
    cc_toolchain_info = IDE_CC.cc_toolchain_info(target, ctx)
    if not cc_toolchain_info:
        return None

    cc_toolchain_file_name = target.label.name + "." + cc_toolchain_info.target_name + ".txt"
    cc_toolchain_file = ctx.actions.declare_file(cc_toolchain_file_name)
    ctx.actions.write(
        cc_toolchain_file,
        proto.encode_text(
            struct(toolchains = cc_toolchain_info),
        ),
    )

    return create_cc_toolchain_info(
        cc_toolchain_info = struct(file = cc_toolchain_file, id = cc_toolchain_info.id),
    )

def _get_ide_aar_file(target, ctx):
    """
    Builds a resource only .aar file for the ide.

    The IDE requires just resource files and the manifest from the IDE.
    Moreover, there are cases when the existing rules fail to build a full .aar
    file from a library, on which other targets can still depend.

    The function builds a minimalistic .aar file that contains resources and the
    manifest only.
    """
    android_info = IDE_ANDROID.get_android_info(target, ctx.rule)
    full_aar = android_info.aar
    if full_aar:
        resource_files = _collect_resource_files(ctx)
        resource_map = _build_ide_aar_file_map(android_info.manifest, resource_files)
        aar = ctx.actions.declare_file(full_aar.short_path.removesuffix(".aar") + "_ide/" + full_aar.basename)
        _package_ide_aar(ctx, aar, resource_map)
        return aar
    else:
        return None

def _collect_resource_files(ctx):
    """
    Collects the list of resource files from the target rule attributes.
    """

    # Unfortunately, there are no suitable bazel providers that describe
    # resource files used a target.
    # However, AndroidIdeInfo returns a reference to a so-called resource APK
    # file, which contains everything the IDE needs to load resources from a
    # given library. However, this format is currently supported by Android
    # Studio in the namespaced resource mode. We should consider conditionally
    # enabling support in Android Studio and use them in ASwB, instead of
    # building special .aar files for the IDE.
    resource_files = []
    for t in ctx.rule.attr.resource_files:
        for f in t.files.to_list():
            resource_files.append(f)
    return resource_files

def _build_ide_aar_file_map(manifest_file, resource_files):
    """
    Build the list of files and their paths as they have to appear in .aar.
    """
    file_map = {}
    file_map["AndroidManifest.xml"] = manifest_file
    for f in resource_files:
        res_dir_path = f.short_path \
            .removeprefix(android_common.resource_source_directory(f)) \
            .removeprefix("/")
        if res_dir_path:
            res_dir_path = "res/" + res_dir_path
            file_map[res_dir_path] = f
    return file_map

def _package_ide_aar(ctx, aar, file_map):
    """
    Declares a file and defines actions to build .aar according to file_map.
    """
    files_map_args = []
    files = []
    for aar_dir_path, f in file_map.items():
        files.append(f)
        files_map_args.append("%s=%s" % (aar_dir_path, f.path))

    ctx.actions.run(
        mnemonic = "GenerateIdeAar",
        executable = ctx.executable._build_zip,
        inputs = files,
        outputs = [aar],
        arguments = ["c", aar.path] + files_map_args,
    )

# List of tuples containing:
#   1. An attribute for the aspect to traverse
#   2. A list of rule kinds to specify which rules for which the attribute labels
#      need to be added as dependencies. If empty, the attribute is followed for
#      all rules.
FOLLOW_JAVA_ATTRIBUTES = [
    "deps",
    "test_deps",
    "exports",
    "srcs",
    "_junit",
    "_aspect_proto_toolchain_for_javalite",
    "_aspect_java_proto_toolchain",
] + IDE_KOTLIN.follow_attributes

FOLLOW_JAVA_PROTO_ATTRIBUTES = IDE_JAVA_PROTO.follow_attributes
FOLLOW_CC_ATTRIBUTES = IDE_CC.follow_attributes

FOLLOW_ADDITIONAL_ATTRIBUTES = ["runtime", "_toolchain"] + IDE_KOTLIN.follow_additional_attributes

FOLLOW_ATTRIBUTES = _unique(FOLLOW_JAVA_ATTRIBUTES + FOLLOW_JAVA_PROTO_ATTRIBUTES + FOLLOW_CC_ATTRIBUTES + FOLLOW_ADDITIONAL_ATTRIBUTES)

TOOLCHAINS_ASPECTS = IDE_KOTLIN.toolchains_aspects + IDE_JAVA_PROTO.toolchains_aspects + IDE_CC.toolchains_aspects

def collect_dependencies(parameters):
    def _impl(target, ctx):
        return _collect_dependencies_impl(target, ctx, parameters)

    return aspect(
        implementation = _impl,
        provides = [DependenciesInfo],
        attr_aspects = FOLLOW_ATTRIBUTES,
        attrs = {
            "_build_zip": attr.label(
                allow_files = True,
                cfg = "exec",
                executable = True,
                default = ZIP_TOOL_LABEL,
            ),
        },
        fragments = ["cpp"],
        **{
            "toolchains_aspects": TOOLCHAINS_ASPECTS,
        } if TOOLCHAINS_ASPECTS else {}
    )