"""Export the raw A2A-MetaTrace capture JSON into a HuggingFace-style dataset.

Each generation run (``corpus.run_corpus``) writes a capture document
``results/corpus/a2a_metatrace.json`` whose ``messages`` list is a flat sequence of
metadata-only records ``obs(m)`` with workflow ground-truth labels.
This script turns that capture into the layout the HuggingFace Hub expects:

* one Parquet file per config under ``data/<config>/train.parquet`` (message-level rows,
  the natural tabular form; reconstruct a workflow by grouping on ``trace_id``), and
* a dataset card ``README.md`` whose YAML front matter declares the ``configs`` and
  ``dataset_info`` so ``datasets.load_dataset("<repo>", "<config>")`` just works.

Run:
    uv run python scripts/export_hf.py
The published artifact is ``data/*.parquet`` + ``README.md``; the raw JSON is an
intermediate (gitignored). The prose datasheet lives in ``DATASHEET.md``.
"""

from __future__ import annotations

import json
from pathlib import Path

import pandas as pd

ROOT = Path(__file__).resolve().parents[1]
CORPUS = ROOT / "results" / "corpus"
DATA = ROOT / "data"

# capture file -> (config name, mode, transport). A config is one coherent slice a
# consumer would load on its own; mode/transport ride along as columns too.
CONFIGS: list[tuple[str, str, str, str]] = [
    # traffic from real official a2a-samples agents
    ("a2a_metatrace.json", "default", "agents", "https"),
]

# The message-level row schema. Order is the dataset's column order; dtypes are the
# HuggingFace feature dtypes the card advertises.
SCHEMA: list[tuple[str, str]] = [
    ("trace_id", "int64"),       # workflow id; group on this to reconstruct a workflow
    ("task_class", "string"),    # the label an adversary recovers
    ("variant", "string"),       # the concrete composition (group for leave-variant-out)
    ("client_id", "string"),     # orchestrating client (opaque token)
    ("n_stages", "int32"),       # stages in this workflow
    ("stage_idx", "int32"),      # which stage this message belongs to
    ("step_type", "string"),     # discovery_query|discovery_result|request|update|response
    ("direction", "string"),     # c2s | s2c
    ("src", "string"),           # opaque source endpoint token
    ("dst", "string"),           # opaque destination endpoint token
    ("t", "float64"),            # relative timestamp (seconds)
    ("length", "int64"),         # wire byte length of the message (the obs(m) volume axis)
    ("capability", "string"),    # capability named at this stage
    ("label_visible", "bool"),   # whether the semantic label is visible at this message
    ("mode", "string"),          # agent backend
    ("transport", "string"),     # transport the capture ran over
]


def _frame(capture: dict, mode: str, transport: str) -> pd.DataFrame:
    rows = []
    for m in capture["messages"]:
        row = {name: m.get(name) for name, _ in SCHEMA if name not in ("mode", "transport")}
        row["mode"], row["transport"] = mode, transport
        rows.append(row)
    df = pd.DataFrame(rows, columns=[n for n, _ in SCHEMA])
    for name, dtype in SCHEMA:
        df[name] = df[name].astype(dtype)
    return df


def _features_yaml() -> list[str]:
    return [f"  - name: {n}\n    dtype: {d}" for n, d in SCHEMA]


def _front_matter(stats: list[dict]) -> str:
    configs = []
    info = []
    for s in stats:
        configs.append(
            f"- config_name: {s['config']}\n"
            f"  data_files:\n"
            f"  - split: train\n"
            f"    path: data/{s['config']}/train.parquet"
        )
        info.append(
            f"- config_name: {s['config']}\n"
            f"  features:\n" + "\n".join(_features_yaml()) + "\n"
            f"  splits:\n"
            f"  - name: train\n"
            f"    num_examples: {s['rows']}"
        )
    total = sum(s["rows"] for s in stats)
    size_bucket = ("1K<n<10K" if total < 10_000 else
                   "10K<n<100K" if total < 100_000 else "100K<n<1M")
    return (
        "---\n"
        "pretty_name: A2A-MetaTrace\n"
        "task_categories:\n- tabular-classification\n"
        "tags:\n"
        "- traffic-analysis\n- metadata-privacy\n- agent\n- a2a\n"
        "- multi-agent\n- workflow-fingerprinting\n"
        f"size_categories:\n- {size_bucket}\n"
        "configs:\n" + "\n".join(configs) + "\n"
        "dataset_info:\n" + "\n".join(info) + "\n"
        "---\n"
    )


def _body(stats: list[dict]) -> str:
    rows = "\n".join(
        f"| `{s['config']}` | {s['mode']} | {s['transport']} | {s['workflows']} | "
        f"{s['classes']} | {s['variants']} | {s['rows']} |"
        for s in stats
    )
    return f"""# A2A-MetaTrace

A labeled, **metadata-only** corpus of multi-agent **A2A** (Agent-to-Agent) workflow
traffic. Each row is one wire message reduced to what a passive network observer sees,
`obs(m) = (src, dst, t, length, direction)`, with workflow ground-truth labels; message
bodies are discarded. The corpus exists to study how much of a *pending agent workflow*
leaks from communication-graph metadata alone, and to evaluate metadata-protecting
transports against it.

**Provenance (disclosed).** Workflows run over the real `a2a-sdk` protocol path
(Agent Cards, discovery, `message/send`, SSE) against real official `a2a-samples` agent
servers backed by real language-model calls. The workflow *compositions* and *labels*
are ours (see `DATASHEET.md`). This is the honest provenance claim: the protocol path and
agent behavior are real; the composition is designed.

## Config

| config | agent backend | transport | workflows | classes | variants | rows (messages) |
|---|---|---|---|---|---|---|
{rows}

The corpus is captured from official `a2a-samples` agents composed into multi-agent
workflows; transport is HTTPS-direct (the metadata-protecting transport is evaluated
analytically; see `DATASHEET.md`).

## Usage

```python
from datasets import load_dataset
import pandas as pd

ds = load_dataset("a2a-metatrace", split="train")   # message-level rows
df = ds.to_pandas()

# reconstruct workflows and their labels by grouping on trace_id
by_wf = df.groupby("trace_id")
labels = by_wf["task_class"].first()
```

A workflow is the unit an adversary classifies; featurize per `trace_id` (message counts,
length stats, timing, direction n-grams) and recover `task_class`. Use the `variant`
column for a **leave-variant-out** split (generalization to unseen compositions).

## Regenerating the corpus

The published Parquet is produced by capturing real official `a2a-samples` agents. To
reproduce it end to end:

1. **Get the agents.** Clone the official samples repo and point the harness at its
   Python agents directory:
   ```bash
   git clone https://github.com/a2aproject/a2a-samples.git
   export A2A_SAMPLES_DIR=$(pwd)/a2a-samples/samples/python/agents
   ```
2. **Provide model credentials.** The sample agents call real models:
   - `export OPENAI_API_KEY=...` (the OpenAI- and LiteLLM-backed agents), and
   - for the Google-ADK agents, a Vertex project via Application Default Credentials:
     `export GOOGLE_CLOUD_PROJECT=...` and `gcloud auth application-default login`.

   Keys may instead be placed in a local `.envrc` (`export KEY=VALUE` lines); see
   `corpus/sample_agents.py` for all configuration variables.
3. **Install and run** (Python 3.13):
   ```bash
   uv sync
   uv run python -m corpus.run_corpus --runs-per-class 30   # writes results/corpus/a2a_metatrace.json
   uv run python scripts/export_hf.py                        # writes data/ + this README
   ```

See `DATASHEET.md` for the workflow classes, provenance, and disclosed model substitutions.

## What it is for

- **Workflow-fingerprinting / traffic analysis** on agent interoperation traffic.
- **Evaluating metadata-protecting transports** for agent interoperation.
- A reproducible, provenance-disclosed alternative to purely synthetic agent-traffic models.

See `DATASHEET.md` for construction, intended use, and limitations. Regenerate this card
and the Parquet files with `uv run python scripts/export_hf.py`.

## Citation

```bibtex
@misc{{a2ametatrace,
  title  = {{A2A-MetaTrace: a metadata-only corpus of multi-agent A2A workflow traffic}},
  author = {{Dangol, Bijaya}},
  year   = {{2026}}
}}
```
"""


def main() -> None:
    stats: list[dict] = []
    for fname, config, mode, transport in CONFIGS:
        src = CORPUS / fname
        if not src.exists():
            print(f"skip {config}: no capture at {src.name}")
            continue
        cap = json.loads(src.read_text())
        df = _frame(cap, mode, transport)
        out = DATA / config
        out.mkdir(parents=True, exist_ok=True)
        df.to_parquet(out / "train.parquet", index=False)
        stats.append({
            "config": config, "mode": mode, "transport": transport,
            "rows": len(df), "workflows": int(df["trace_id"].nunique()),
            "classes": int(df["task_class"].nunique()),
            "variants": int(df["variant"].nunique()),
        })
        print(f"wrote data/{config}/train.parquet  "
              f"({len(df)} rows, {df['trace_id'].nunique()} workflows)")

    if not stats:
        print("no captures found; run `python -m corpus.run_corpus` first")
        return
    (ROOT / "README.md").write_text(_front_matter(stats) + "\n" + _body(stats))
    print(f"wrote README.md (dataset card) for {len(stats)} configs")


if __name__ == "__main__":
    main()