# Copyright lowRISC contributors (OpenTitan project).
# Licensed under the Apache License, Version 2.0, see LICENSE for details.
# SPDX-License-Identifier: Apache-2.0

"""Class describing synthesis configuration object."""

from pathlib import Path

import hjson
from tabulate import tabulate

from dvsim.flow.one_shot import OneShotCfg
from dvsim.logging import log
from dvsim.utils import print_msg_list, subst_wildcards


class SynCfg(OneShotCfg):
    """Derivative class for synthesis purposes."""

    flow = "syn"

    def __init__(self, flow_cfg_file, hjson_data, args, mk_config) -> None:
        super().__init__(flow_cfg_file, hjson_data, args, mk_config)
        # Set the title for synthesis results.
        self.results_title = self.name.upper() + " Synthesis Results"

    def gen_results_summary(self):
        """Gathers the aggregated results from all sub configs."""
        # Generate results table for runs.
        log.info("Create summary of synthesis results")

        results_str = "## " + self.results_title + " (Summary)\n\n"
        results_str += "### " + self.timestamp_long + "\n"
        if self.revision:
            results_str += "### " + self.revision + "\n"
        results_str += "### Branch: " + self.branch + "\n"
        results_str += "\n"

        self.results_summary_md = results_str + "\nNot supported yet.\n"

        # Return only the tables
        return self.results_summary_md

    def _gen_results(self, results):
        """The function is called after the regression has completed.

        It looks for a regr_results.hjson file with aggregated results from the
        synthesis run. The hjson needs to have the following (potentially
        empty) fields.

        results = {
            "tool": "dc",
            "top" : <name of toplevel>,

            "messages": {
                "flow_errors"      : [],
                "flow_warnings"    : [],
                "analyze_errors"   : [],
                "analyze_warnings" : [],
                "elab_errors"      : [],
                "elab_warnings"    : [],
                "compile_errors"   : [],
                "compile_warnings" : [],
            },

            "timing": {
                # per timing group (usually a clock domain)
                # in nano seconds
                <group>  : {
                    "tns"    : <value>,
                    "wns"    : <value>,
                    "period" : <value>,
                ...
                }
            },

            "area": {
                # gate equivalent of a NAND2 gate
                "ge"     : <value>,

                # summary report, in GE
                "comb"   : <value>,
                "buf"    : <value>,
                "reg"    : <value>,
                "macro"  : <value>,
                "total"  : <value>,

                # hierarchical report of first submodule level
                "instances" : {
                    <name> : {
                      "comb"  : <value>,
                      "buf"   : <value>,
                      "reg"   : <value>,
                      "macro" : <value>,
                      "total" : <value>,
                    },
                    ...
                },
            },

            "power": {
                "net"  : <value>,
                "int"  : <value>,
                "leak" : <value>,
            },

            "units": {
                "voltage"     : <value>,
                "capacitance" : <value>,
                "time"        : <value>,
                "dynamic"     : <value>,
                "static"      : <value>,
            }
        }

        note that if this is a primary config, the results will
        be generated using the _gen_results_summary function
        """

        def _create_entry(val, norm=1.0, total=None, perctag="%"):
            """Create normalized entry with an optional
            percentage appended in brackets.
            """
            if val is not None and norm is not None:
                if total is not None:
                    if total <= 0.0:
                        entry = "--"
                    else:
                        perc = float(val) / float(total) * 100.0
                        entry = f"{perc:2.1f} {perctag}"
                else:
                    value = float(val) / norm
                    entry = f"{value:2.2f}" if value < 1.0 else f"{value:2.1f}"

            else:
                entry = "--"

            return entry

        self.result = {}

        # Generate results table for runs.
        results_str = "## " + self.results_title + "\n\n"
        results_str += "### " + self.timestamp_long + "\n"
        if self.revision:
            results_str += "### " + self.revision + "\n"
        results_str += "### Branch: " + self.branch + "\n"
        results_str += "### Synthesis Tool: " + self.tool.upper() + "\n\n"

        # TODO: extend this to support multiple build modes
        for mode in self.build_modes:
            # results_str += "## Build Mode: " + mode.name + "\n\n"

            result_data = Path(
                subst_wildcards(self.build_dir, {"build_mode": mode.name}) + "/results.hjson",
            )
            log.info("looking for result data file at %s", result_data)

            try:
                with result_data.open() as results_file:
                    self.result = hjson.load(results_file, use_decimal=True)
            except OSError as err:
                log.warning("%s", err)
                self.result = {
                    "messages": {
                        "flow_errors": [f"IOError: {err}"],
                        "flow_warnings": None,
                        "analyze_errors": None,
                        "analyze_warnings": None,
                        "elab_errors": None,
                        "elab_warnings": None,
                        "compile_errors": None,
                        "compile_warnings": None,
                    },
                }

            # Message summary
            # results_str += "### Tool Message Summary\n\n"
            if "messages" in self.result:
                header = [
                    "Build Mode",
                    "Flow Warnings",
                    "Flow Errors",
                    "Analyze Warnings",
                    "Analyze Errors",
                    "Elab Warnings",
                    "Elab Errors",
                    "Compile Warnings",
                    "Compile Errors",
                ]
                colalign = ("left",) + ("center",) * (len(header) - 1)
                table = [header]

                msg_list = [
                    ("flow_warnings", " W "),
                    ("flow_errors", " E "),
                    ("analyze_warnings", " W "),
                    ("analyze_errors", " E "),
                    ("elab_warnings", " W "),
                    ("elab_errors", " E "),
                    ("compile_warnings", " W "),
                    ("compile_errors", " E "),
                ]

                msgs = [mode.name]
                for key, sev in msg_list:
                    if self.result["messages"][key] is None:
                        msgs.append("--")
                    else:
                        msgs.append(str(len(self.result["messages"][key])) + sev)

                table.append(msgs)

                if len(table) > 1:
                    results_str += (
                        tabulate(table, headers="firstrow", tablefmt="pipe", colalign=colalign)
                        + "\n\n"
                    )
                else:
                    results_str += "No messages found\n\n"
            else:
                results_str += "No messages found\n\n"

            # Hierarchical Area report
            results_str += "### Circuit Complexity in [kGE]\n\n"
            if "area" in self.result:
                header = [
                    "Instance",
                    "Comb ",
                    "Buf/Inv",
                    "Regs",
                    "Logic",
                    "Macros",
                    "Total",
                    "Logic [%]",
                    "Macro [%]",
                    "Total [%]",
                ]
                colalign = ("left",) + ("center",) * (len(header) - 1)
                table = [header]

                try:
                    kge = float(self.result["area"]["ge"]) * 1000.0

                    # go through submodules. this assumes that the top-level
                    # is listed before any other modules
                    totals = [0] * 3
                    for name in self.result["area"]["instances"]:
                        row = []
                        is_top = self.result["area"]["instances"][name]["depth"] == 0
                        row = ["**" + name + "**"] if is_top else [name]

                        for field in ["comb", "buf", "reg", "logic", "macro", "total"]:
                            entry = _create_entry(
                                self.result["area"]["instances"][name][field],
                                kge,
                            )
                            entry = "**" + entry + "**" if is_top else entry
                            row.append(entry)

                        for k, field in enumerate(["logic", "macro", "total"]):
                            if is_top:
                                row.append("**--**")
                                totals[k] = self.result["area"]["instances"][name][field]
                            else:
                                row.append(
                                    _create_entry(
                                        self.result["area"]["instances"][name][field],
                                        kge,
                                        totals[k],
                                        "%u",
                                    ),
                                )

                        table.append(row)

                except TypeError:
                    results_str += "Gate equivalent is not properly defined\n\n"

                if len(table) > 1:
                    results_str += (
                        tabulate(table, headers="firstrow", tablefmt="pipe", colalign=colalign)
                        + "\n\n"
                    )
                else:
                    results_str += "No area report found\n\n"
            else:
                results_str += "No area report found\n\n"

            # Timing report
            results_str += "### Timing in [ns]\n\n"
            if "timing" in self.result and "units" in self.result:
                header = ["Path Group", "Period", "WNS", "TNS"]
                colalign = ("left",) + ("center",) * (len(header) - 1)
                table = [header]

                for clock in self.result["timing"]:
                    row = [clock]
                    row += [
                        _create_entry(
                            self.result["timing"][clock]["period"],
                            1.0e-09 / float(self.result["units"]["time"]),
                        ),
                        _create_entry(
                            self.result["timing"][clock]["wns"],
                            1.0e-09 / float(self.result["units"]["time"]),
                        )
                        + " EN",
                        _create_entry(
                            self.result["timing"][clock]["tns"],
                            1.0e-09 / float(self.result["units"]["time"]),
                        )
                        + " EN",
                    ]
                    table.append(row)

                if len(table) > 1:
                    results_str += (
                        tabulate(table, headers="firstrow", tablefmt="pipe", colalign=colalign)
                        + "\n\n"
                    )
                else:
                    results_str += "No timing report found\n\n"
            else:
                results_str += "No timing report found\n\n"

            # Power report
            results_str += "### Power Estimates in [mW]\n\n"
            if "power" in self.result and "units" in self.result:
                header = ["Network", "Internal", "Leakage", "Total"]
                colalign = ("center",) * len(header)
                table = [header]

                try:
                    self.result["power"]["net"]

                    power = [
                        float(self.result["power"]["net"]) * float(self.result["units"]["dynamic"]),
                        float(self.result["power"]["int"]) * float(self.result["units"]["dynamic"]),
                        float(self.result["power"]["leak"]) * float(self.result["units"]["static"]),
                    ]

                    total_power = sum(power)

                    row = [
                        _create_entry(power[0], 1.0e-3)
                        + " / "
                        + _create_entry(power[0], 1.0e-3, total_power),
                        _create_entry(power[1], 1.0e-3)
                        + " / "
                        + _create_entry(power[1], 1.0e-3, total_power),
                        _create_entry(power[2], 1.0e-3)
                        + " / "
                        + _create_entry(power[2], 1.0e-3, total_power),
                        _create_entry(total_power, 1.0e-3),
                    ]

                    table.append(row)
                # in case fp values are NoneType
                except TypeError:
                    results_str += "No power report found\n\n"

                if len(table) > 1:
                    results_str += (
                        tabulate(table, headers="firstrow", tablefmt="pipe", colalign=colalign)
                        + "\n\n"
                    )
            else:
                results_str += "No power report found\n\n"

            # Append detailed messages if they exist
            # Note that these messages are omitted in publication mode
            hdr_key_pairs = [
                ("Flow Warnings", "flow_warnings", False),
                ("Flow Errors", "flow_errors", True),
                ("Analyze Warnings", "analyze_warnings", False),
                ("Analyze Errors", "analyze_errors", True),
                ("Elab Warnings", "elab_warnings", False),
                ("Elab Errors", "elab_errors", True),
                ("Compile Warnings", "compile_warnings", False),
                ("Compile Errors", "compile_errors", True),
            ]

            # helper function
            def _getlen(x):
                return len(x) if x is not None else 0

            # Synthesis fails if any error messages have occurred
            self.errors_seen = 0
            msgs_seen = 0
            fail_msgs = ""
            for _, key, fail in hdr_key_pairs:
                if key in self.result["messages"]:
                    num_msgs = _getlen(self.result["messages"][key])
                    msgs_seen += num_msgs
                    self.errors_seen += num_msgs if fail else 0

            if msgs_seen > 0:
                fail_msgs += "\n### Errors and Warnings for Build Mode `'" + mode.name + "'`\n"
                for hdr, key, _ in hdr_key_pairs:
                    msgs = self.result["messages"].get(key)
                    fail_msgs += print_msg_list("#### " + hdr, msgs, self.max_msg_count)

            # Th published report will default to self.results_md if they are
            # empty. In case it needs need to be sanitized, override it and do
            # not append detailed messages.
            if self.sanitize_publish_results:
                self.publish_results_md = results_str

            # locally generated result always contains all details
            self.results_md = results_str + fail_msgs

            # TODO: add support for pie / bar charts for area splits and
            # QoR history

        return self.results_md
