#!/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.
"""Command-line tool for finding differences in dependency graphs."""

import argparse

import itertools
from typing import List, Set, Tuple, Callable

import chrome_names
import count_cycles
import graph
import serialization


def _print_diff_num_nodes(graph1: graph.Graph, graph2: graph.Graph, label: str):
    before: int = graph1.num_nodes
    after: int = graph2.num_nodes
    _print_diff_metric(before, after, label)


def _print_diff_num_edges(graph1: graph.Graph, graph2: graph.Graph, label: str):
    before: int = graph1.num_edges
    after: int = graph2.num_edges
    _print_diff_metric(before, after, label)


def _print_diff_metric(before: int, after: int, label: str):
    diff: int = after - before
    print(f'{label}: {diff:+} ({before} -> {after})')


def _print_diff_node_list(graph1: graph.Graph, graph2: graph.Graph, label: str):
    before_nodes: Set[str] = set(node.name for node in graph1.nodes)
    after_nodes: Set[str] = set(node.name for node in graph2.nodes)
    _print_set_diff(before_nodes, after_nodes, label)


def _print_diff_node_list_filtered(
    graph1: graph.Graph,
    graph2: graph.Graph,
    label: str,
    filter_fn: Callable[[graph.Node], bool],
):

    before_nodes: Set[str] = set(
        node.name for node in graph1.nodes if filter_fn(node)
    )
    after_nodes: Set[str] = set(
        node.name for node in graph2.nodes if filter_fn(node)
    )
    _print_diff_metric(len(before_nodes), len(after_nodes), label)
    _print_set_diff(before_nodes, after_nodes, label)


def _print_diff_edge_list(graph1: graph.Graph, graph2: graph.Graph, label: str):
    before_edges: Set[str] = set(_edge_str(edge) for edge in graph1.edges)
    after_edges: Set[str] = set(_edge_str(edge) for edge in graph2.edges)
    _print_set_diff(before_edges, after_edges, label)


def _edge_str(edge: Tuple[graph.Node, graph.Node]) -> str:
    return f'{edge[0]} -> {edge[1]}'


def _print_diff_cycle_list(
    cycles1: Set[count_cycles.Cycle],
    cycles2: Set[count_cycles.Cycle],
    label: str,
):
    before_cycles: Set[str] = set(_cycle_str(cycle) for cycle in cycles1)
    after_cycles: Set[str] = set(_cycle_str(cycle) for cycle in cycles2)
    _print_set_diff(before_cycles, after_cycles, label)


def _cycle_str(cycle: count_cycles.Cycle) -> str:
    return ' > '.join(chrome_names.shorten_class(node.name) for node in cycle)


def _print_set_diff(before_set: Set[str], after_set: Set[str], label: str):
    all_added: List[str] = sorted(after_set - before_set)
    all_removed: List[str] = sorted(before_set - after_set)
    if not all_added and not all_removed:
        print(f'{label} - no changes')
        return

    print(f'{label} added (+) and removed (-):')
    for i, added in enumerate(all_added, start=1):
        print(f'+ [{i:4}] {added}')
    for i, removed in enumerate(all_removed, start=1):
        print(f'- [{i:4}] {removed}')


def _cycle_set(
    graph: graph.Graph, max_cycle_size: int
) -> Set[count_cycles.Cycle]:
    all_cycles_by_size = count_cycles.find_cycles(graph, max_cycle_size)
    return set(itertools.chain(*all_cycles_by_size))


def main():
    arg_parser = argparse.ArgumentParser(
        description='Given two JSON dependency graphs, output the differences '
        'between them. By default, outputs the differences in the sets of '
        'class and package nodes.'
    )
    required_arg_group = arg_parser.add_argument_group('required arguments')
    required_arg_group.add_argument(
        '-b',
        '--before',
        required=True,
        help='Path to the JSON file containing the "before" dependency graph. '
        'See the README on how to generate this file.',
    )
    required_arg_group.add_argument(
        '-a',
        '--after',
        required=True,
        help='Path to the JSON file containing the "after" dependency graph.',
    )
    arg_parser.add_argument(
        '-e',
        '--edges',
        action='store_true',
        help='Also diff the set of graph edges.',
    )
    arg_parser.add_argument(
        '--package-cycles',
        type=int,
        help='Also diff the set of package cycles up to the specified size.',
    )
    arg_parser.add_argument(
        '--build-target',
        type=str,
        help='Also diff the set of class nodes in the given build target, e.g. '
        '"//chrome/android:chrome_java"',
    )
    arguments = arg_parser.parse_args()

    class_graph_before, package_graph_before, _ = (
        serialization.load_class_and_package_graphs_from_file(arguments.before)
    )
    class_graph_after, package_graph_after, _ = (
        serialization.load_class_and_package_graphs_from_file(arguments.after)
    )
    _print_diff_num_nodes(
        class_graph_before, class_graph_after, 'Total Java class count'
    )
    _print_diff_num_nodes(
        package_graph_before, package_graph_after, 'Total Java package count'
    )

    print()
    _print_diff_node_list(class_graph_before, class_graph_after, 'Java classes')
    print()
    _print_diff_node_list(
        package_graph_before, package_graph_after, 'Java packages'
    )

    if arguments.edges:
        print()
        _print_diff_num_edges(
            class_graph_before, class_graph_after, 'Total Java class edge count'
        )
        _print_diff_num_edges(
            package_graph_before,
            package_graph_after,
            'Total Java package edge count',
        )

        print()
        _print_diff_edge_list(
            class_graph_before, class_graph_after, 'Java class edges'
        )
        print()
        _print_diff_edge_list(
            package_graph_before, package_graph_after, 'Java package edges'
        )

    if arguments.package_cycles:
        cycles_before = _cycle_set(
            package_graph_before, arguments.package_cycles
        )
        cycles_after = _cycle_set(package_graph_after, arguments.package_cycles)
        print()
        _print_diff_metric(
            len(cycles_before),
            len(cycles_after),
            'Total Java package cycle count (up to size '
            f'{arguments.package_cycles})',
        )

        print()
        _print_diff_cycle_list(
            cycles_before,
            cycles_after,
            f'Java package cycles (up to size {arguments.package_cycles})',
        )

    if arguments.build_target:

        def is_in_build_target(node):
            return arguments.build_target in node.build_targets

        print()
        _print_diff_node_list_filtered(
            class_graph_before,
            class_graph_after,
            f'Java classes in {arguments.build_target}',
            is_in_build_target,
        )


if __name__ == '__main__':
    main()