"""Offline synthetic metric reference. No network, authentication, or field verification."""
import argparse
import json
from datetime import datetime
from pathlib import Path


def require(condition, message):
    if not condition:
        raise ValueError(message)


def timestamp(value):
    require(isinstance(value, str), "Timestamp must be an ISO string")
    parsed = datetime.fromisoformat(value.replace("Z", "+00:00"))
    require(parsed.tzinfo is not None and parsed.utcoffset() is not None, "Timestamp needs an explicit timezone")
    return parsed


def snapshot(fixture, as_of):
    """Validate the full fixture, then replay only upstream-accepted reports visible at as_of."""
    require(fixture.get("synthetic") is True, "This reference accepts explicitly synthetic fixtures only")
    require(fixture.get("study_id") == "AM-RP-002", "Unexpected study ID")
    plan = fixture["plan"]
    require(plan.get("synthetic") is True, "Plan must be labelled synthetic")
    visits = plan["visits"]
    require(isinstance(visits, list) and all(isinstance(v, str) and v.strip() for v in visits), "Visit IDs must be nonempty strings")
    require(len(visits) == len(set(visits)), "Duplicate planned visit ID")
    start, end = (timestamp(plan["service_window"][key]) for key in ("start", "end"))
    require(start < end, "Invalid service window")
    cutoff = timestamp(as_of)
    unique_events, revisions = {}, {}
    for event in fixture["events"]:
        require(isinstance(event, dict), "Event must be an object")
        event_id = event["event_id"]
        require(isinstance(event_id, str) and event_id.strip(), "Event ID required")
        require(event["visit_id"] in visits, "Unknown planned visit")
        require(type(event["revision"]) is int and event["revision"] > 0, "Revision must be a positive integer")
        require(event["status"] in {"completed", "exception"}, "Unknown accepted status")
        occurred, received = timestamp(event["occurred_at"]), timestamp(event["received_at"])
        require(start <= occurred < end, "Event outside fixed service window")
        require(occurred <= received, "Receipt cannot precede event time")
        if event_id in unique_events:
            require(unique_events[event_id] == event, "Conflicting event ID payload")
            continue
        key = (event["visit_id"], event["revision"])
        require(key not in revisions, "Conflicting visit revision")
        unique_events[event_id] = event
        revisions[key] = event_id
    latest = {}
    for event in unique_events.values():
        if timestamp(event["received_at"]) > cutoff:
            continue
        visit_id = event["visit_id"]
        if visit_id not in latest or event["revision"] > latest[visit_id]["revision"]:
            latest[visit_id] = event
    states = {visit: latest[visit]["status"] if visit in latest else "unreported" for visit in sorted(visits)}
    counts = {status: sum(value == status for value in states.values()) for status in ("completed", "exception", "unreported")}
    require(sum(counts.values()) == len(visits), "State counts must reconcile to plan")
    return {
        "plan_id": plan["plan_id"], "as_of": cutoff.isoformat(), "planned_visits": len(visits),
        **counts, "recorded_completion_fraction": counts["completed"] / len(visits) if visits else None,
        "visit_states": states,
        "selected_event_ids": {visit: latest[visit]["event_id"] if visit in latest else None for visit in sorted(visits)},
    }


def main():
    parser = argparse.ArgumentParser(description=__doc__)
    parser.add_argument("--fixture", type=Path, default=Path(__file__).with_name("synthetic-fixture.json"))
    parser.add_argument("--as-of", required=True, help="Explicit timezone-aware reporting cutoff")
    args = parser.parse_args()
    fixture = json.loads(args.fixture.read_text(encoding="utf-8"))
    result = snapshot(fixture, args.as_of)
    print(json.dumps({"status": "synthetic_software_fixture_only", "snapshot": result}, indent=2, sort_keys=True))


if __name__ == "__main__":
    main()