# Copyright (C) 2022 The Android Open Source Project
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.

load("@bazel_skylib//lib:unittest.bzl", "analysistest", "asserts")
load("//build/bazel/rules/sysprop:sysprop_library.bzl", "sysprop_library")
load("//build/bazel/rules/test_common:args.bzl", "get_arg_value")
load(
    "//build/bazel/rules/test_common:paths.bzl",
    "get_output_and_package_dir_based_path",
    "get_package_dir_based_path",
)
load(":cc_sysprop_library.bzl", "cc_gen_sysprop")

def _provides_correct_outputs_test_impl(ctx):
    env = analysistest.begin(ctx)

    target_under_test = analysistest.target_under_test(env)
    output_files = target_under_test[DefaultInfo].files.to_list()
    actual_output_strings = [
        file.short_path
        for file in output_files
    ]

    asserts.equals(
        env,
        6,
        len(output_files),
        "List of outputs incorrect length",
    )
    for name in ["foo", "bar"]:
        expected_cpp_path = get_package_dir_based_path(
            env,
            "sysprop/path/to/%s.sysprop.cpp" % (name),
        )
        asserts.true(
            env,
            expected_cpp_path in actual_output_strings,
            ("Generated cpp source file for %s.sysprop not present in " +
             "output.\n" +
             "Expected Value: %s\n" +
             "Actual output: %s") % (
                name,
                expected_cpp_path,
                actual_output_strings,
            ),
        )
        expected_header_path = get_package_dir_based_path(
            env,
            "sysprop/include/path/to/%s.sysprop.h" % (name),
        )
        asserts.true(
            env,
            expected_header_path in actual_output_strings,
            ("Generated header source file for %s.sysprop not present in " +
             "output.\n" +
             "Expected Value: %s\n" +
             "Actual output: %s") % (
                name,
                expected_header_path,
                actual_output_strings,
            ),
        )
        expected_public_header_path = get_package_dir_based_path(
            env,
            "sysprop/public/include/path/to/%s.sysprop.h" % (name),
        )
        asserts.true(
            env,
            expected_public_header_path in actual_output_strings,
            ("Generated public header source file for %s.sysprop not present " +
             "in output.\n" +
             "Expected Value: %s\n" +
             "Actual output: %s") % (
                name,
                expected_public_header_path,
                actual_output_strings,
            ),
        )

    return analysistest.end(env)

provides_correct_outputs_test = analysistest.make(
    _provides_correct_outputs_test_impl,
)

# TODO(b/240466571): This test will be notably different after implementing
#                    exported include and header selection
def _provides_correct_ccinfo_test_impl(ctx):
    env = analysistest.begin(ctx)

    target_under_test = analysistest.target_under_test(env)
    target_ccinfo = target_under_test[CcInfo]
    actual_includes = target_ccinfo.compilation_context.includes.to_list()
    actual_headers = target_ccinfo.compilation_context.headers.to_list()
    expected_package_relative_include = get_package_dir_based_path(
        env,
        "sysprop/include",
    )
    asserts.true(
        env,
        expected_package_relative_include in actual_includes,
        ("Package relative include incorrect or not found in CcInfo.\n" +
         "Expected value: %s\n" +
         "Actual output: %s") % (
            expected_package_relative_include,
            actual_includes,
        ),
    )
    expected_root_relative_include = get_output_and_package_dir_based_path(
        env,
        "sysprop/include",
    )
    asserts.true(
        env,
        expected_root_relative_include in actual_includes,
        ("Root relative include incorrect or not found in CcInfo.\n" +
         "Expected value: %s\n" +
         "Actual output: %s") % (
            expected_root_relative_include,
            actual_includes,
        ),
    )
    asserts.true(
        env,
        len(actual_includes) == 2,
        ("CcInfo includes should contain a package relative and a " +
         "root-relative path and nothing else. Actual output: %s" % (
             actual_includes,
         )),
    )
    actual_header_strings = [
        header.path
        for header in actual_headers
    ]
    for name in ["foo", "bar"]:
        asserts.true(
            env,
            get_output_and_package_dir_based_path(
                env,
                "sysprop/include/path/to/%s.sysprop.h" % (name),
            ) in actual_header_strings,
            ("Generated header file for %s.sysprop not present in CcInfo " +
             "headers. Actual output: %s") % (name, actual_header_strings),
        )
    asserts.true(
        env,
        len(actual_headers) == 2,
        ("List of generated headers in CcInfo was incorrect length. Should " +
         "be exactly two. Actual output: %s" % actual_headers),
    )

    return analysistest.end(env)

provides_correct_ccinfo_test = analysistest.make(
    _provides_correct_ccinfo_test_impl,
)

def _correct_args_test_impl(ctx):
    env = analysistest.begin(ctx)

    actions = analysistest.target_actions(env)

    asserts.equals(
        env,
        2,
        len(actions),
        "Incorrect number of actions",
    )
    names = ["foo", "bar"]
    for i in range(2):
        name = names[i]
        actual_args = actions[i].argv

        asserts.equals(
            env,
            get_output_and_package_dir_based_path(env, "sysprop/include/path/to"),
            get_arg_value(actual_args, "--header-dir"),
            "--header-dir argument incorrect or not found.\n",
        )
        asserts.equals(
            env,
            get_output_and_package_dir_based_path(env, "sysprop/public/include/path/to"),
            get_arg_value(actual_args, "--public-header-dir"),
            "--public-header-dir argument incorrect or not found.\n",
        )
        asserts.equals(
            env,
            get_output_and_package_dir_based_path(env, "sysprop/path/to"),
            get_arg_value(actual_args, "--source-dir"),
            "--source-dir argument incorrect or not found.\n",
        )
        asserts.equals(
            env,
            "path/to/%s.sysprop.h" % name,
            get_arg_value(actual_args, "--include-name"),
            "--include-name argument incorrect or not found.\n",
        )
        expected_input = get_package_dir_based_path(
            env,
            "path/to/%s.sysprop" % name,
        )
        actual_cli_string = " ".join(actual_args)
        asserts.true(
            env,
            expected_input in actual_cli_string,
            ("Input argument not found.\n" +
             "Expected Value: %s\n" +
             "Command: %s") % (expected_input, actual_cli_string),
        )

    return analysistest.end(env)

correct_args_test = analysistest.make(
    _correct_args_test_impl,
)

def _create_test_targets(name, rule_func):
    wrapper_name = name + "_wrapper"
    test_name = name + "_test"
    sysprop_library(
        name = wrapper_name,
        srcs = [
            "path/to/foo.sysprop",
            "path/to/bar.sysprop",
        ],
        tags = ["manual"],
    )
    cc_gen_sysprop(
        name = name,
        dep = ":" + wrapper_name,
        tags = ["manual"],
    )
    rule_func(
        name = test_name,
        target_under_test = name,
    )
    return test_name

def cc_gen_sysprop_test_suite(name):
    native.test_suite(
        name = name,
        tests = [
            _create_test_targets(
                "provides_correct_outputs",
                provides_correct_outputs_test,
            ),
            _create_test_targets(
                "provides_correct_ccinfo",
                provides_correct_ccinfo_test,
            ),
            _create_test_targets(
                "correct_args_test",
                correct_args_test,
            ),
        ],
    )