#!/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.
"""Graph analysis functions for the testing framework.
"""

import logging
from typing import List, Optional, Tuple

from models import ActionCoverage
from models import ActionType
from models import Action
from models import ActionNode
from models import CoverageTest
from models import TestPlatform


def build_action_node_graph(root_node: ActionNode,
                            tests: List[CoverageTest]) -> None:
    """
    Builds a graph of ActionNodes on the given `root_node`. The graph is
    generated by iterating the `tests`, starting at the `root_node` for each
    test, and adding ActionNodes to the graph for each state-change action
    (following the graph for every state-change action). State-check actions are
    added to the previous state-change action ActionNode.
    """
    assert root_node is not None
    assert isinstance(root_node, ActionNode)
    assert isinstance(tests, list)
    for test in tests:
        assert isinstance(test, CoverageTest)
        parent = root_node
        for action in test.actions:
            assert isinstance(action, Action)
            assert action.type is not ActionType.PARAMETERIZED
            if action.is_state_check():
                parent.add_state_check_action(action)
            else:
                node = None
                if action.name in parent.children:
                    node = parent.children[action.name]
                else:
                    node = ActionNode(action)
                    parent.add_child(node)
                parent = node


def generage_graphviz_dot_file(root_node: ActionNode,
                               platform: Optional[TestPlatform]) -> str:
    def get_all_nodes_and_assign_graph_ids(root: ActionNode
                                           ) -> List[ActionNode]:
        current_graph_id = 0

        def get_all_nodes_helper(node: ActionNode, nodes: List[ActionNode]):
            nonlocal current_graph_id
            if node.graph_id is not None:
                return
            node.graph_id = current_graph_id
            current_graph_id += 1
            nodes.append(node)
            if not node.children:
                return
            for child in node.children.values():
                get_all_nodes_helper(child, nodes)

        # Skip the root node, as it is only there for the algorithm to work.
        all_nodes = []
        for child in root.children.values():
            get_all_nodes_helper(child, all_nodes)
        return all_nodes

    def print_graph(node: ActionNode) -> List[str]:
        assert node.graph_id is not None, node.action.name
        if not node.children:
            return []
        lines = []
        for child in node.children.values():
            assert child.graph_id is not None, child.action.name
            edge_str = str(node.graph_id) + " -> " + str(child.graph_id)
            lines.append(edge_str)
            lines.extend(print_graph(child))
        return lines

    lines = []
    lines.append("strict digraph {")
    nodes = get_all_nodes_and_assign_graph_ids(root_node)
    for node in nodes:
        color_str = ("seagreen" if platform is None
                     or platform in node.action.full_coverage_platforms else
                     "sandybrown")
        label_str = node.get_graphviz_label()
        lines.append(f"{node.graph_id}[label={label_str} color={color_str}]")
    # Skip the root node, as it is only there for the algorithm to work.
    for child in root_node.children.values():
        lines.extend(print_graph(child))
    lines.append("}")
    return "\n".join(lines)


# Removes any nodes and actions from the graph that are not supported by the
# given platform.
def trim_graph_to_platform_actions(root_node: ActionNode,
                                   platform: TestPlatform) -> None:
    """
    Removes any nodes and actions from the graph that are not supported by the
    given platform.
    """
    new_children = {}
    for child in root_node.children.values():
        if child.action.supported_for_platform(platform):
            new_children[child.action.name] = child
    root_node.children = new_children
    new_state_check_actions = {}
    for action in root_node.state_check_actions.values():
        if action.supported_for_platform(platform):
            new_state_check_actions[action.name] = action
    root_node.state_check_actions = new_state_check_actions
    for child in root_node.children.values():
        trim_graph_to_platform_actions(child, platform)


def generate_framework_tests(root_node: ActionNode,
                             platform: TestPlatform) -> List[CoverageTest]:
    assert isinstance(root_node, ActionNode)

    def GetAllPaths(node: ActionNode) -> List[List[ActionNode]]:
        assert node is not None
        assert isinstance(node, ActionNode)
        paths = []
        for child in node.children.values():
            for path in GetAllPaths(child):
                assert path is not None
                assert isinstance(path, list)
                assert bool(path)
                paths.append([node] + path)
        if len(paths) == 0:
            paths = [[node]]
        return paths

    all_paths = GetAllPaths(root_node)
    result = []
    for path in all_paths:
        all_actions_in_path = []
        for node in path[1:]:  # Skip the root node
            all_actions_in_path.append(node.action)
            all_actions_in_path.extend(node.state_check_actions.values())
        result.append(CoverageTest(all_actions_in_path, {platform}))
    return result


def generate_coverage_file_and_percents(
        required_coverage_tests: List[CoverageTest],
        tested_graph_root: ActionNode,
        platform: TestPlatform) -> Tuple[str, float, float]:
    lines = []
    total_actions = 0.0
    actions_fully_covered = 0.0
    actions_partially_covered = 0.0
    for coverage_test in required_coverage_tests:
        action_strings = []
        last_action_node = tested_graph_root
        for action in coverage_test.actions:
            total_actions += 1
            coverage = None
            if last_action_node is not None:
                if action.name in last_action_node.children:
                    coverage = action.get_coverage_for_platform(platform)
                if (action.is_state_check()
                        and last_action_node.has_state_check_action(action)):
                    coverage = action.get_coverage_for_platform(platform)
            if coverage is None:
                last_action_node = None
                action_strings.append(action.name + '🌑')
                continue
            elif (coverage == ActionCoverage.FULL):
                actions_fully_covered += 1
                action_strings.append(action.name + '🌕')
            elif (coverage == ActionCoverage.PARTIAL):
                action_strings.append(action.name + '🌓')
                actions_partially_covered += 1
            # Only proceed if the action was in the children. If not, then it
            # was in the stateless action list and we stay at the same node.
            if action.name in last_action_node.children:
                last_action_node = last_action_node.children[action.name]
        lines.append(action_strings)

    full_coverage = actions_fully_covered / total_actions
    partial_coverage = ((actions_fully_covered + actions_partially_covered) /
                        total_actions)
    logging.info(f"Coverage for {platform}:")
    logging.info(f"Full coverage: {full_coverage:.0%}, "
                 f", with partial coverage: {partial_coverage:.0%}")
    return ("\n".join(["\t".join(line)
                       for line in lines]), full_coverage, partial_coverage)