#!/usr/bin/env python3
import argparse
import functools
import os
import shlex
import subprocess
import sys
import pathlib
import re

import get_deps

build_format = '| {:29} | {:30} | {:18} | {:7} | {:6} | {:6} |'

SUCCEEDED = "\033[32msucceeded\033[0m"
FAILED = "\033[31mfailed\033[0m"
SKIPPED = "\033[33mskipped\033[0m"


# Every read here is a source file, not user text: decode it the same way on every
# machine. Without this the reads take the locale's encoding, and one of the eight
# tracked non-ASCII files this now touches (hw/bsp/nrf/boards/nrf54lm20dk/board.cmake
# among them) raises UnicodeDecodeError under LC_ALL=C - a ValueError, which sails
# straight through the `except OSError` fail-opens.
_TEXT = {'encoding': 'utf-8', 'errors': 'replace'}

_FAMILY_MCUS_RE = re.compile(r'set\s*\(\s*FAMILY_MCUS\s+([^)]*)\)')
# cmake command names are case-insensitive, so SET(...) defines a variable as much
# as set(...) does; the name group keeps `SET(${OUTVAR} ...)` out either way.
_CMAKE_SET_RE = re.compile(r'set\s*\(\s*([A-Za-z_]\w*)\s+([^)\s]+)', re.IGNORECASE)
_CMAKE_VAR_RE = re.compile(r'\$\{([A-Za-z_]\w*)\}')
_CMAKE_CASE_RE = re.compile(r'string\s*\(\s*(TOUPPER|TOLOWER)\s+(\S+)\s+([A-Za-z_]\w*)\s*\)')


def _cwd_cache(fn):
    """lru_cache, keyed on the working directory as well as the arguments.

    Every cached helper below takes repo-RELATIVE paths ('hw/bsp/<fam>',
    'examples/<ex>/skip.txt', or the literal 'hw/bsp' glob), while ci_select._in_repo()
    chdirs around each call so one process can classify more than one tree - the
    code-size skill's base-vs-branch worktrees, /pre-pr, a test pointing at a fixture.
    Without the cwd in the key the second tree silently gets the first tree's
    skip.txt/only.txt and FAMILY_MCUS answers. Master had no caching here, so this
    hazard arrived with it."""
    cache = {}

    @functools.wraps(fn)
    def wrapper(*args):
        key = (os.getcwd(), args)
        if key not in cache:
            cache[key] = fn(*args)
        return cache[key]

    wrapper.cache_clear = cache.clear
    return wrapper

@_cwd_cache
def _cmake_sets(path):
    """One cmake file's variable assignments as NAME -> first definition seen, as
    either a literal value or an ('TOUPPER'|'TOLOWER', source) pair. Only used to
    expand ${...} tokens; never mutate the cached dict.

    string(TOUPPER ...) is not decoration: hw/bsp/maxim derives its ONLY FAMILY_MCUS
    entry that way (`string(TOUPPER ${MAX_DEVICE} MAX_DEVICE_UPPER)`), as do the eight
    at32 families, so dropping those lines left nine families with an empty MCU set."""
    try:
        text = pathlib.Path(path).read_text(**_TEXT)
    except OSError:
        return {}
    out = {}
    for line in text.splitlines():
        line = line.strip()
        if line.startswith('#'):
            continue
        m = _CMAKE_CASE_RE.match(line)
        if m:
            # strip quotes like the set() branch below: string(TOUPPER "${VAR}" DST) is
            # idiomatic cmake, and keeping them yields a '"NAME"' token that can never
            # equal a mcu: entry
            out.setdefault(m.group(3), (m.group(1), m.group(2).strip('"')))
            continue
        m = _CMAKE_SET_RE.match(line)
        if m:
            out.setdefault(m.group(1), m.group(2).strip('"'))
    return out


def _cmake_expand(value, files, depth=0):
    """`value` with every ${VAR} replaced, resolving each name against `files` in
    order, or None when any name resolves nowhere OR the result still carries a `${`.
    That last case is the one _CMAKE_VAR_RE cannot see - a hyphen in the name, a nested
    ${${X}}, an unterminated brace - where the loop below finds nothing to substitute
    and would otherwise hand the raw text back as if it were a resolved MCU name.
    Bounded depth: a cmake file may define a var in terms of another one, and a
    self-referential set() must not recurse forever."""
    if depth > 4:
        return None
    out = value
    for name in set(_CMAKE_VAR_RE.findall(value)):
        val = None
        for f in files:
            val = _cmake_sets(f).get(name)
            if val is not None:
                break
        if val is None:
            return None
        if isinstance(val, tuple):                     # string(TOUPPER src DST)
            src = _cmake_expand(val[1], files, depth + 1)
            if src is None:
                return None
            val = src.upper() if val[0] == 'TOUPPER' else src.lower()
        else:
            val = _cmake_expand(val, files, depth + 1)
            if val is None:
                return None
        out = out.replace('${' + name + '}', val)
    return None if '${' in out else out


@_cwd_cache
def _board_dirs(board):
    """(board_dir, family_dir) for a board name, or (None, None). Cached: skip_example
    is asked (board x example) times - 566k lstat calls per selector run without this,
    since the glob rescans every hw/bsp/*/boards for each example."""
    hits = list(pathlib.Path("hw/bsp").glob("*/boards/" + board))
    if not hits:
        return None, None
    return hits[0], hits[0].parent.parent


@_cwd_cache
def _family_mcus(family_dir, board_dir):
    """The MCU names CMake's family_filter iterates. family_support.cmake:176/190
    loop `foreach(MCU IN LISTS FAMILY_MCUS)`, so a family-wide list (broadcom_64bit
    sets "BCM2711 BCM2835") makes ANY of its entries decide skip.txt/only.txt -- not
    just the one CFG_TUSB_MCU the configured board names.

    ${...} tokens are expanded from `set(VAR value)` and `string(TOUPPER src VAR)` in
    the board's board.cmake first, then in family.cmake: hw/bsp/ra sets
    `FAMILY_MCUS RAXXX ${MCU_VARIANT}` and ra6m5_ek/board.cmake sets MCU_VARIANT ra6m5,
    which is the token dual/host_info_to_device_cdc/only.txt actually spells; hw/bsp/maxim
    sets `FAMILY_MCUS ${MAX_DEVICE_UPPER}`, upper-cased from the board's MAX_DEVICE. A
    token resolving nowhere is dropped (nothing can be said about it).

    A family that never spells `set(FAMILY_MCUS ...)` at all gets one more chance: the
    name is resolved as a variable, which covers the derived form hw/bsp/espressif uses
    (`string(TOUPPER ${IDF_TARGET} FAMILY_MCUS)`).

    Only unconditional set() calls count: nrf and mcx pick FAMILY_MCUS per board
    inside if() blocks this does not evaluate, so for those two families the whole
    cmake-side MCU set is whatever the CFG_TUSB_MCU scrape in _board_mcu finds.

    nrf: the scrape reads the FIRST CFG_TUSB_MCU token of hw/bsp/nrf/family.mk, so
    every nrf board answers NRF54, the NRF5X ones included. Harmless only because no
    skip.txt/only.txt names an nrf token today.

    mcx: load-bearing, not academic -- mcu:MCXA15 is live in six examples' skip.txt
    (device/{cdc_msc,audio_test,hid_composite,audio_4_channel_mic,midi_test}_freertos
    and device/net_lwip_webserver). Those answers come out right only because the
    scrape falls through to each board's make-only board.mk, which still spells the
    token; an mcx board carrying board.cmake alone (MCU_VARIANT and no CFG_TUSB_MCU)
    would scrape 'NONE' and skip EVERY example on it, silently. TestFamilyMcusFallback
    fails the day such a board lands. The fix then is to evaluate the
    if(MCU_VARIANT STREQUAL ...) branches, not to add another scrape.
    """
    fam_cmake = pathlib.Path(family_dir) / "family.cmake"
    try:
        text = fam_cmake.read_text(**_TEXT)
    except OSError:
        return frozenset()
    board_cmake = pathlib.Path(board_dir) / "board.cmake"
    out = set()
    depth = 0
    any_set = False
    for line in text.splitlines():
        line = line.strip()
        m = _FAMILY_MCUS_RE.match(line)
        if m:
            any_set = True
        if m and depth == 0:
            files = (str(board_cmake), str(fam_cmake))
            for tok in m.group(1).split():
                if tok in ("CACHE", "INTERNAL") or tok.startswith('"'):
                    continue
                val = _cmake_expand(tok, files)
                if val:
                    out.add(val)
        if re.match(r'if\s*\(', line):
            depth += 1
        elif re.match(r'endif\s*\(', line):
            depth = max(0, depth - 1)
    if not out and not any_set:
        # FAMILY_MCUS can also be produced rather than set: hw/bsp/espressif derives it
        # with `string(TOUPPER ${IDF_TARGET} FAMILY_MCUS)`, which _FAMILY_MCUS_RE cannot
        # see, leaving espressif's whole cmake answer resting on the IDF_TARGET scrape.
        #
        # `not any_set` is load-bearing: _cmake_sets is if()-blind and keeps the FIRST
        # definition, so on a family that sets FAMILY_MCUS only inside conditionals
        # (mcx, nrf) this would leak branch one's value onto every board - mcx/frdm_mcxn947
        # answered MCXA15, which six examples' skip.txt names, dropping 12 firmware
        # images CMake actually builds. Those families keep the CFG_TUSB_MCU scrape.
        val = _cmake_expand('${FAMILY_MCUS}', (str(board_cmake), str(fam_cmake)))
        if val:
            out.add(val)
    return frozenset(out)


@_cwd_cache
def _scrape_mcu(family_dir, board_dir, family):
    """(CFG_TUSB_MCU token of this board, the text it was read from), master's
    algorithm verbatim: family.mk (family.cmake when there is none) first, falling
    back to the board's board.mk (board.cmake when there is none) only when the
    family file names no token at all. espressif spells its MCU as
    `set(IDF_TARGET "...")` instead. The text comes back with it because the make
    path reads MAX3421_HOST out of that same single file - which file that is IS
    part of master's answer, so it cannot be re-derived by the caller."""
    family_mk = family_dir / "family.mk"
    if not family_mk.exists():
        family_mk = family_dir / "family.cmake"
    mk_contents = family_mk.read_text(**_TEXT)

    # Find the mcu, first in family mk then board mk
    if "CFG_TUSB_MCU=OPT_MCU_" not in mk_contents:
        board_mk = board_dir / "board.mk"
        if not board_mk.exists():
            board_mk = board_dir / "board.cmake"
        mk_contents = board_mk.read_text(**_TEXT)

    mcu = "NONE"
    if family == "espressif":
        for line in mk_contents.splitlines():
            match = re.search(r'set\(IDF_TARGET\s+"([^"]+)"\)', line)
            if match:
                mcu = match.group(1).upper()
                break
    else:
        for token in mk_contents.split():
            if "CFG_TUSB_MCU=OPT_MCU_" in token:
                # Strip " because cmake files has them.
                token = token.strip("\"")
                _, opt_mcu = token.split("=")
                mcu = opt_mcu[len("OPT_MCU_"):]
            if mcu != "NONE":
                break
    return mcu, mk_contents


@_cwd_cache
def _board_mcu(board_dir, family_dir, family):
    """(CFG_TUSB_MCU of this board, MAX3421_HOST enabled by its cmake BSP).

    MAX3421_HOST is read from family.cmake AND board.cmake rather than only the file
    the MCU token came from: feather_rp2040_max3421 sets it in its board.cmake while
    its MCU token comes from rp2040's family file, and family_support.cmake:940
    appends MAX3421 to FAMILY_MCUS for it. board.mk is deliberately not read - a
    make-only option compiles nothing in a cmake build (and the make path answers
    with master's own single-file scrape, see _skip_example_make)."""
    family_dir = pathlib.Path(family_dir)
    board_dir = pathlib.Path(board_dir)
    mcu, _ = _scrape_mcu(family_dir, board_dir, family)
    if "${" in mcu:
        # the scrape is textual, so a computed token comes back verbatim
        # (tm4c board.cmake spells OPT_MCU_TM4C${MCU_SUB_VARIANT}, maxim
        # OPT_MCU_${MAX_DEVICE_UPPER}). Expand it the same way FAMILY_MCUS tokens are;
        # what still will not resolve stays as-is and _skip_example treats it as
        # "MCU unknown" rather than silently matching no mcu: token at all.
        mcu = _cmake_expand(mcu, (str(board_dir / "board.cmake"),
                                  str(family_dir / "family.cmake"))) or mcu

    max3421_enabled = False
    for f in (family_dir / "family.cmake", board_dir / "board.cmake"):
        try:
            text = f.read_text(**_TEXT)
        except OSError:
            continue
        # a commented-out `# set(MAX3421_HOST 1)` (feather_nrf52840_express) enables
        # nothing; master never hit one because it only read the MCU token's file
        if any(not l.lstrip().startswith('#') and
               ("MAX3421_HOST=1" in l or 'MAX3421_HOST 1' in l)
               for l in text.splitlines()):
            max3421_enabled = True
            break

    return mcu, max3421_enabled


@_cwd_cache
def _filter_tokens(path):
    """skip.txt / only.txt as a token set, or None when the file does not exist."""
    f = pathlib.Path(path)
    return frozenset(f.read_text(**_TEXT).split()) if f.exists() else None


def skip_example(example, board, extra_defines=(), build_system='cmake'):
    """Is this example unbuildable on this board, for this build system?

    The two build systems ask DIFFERENT questions and must not share an answer:

    'cmake' mirrors CMake's family_filter (hw/bsp/family_support.cmake:171-207),
    including the whole FAMILY_MCUS list the family.cmake sets.

    'make' is master's original algorithm, unchanged. family.mk and family.cmake are
    not the same build: hw/bsp/lpc54/family.cmake sets FAMILY_MCUS LPC54 and wires the
    ohci host sources, while family.mk builds OPT_MCU_LPC54XXX and compiles no HCD
    source at all -- feeding the cmake MCU union to a make build un-skips the host
    examples only.txt gates on mcu:LPC54 and they fail to link (undefined hcd_init).

    extra_defines: NAME=VALUE tokens the build passes on the command line
    (build.py -D). MAX3421_HOST=1 there enables the max3421 host controller
    exactly like a BSP that sets it, and family_support.cmake:940 appends MAX3421
    to FAMILY_MCUS for it -- so a roster board whose MAX3421 comes from the build
    args (metro_m4_express) must resolve its only.txt the same way. cmake only:
    master's make algorithm never looked at them.
    """
    return _skip_example(example, board, tuple(extra_defines), build_system)


@_cwd_cache
def _skip_example_make(example, board):
    """master's skip_example, verbatim (tools/build_utils.py @ 9c202e8c6): the
    make build's own answer, derived from family.mk/board.mk with the single
    CFG_TUSB_MCU token that file names. Do not "improve" it -- it is the mirror of
    what `make BOARD=... all` actually compiles."""
    ex_dir = pathlib.Path('examples/') / example

    # board within family
    board_dir, family_dir = _board_dirs(board)
    if board_dir is None:
        # Skip unknown boards
        return True
    family = family_dir.name

    mcu, mk_contents = _scrape_mcu(family_dir, board_dir, family)

    # Skip all OPT_MCU_NONE these are WIP port
    if mcu == "NONE":
        return True

    max3421_enabled = False
    for line in mk_contents.splitlines():
        if "MAX3421_HOST=1" in line or 'MAX3421_HOST 1' in line:
            max3421_enabled = True
            break

    skip_file = ex_dir / "skip.txt"
    only_file = ex_dir / "only.txt"

    if skip_file.exists():
        skips = skip_file.read_text(**_TEXT).split()
        if ("mcu:" + mcu in skips or
            "board:" + board in skips or
            "family:" + family in skips):
            return True

    if only_file.exists():
        onlys = only_file.read_text(**_TEXT).split()
        if not ("mcu:" + mcu in onlys or
                ("mcu:MAX3421" in onlys and max3421_enabled) or
                "board:" + board in onlys or
                "family:" + family in onlys):
            return True

    return False


@_cwd_cache
def _skip_example(example, board, extra_defines, build_system):
    if build_system == 'make':
        return _skip_example_make(example, board)

    ex_dir = pathlib.Path('examples/') / example

    # board within family
    board_dir, family_dir = _board_dirs(board)
    if board_dir is None:
        # Skip unknown boards
        return True
    family = family_dir.name

    mcu, max3421_enabled = _board_mcu(str(board_dir), str(family_dir), family)

    # Skip all OPT_MCU_NONE these are WIP port
    if mcu == "NONE":
        return True

    if any(t.strip().strip('"') == "MAX3421_HOST=1" for t in extra_defines):
        max3421_enabled = True

    mcus = set(_family_mcus(str(family_dir), str(board_dir)))
    if "${" not in mcu:
        mcus.add(mcu)
    if not mcus:
        # nothing resolved: neither FAMILY_MCUS nor the scraped CFG_TUSB_MCU token
        # yielded a name. Answering "skip" here would silently drop EVERY example on
        # the board (an only.txt can then never match), so say "buildable" and let
        # the real filter decide - build.py checks the targets CMake actually
        # registered, and CMake itself is the authority on the make/cmake legs.
        return False
    if max3421_enabled:
        mcus.add("MAX3421")                      # family_support.cmake:940

    keys = {"board:" + board, "family:" + family} | {"mcu:" + m for m in mcus}

    skips = _filter_tokens(str(ex_dir / "skip.txt"))
    if skips is not None and (skips & keys):
        return True

    onlys = _filter_tokens(str(ex_dir / "only.txt"))
    if onlys is not None and not (onlys & keys):
        return True

    return False


HEAD_UNKNOWN = object()


def dep_head(path):
    """The dep checkout's commit; None when git would answer for the enclosing tinyusb
    repo (no .git of its own, a vendored copy), so the pin cannot apply; HEAD_UNKNOWN
    when the dir has its own .git that names no commit - a git-init without a fetch, or
    a checkout broken partway - where the revision built is anybody's guess."""
    if not (path / '.git').exists():
        return None
    r = subprocess.run(['git', '-C', str(path), 'rev-parse', 'HEAD'], capture_output=True, text=True)
    head = r.stdout.strip()
    return head if r.returncode == 0 and head else HEAD_UNKNOWN


def missing_deps(family, root=None):
    """The family's dependencies that are not what get_deps.py's table asks for, each
    named with why. Present means content, not a directory: get_deps.py git-inits the dep
    dir before fetching and exits 0 whatever the fetch did (its run_cmd's status is
    ignored), so a fetch that failed leaves a dir holding nothing but .git. A checkout at
    another commit is the same kind of miss: when the change under test bumps a pin, a
    stale checkout builds the revision the change is replacing and verifies nothing."""
    root = pathlib.Path(root) if root else pathlib.Path(__file__).resolve().parents[1]
    needed = list(get_deps.deps_mandatory) + \
        [d for d, entry in get_deps.deps_optional.items() if family in entry[2].split()]
    out = []
    for d in needed:
        p = root / d
        if not p.is_dir() or not any(f.name != '.git' for f in p.iterdir()):
            out.append(d)
            continue
        pin, head = get_deps.deps_all[d][1], dep_head(p)
        if head is HEAD_UNKNOWN:
            out.append(f'{d} (revision unknown, pinned {pin[:10]})')
        elif head is not None and head != pin:
            out.append(f'{d} (at {head[:10]}, pinned {pin[:10]})')
    return out


def build_size(make_cmd):
    size_output = subprocess.run(make_cmd + ' size', shell=True, stdout=subprocess.PIPE).stdout.decode("utf-8").splitlines()
    for i, l in enumerate(size_output):
        text_title = 'text	   data	    bss	    dec'
        if text_title in l:
            size_list = size_output[i+1].split('\t')
            flash_size = int(size_list[0])
            sram_size = int(size_list[1]) + int(size_list[2])
            return (flash_size, sram_size)

    return (0, 0)


class BoardInfoError(ValueError):
    pass


def _cmake_set_values(path, name):
    """Every uncommented set(NAME value) of one variable in a cmake file, in order."""
    try:
        text = pathlib.Path(path).read_text(**_TEXT)
    except OSError:
        return []
    out = []
    for line in text.splitlines():
        line = line.strip()
        if line.startswith('#'):
            continue
        m = _CMAKE_SET_RE.match(line)
        if m and m.group(1) == name:
            out.append(m.group(2).strip('"'))
    return out


def _expand_or_refuse(value, files, depth=0):
    """`value` with every ${VAR} replaced from the first of `files` that sets it.
    Unlike _cmake_expand this refuses a variable set more than once in that file:
    those are conditional branches (`if (M4 STREQUAL "1") set(JLINK_CORE _M4)`)
    the textual parser cannot pick between, and a debug probe pointed at the
    wrong core is worse than no answer."""
    if depth > 4:
        raise BoardInfoError(f'{value}: expansion too deep')
    out = value
    for name in set(_CMAKE_VAR_RE.findall(value)):
        for f in files:
            vals = _cmake_set_values(f, name)
            if vals:
                break
        else:
            raise BoardInfoError(f'${{{name}}} is set in none of {", ".join(files)}')
        distinct = list(dict.fromkeys(vals))
        if len(distinct) > 1:
            raise BoardInfoError(f'${{{name}}} is set conditionally in {f}: '
                                 f'{", ".join(distinct)} - pass the value by hand')
        out = out.replace('${' + name + '}', _expand_or_refuse(distinct[0], files, depth + 1))
    if '${' in out:
        raise BoardInfoError(f'{value}: cannot expand')
    return out


def _board_files(board):
    if not pathlib.Path('hw/bsp').is_dir():
        raise BoardInfoError('no hw/bsp here - run from the tinyusb root')
    if not re.fullmatch(r'[A-Za-z0-9_.-]+', board):
        raise BoardInfoError(f'{board!r} is not a board name')   # _board_dirs would glob it
    hits = sorted(pathlib.Path('hw/bsp').glob('*/boards/' + board))
    if not hits:
        raise BoardInfoError(f'unknown board {board}')
    if len(hits) > 1:
        raise BoardInfoError(f'{board} exists in several families: ' + ', '.join(map(str, hits)))
    board_dir = hits[0]
    return board_dir, (str(board_dir / 'board.cmake'), str(board_dir.parent.parent / 'family.cmake'))


def _checked_device(value, source):
    """A J-Link device name as the BSPs and Ozone projects spell it (LPC11U37/401,
    XMC4500-1024). A scrape that yields anything else reaches a probe's command line
    as an option rather than a device, so refuse it like _board_files refuses a board."""
    if not re.fullmatch(r'[A-Za-z0-9][A-Za-z0-9_./+-]*', value):
        raise BoardInfoError(f'{value!r} in {source} is not a J-Link device name')
    return value


def board_jlink(board):
    """The board's J-Link device name from its board.cmake, else its family.cmake,
    ${...} expanded. A conditional or unresolvable definition is refused unless
    the board's reference Ozone project names the device (it is what a trace
    capture drives anyway)."""
    _, files = _board_files(board)
    for f in files:
        vals = _cmake_set_values(f, 'JLINK_DEVICE')
        if vals:
            break
    else:
        raise BoardInfoError(f'{board}: no JLINK_DEVICE in board.cmake or family.cmake')
    distinct = list(dict.fromkeys(vals))
    try:
        if len(distinct) > 1:
            raise BoardInfoError(f'{board}: JLINK_DEVICE is set conditionally in {f}: '
                                 f'{", ".join(distinct)} - pass the device by hand')
        return _checked_device(_expand_or_refuse(distinct[0], files), f)
    except BoardInfoError as e:
        jdebug = board_jdebug(board)
        if not jdebug:
            raise
        m = re.search(r'^\s*Project\.SetDevice\s*\(\s*"([^"]+)"', pathlib.Path(jdebug).read_text(**_TEXT), re.M)
        if not m:
            raise BoardInfoError(f'{e}; {jdebug} names no device either')
        return _checked_device(m.group(1), jdebug)


def board_jdebug(board):
    """The board's reference Ozone project (hw/bsp/<family>/boards/<board>/ozone/*.jdebug),
    or None; refuses when there are several."""
    board_dir, _ = _board_files(board)
    hits = sorted((board_dir / 'ozone').glob('*.jdebug'))
    if len(hits) > 1:
        raise BoardInfoError(f'{board}: several reference projects: '
                             + ', '.join(str(h) for h in hits))
    return str(hits[0]) if hits else None


def main(argv=None):
    p = argparse.ArgumentParser(description='Board facts for the debug skills; run from the tinyusb root.')
    sub = p.add_subparsers(dest='cmd', required=True)
    bi = sub.add_parser('board-info', help='J-Link device and reference Ozone project of a '
                                           'board, as shell assignments')
    bi.add_argument('board')
    args = p.parse_args(argv)
    try:
        device = board_jlink(args.board)
        jdebug = board_jdebug(args.board)
    except BoardInfoError as e:
        print(f'error: {e}', file=sys.stderr)
        return 1
    print(f'JLINK_DEVICE={shlex.quote(device)}')
    print(f'JDEBUG={shlex.quote(jdebug) if jdebug else ""}')
    return 0


if __name__ == '__main__':
    sys.exit(main())