"""Gate lint for the scraped world of a built task (scraped.py): every hidden group, the preservation replay's
exercise groups included, has to look like something a Prometheus scraped.

1. completeness: a service with an `up` target at 1 has every series family it exports in this world (request
   counters for the kinds that serve requests, the per-pod families its rules read, its exporters), unless the
   group declares the gap (`bare`);
2. coverage: at every minute one of its targets is up, some request counter of the service has a sample (a card's
   own traffic can't stop short of its targets' lifetime);
3. consistency: an app series is only sampled while the target it was scraped from is up (a target that is down or
   gone has stale or no series, as Prometheus writes them);
4. reach: no rule in the repo reads a metric about a service that no scenario carries;
5. ingress: the README says this Prometheus scrapes the ingress, so every HTTP service with a target up has the
   controller's request counters (`nginx_ingress_controller_requests`).
"""

from __future__ import annotations

import json
import os
import re

from ..promsim import STALE
from .scraped import FAMILY, INGRESS, SERVES
from .xscen import dec

_LAB = re.compile(r'([a-zA-Z_][a-zA-Z0-9_]*)="((?:[^"\\]|\\.)*)"')
MAX_REPORTS = 12


def _parse(g: dict) -> list[tuple[str, dict, list]]:
    out = []
    for s in g["input_series"]:
        name, inner = s["series"].split("{", 1)
        out.append((name, dict(_LAB.findall(inner)), dec(s["values"])))
    return out


def _num(v) -> bool:
    return v is not None and v != STALE


def check_groups(plan, groups: list[dict]) -> list[str]:
    bad: list[str] = []
    for g in groups:
        series = _parse(g)
        bare = g.get("bare", {})
        ups: dict[str, list[tuple[dict, list]]] = {}
        fams: dict[str, set] = {}
        for name, lab, vals in series:
            svc = lab.get("service")
            if name == "up" and svc in plan.svcs and lab.get("job") == svc:
                ups.setdefault(svc, []).append((lab, vals))
            if svc and name in FAMILY:
                fams.setdefault(svc, set()).add(FAMILY[name])
        for svc, targets in ups.items():
            n = max(len(v) for _, v in targets)
            live = [m for m in range(n) if any(m < len(v) and v[m] == 1 for _, v in targets)]
            if not live:
                continue
            skip = set(bare.get(svc, []))
            for fam in sorted(plan.need[svc] - fams.get(svc, set()) - skip):
                bad.append(f"{g['name']}: {svc} has targets up and no {fam} series")
            for t in plan.templates:
                if t["service"] == svc and not any(
                        name == t["metric"] and all(lab.get(k) == t["labels"][k] for k in t["key"])
                        for name, lab, _ in series):
                    bad.append(f"{g['name']}: {svc} has targets up and no {t['metric']}")
            req = SERVES.get(plan.svcs[svc].kind)
            if req and req not in skip:
                rs = [v for name, lab, v in series if lab.get("service") == svc and FAMILY.get(name) == req]
                gap = next((m for m in live if not any(m < len(v) and _num(v[m]) for v in rs)), None)
                if gap is not None:
                    bad.append(f"{g['name']}: {svc} has a target up at minute {gap} and no request series sample")
            if req == "http" and req not in skip and not any(name == INGRESS and lab.get("service") == svc
                                                             for name, lab, _ in series):
                bad.append(f"{g['name']}: {svc} has targets up and no ingress series")
        by_target = {(lab.get("service"), lab.get("instance"), lab.get("pod")): vals
                     for name, lab, vals in series if name == "up" and lab.get("pod")}
        for name, lab, vals in series:
            if name == "up" or name.startswith("container_") or not lab.get("pod"):
                continue
            up = by_target.get((lab.get("service"), lab.get("instance"), lab.get("pod")))
            if up is None or lab.get("job", lab.get("service")) != lab.get("service"):
                continue
            m = next((m for m, v in enumerate(vals) if _num(v) and not (m < len(up) and up[m] == 1)), None)
            if m is not None:
                bad.append(f"{g['name']}: {name}{{pod={lab['pod']}}} sampled at minute {m} while its target is not up")
    return bad


def lint(m: dict) -> list[str]:
    """The checks above on a built task (build_task's result), exercise groups included."""
    plan = m.get("scrape")
    if plan is None:
        return []
    groups = list(m["groups"])
    ex = os.path.join(m["hidden_dir"], "exercise.json")
    if os.path.exists(ex):
        with open(ex) as fh:
            groups += json.load(fh)
    bad = check_groups(plan, groups)
    for svc, metrics in sorted(plan.uncovered.items()):
        for metric in metrics:
            bad.append(f"rules read {metric} about {svc}, which no scenario carries")
    if len(bad) > MAX_REPORTS:
        bad = bad[:MAX_REPORTS] + [f"... {len(bad) - MAX_REPORTS} more scraped-world findings"]
    return [f"scraped world: {b}" for b in bad]