#!/usr/bin/env python3
"""Synthetic change-impact planner, Python 3.9 stdlib only.

No network, environment, secret, process or production configuration access.
The supplied graph and evidence declarations require human verification.
"""
from dataclasses import dataclass
from typing import Dict, FrozenSet, Tuple

@dataclass(frozen=True)
class Change:
    components: FrozenSet[str]
    inventory_confirmed: bool

@dataclass(frozen=True)
class Job:
    name: str
    roots: FrozenSet[str]
    mapping_complete: bool
    baseline_reference_confirmed: bool

EDGES: Dict[str, FrozenSet[str]] = {
    "catalog_read": frozenset({"collector-v3"}),
    "price_report": frozenset({"collector-v3"}),
    "collector-v3": frozenset({"startup_env[shared]"}),
    "regional_qa": frozenset({"qa-browser", "market-session[qa-browser]"}),
    "qa-browser": frozenset({"no_proxy[qa-browser]"}),
    "invoice_reconcile": frozenset({"direct_reporter[finance]"}),
    "scheduled_audit": frozenset({"audit-cron", "unmapped_plugin[audit-cron]"}),
    "audit-cron": frozenset({"startup_env[shared]"}),
}
LEAVES = frozenset({"startup_env[shared]", "market-session[qa-browser]",
                    "no_proxy[qa-browser]", "direct_reporter[finance]"})
KNOWN = frozenset(EDGES) | LEAVES
CHANGED = Change(frozenset({"startup_env[shared]"}), True)
JOBS: Tuple[Job, ...] = (
    Job("catalog_read", frozenset({"catalog_read"}), True, True),
    Job("price_report", frozenset({"price_report"}), True, True),
    Job("regional_qa", frozenset({"regional_qa"}), True, True),
    Job("invoice_reconcile", frozenset({"invoice_reconcile"}), True, True),
    Job("scheduled_audit", frozenset({"scheduled_audit"}), False, False),
)

def key_set(value: FrozenSet[str], label: str) -> None:
    if not isinstance(value, frozenset) or not value:
        raise ValueError(label + " must be a non-empty frozenset")
    if any(not isinstance(x, str) or not x.strip() or x != x.strip() for x in value):
        raise ValueError(label + " requires exact non-empty component keys")

def closure(roots: FrozenSet[str]) -> FrozenSet[str]:
    key_set(roots, "roots")
    pending, seen = list(roots), set()
    while pending:
        node = pending.pop()
        if node in seen:
            continue
        if node not in KNOWN:
            raise ValueError("unmapped dependency: " + node)
        seen.add(node)
        if node in EDGES:
            children = EDGES[node]
            key_set(children, "non-leaf dependencies")
            pending.extend(children)
    return frozenset(seen)

def classify(job: Job, change: Change) -> str:
    key_set(change.components, "changed components")
    key_set(job.roots, "job roots")
    if (change.inventory_confirmed is not True or
            job.mapping_complete is not True or
            job.baseline_reference_confirmed is not True):
        return "UNKNOWN_HOLD"
    if not change.components <= KNOWN:
        return "UNKNOWN_HOLD"
    try:
        dependencies = closure(job.roots)
    except ValueError:
        return "UNKNOWN_HOLD"
    if dependencies & change.components:
        return "AFFECTED"
    return "NO_CHANGE_SPECIFIC_RETEST"

def main() -> None:
    expected = ("AFFECTED", "AFFECTED", "NO_CHANGE_SPECIFIC_RETEST",
                "NO_CHANGE_SPECIFIC_RETEST", "UNKNOWN_HOLD")
    for job, want in zip(JOBS, expected):
        result = classify(job, CHANGED)
        assert result == want
        print(job.name + ": " + result)
    assert "startup_env[shared]" in closure(JOBS[0].roots)
    assert classify(JOBS[2], Change(frozenset({"unmapped-change"}), True)) == "UNKNOWN_HOLD"
    assert classify(JOBS[2], Change(CHANGED.components, False)) == "UNKNOWN_HOLD"
    assert classify(JOBS[2], Change(CHANGED.components, "yes")) == "UNKNOWN_HOLD"
    assert classify(Job("bad-flag", JOBS[2].roots, "yes", True), CHANGED) == "UNKNOWN_HOLD"
    assert classify(Job("unknown-root", frozenset({"not-in-map"}), True, True), CHANGED) == "UNKNOWN_HOLD"
    # Even if flags are incorrectly True, an unknown transitive node still holds.
    assert classify(Job("audit", JOBS[4].roots, True, True), CHANGED) == "UNKNOWN_HOLD"
    for bad in (frozenset(), frozenset({""}), frozenset({" padded "}), "startup_env[shared]"):
        try:
            classify(JOBS[0], Change(bad, True))
        except ValueError:
            pass
        else:
            raise AssertionError("malformed change inventory accepted")
    try:
        classify(Job("empty", frozenset(), True, True), CHANGED)
    except ValueError:
        pass
    else:
        raise AssertionError("empty roots accepted")

if __name__ == "__main__":
    main()
