1"""SwiftUI lane parser (Xcode 26+).
2 
3Primary schema is `swiftui-updates` with columns: start, duration, id,
4update-type, allocations, description, category, view-hierarchy, module,
5view-name, process, thread, root-causes, severity, cause-graph-node,
6full-cause-graph-node.
7 
8We aggregate by view-name across all SwiftUI schemas (future-proofing against
9schema renames) and break severity out separately so the agent can focus on
10the high-severity rows.
11"""
12from __future__ import annotations
13 
14from collections import Counter, defaultdict
15from pathlib import Path
16from typing import Any
17 
18from . import xctrace, xml_utils
19 
20START_KEYS = ("start", "time", "sample-time", "timestamp")
21DURATION_KEYS = ("duration", "body-duration", "update-duration")
22VIEW_KEYS = ("view-name", "view", "view-type", "name", "type")
23MODULE_KEYS = ("module",)
24CATEGORY_KEYS = ("category",)
25UPDATE_TYPE_KEYS = ("update-type",)
26SEVERITY_KEYS = ("severity",)
27DESCRIPTION_KEYS = ("description",)
28 
29HIGH_SEVERITIES = {"High", "Very High", "Severe", "Critical"}
30 
31# Ongoing / unterminated updates carry a sentinel duration (≈ UINT64_MAX-ish).
32# Any duration longer than an hour is almost certainly that sentinel and would
33# break aggregates + the correlation overlap check.
34_SENTINEL_DURATION_NS = 60 * 60 * 1_000_000_000  # 1 hour
35 
36 
37def analyze(
38    trace_path: Path,
39    toc_schemas: frozenset[str],
40    top_n: int = 10,
41    window: tuple[int, int] | None = None,
42    run: int = 1,
43) -> dict[str, Any]:
44    schemas = sorted(
45        s for s in toc_schemas
46        if s.startswith("swiftui") and not s.endswith("-causes")
47    )
48    if not schemas:
49        return {
50            "lane": "swiftui",
51            "available": False,
52            "notes": ["SwiftUI lane not in trace (Xcode 26+ SwiftUI template required)."],
53        }
54 
55    events: list[dict] = []
56    per_view_total_ns: dict[str, int] = defaultdict(int)
57    per_view_count: dict[str, int] = defaultdict(int)
58    severity_counts: Counter[str] = Counter()
59    update_type_counts: Counter[str] = Counter()
60    category_counts: Counter[str] = Counter()
61 
62    for schema in schemas:
63        xml_bytes = xctrace.export_schema(trace_path, schema, run=run)
64        stream = xml_utils.RowStream(xml_bytes)
65        for row in stream:
66            start_ns = _first_int(row, stream, START_KEYS)
67            dur_ns = _first_int(row, stream, DURATION_KEYS)
68            if start_ns is None or dur_ns is None:
69                continue
70            if dur_ns < 0 or dur_ns > _SENTINEL_DURATION_NS:
71                # Unterminated / ongoing update; skip so it doesn't poison
72                # totals and the correlation overlap check.
73                continue
74            if not xml_utils.event_overlaps_window(start_ns, start_ns + dur_ns, window):
75                continue
76 
77            view = _first_str(row, stream, VIEW_KEYS)
78            module = _first_str(row, stream, MODULE_KEYS)
79            category = _first_str(row, stream, CATEGORY_KEYS)
80            update_type = _first_str(row, stream, UPDATE_TYPE_KEYS)
81            severity = _first_str(row, stream, SEVERITY_KEYS)
82            description = _first_str(row, stream, DESCRIPTION_KEYS)
83            # Fall back through description → category → update-type so the
84            # agent sees "EnvironmentWriter: RootEnvironment" instead of
85            # "<unknown>" when SwiftUI doesn't record a view type.
86            if not view:
87                view = description or category or update_type or "<unknown>"
88 
89            per_view_total_ns[view] += dur_ns
90            per_view_count[view] += 1
91            if severity:
92                severity_counts[severity] += 1
93            if update_type:
94                update_type_counts[update_type] += 1
95            if category:
96                category_counts[category] += 1
97 
98            events.append({
99                "schema": schema,
100                "start_ns": start_ns,
101                "end_ns": start_ns + dur_ns,
102                "duration_ns": dur_ns,
103                "duration_ms": round(dur_ns / 1_000_000, 2),
104                "start_ms": round(start_ns / 1_000_000, 2),
105                "view": view,
106                "module": module,
107                "category": category,
108                "update_type": update_type,
109                "severity": severity,
110                "description": description,
111            })
112 
113    events.sort(key=lambda e: e["duration_ns"], reverse=True)
114 
115    top_by_total = sorted(
116        per_view_total_ns.items(), key=lambda kv: kv[1], reverse=True
117    )[:top_n]
118    top_offenders = [
119        {
120            "view": view,
121            "total_ms": round(total_ns / 1_000_000, 2),
122            "count": per_view_count[view],
123            "avg_ms": round(total_ns / per_view_count[view] / 1_000_000, 2),
124        }
125        for view, total_ns in top_by_total
126    ]
127 
128    high_severity = [
129        {
130            "view": e["view"],
131            "severity": e["severity"],
132            "duration_ms": e["duration_ms"],
133            "start_ms": e["start_ms"],
134            "category": e["category"],
135            "update_type": e["update_type"],
136            "description": e["description"],
137        }
138        for e in events if e["severity"] in HIGH_SEVERITIES
139    ][:top_n]
140 
141    longest = [
142        {
143            "view": e["view"],
144            "duration_ms": e["duration_ms"],
145            "start_ms": e["start_ms"],
146            "category": e["category"],
147            "update_type": e["update_type"],
148            "severity": e["severity"],
149        }
150        for e in events[:top_n]
151    ]
152 
153    return {
154        "lane": "swiftui",
155        "available": True,
156        "schemas_used": schemas,
157        "metrics": {
158            "total_events": len(events),
159            "unique_views": len(per_view_total_ns),
160            "total_duration_ms": round(
161                sum(per_view_total_ns.values()) / 1_000_000, 2
162            ),
163            "severity_breakdown": dict(severity_counts.most_common()),
164            "update_type_breakdown": dict(update_type_counts.most_common()),
165            "category_breakdown": dict(category_counts.most_common()),
166        },
167        "top_offenders": top_offenders,
168        "longest_single_events": longest,
169        "high_severity_events": high_severity,
170        "notes": [],
171        "_events": events,
172    }
173 
174 
175def _first_int(row, stream, keys):
176    for key in keys:
177        el = row.get(key)
178        if el is None:
179            continue
180        val = xml_utils.int_text(stream.resolve(el))
181        if val is not None:
182            return val
183    return None
184 
185 
186def _first_str(row, stream, keys):
187    for key in keys:
188        el = row.get(key)
189        if el is None:
190            continue
191        resolved = stream.resolve(el)
192        txt = xml_utils.str_text(resolved) or resolved.get("fmt")
193        if txt:
194            return txt
195    return None
196