#!/usr/bin/env python3.8
# Copyright 2020 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.
"""A helper script for verifying dependencies are released in an SDK.

This script is intended to run as a build time check to make sure that dependencies
are released in a "public" or "partner" SDK. This is to ensure that a target depends
on stable API / ABI.
"""

import argparse
import json
import os
import re
import sys

CTF_EXTENSION = '.this_is_ctf'


class VerifyDepsInSDK:
    """Helper class to verify GN dependencies are released in a public SDK.

    Args:
      root_build_dir (string): An absolute path to the GN's $root_build_dir.
      output_file (string): The path to (including) the file to be generated.
      invoker_label (string): The label of the invoker of verify_deps_in_sdk.
      deps_to_verify (list(string)): A list of fully qualified GN labels.
      allowed_deps (list(string)): A list of allowed deps found in //sdk/ctf/allowed_ctf_deps.gni"
      allowed_dirs (list(string)): A list of allowed directories found in //sdk/ctf/allowed_ctf_deps.gni"
      sdk_manifests (list(string)): A list of absolute paths to SDK manifest files.

    Raises:
      ValueError if any parameter is empty, if root_build_dir does not exist, or if the sdk_manifests do not exist.
    """

    def __init__(
            self, root_build_dir, output_file, invoker_label, deps_to_verify,
            allowed_deps, allowed_dirs, sdk_manifests):
        if not (root_build_dir and os.path.exists(root_build_dir)):
            raise ValueError('root_build_dir cannot be empty and must exist.')

        if not output_file:
            raise ValueError('output_file cannot be empty.')

        if not invoker_label:
            raise ValueError('invoker_label cannot be empty.')

        if not deps_to_verify:
            raise ValueError('deps_to_verify cannot be empty.')

        if not allowed_deps:
            raise ValueError('allowed_deps cannot be empty')

        if not allowed_dirs:
            raise ValueError('allowed_dirs cannot be empty')

        if sdk_manifests:
            for manifest in sdk_manifests:
                if not os.path.isfile(manifest):
                    raise ValueError(f'manifest {manifest} does not exist')
        else:
            raise ValueError('sdk_manifests cannot be empty')

        self.root_build_dir = root_build_dir
        self.output_file = output_file
        self.invoker_label = invoker_label
        self.deps_to_verify = deps_to_verify
        self.allowed_deps = allowed_deps
        self.allowed_dirs = allowed_dirs
        self.sdk_manifests = sdk_manifests

    def get_ctf_file_path(self, dep):
        """Returns the path to a CTF file.

        The CTF creates a file for each CTF target at GN gen time. This CTF file is used to indicate
        that a target is acceptable in CTF. Each CTF target verifies its own dependencies using this script.
        If a dependency does not have a CTF file, the script will look for that fully qualified dependency
        in allowed_deps. If it does have a CTF file, verification of that target will be deferred such
        that the target may verify its own dependencies.

        Args:
          dep (string): A GN label.

        Returns:
          A string containing the absolute path to the target's CTF file.
        """

        # Remove the leading slashes from the label.
        dep = dep[2:]

        # Get the target_name from the label.
        if ':' in dep:
            # path/to/lib:lib
            dep, target_name = dep.split(':')
        elif '/' in dep:
            # path/to/lib
            _, target_name = dep.rsplit('/', 1)
        else:
            # lib
            target_name = dep

        return self.root_build_dir + '/ctf/' + dep + '/' + target_name + CTF_EXTENSION

    def verify_deps(self):
        """Verifies the element's dependencies are released in a public SDK.

        All dependencies must be in allowed_deps, allowed_dirs, or be CTF targets themselves.

        Note: At the time this script runs, these dependencies (self.deps_to_verify)
        have not necessarily been built. The verification target does not depend on them.

        Returns:
          A list of labels that are not allowed to be used. The list will be empty if all deps are allowed.
        """
        unaccepted_deps = []
        unverified_deps = []
        for dep in self.deps_to_verify:
            # Removes FIDL binding suffixes because the SDK manifests will only
            # contain the FIDL name.
            for suffix in ["_hlcpp", "_rust", "_cpp_wire"]:
                if dep.endswith(suffix):
                    dep = dep[:-len(suffix)]
                    break

            dep_found = False
            if dep in self.allowed_deps or os.path.exists(
                    self.get_ctf_file_path(dep)):
                dep_found = True
            else:
                # Dep isn't in the allow list and a CTF file doesn't exist. Check if
                # all targets in dep's directory are allowed (//third_party/dart-pkg/pub/*).
                for allowed_dir in self.allowed_dirs:
                    pattern = re.compile(allowed_dir)
                    if pattern.match(dep):
                        dep_found = True

                # Check if dep is an SDK target.
                if not dep_found:
                    unverified_deps.append(dep)

        if len(unverified_deps) > 0:
            unaccepted_deps = self.verify_deps_in_sdk(unverified_deps)

        return unaccepted_deps

    def verify_deps_in_sdk(self, deps):
        """Verifies that dependencies are released in an SDK.

        Returns:
            The list of dependencies that are not released in an SDK.
        """
        # SDK atoms are appended with one of the following and a
        # toolchain, so we want to ignore them to match against the
        # provided label.
        match_label = re.compile(
            "(?:(_sdk)|(_sdk_manifest)|(_sdk_legacy))\(.*\)")

        sdk_atom_label_to_category = {}
        for sdk_manifest in self.sdk_manifests:
            try:
                with open(sdk_manifest, 'r') as manifest:
                    data = json.load(manifest)
            except json.JSONDecodeError:
                continue
            for atom in data['atoms']:
                label = re.sub(match_label, '', atom['gn-label'])
                sdk_atom_label_to_category[label] = atom['category']

        unaccepted_deps = []
        for dep in deps:
            if dep not in sdk_atom_label_to_category or sdk_atom_label_to_category[
                    dep] not in ['partner', 'public']:
                unaccepted_deps.append(dep)

        return unaccepted_deps

    def create_output_file(self):
        """Create an output file containing the verified dependencies.

        Should only be run after dependencies are verified using verify_deps.
        """
        target_gen_dir, _ = self.output_file.rsplit('/', 1)
        if not os.path.exists(target_gen_dir):
            os.makedirs(target_gen_dir)

        with open(self.output_file, 'w') as f:
            for dep in self.deps_to_verify:
                f.write(f'{dep}\n')


def main():
    parser = argparse.ArgumentParser()
    parser.add_argument(
        '--root_build_dir',
        required=True,
        help='Path to the GN $root_build_dir. The default is //out/default.')
    parser.add_argument(
        '--output',
        required=True,
        help='The path to (including) the file to be generated.')
    parser.add_argument(
        '--invoker_label',
        required=True,
        help='The label of the invoker of verify_deps_in_sdk.')
    parser.add_argument(
        '--deps_to_verify',
        nargs='+',
        required=True,
        help=
        'A list of at least one GN label representing the target\'s dependencies.'
    )
    parser.add_argument(
        '--allowed_deps',
        nargs='+',
        required=True,
        help='A list of allowed dependencies.')
    parser.add_argument(
        '--allowed_dirs',
        nargs='+',
        required=True,
        help=
        'A list of directories where any dependency is allowed. Directories should end in /*'
    )
    parser.add_argument(
        '--sdk_manifests',
        nargs='+',
        required=True,
        help='The list of paths to public and partner SDK manifests')
    args = parser.parse_args()
    try:
        target = VerifyDepsInSDK(
            args.root_build_dir, args.output, args.invoker_label,
            args.deps_to_verify, args.allowed_deps, args.allowed_dirs,
            args.sdk_manifests)
    except ValueError as e:
        print(f'ValueError: {e}')
        return 1

    unaccepted_deps = target.verify_deps()
    if not unaccepted_deps:
        target.create_output_file()
    else:
        print(
            f'The following dependencies of "{args.invoker_label}" are not allowed: {unaccepted_deps}'
        )
        return 1

    return 0


if __name__ == '__main__':
    sys.exit(main())