#!/usr/bin/env fuchsia-vendored-python
# Copyright 2023 The Fuchsia Authors. All rights reserved.
# Use of this source code is governed by a BSD-style license that can be
# found in the LICENSE file.

import collections
import os
import typing as T

# The following runtime libraries are provided directly by the SDK sysroot,
# and not as SDK atoms.
_SYSROOT_LIBS = ["libc.so", "libzircon.so"]

# Information about an atom.
AtomInfo: T.TypeAlias = dict[str, T.Any]

# The contents of a JSON file.
JsonFileContent: T.TypeAlias = dict[str, T.Any]


_NON_SDK_DEPS_ERROR_HEADER = r"""## Non-SDK dependencies required at runtime:
"""

_NON_SDK_DEPS_ERROR_FOOTER = r"""
HINT: These should be defined by an sdk_shared_library() call, or by a
zx_library() one that sets 'sdk = "shared"'.
"""

_BAD_SDK_DEPS_ERROR_HEADER = r"""## Non prebuilt libraries required at runtime:
"""

_BAD_SDK_DEPS_ERROR_FOOTER = _NON_SDK_DEPS_ERROR_FOOTER

_MISSING_SDK_DEPS_ERROR_HEADER = r"""## No dependency generates SDK runtime requirement:
"""

_MISSING_SDK_DEPS_ERROR_FOOTER = r"""
HINT: Add the missing atom(s)'s targets to the 'runtime_deps' list.
"""


class DependencyErrors(object):
    """Models list of errors found during verification."""

    def __init__(self) -> None:
        self._errors: list[tuple[dict[str, str], str]] = []

    def has_error(self) -> bool:
        """Return True iff this instance contains errors."""
        return bool(self._errors)

    def add_non_sdk_dependency(self, entry: dict[str, str]) -> None:
        """Add an entry for a non-SDK dependency.

        This happens when an SDK atom depends on a shared_library() instance
        directly, instead of an skd_shared_library() one.
        """
        self._errors.append((entry, "non_sdk_deps"))

    def add_bad_sdk_dependency(self, entry: dict[str, str]) -> None:
        """Add an entry for a non-prebuilt shared library."""
        self._errors.append((entry, "bad_sdk_deps"))

    def add_missing_sdk_dependency(self, entry: dict[str, str]) -> None:
        """Add an entry for a non-SDK shared library dependency."""
        self._errors.append((entry, "missing_sdk_deps"))

    def __str__(self) -> str:
        result = ""
        # Split errors by categories
        errors = collections.defaultdict(list)
        for entry, category in self._errors:
            errors[category].append(entry)

        for category, entries in errors.items():
            if category == "non_sdk_deps":
                result += _NON_SDK_DEPS_ERROR_HEADER
                for entry in entries:
                    result += "- `%s` generated_by `%s`\n" % (
                        entry["source"],
                        entry["label"],
                    )
                result += _NON_SDK_DEPS_ERROR_FOOTER

            elif category == "bad_sdk_deps":
                result += _BAD_SDK_DEPS_ERROR_HEADER
                for entry in entries:
                    result += "- IDK atom `%s` generated_by `%s`\n" % (
                        entry["sdk_id"],
                        entry["label"],
                    )
                result += _BAD_SDK_DEPS_ERROR_FOOTER

            elif category == "missing_sdk_deps":
                result += _MISSING_SDK_DEPS_ERROR_HEADER
                for entry in entries:
                    result += "- IDK atom `%s` generated_by `%s`\n" % (
                        entry["sdk_id"],
                        entry["label"],
                    )
                result += _MISSING_SDK_DEPS_ERROR_FOOTER

            else:
                assert False, "Unknown category: %s" % category

        return result


def check_for_missing_runtime_deps(
    runtime_files: T.Sequence[dict[str, str]], atom_deps: dict[str, AtomInfo]
) -> DependencyErrors:
    """Verifies the runtime dependencies of a prebuilt IDK library (static or shared).

    Verifies the atoms corresponding to the list of runtime requirements in
    `runtime_files` are all included in `atom_deps`.

    This ensures that atoms containing all runtime files are included in the
    atom's deps so that IDK consumers will know to package them when using
    the atom. This also verifies those atoms will be included in the IDK.

    Args:
      runtime_files: A JSON list of dictionaries, each representing a runtime
        dependency. Each dictionary must follow the schema described in
        //build/cpp/verify_runtime_deps.gni and contain either an 'sdk_id' or a
        'source' key.
      atom_deps: A dictionary mapping the atom IDs of the atom and its
        dependencies to their corresponding atom information. (The
        implementation does not care whether the dependencies are only direct or
        include all its transitive dependencies, but the results may vary
        depending on this.)

    Returns:
      A DependencyErrors instance containing any errors found during
      verification.
    """
    errors = DependencyErrors()

    for entry in runtime_files:
        sdk_id = entry.get("sdk_id")
        source = entry.get("source")

        assert bool(sdk_id) != bool(source), (
            'Exactly one of "sdk_id" or "source" must be defined in entry: %s'
            % entry
        )

        if sdk_id:
            # This runtime dependency is an IDK library. Verify that the library
            # is in the atom's deps.
            assert not source, "Only one of `sdk_id` or `source` should be set."
            dep = atom_deps.get(sdk_id)
            if not dep:
                errors.add_missing_sdk_dependency(entry)
            elif "type" in dep:
                # The atom info is from the old .sdk build manifest.
                if dep["type"] != "cc_prebuilt_library":
                    errors.add_bad_sdk_dependency(entry)
            # Else the atom info is from prebuild info.
            elif dep["atom_type"] != "cc_prebuilt_library":
                errors.add_bad_sdk_dependency(entry)
        elif source:
            # A non-IDK library.

            # Ignore sysroot libs
            if os.path.basename(source) in _SYSROOT_LIBS:
                # TODO(https://fxbug.dev/447151364): Determine whether this
                # unused logic is necessary.
                assert False
                continue

            # This runtime dependency is *not* an IDK library. This is an error.
            errors.add_non_sdk_dependency(entry)
        else:
            assert False, "Runtime entry is missing 'sdk_id' or 'source'."

    return errors