#!/usr/bin/env python3
# Copyright 2021 The Chromium Authors
# Use of this source code is governed by a BSD-style license that can be
# found in the LICENSE file.
"""Classes used to process the Web App testing framework data.
"""

import collections
from enum import Enum
from enum import unique
import os
from typing import FrozenSet, Optional, Set, List, Dict, Tuple

TestId = str


@unique
class ActionCoverage(Enum):
    PARTIAL = 1
    FULL = 2
    NONE = 3


@unique
class ActionType(Enum):
    # The action changes the state of the system.
    STATE_CHANGE = 1
    # The action checks the state of the system (and does not change it).
    STATE_CHECK = 2
    # The action generates one or more other actions, allowing a parameterized
    # action to produce multiple tests.
    PARAMETERIZED = 3


@unique
class TestPlatform(Enum):
    """
    Describes a platform that is being tested.
    Attributes:
        macro: This is the macro used in a browsertest file by a gardener to
               specify the platform. Formatted for use in regex.
        char: This is the character used in the unprocessed required coverage
              test spreadsheet to specify if a test applies to a given platform.
        suffix: The suffix applied to browsertest files to specify that the
                file runs on that platform.
    """
    MAC = ("BUILDFLAG(IS_MAC)", "M", "mac")
    WINDOWS = ("BUILDFLAG(IS_WIN)", "W", "win")
    LINUX = ("BUILDFLAG(IS_LINUX)", "L", "linux")
    CHROME_OS = ("BUILDFLAG(IS_CHROMEOS)", "C", "cros")

    def __init__(self, macro: str, char: str, suffix: str):
        self.macro: str = macro
        self.char: str = char
        self.suffix: str = suffix

    @staticmethod
    def get_platforms_from_chars(string: str) -> Set["TestPlatform"]:
        """Parse the string for platforms.
        M = Mac, L = Linux, W = Windows, and C = ChromeOS
        Example inputs: "MLWC", "WLM", "C", ""
        """
        result = set()
        for platform in TestPlatform:
            if platform.char in string:
                result.add(platform)
        return result

    @staticmethod
    def get_test_fixture_suffix(platforms: Set["TestPlatform"]) -> str:
        """Output a string from the platforms to suffix the test fixture name.
        If all platforms are specified, the suffix is blank.
        Example: {MAC, LINUX} outputs "MacLinux"
        """
        if len(platforms) == len(TestPlatform):
            return ""
        result: str = ""
        for platform in TestPlatform:
            if platform in platforms:
                result += platform.suffix.capitalize()
        return result

    @staticmethod
    def get_platforms_from_browsertest_filename(filename: str
                                                ) -> Set["TestPlatform"]:
        result = set()
        for platform in TestPlatform:
            if platform.suffix in filename:
                result.add(platform)
        if not result:
            result.update(TestPlatform)
        return result


class ArgEnum:
    """Represents an enumeration used as an argument in an action."""

    def __init__(self, type_name: str, values: List[str],
                 default_value: Optional[str]):
        assert type_name is not None
        assert values is not None
        assert len(values) != 0
        self.type_name = type_name
        self.values = values
        self.default_value = default_value


class Action:
    """Represents a user action.

    Attributes:
        name: The name of the action often can contain arguments, which are
              resolved at parse time.
        base_name: If the action has arguments, this is the base action name
                   before the argument was concatenated, resulting in the name.
        cpp_method: Resolved method to call in C++ to execute this action. This
                    includes any arguments.
        type: The type of the action (see ActionType).
        output_actions: Only populated if `type` is PARAMETERIZED. These are the
                        possible actions that can take the place of this action
                        when generating processed tests.
        full_coverage_platforms: Platforms where this action is fully supported.
        partial_coverage_platforms: Platforms where this action is partially
                                    supported.
    """

    def __init__(self, name: str, base_name: str, shortened_base_name: str,
                 cpp_method: str, type: ActionType,
                 full_coverage_platforms: Set[TestPlatform],
                 partial_coverage_platforms: Set[TestPlatform]):
        assert name is not None
        assert base_name is not None
        assert type is not None
        self.name: str = name
        self.base_name: str = base_name
        self.shortened_base_name: str = shortened_base_name
        self.cpp_method: str = cpp_method
        self.type: ActionType = type
        self.output_actions: List[Action] = []
        self.full_coverage_platforms: Set[
            TestPlatform] = full_coverage_platforms
        self.partial_coverage_platforms: Set[
            TestPlatform] = partial_coverage_platforms
        # Used in `read_action_files` as temporary storage.
        self._output_canonical_action_names: List[str] = []

    def get_coverage_for_platform(self,
                                  platform: TestPlatform) -> ActionCoverage:
        if platform in self.full_coverage_platforms:
            return ActionCoverage.FULL
        if platform in self.partial_coverage_platforms:
            return ActionCoverage.PARTIAL
        return ActionCoverage.NONE

    def supported_for_platform(self, platform: TestPlatform) -> bool:
        return (platform in self.full_coverage_platforms
                or platform in self.partial_coverage_platforms)

    def is_state_check(self) -> bool:
        return self.type == ActionType.STATE_CHECK

    def __str__(self):
        return (f"Action[{self.name}, "
                f"base_name: {self.base_name}, "
                f"shortened_base_name: {self.shortened_base_name}, "
                f"type: {self.type}, "
                f"output_actions: "
                f"{[a.name for a in self.output_actions]}, "
                f"full_coverage_platforms: "
                f"{[p.char for p in self.full_coverage_platforms]}, "
                f"partial_coverage_platforms: "
                f"{[p.char for p in self.partial_coverage_platforms]}]")


class ActionNode:
    """Represents a node in an action graph, where all nodes are
    state change actions.

    Attributes:
        action: The action this node represents.
        children: The children of this node, keyed by action name.
        state_check_actions: State checks that can be performed on this node.
        graph_id: Used for graphviz file generation.
    """

    @staticmethod
    def CreateRootNode():
        return ActionNode(
            Action("root", "root", "root", "root()", ActionType.STATE_CHANGE,
                   set(), set()))

    def __init__(self, action: Action):
        assert action is not None
        assert action.type == ActionType.STATE_CHANGE
        self.action: Action = action
        self.children: Dict[str, "ActionNode"] = {}
        self.state_check_actions: Dict[str, Action] = {}
        self.graph_id: Optional[int] = None

    def add_child(self, child: 'ActionNode'):
        assert child is not self
        assert not child.action.name in self.children
        self.children[child.action.name] = child

    def add_state_check_action(self, action: Action):
        assert action is not None and isinstance(action, Action)
        assert action.is_state_check(), action
        self.state_check_actions[action.name] = action

    def has_state_check_action(self, action: Action) -> bool:
        assert action.is_state_check()
        return action.name in self.state_check_actions

    def get_graphviz_label(self) -> str:
        node_str = "< <B>" + self.action.name + "</B>"
        if self.state_check_actions:
            node_str += "<BR/>(" + ", ".join(
                [action_name
                 for action_name in self.state_check_actions]) + ")"
        return node_str + " >"

    def __str__(self):
        return (f"ActionNode[{self.action.name}, "
                f"children: {self.children.keys()}")


class CoverageTest:
    """Represents a test with a list of actions

    Attributes:
        id: Unique name, or identifier, of the test.
        actions: list of actions the test specifies to execute.
        platforms: set of platforms this test is run on.
    """

    TEST_ID_PREFIX = "WAI_"

    def __init__(self, actions: List[Action], platforms: Set[TestPlatform]):
        assert actions is not None
        assert platforms is not None
        self.id: TestId = "_".join([a.name for a in actions])
        self.actions: List[Action] = actions
        self.platforms: Set[TestPlatform] = platforms

    def generate_browsertest(self, test_partition: "TestPartitionDescription"
                             ) -> str:
        comments = [
            "Test contents are generated by script. Please do not modify!",
            "See `docs/webapps/why-is-this-test-failing.md` or",
            "`docs/webapps/integration-testing-framework` for more info.",
            "Gardeners: Disabling this test is supported."
        ]
        body = ''.join(["  // " + comment + "\n" for comment in comments])
        body += '\n'.join([(f"  helper_.{action.cpp_method};")
                           for action in self.actions])
        fixture = f"{test_partition.test_fixture}"
        return (f"IN_PROC_BROWSER_TEST_F("
                f"{fixture}, "
                f"{CoverageTest.TEST_ID_PREFIX}{self.generate_test_name()}) "
                f"{{\n{body}\n}}")

    def generate_test_name(self):
        state_change_list = []
        for a in self.actions:
            if "check" not in a.name:
                action_name = (a.shortened_base_name
                               if a.shortened_base_name else a.base_name)
                action = a.name.replace(a.base_name, action_name)
                action_list = action.split("_")
                state_change = "".join(a[0].upper() + a[1:]
                                       for a in action_list)
                state_change_list.append(state_change)
        return "_".join(state_change_list)

    def __str__(self):
        return (f"CoverageTest[id: {self.id}, "
                f"actions: {[a.name for a in self.actions]}, "
                f"platforms: {[str(p) for p in self.platforms]}]")


class TestPartitionDescription:
    """
    Due to framework implementation limitations, some tests need to be split
    into different browsertest files. This class describes that partition.

    Attributes:
        action_name_prefixes: If a test has any actions that have any of these
                              prefixes, then that tests is considered part of
                              this partition.
        browsertest_dir: The directory where the browsertests for this partition
                         live.
        test_file_prefix: The filename prefix used for the expected browsertest
                          file. The full filename is expected to optionally
                          contain per-platform suffixes, followed by a ".cc".
        test_fixture: The gtest fixture used when printing the test declaration.
    """

    def __init__(self, action_name_prefixes: Set[str], browsertest_dir: str,
                 test_file_prefix: str, test_fixture: str):
        self.action_name_prefixes: Set[str] = action_name_prefixes
        self.browsertest_dir: str = browsertest_dir
        self.test_file_prefix: str = test_file_prefix
        self.test_fixture: str = test_fixture

    def generate_browsertest_filepath(self, platforms: Set[TestPlatform]):
        """
        Genenerates the browsertest file path given the set of platforms. The
        suffixes are deterministically ordered by the TestPlatform enum order.
        Example:
            self.browsertest_dir = "/path/to/test"
            self.test_file_prefix = "tests_file"
            platforms = {TestPlatform.WINDOWS, TestPlatform.MAC}

            return "/path/to/test/tests_file_mac_win.cc"
        """
        suffix = ""
        if len(platforms) != len(TestPlatform):
            # Iterating TestPlatform to get stable ordering.
            for platform in TestPlatform:
                if platform in platforms:
                    suffix += "_" + platform.suffix
        return (os.path.join(self.browsertest_dir,
                             (self.test_file_prefix + suffix + ".cc")))


TestIdTestNameTuple = collections.namedtuple("TestIdTestNameTuple",
                                             "test_id, test_name")
TestIdsTestNamesByPlatform = Dict[TestPlatform, Set[TestIdTestNameTuple]]
TestIdsTestNamesByPlatformSet = Dict[FrozenSet[TestPlatform],
                                     Set[TestIdTestNameTuple]]
CoverageTestsByPlatformSet = Dict[FrozenSet[TestPlatform], List[CoverageTest]]
CoverageTestsByPlatform = Dict[TestPlatform, List[CoverageTest]]
EnumsByType = Dict[str, ArgEnum]
ActionsByName = Dict[str, Action]
EnumsByType = Dict[str, ArgEnum]
PartialAndFullCoverageByBaseName = Dict[
    str, Tuple[Set[TestPlatform], Set[TestPlatform]]]