# Copyright (c) Qualcomm Technologies, Inc. and/or its subsidiaries.
# SPDX-License-Identifier: Apache-2.0

'''
Process a build folder and generate a comprehensive HTML dashboard
including memory use, Kconfig values, devicetree browser, sys-init
ordering, and other general details.

Data sources
============

The following build artifacts (read from <build_dir>/zephyr/ unless noted)
are used by this script:

  <build_dir>/build_info.yml
      Build metadata produced by CMake: application source path, board
      name, west build command, and workspace top directory.

  <zephyr_base>/VERSION
      Zephyr source version (major, minor, patchlevel, extraversion).

  <build_dir>/CMakeFiles/*/CMakeCCompiler.cmake
      CMake compiler description file, parsed to extract the toolchain
      name and version string.

  zephyr/<kernel>.elf
      ELF image of the built kernel. Used by pyelftools to compute the
      memory summary (text/rodata/rwdata/bss section sizes), to check
      sys-init ordering via check_init_priorities, and by the
      scripts/footprint/size_report script to generate memory reports.

  zephyr/<kernel>.bin
      Binary image.  Only its file size is read, reported as "Bin Size"
      on the build summary page.

  zephyr/.config-trace.pickle
      Pickled output of the traceconfig script.  Contains the list of
      Kconfig symbols that were evaluated during the build, together
      with their values and source locations, used to populate the
      Kconfig browser tab.

  zephyr/edt.pickle
      Pickled edtlib.EDT object representing the fully resolved
      devicetree for the build.  Used in two ways:

      1. General devicetree browser — the full DT node tree is rendered
         as a searchable, expandable view in the Devicetree tab.

      2. Per-region memory reports — all nodes whose "compatible"
         includes "zephyr,memory-region" and whose status is "okay" are
         enumerated.  For each such node the "zephyr,memory-region"
         property provides the region name and the first "reg" entry
         provides its base address and size.  If the ELF contains at
         least one allocated section that overlaps the region's address
         range, a report is created and shown as an additional tab in the
         Memory Report view.

  zephyr/zephyr.dts
      Raw DTS source file, syntax-highlighted with Pygments and
      displayed verbatim in the Devicetree tab.
'''

import argparse
import contextlib
import glob
import html
import io
import json
import logging
import os
import pickle
import re
import shutil
import subprocess
import sys
import webbrowser
from datetime import datetime
from functools import partial
from http.server import HTTPServer, SimpleHTTPRequestHandler
from pathlib import Path

import jinja2
import yaml
from elftools.elf.constants import SH_FLAGS
from elftools.elf.elffile import ELFFile
from pygments import highlight
from pygments.formatters import HtmlFormatter  # pylint: disable=E0611
from pygments.lexers import DevicetreeLexer  # pylint: disable=E0611
from pygments.styles import get_style_by_name

sys.path.append(str(Path(__file__).parents[1] / "build"))
from check_init_priorities import Validator

sys.path.append(str(Path(__file__).parents[1] / "dts" / "python-devicetree" / "src" / "devicetree"))
from dtlib import DT

sys.path.append(str(Path(__file__).parents[1] / "footprint"))
try:
    from plot import generate_figure
    from plotly.offline.offline import get_plotlyjs
except ImportError:
    generate_figure = None

logger = logging.getLogger('dashboard')

# Online path to the kconfig browser.
KCONFIG_BROWSER = 'https://docs.zephyrproject.org/latest/kconfig.html'

# Set to match the CSS used in the HTML as it is set via CSS variable
# that we cannot access from Python script.
CSS_BS_TABLE_BG = '#f8f9fa'

# Height of the memory report plot.
MEMORY_PLOT_HEIGHT = 600

# Constants for converting from bytes to human-friendly sizes.
MEMORY_UNIT_SIZES = {
    1073741824: 'GB',
    1048576: 'MB',
    1024: 'KB',
    1: 'Bytes',
}


def display_size(byte_cnt):
    '''
    Display a number of bytes in human-readable form with a size indicator.
    '''

    if byte_cnt in [None, '']:
        return ''

    compressed_bytes = byte_cnt
    unit = 'Bytes'
    for unit_size, unit_str in MEMORY_UNIT_SIZES.items():
        if abs(byte_cnt) >= unit_size:
            compressed_bytes = float(byte_cnt) / unit_size
            unit = unit_str
            break

    return f"{compressed_bytes:.1f} {unit}".replace('.0', '')


def elf_memory_summary(elf_file):
    '''
    Get a summary of memory use from the given ELF file.

    This function will parse the given elf file and determine the total memory
    used by read-only, read-write, and executable regions.

    :param elf_file: Path to an elf file.
    :return: A dictionary with keys "bss", "rwdata", "rodata", "text", "other"
    '''

    report = {'bss': 0, 'rodata': 0, 'rwdata': 0, 'text': 0, 'other': 0}

    with ELFFile.load_from_path(elf_file) as elf:
        for section in elf.iter_sections():
            flags = section.header['sh_flags']
            size = section.header['sh_size']
            sh_type = section.header['sh_type']

            if sh_type == 'SHT_NOBITS':
                report['bss'] += size
            elif sh_type == 'SHT_PROGBITS':
                if flags & SH_FLAGS.SHF_EXECINSTR:
                    report['text'] += size
                elif flags & SH_FLAGS.SHF_WRITE:
                    report['rwdata'] += size
                elif flags & SH_FLAGS.SHF_ALLOC:
                    report['rodata'] += size
                else:
                    report['other'] += size
            else:
                report['other'] += size

    return report


class ZephyrVersion:
    '''
    Class representing the version of Zephyr kernel. See
    https://docs.zephyrproject.org/latest/project/release_process.html
    for what the fields represent.
    Data is loaded from the VERSION file in the Zephyr base.
    '''

    FIELDS = ['version_major', 'version_minor', 'patchlevel', 'version_tweak', 'extraversion']

    def __init__(self, zephyr_base):
        self.version_major = None
        self.version_minor = None
        self.patchlevel = None
        self.version_tweak = None
        self.extraversion = None

        version_file = zephyr_base / 'VERSION'

        try:
            with open(version_file, encoding='utf-8') as f:
                version_data = f.readlines()
        except OSError as e:
            logger.error(f"Unable to read version information from {version_file}: {e}")
            return

        for version_line in version_data:
            field, value = version_line.split('=')
            field = field.strip().lower()
            value = value.strip()
            if field in ZephyrVersion.FIELDS:
                setattr(self, field, value)

    def __str__(self):
        version = f"{self.version_major}.{self.version_minor}"
        if self.patchlevel and self.patchlevel != '0':
            version += f'.{self.patchlevel}'
        if self.extraversion and self.extraversion != '0':
            version += f'-{self.extraversion}'
        if self.version_tweak and self.version_tweak != '0':
            version += f'+{self.version_tweak}'
        return version


class ZephyrToolchain:
    '''
    Container for the Zephyr toolchain information.
    Extracted from the CMakeCCompiler.cmake file.
    '''

    def __init__(self, build_path):
        self.cmake_c_compiler_id = None
        self.cmake_c_compiler_version = None

        cmake_glob = build_path / 'CMakeFiles' / '*' / 'CMakeCCompiler.cmake'
        cmake_file = glob.glob(str(cmake_glob))
        if cmake_file:
            cmake_file = cmake_file[0]
        else:
            return

        try:
            with open(cmake_file, encoding='utf-8') as f:
                lines = f.readlines()
        except OSError as e:
            logger.error(f"Unable to load CMakeCCompiler.cmake file {cmake_file}: {e}")
            return

        cmake_c_compiler_id_re = re.compile(r'\s*set\(CMAKE_C_COMPILER_ID\s+"(.*)"\)')
        cmake_c_compiler_version_re = re.compile(r'\s*set\(CMAKE_C_COMPILER_VERSION\s+"(.*)"\)')

        for line in lines:
            if match := cmake_c_compiler_id_re.match(line):
                self.cmake_c_compiler_id = match.group(1)
            if match := cmake_c_compiler_version_re.match(line):
                self.cmake_c_compiler_version = match.group(1)
            if self.cmake_c_compiler_id and self.cmake_c_compiler_version:
                break

    def __str__(self):
        return f"{self.cmake_c_compiler_id} {self.cmake_c_compiler_version}"


class KconfigSymbol:
    '''
    Class representing a KconfigSymbol and its value in a given build.
    '''

    def __init__(self, name, visible, sym_type, value, src, loc, build):
        self.sym_type = sym_type
        self.visible = bool(visible == 'y')
        self.name = name
        self.value = value
        if sym_type == "string" and self.value is not None:
            self.value = f'"{self.value}"'
        self.src = src
        self.loc = loc
        self.build = build

    def loc_html(self):
        '''
        Return an HTML representation of the symbol location.
        '''
        if self.loc and self.src in ['default', 'assign']:
            fn = os.path.relpath(self.loc[0], self.build.zephyr_base)
            disp_fn = os.path.normpath(fn).replace("../", "")
            sym_loc = f'{disp_fn}:{self.loc[1]}'
        elif self.loc and self.src in ['select', 'imply']:
            if len(self.loc) > 1:
                sym_loc = " || ".join(f"({html.escape(loc)})" for loc in self.loc)
            else:
                sym_loc = html.escape(self.loc[0])
            sym_loc = f"<code>{sym_loc}</code>"
        elif self.loc is None and self.src == "default":
            sym_loc = "<i>(implicit)</i>"
        else:
            sym_loc = ''
        return sym_loc

    def src_html(self):
        '''
        Return an HTML representation of the symbol source tag.
        '''
        if self.src == "unset":
            return ''
        if self.src == "default":
            return '<span class="badge bg-secondary">default</span>'
        if self.src == "assign":
            return '<span class="badge bg-primary">assigned</span>'
        if self.src == "select":
            return '<span class="badge bg-info">selected</span>'
        if self.src == "imply":
            return '<span class="badge bg-warning">implied</span>'
        return self.src


def _build_memory_report_tree(report):
    '''
    Convert a size_report JSON dict into the tree structure expected by the
    JS tree widget.

    Returns a dict with keys "size" (total bytes) and "tree" (list of nodes).
    Each node has "expanded", "data" (name/size/displaySize/memoryType), and
    optionally "children".
    '''

    def create_node(symbol, expanded=False):
        size = symbol['size']
        return (
            {
                "expanded": expanded,
                "data": {
                    "name": symbol['name'],
                    "size": size,
                    "displaySize": display_size(size),
                    "memoryType": [loc.upper() for loc in symbol.get('loc', [])],
                },
            }
            if size
            else None
        )

    def add_children(node, children):
        if not children:
            return
        node['children'] = []
        for symbol in sorted(children, key=lambda c: c['name']):
            child_node = create_node(symbol)
            if not child_node:
                continue
            node['children'].append(child_node)
            add_children(child_node, symbol.get('children'))

    tree = {}
    symbol = report.get('symbols')
    if symbol:
        tree['size'] = symbol['size']
        tree['tree'] = []
        node = create_node(symbol, expanded=True)
        tree['tree'].append(node)
        add_children(node, symbol.get('children'))
    return tree


class ZephyrDashboard:
    '''
    Class for collecting and processing Zephyr build artifacts to create the
    HTML dashboard.
    '''

    def __init__(
        self,
        zephyr_base,
        build_path,
        output_path,
        kernel_bin_name="zephyr",
        skip_memory_report=False,
    ):
        self.zephyr_base = Path(zephyr_base)
        self.kernel_bin_name = kernel_bin_name
        self.build_path = Path(build_path) if build_path else self.zephyr_base / "build"
        self.output_path = Path(output_path) if output_path else self.build_path / "dashboard"

        self.elf_file = self.build_path / "zephyr" / f"{self.kernel_bin_name}.elf"
        self.dts_file = self.build_path / "zephyr" / "zephyr.dts"
        self.kconfig_file = self.build_path / "zephyr" / ".config"

        # Read details from the build_info.yml file.
        with open(self.build_path / "build_info.yml", encoding='utf-8') as fd:
            self.build_info = yaml.safe_load(fd)
        try:
            self.application = self.build_info['cmake']['application']['source-dir']
            base_prefix = '^' + str(self.zephyr_base.absolute()).replace('\\', '/') + '/'
            self.application = re.sub(base_prefix, '', self.application)
        except KeyError:
            self.application = None
        try:
            self.board = self.build_info['cmake']['board']['name']
        except KeyError:
            self.board = None
        try:
            self.command = self.build_info['west']['command']
            self.command = re.sub(r'\S*west', 'west', self.command)
        except KeyError:
            self.command = None
        try:
            self.topdir = Path(self.build_info['west']['topdir'])
        except KeyError:
            self.topdir = self.zephyr_base

        # Get some details on the build binary file - may not exist in all
        # builds (like QEMU).
        try:
            bin_file = self.build_path / "zephyr" / f"{self.kernel_bin_name}.bin"
            bin_stats = bin_file.stat()
            self.bin_size_str = display_size(bin_stats.st_size)
        except OSError:
            self.bin_size_str = None

        # Get some details on the build ELF file.
        elf_stats = self.elf_file.stat()
        self.elf_date_str = datetime.fromtimestamp(elf_stats.st_mtime).strftime("%Y-%m-%d %H:%M:%S")
        self.elf_size_str = display_size(elf_stats.st_size)

        self.toolchain = ZephyrToolchain(self.build_path)
        self.zephyr_version = ZephyrVersion(self.zephyr_base)

        self._init_kconfigs()
        self._init_sysinit()

        self.memory_summary = elf_memory_summary(self.elf_file)

        # Create the memory reports if they are stale.
        self.skip_memory_report = skip_memory_report
        self.memory_regions = []
        if not self.skip_memory_report:
            memory_report = self.output_path / "all_report.json"
            if not os.path.isfile(memory_report) or os.path.getmtime(
                memory_report
            ) < os.path.getmtime(self.elf_file):
                self._create_memory_reports()

    def _init_sysinit(self):
        '''
        Get the sys-init levels and validate against DT dependencies.
        '''
        validator_log = io.StringIO()
        stream_handler = logging.StreamHandler(validator_log)
        stream_handler.setFormatter(logging.Formatter("%(levelname)s: %(message)s"))

        validator_logger = logging.getLogger('check_init_priorities')
        validator_logger.propagate = False
        validator_logger.addHandler(stream_handler)
        validator_logger.setLevel(logging.WARNING)

        with open(self.elf_file, 'rb') as fd:
            validator = Validator(self.elf_file, 'edt.pickle', validator_logger, fd)
            validator.check_edt()

        self.sys_init_errors = validator_log.getvalue().splitlines()
        self.sys_init_levels = validator.initlevels

    def _init_kconfigs(self):
        '''
        Load the kconfig trace information from the pickled data file and convert
        to a list of KconfigSymbol objects.
        '''
        pickle_path = self.build_path / "zephyr" / ".config-trace.pickle"
        with open(pickle_path, 'rb') as f:
            trace_data = pickle.load(f)
        self.kconfigs = [KconfigSymbol(*sym, build=self) for sym in trace_data]
        self.kconfigs.sort(key=lambda kc: kc.name)

    def _get_dt_memory_regions(self):
        '''
        Return a list of DT memory regions from edt.pickle.

        Each entry is a dict with "name" (str), "addr" (int), "size" (int).
        Only nodes with compatible "zephyr,memory-region", status "okay", a
        valid "zephyr,memory-region" name property, and at least one reg are
        included.
        '''
        edt_pickle_path = self.build_path / "zephyr" / "edt.pickle"
        with open(edt_pickle_path, "rb") as f:
            edt = pickle.load(f)

        regions = []
        for node in edt.compat2nodes.get("zephyr,memory-region", []):
            if node.status != "okay":
                continue
            name_prop = node.props.get("zephyr,memory-region")
            if not name_prop:
                continue
            name = name_prop.val
            if not node.regs:
                continue
            reg = node.regs[0]
            if reg.addr is None or reg.size is None:
                continue
            regions.append({"name": name, "addr": reg.addr, "size": reg.size, "path": node.path})
        return regions

    def _has_sections_in_range(self, addr, size):
        '''
        Return True if the ELF contains any allocated, non-empty section
        whose address range overlaps [addr, addr+size).
        '''
        end = addr + size
        with ELFFile.load_from_path(self.elf_file) as elf:
            for section in elf.iter_sections():
                if section["sh_size"] == 0:
                    continue
                if section["sh_flags"] & SH_FLAGS.SHF_ALLOC == 0:
                    continue
                sec_start = section["sh_addr"]
                sec_end = sec_start + section["sh_size"]
                if sec_start < end and sec_end > addr:
                    return True
        return False

    def _create_memory_reports(self):
        '''
        Use the footprint size_report tool to create the ram/rom/all JSON data.
        '''
        logger.info("Creating memory reports (may take a few minutes).")

        # Create the output location for the report files.
        self.output_path.mkdir(parents=True, exist_ok=True)

        cmd = [
            sys.executable,
            str(self.zephyr_base / "scripts" / "footprint" / "size_report"),
            '-k',
            str(self.elf_file),
            '-z',
            str(self.zephyr_base.absolute()),
            f'--workspace={self.topdir}',
            '--json',
            str(self.output_path / '{target}_report.json'),
            '--quiet',
            '--output',
            '.',
            'rom',
            'ram',
            'all',
        ]

        logger.debug(' '.join(cmd))
        try:
            subprocess.check_call(cmd)
        except subprocess.CalledProcessError as e:
            logger.error(
                f"Failed generating memory size report (exit code {e.returncode}). "
                + f"Command:\n{' '.join(e.cmd)}"
            )

        # Generate per-region reports for non-empty DT memory regions.
        try:
            regions = self._get_dt_memory_regions()
        except Exception as e:
            logger.warning(f"Could not load DT memory regions: {e}")
            regions = []

        for region in regions:
            if not self._has_sections_in_range(region["addr"], region["size"]):
                continue

            region_cmd = [
                sys.executable,
                str(self.zephyr_base / "scripts" / "footprint" / "size_report"),
                '-k',
                str(self.elf_file),
                '-z',
                str(self.zephyr_base.absolute()),
                f'--workspace={self.topdir}',
                '--json',
                str(self.output_path / f"{region['name']}_report.json"),
                '--filter-address-range',
                str(region["addr"]),
                str(region["size"]),
                '--quiet',
                '--output',
                '.',
                'all',
            ]
            logger.debug(' '.join(region_cmd))
            try:
                subprocess.check_call(region_cmd)
                self.memory_regions.append(region)
            except subprocess.CalledProcessError as e:
                logger.error(
                    f"Failed generating memory region report for {region['name']} "
                    f"(exit code {e.returncode}). Command:\n{' '.join(e.cmd)}"
                )

    def _load_memory_report(self, mem_type):
        '''
        Load the memory report of the given type from an existing json file.

        :param type: Which report, "ram", "rom", or "all"
        :return: Dictionary of the loaded memory report.
        '''
        fname = self.output_path / f"{mem_type}_report.json"
        if not os.path.isfile(fname):
            logger.error(f'Memory report file "{fname}" not found.')
            return None

        with open(fname, encoding="utf-8") as fd:
            return json.load(fd)

    def _symbols_by_size(self, report, limit=None):
        '''
        Sort the symbols from a memory report by their size.

        :param report: A memory report as created by the Zephyr size_report script.
        :param limit: How many results to return.

        :return: A list of all the symbols with the largest first.
        '''

        if not report:
            return []

        symbol_list = []

        def flatten(symbols, lst):
            for symbol in symbols:
                children = symbol.get('children')
                if children:
                    flatten(children, lst)
                elif symbol['name'][0] != '(':
                    lst.append(symbol)

        flatten(report['symbols']['children'], symbol_list)

        symbol_list = sorted(symbol_list, key=lambda s: s['size'], reverse=True)

        if limit:
            symbol_list = symbol_list[0:limit]

        return symbol_list

    def _memory_report_template_context(self, mem_type, ctxt):
        '''
        Add the HTML template context for the memory report of the given type.
        '''

        report = self._load_memory_report(mem_type)

        if report:
            tree = _build_memory_report_tree(report)
            ctxt[f'{mem_type}_report'] = json.dumps(tree)
            ctxt[f'{mem_type}_report_size'] = tree['size']

            if generate_figure:
                figure = generate_figure(report)
                figure.update_layout(paper_bgcolor=CSS_BS_TABLE_BG, height=MEMORY_PLOT_HEIGHT)
                ctxt[f'{mem_type}_plot'] = figure.to_html(full_html=False, include_plotlyjs=False)
            else:
                ctxt[f'{mem_type}_plot'] = None
        else:
            ctxt[f'{mem_type}_report'] = None
            ctxt[f'{mem_type}_plot'] = None

        if mem_type == 'all':
            ctxt['top_ten'] = self._symbols_by_size(report, 10)

    def _region_reports_template_context(self, ctxt):
        '''
        Add the HTML template context for per-region memory reports.

        Populates ctxt["memory_regions"] with a list of dicts, one per
        non-empty DT memory region, each containing:
          name       - region name (e.g. "ITCM")
          tab_id     - sanitized lowercase id safe for use in HTML attributes
          report     - JSON-encoded tree data for the JS tree widget
          report_size - total size in bytes (for percentage display)
        '''

        region_ctxt_list = []
        for region in self.memory_regions:
            name = region['name']
            tab_id = re.sub(r'[^a-zA-Z0-9]', '_', name).lower()
            fname = self.output_path / f"{name}_report.json"
            if not os.path.isfile(fname):
                logger.warning(f'Region report file "{fname}" not found.')
                continue
            with open(fname, encoding="utf-8") as fd:
                report = json.load(fd)
            if not report:
                continue
            tree = _build_memory_report_tree(report)
            if generate_figure:
                # When doing a memory-region report, the total size of the children
                # may exceed the region size by a few bytes due to how the linker
                # deals with alignment padding at a section boundary. plotly
                # barfs if they do not match, so force them to be the same.
                saved_size = report['symbols']['size']
                report['symbols']['size'] = sum(
                    node['size'] for node in report['symbols']['children']
                )
                figure = generate_figure(report)
                figure.update_layout(paper_bgcolor=CSS_BS_TABLE_BG, height=MEMORY_PLOT_HEIGHT)
                plot = figure.to_html(full_html=False, include_plotlyjs=False)
                report['symbols']['size'] = saved_size
            else:
                plot = None
            region_ctxt_list.append(
                {
                    'name': name,
                    'tab_id': tab_id,
                    'path': region['path'],
                    'region_size': region['size'],
                    'report': json.dumps(tree),
                    'report_size': tree.get('size', 0),
                    'plot': plot,
                }
            )

        ctxt['memory_regions'] = region_ctxt_list

    def _safe_relpath(self, filename):
        '''
        Returns a relative path to the file from the top dir, or
        the absolute path if a relative path cannot be established
        (on Windows with files in different drives, for example).
        '''
        try:
            return os.path.relpath(filename, start=self.topdir)
        except ValueError:
            return filename

    def _edt_fancytree(self):
        '''
        Create the Fancytree data object for the EDT tree.
        '''

        edt_pickle_path = self.build_path / "zephyr" / 'edt.pickle'
        with open(edt_pickle_path, "rb") as f:
            edt = pickle.load(f)

        # Load the same DTS file into a dtlib object so we can iterate over
        # all properties (not just ones that edtlib tracks).
        dt = DT(edt.dts_path, base_dir=self.topdir)

        label2path = {}

        def create_tree_node(dt_node, expanded=False):
            edt_node = edt.get_node(dt_node.path)
            if edt_node and edt_node.binding_path:
                binding_path = self._safe_relpath(edt_node.binding_path)
            else:
                binding_path = ""

            return {
                "id": dt_node.path,
                "expanded": expanded,
                "edtNode": {
                    "isProperty": False,
                    "name": dt_node.name,
                    "labels": dt_node.labels,
                    "filename": self._safe_relpath(dt_node.filename),
                    "lineno": dt_node.lineno,
                    "description": edt_node.description if edt_node else "",
                    "bindingPath": binding_path,
                },
            }

        def create_prop_tree_node(dt_prop, edt_prop):
            # Extract the original text value from the string conversion of the
            # property. No other way to get it from this object. Also remove
            # the trailing semi-colon and extra spaces around <>.
            value = re.sub('^.*= ', '', str(dt_prop))[:-1].replace('< ', '<').replace(' >', '>')

            # Find all the label references and create a look-up table to the node path.
            # This will be used on the render side to create links.
            for m in re.finditer(r'&(\w+)', value):
                try:
                    label2path[m.group(1)] = dt.label2node[m.group(1)].path
                except KeyError:
                    continue

            return {
                "id": dt_prop.node.path + f':{dt_prop.name}',
                "edtNode": {
                    "isProperty": True,
                    "name": dt_prop.name,
                    "value": value,
                    "filename": self._safe_relpath(dt_prop.filename),
                    "lineno": dt_prop.lineno,
                    "description": edt_prop.description if edt_prop else "",
                    "typeSpec": edt_prop.type if edt_prop else "",
                    "bindingPath": "",
                },
            }

        def add_children(tree_node, parent):
            tree_node['children'] = []

            edt_node = edt.get_node(parent.path)

            for name, dt_prop in parent.props.items():
                prop_node = create_prop_tree_node(dt_prop, edt_node.props.get(name))
                tree_node['children'].append(prop_node)

            for _, dt_node in parent.nodes.items():
                child_tree_node = create_tree_node(dt_node)
                tree_node['children'].append(child_tree_node)
                add_children(child_tree_node, dt_node)

        tree = {'tree': [], 'label2path': label2path}
        tree_node = create_tree_node(dt.root, expanded=True)
        tree['tree'].append(tree_node)
        add_children(tree_node, dt.root)

        return tree

    def create_html(self):
        '''
        Generate all the HTML output.
        '''

        templates_path = Path(__file__).parents[0] / "templates"
        template_loader = jinja2.FileSystemLoader(searchpath=str(templates_path))
        env = jinja2.Environment(
            loader=template_loader, autoescape=True, trim_blocks=True, lstrip_blocks=True
        )
        env.filters['display_size'] = display_size

        # Create the output directory tree.
        self.output_path.mkdir(parents=True, exist_ok=True)

        # Copy the static tree from the dashboard location as well as
        # doc/_static for the logo images.
        rpt_static = self.output_path / "static"
        doc_static = self.zephyr_base / "doc" / "_static"
        shutil.copytree(Path(__file__).parent.resolve() / 'static', rpt_static, dirs_exist_ok=True)
        img_dir = rpt_static / "img"
        img_dir.mkdir(exist_ok=True)
        shutil.copy2(doc_static / "images" / "logo.svg", rpt_static / "img")
        shutil.copy2(doc_static / "images" / "favicon.png", rpt_static / "img")
        shutil.copy2(doc_static / "css" / "light.css", rpt_static / "css")

        # Create the pygments CSS file.
        pygments_style = get_style_by_name('default')
        pygments_formatter = HtmlFormatter(style=pygments_style)
        pygments_css = pygments_formatter.get_style_defs('.highlight')
        with open(rpt_static / "css" / "pygments.css", 'w', encoding="utf-8") as fd:
            fd.write(pygments_css)

        # Create the plotly.js file if plotly was found.
        if generate_figure:
            with open(rpt_static / "js" / "plotly.js", 'w', encoding="utf-8") as fd:
                fd.write(get_plotlyjs())

        # ---------------------------------
        # HTML: index.html
        # ---------------------------------

        template = env.get_template("index.html")
        context = {'build': self, 'title': 'Build Summary', 'current': 'home'}
        fname = self.output_path / "index.html"
        logger.info(f"Creating {fname}")
        with open(fname, 'w', encoding="utf-8") as fd:
            fd.write(template.render(**context))

        # ---------------------------------
        # HTML: kconfig.html
        # ---------------------------------

        template = env.get_template("kconfig.html")
        context = {
            'build': self,
            'title': 'Kconfig',
            'current': 'kconfig',
            'kconfig_browser': KCONFIG_BROWSER,
        }
        fname = os.path.join(self.output_path, 'kconfig.html')
        logger.debug(f"Creating {fname}")
        with open(fname, 'w', encoding="utf-8") as fd:
            fd.write(template.render(**context))

        # ---------------------------------
        # HTML: sysinit.html
        # ---------------------------------

        template = env.get_template("sysinit.html")
        context = {'build': self, 'title': 'Sys Init', 'current': 'sysinit'}
        fname = os.path.join(self.output_path, 'sysinit.html')
        logger.debug(f"Creating {fname}")
        with open(fname, 'w', encoding="utf-8") as fd:
            fd.write(template.render(**context))

        # ---------------------------------
        # HTML: dts.html
        # ---------------------------------

        try:
            with open(self.dts_file, encoding="utf-8") as fd:
                dts_contents = fd.read()
        except OSError as e:
            logger.warning(f'Unable to load device tree file at {self.dts_file}: {e}')
            dts_contents = None

        if dts_contents:
            dts_contents = highlight(dts_contents, DevicetreeLexer(), pygments_formatter)

        edt_tree = self._edt_fancytree()

        template = env.get_template("dts.html")
        context = {
            'build': self,
            'title': 'Device Tree',
            'current': 'dts',
            'file_contents': dts_contents,
            'file_path': self.dts_file.absolute(),
            'edt_tree': json.dumps(edt_tree),
        }
        fname = self.output_path / "dts.html"
        logger.debug(f"Creating {fname}")
        with open(fname, 'w', encoding='utf-8') as fd:
            fd.write(template.render(**context))

        # ---------------------------------
        # HTML: memoryreport.html
        # ---------------------------------

        if not self.skip_memory_report:
            template = env.get_template("memoryreport.html")
            context = {
                'build': self,
                'title': 'Memory Report',
                'current': 'memory',
                'include_plotly_js': bool(generate_figure),
            }
            self._memory_report_template_context('all', context)
            self._memory_report_template_context('ram', context)
            self._memory_report_template_context('rom', context)
            self._region_reports_template_context(context)
            fname = self.output_path / 'memoryreport.html'
            logger.debug(f"Creating {fname}")
            with open(fname, 'w', encoding="utf-8") as fd:
                fd.write(template.render(**context))

        # ---------------------------------
        # HTML: elfstats.html
        # ---------------------------------

        fname = self.build_path / "zephyr" / f"{self.kernel_bin_name}.stat"
        try:
            with open(fname, encoding="utf-8") as fd:
                file_contents = fd.read()
        except OSError as e:
            logger.warning(f'Unable to load zephyr elf stat file at {fname}: {e}')
            file_contents = ''

        template = env.get_template("textviewer.html")
        context = {
            'build': self,
            'title': 'ELF Stats',
            'current': 'elfstats',
            'file_contents': file_contents,
            'file_path': fname.absolute(),
        }
        fname = self.output_path / "elfstats.html"
        logger.debug(f"Creating {fname}")
        with open(fname, 'w', encoding='utf-8') as fd:
            fd.write(template.render(**context))

    def clean_up(self):
        '''
        Clean-up any temporary files.
        '''
        for mem_type in ['ram', 'rom', 'all']:
            fname = self.output_path / f"{mem_type}_report.json"
            fname.unlink(missing_ok=True)
        for region in self.memory_regions:
            fname = self.output_path / f"{region['name']}_report.json"
            fname.unlink(missing_ok=True)

    def open_browser(self):
        '''
        Open the default web browser to the index page of the dashboard.

        Uses a one-shot HTTP server so that the browser loads from
        http://localhost, which works reliably across most platforms.
        '''

        handler = partial(SimpleHTTPRequestHandler, directory=str(self.output_path))
        server = HTTPServer(("127.0.0.1", 0), handler)
        url = f"http://127.0.0.1:{server.server_port}/index.html"
        logger.info("Serving dashboard at %s (Ctrl+C to stop)", url)
        webbrowser.open(url)
        with contextlib.suppress(KeyboardInterrupt):
            server.serve_forever()


def parse_args():
    """
    Parse command line arguments.
    """

    parser = argparse.ArgumentParser(allow_abbrev=False)

    parser.add_argument("build", help="Build directory", nargs='?', default="build")
    parser.add_argument("--output", help="Output directory for index.html")
    parser.add_argument("--zephyr-base", default=".", help="Zephyr base directory")
    parser.add_argument("--kernel-bin-name", default="zephyr", help="Kernel binary name")
    parser.add_argument(
        "--skip-memory-report",
        action="store_true",
        help="Skip the memory report to generate faster",
    )
    parser.add_argument(
        "--no-clean", action="store_true", help="Do not remove temporary memory map json data"
    )
    parser.add_argument(
        "-v", "--verbose", action="store_true", help="Print extra debugging information"
    )
    parser.add_argument("-q", "--quiet", action="store_true", help="Print nothing to the console.")
    parser.add_argument(
        "--open", action="store_true", help="Open the default web browser to the dashboard."
    )
    return parser.parse_args()


def main():
    '''
    Main function when invoked from the command-line.
    '''

    args = parse_args()

    if args.verbose:
        logging.basicConfig(level=logging.DEBUG)
        logger.setLevel(logging.DEBUG)
    elif not args.quiet:
        logging.basicConfig(level=logging.INFO)
        logger.setLevel(logging.INFO)

    output_path = args.output
    zephyr_base = args.zephyr_base
    build_path = args.build

    build = ZephyrDashboard(
        zephyr_base,
        build_path,
        output_path,
        kernel_bin_name=args.kernel_bin_name,
        skip_memory_report=args.skip_memory_report,
    )
    build.create_html()

    if not args.no_clean:
        build.clean_up()

    if args.open:
        build.open_browser()


if __name__ == "__main__":
    main()