"""The repo the incident packets were taken from (BM-6, FA-6, S7, FA-4).

Every packet shows the world before this week's queue was worked on: the rules, labels and routing the task's
`environment/` ships. PagerDuty rows, Slack titles, the rule-manager log and the rules API paste are rendered from
that state (every item's `break_` applied), never from the fixed one. A page went to whatever rota the alert's
`team` label and the routing tree sent it to then; an alert the repo doesn't have never paged anyone.
"""

from __future__ import annotations

import re

from ..grader import notify
from . import evidence as ev

_BY = re.compile(r"\bby \(([^)]*)\)")


def state(w) -> tuple[dict, dict]:
    """(rule files, Alertmanager config) as the queue found them; computed once per world."""
    if "then" not in w.notes:
        from .build import materialize
        w.notes["then"] = materialize(w, list(w.items), set())
    return w.notes["then"]


def rules(w, name: str) -> list[tuple]:
    """(file spec, group, rule) for every pristine definition of an alert."""
    files, _ = state(w)
    return [(f, g, r) for f in files.values() for g in f.groups for r in g["rules"] if r.get("alert") == name]


def exists(w, name: str) -> bool:
    return bool(rules(w, name))


def labels(w, alert: str, svc: str | None = None, cluster: str | None = None) -> dict | None:
    """The labels a firing `alert` about `svc` carries in the pristine repo: static labels (group labels merged) and
    what the expression keeps (`service`, `cluster`). None when the repo has no such alert."""
    defs = rules(w, alert)
    if svc is not None:
        defs = [d for d in defs if f'service="{svc}"' in str(d[2].get("expr", ""))] or defs
    if not defs:
        return None
    _, g, r = defs[0]
    out = {"alertname": alert}
    out.update({str(k): str(v) for k, v in {**(g.get("labels") or {}), **(r.get("labels") or {})}.items()})
    expr = str(r.get("expr", ""))
    if svc is not None:
        out.setdefault("service", svc)
    if cluster and any("cluster" in m.group(1) for m in _BY.finditer(expr)):
        out["cluster"] = cluster
    return out


def page_alerts(w, svc: str, skip: set = frozenset()) -> list[str]:
    """Alerts about `svc` alone that page in the pristine repo (its own Down, error ratio, burn page)."""
    files, _ = state(w)
    out = []
    for f in files.values():
        for g in f.groups:
            for r in g["rules"]:
                name = r.get("alert")
                if not name or name in skip or name in out:
                    continue
                sev = str({**(g.get("labels") or {}), **(r.get("labels") or {})}.get("severity", ""))
                if sev in ("page", "critical") and f'service="{svc}"' in str(r.get("expr", "")):
                    out.append(name)
    return sorted(out)


def receivers(w, lab: dict) -> list[tuple[str, object]]:
    """[(receiver, group_by)] the pristine routing tree sends these labels to."""
    _, am = state(w)
    got = notify.walk(am, lab) or []
    return [(r, gb) for r, gb, _ in got]


def pager(w, lab: dict) -> str | None:
    """The PagerDuty service a page with these labels opened an incident on (`claims`, `sre`), or None."""
    for r, _ in receivers(w, lab):
        if r.startswith("pagerduty-"):
            return r[len("pagerduty-"):]
    return None


def group_by(w, lab: dict, receiver_prefix: str = "pagerduty-") -> list:
    """The grouping on the leaf that delivers these labels to a receiver of that kind: the team's own one first (a
    page also reaches #sre-fyi, which groups the root's way)."""
    got = receivers(w, lab)
    own = [x for x in got if x[0] == f"{receiver_prefix}{lab.get('team')}"]
    for r, gb in own + [x for x in got if x[0] != "slack-sre-fyi"] + got:
        if r.startswith(receiver_prefix):
            return sorted(lab) if gb == notify.ALL else list(gb)
    return ["alertname", "service"]


def title(w, lab: dict, status: str = "firing", n: int = 1, receiver_prefix: str = "pagerduty-") -> str:
    """Alertmanager's default title for a group of `n` alerts like `lab` on that receiver."""
    return ev.slack_title(status, [lab] * n if status == "firing" else [lab], group_by(w, lab, receiver_prefix))


def paged_team(w, svc: str) -> str | None:
    """The `team` label the service's own pages carried before this week's fixes (a service moved in the split
    still carries its old team; one whose rules lost the label carries none)."""
    for name in page_alerts(w, svc):
        lab = labels(w, name, svc)
        if lab is not None:
            return lab.get("team")
    tr = getattr(w, "trigger", None) or {}
    return tr["old"] if svc in tr.get("moved", []) else w.svc(svc).team


def team_word(w, svc: str) -> str:
    """The team to name in prose about who got (or didn't get) paged for `svc`."""
    return paged_team(w, svc) or w.svc(svc).team


def has_down_dedupe(w) -> bool:
    """The pristine Alertmanager holds Down alerts back with other Down alerts (H20's planted rule)."""
    _, am = state(w)
    return any(any(".*Down" in m or ".+Down" in m for m in (r.get("source_matchers") or []))
               for r in am.get("inhibit_rules") or [])