#!/usr/bin/env python3
"""
Gera data/raw/: TODAS as medições de TODOS os arquivos de raw/, uma linha por
repetição individual quando ela existe, ANTES de qualquer média/mediana.

Escreve um arquivo por workload (full_raw_serving.csv, raw_ocr.csv, ...) mais
o consolidado full_raw.csv com tudo numa tabela só.

Cobre 100% do que está em raw/:
  - os JSON (com "reps" = repetições individuais, ou só o agregado)
  - os CSV que não têm JSON par (rodadas em que só o agregado foi salvo)

E preserva 100% dos metadados existentes, sem lista fixa de chaves:
  - tudo que estiver em env/meta do JSON (python, platform, seed, backend,
    warmups, input_len, model_revision, served_model, device, language, ...)
  - o que só existe no caminho e no nome do arquivo (máquina, workload,
    job Slurm, tag de imagem como NGC, GPU, tensor-parallel, output_len,
    timestamp, modelo)
"""
import json, glob, csv, os, re, sys

RAW = "raw"
# data/raw/ separa o bruto consolidado dos CSV agregados de análise em data/
OUTDIR = "data/raw"
OUT = f"{OUTDIR}/full_raw.csv"

# ordem preferida das primeiras colunas; qualquer chave nova entra depois
PREFIX = [
    "source_file", "source_format", "machine", "workload", "model",
    "gpu_name", "gpu_count", "gpu_mem_total_mib", "nvidia_driver",
    "engine_version", "engine", "timestamp_utc", "tensor_parallel",
    "output_len", "slurm_job_id", "image_tag",
]
POINT_CFG = ["concurrency", "batch_size", "dim", "audio_seconds", "doc_pages", "n_ok", "n_reps"]
IDX = ["rep_index", "is_aggregate"]


def parse_name(path):
    """extrai do caminho e do nome do arquivo tudo que dá pra extrair"""
    parts = path.split(os.sep)
    base = os.path.splitext(os.path.basename(path))[0]
    wl = base.split("_")[0] if "_" in base else base
    if wl not in KNOWN_WORKLOADS:
        # nomes fora do padrão: classifica pelo que o arquivo mede
        # (spark_ocr_full/spark_gaps_full são OCR; l40s_coder32b é serving)
        wl = "ocr" if "ocr" in base or "gaps" in base else "serving"
        meta_wl_raw = base.split("_")[0]
    else:
        meta_wl_raw = None
    meta = {
        "machine": parts[1] if len(parts) > 1 else "",
        "workload": wl,
    }
    if meta_wl_raw:
        meta["workload_from_filename"] = meta_wl_raw
    # subpastas intermediárias entre a máquina e o arquivo, se houver
    if len(parts) > 3:
        meta["subdir"] = "/".join(parts[2:-1])

    if m := re.search(r"_tp(\d+)", base):
        meta["tensor_parallel"] = m.group(1)
    if m := re.search(r"_out(\d+)", base):
        meta["output_len"] = m.group(1)
    # job do Slurm: número isolado entre underscores, 3-6 dígitos
    if m := re.search(r"_(\d{3,6})_(?:\d{6}|NGC|\d{8}-)", base):
        meta["slurm_job_id"] = m.group(1)
    # tag de imagem (ex.: NGC) marcada no nome
    if "NGC" in base:
        meta["image_tag"] = "NGC"
    # timestamp no nome: AAAAMMDD-HHMMSS
    if m := re.search(r"(\d{8}-\d{6})", base):
        meta["timestamp_name"] = m.group(1)
    # GPU no nome do arquivo (entre o workload e o resto)
    # GPU no nome: NVIDIA, AMD/Radeon (o nvidia-smi grava "?" nas AMD) e Tesla
    # GPU no nome do arquivo: basta reconhecer o padrão canônico em qualquer
    # posição, já que norm_gpu resolve a grafia (evita truncar 4090/6000/7900).
    for pat, canon in GPU_CANON:
        if re.search(pat, base.replace("_", " "), re.I):
            meta["gpu_from_name"] = canon
            break
    # modelo: o que vem depois do timestamp
    if m := re.search(r"\d{8}-\d{6}_(.+)$", base):
        meta["model_from_name"] = m.group(1).replace("_", "/", 1)
    elif m := re.search(r"_\d{6}_(.+)$", base):
        meta["model_from_name"] = m.group(1).replace("_", "/", 1)
    return meta


# os CSV de OCR gravaram o modelo como "ocrmodel"; estes são os nomes reais
OCR_ALIAS = {
    "deepseek-ocr": "deepseek-ai/DeepSeek-OCR",
    "deepseek-ocr-2": "deepseek-ai/DeepSeek-OCR",
    "numarkdown": "numind/NuMarkdown-8B-Thinking",
    "unlimited-ocr": "unlimited-ocr",
}


def model_from_ocr_name(path):
    """recupera o modelo de OCR a partir do nome do arquivo"""
    base = os.path.splitext(os.path.basename(path))[0]
    for alias, full in OCR_ALIAS.items():
        if alias in base:
            return full
    return ""


# GPUs presentes no benchmark. A grafia varia entre coletas (underscore vs
# espaço, com/sem prefixo do fabricante, sufixo de engine, job do Slurm colado),
# então casamos por padrão explícito em vez de tentar limpar o texto por regex.
GPU_CANON = [
    (r"RTX\s*PRO\s*6000",        "NVIDIA RTX PRO 6000"),
    (r"\bB200\b",                "NVIDIA B200"),
    (r"\bGB10\b",                "NVIDIA GB10"),
    (r"\bL40S\b",                "NVIDIA L40S"),
    (r"RTX\s*4090",              "NVIDIA GeForce RTX 4090"),
    (r"RTX\s*4070",              "NVIDIA GeForce RTX 4070"),
    (r"RTX\s*2080\s*Ti",         "NVIDIA GeForce RTX 2080 Ti"),
    (r"GTX\s*1080\s*Ti",         "NVIDIA GeForce GTX 1080 Ti"),
    (r"P100",                    "Tesla P100-SXM2-16GB"),
    (r"RX\s*7900\s*XT",          "Radeon RX 7900 XT"),
    (r"Radeon\s+Graphics",       "Radeon Graphics"),
]


def norm_gpu(v):
    """devolve o nome canônico da GPU a partir de qualquer grafia usada"""
    s = str(v or "").replace("_", " ").strip()
    if s in ("", "0", "?", "None"):
        return ""
    for pat, canon in GPU_CANON:
        if re.search(pat, s, re.I):
            return canon
    return re.sub(r"\s+", " ", s)


# workloads reais; nomes de arquivo que não seguem o padrão caem em "serving"
KNOWN_WORKLOADS = {"serving", "ocr", "ollama", "stt", "embed", "rerank", "vision"}


def flatten(prefix, obj, out):
    """achata dicionários aninhados em colunas prefixadas"""
    for k, v in obj.items():
        key = f"{prefix}{k}" if prefix else k
        if isinstance(v, dict):
            flatten(f"{key}_", v, out)
        elif isinstance(v, list):
            # listas curtas de escalares viram string; listas de dicts viram linhas
            if v and not isinstance(v[0], (dict, list)):
                out[key] = "|".join(str(x) for x in v)
        else:
            out[key] = v


def base_from_env(path, env, name_meta):
    """junta env/meta (TODAS as chaves) com o que veio do nome do arquivo"""
    row = {"source_file": path}
    flatten("", env, row)  # preserva toda chave de env, sem filtro
    # normaliza os campos que têm nomes alternativos entre coletas
    if not row.get("gpu_name"):
        row["gpu_name"] = env.get("gpu") or name_meta.get("gpu_from_name", "")
    # a mesma GPU aparece com grafias diferentes entre coletas; normaliza e
    # preserva o valor original em gpu_name_raw
    if row.get("gpu_name"):
        row["gpu_name_raw"] = row["gpu_name"]
        row["gpu_name"] = norm_gpu(row["gpu_name"])
    # nas GPUs AMD o nvidia-smi gravou "?"; o modelo real está no nome do arquivo
    if not row.get("gpu_name") and name_meta.get("gpu_from_name"):
        row["gpu_name"] = norm_gpu(name_meta["gpu_from_name"])
    if row.get("gpu_name"):
        row["gpu_vendor"] = ("AMD" if re.search(r"Radeon", row["gpu_name"], re.I)
                             else "NVIDIA")
    if not row.get("engine_version"):
        row["engine_version"] = str(env.get("vllm_version", "")).strip().split("\n")[-1]
    # engine: backend explícito, senão inferido de quem produziu o arquivo
    if not row.get("engine"):
        row["engine"] = env.get("backend") or (
            "vllm" if env.get("vllm_version") else
            "ollama" if env.get("ollama_num_parallel") is not None else
            "faster-whisper" if env.get("compute_type") else "")
    if not row.get("model"):
        row["model"] = env.get("served_model") or name_meta.get("model_from_name", "")
    if not row.get("timestamp_utc"):
        row["timestamp_utc"] = name_meta.get("timestamp_name", "")
    # o nome do arquivo só preenche o que o env não trouxe
    for k, v in name_meta.items():
        if k in ("gpu_from_name", "model_from_name", "timestamp_name"):
            continue
        row.setdefault(k, v)
        if not row.get(k):
            row[k] = v
    # guarda também os valores crus vindos do nome, para rastreabilidade
    for k in ("gpu_from_name", "model_from_name", "timestamp_name"):
        if k in name_meta:
            row[k] = name_meta[k]
    # tensor_parallel só foi gravado em parte das coletas; em single-GPU ele é
    # 1 por definição. Marca a origem para não confundir medido com derivado.
    if row.get("tensor_parallel") not in (None, ""):
        row["tensor_parallel_source"] = "recorded"
    elif str(row.get("gpu_count", "")) == "1":
        row["tensor_parallel"] = 1
        row["tensor_parallel_source"] = "inferred_single_gpu"
    return row


def read_jsons(rows, allcols):
    files = sorted(glob.glob(f"{RAW}/**/*.json", recursive=True))
    for path in files:
        try:
            d = json.load(open(path, encoding="utf-8"))
        except Exception as e:
            print(f"  ! JSON ilegível: {path} ({e})", file=sys.stderr)
            continue

        env = dict(d.get("env") or d.get("meta") or {})
        # chaves top-level que não sejam env/meta/points também são metadados
        for k, v in d.items():
            if k not in ("env", "meta", "points") and not isinstance(v, (dict, list)):
                env.setdefault(k, v)

        base = base_from_env(path, env, parse_name(path))
        base["source_format"] = "json"

        for point in d.get("points", []):
            cfg = {c: point.get(c, "") for c in POINT_CFG if c != "n_reps"}
            reps = point.get("reps") or []
            cfg["n_reps"] = len(reps)
            # qualquer outra chave escalar do point é metadado do ponto
            for k, v in point.items():
                if k not in POINT_CFG and k not in ("reps", "agg", "vram") and not isinstance(v, (dict, list)):
                    cfg[k] = v
            vram = point.get("vram")
            if isinstance(vram, dict):
                vram = vram.get("used_mib") or vram.get("median")

            if reps:  # uma linha por repetição individual
                for i, rep in enumerate(reps, start=1):
                    metrics = {}
                    flatten("", rep, metrics)
                    if vram is not None and "vram_used_mib" not in metrics:
                        metrics["vram_used_mib"] = vram
                    row = {**base, **cfg, "rep_index": i, "is_aggregate": 0, **metrics}
                    allcols.update(row)
                    rows.append(row)
            else:  # só o agregado foi salvo na coleta
                metrics = {}
                for src in ("agg", "vram"):
                    v = point.get(src)
                    if isinstance(v, dict):
                        flatten("" if src == "agg" else "vram_", v, metrics)
                row = {**base, **cfg, "rep_index": 0, "is_aggregate": 1, **metrics}
                allcols.update(row)
                rows.append(row)
    return len(files)


def read_orphan_csvs(rows, allcols):
    """CSV sem JSON par: rodadas em que só o agregado foi gravado"""
    have_json = {os.path.splitext(p)[0] for p in glob.glob(f"{RAW}/**/*.json", recursive=True)}
    orphans = [p for p in sorted(glob.glob(f"{RAW}/**/*.csv", recursive=True))
               if os.path.splitext(p)[0] not in have_json]
    for path in orphans:
        name_meta = parse_name(path)
        try:
            with open(path, encoding="utf-8") as fp:
                for rec in csv.DictReader(fp):
                    rec = {k: v for k, v in rec.items() if k}
                    base = base_from_env(path, {}, name_meta)
                    base["source_format"] = "csv"
                    # o CSV traz gpu/model/engine nas próprias colunas
                    if rec.get("gpu"):
                        base["gpu_name_raw"] = rec["gpu"]
                        # o CSV pode trazer "0"/"?"; nesse caso vale o nome do arquivo
                        base["gpu_name"] = (norm_gpu(rec["gpu"])
                                            or name_meta.get("gpu_from_name", ""))
                    if base.get("gpu_name"):
                        base["gpu_vendor"] = ("AMD" if re.search(r"Radeon", base["gpu_name"], re.I)
                                              else "NVIDIA")
                    if rec.get("model") and rec["model"] != "ocrmodel":
                        base["model"] = rec["model"]
                    elif not base.get("model"):
                        # CSV de OCR gravou o placeholder "ocrmodel"; o modelo
                        # real só sobrevive no nome do arquivo
                        base["model"] = (name_meta.get("model_from_name")
                                         or model_from_ocr_name(path))
                    if rec.get("model") == "ocrmodel":
                        base["model_field_raw"] = "ocrmodel"
                    for src, dst in (("engine", "engine"), ("backend", "engine"),
                                     ("gpu_count", "gpu_count"),
                                     ("vram_total_mib", "gpu_mem_total_mib")):
                        if rec.get(src):
                            base[dst] = rec[src]
                    metrics = {k: v for k, v in rec.items()
                               if k not in ("gpu", "model", "engine", "backend",
                                            "gpu_count", "vram_total_mib")}
                    row = {**base, **metrics, "rep_index": 0, "is_aggregate": 1,
                           "n_reps": rec.get("n_ok", "")}
                    allcols.update(row)
                    rows.append(row)
        except Exception as e:
            print(f"  ! CSV ilegível: {path} ({e})", file=sys.stderr)
    return len(orphans)


def metric_family(row):
    """um mesmo workload pode reunir experimentos com métricas disjuntas.
    Marcar a família evita que o leitor interprete coluna vazia como dado
    faltante, quando na verdade aquela métrica não se aplica à linha."""
    wl = row.get("workload")
    if row.get("cer_median") not in (None, ""):
        return "accuracy_cer"          # OCR: acurácia contra ground-truth
    if row.get("doc_pages") not in (None, ""):
        return "doc_latency"           # OCR: latência/throughput por documento
    if row.get("audio_seconds") not in (None, ""):
        return "audio_latency"         # STT
    if wl == "embed":
        return "embedding"
    if wl == "rerank":
        return "rerank"
    if wl == "vision":
        return "vision"
    if not row.get("is_aggregate"):
        return "serving_per_rep"       # medição individual de serving
    return "serving_aggregate"


def clean(v):
    """campos como platform/engine_version trazem quebras de linha embutidas;
    achata para que 1 linha do arquivo == 1 registro em qualquer ferramenta"""
    if isinstance(v, str) and ("\n" in v or "\r" in v):
        return " ".join(v.split())
    return v


def write_csv(path, rows, ordered_cols):
    """escreve só as colunas que este conjunto de linhas realmente usa"""
    usadas = {c for c in ordered_cols if any(r.get(c) not in (None, "") for r in rows)}
    cols = [c for c in ordered_cols if c in usadas]
    with open(path, "w", newline="", encoding="utf-8") as fp:
        w = csv.DictWriter(fp, fieldnames=cols, extrasaction="ignore")
        w.writeheader()
        for r in rows:
            w.writerow({k: clean(v) for k, v in r.items() if k in usadas})
    return len(cols)


def main():
    rows, allcols = [], set()
    n_json = read_jsons(rows, allcols)
    n_csv = read_orphan_csvs(rows, allcols)

    for r in rows:
        r["metric_family"] = metric_family(r)
        allcols.add("metric_family")

    # ordem preferida das colunas; o resto entra alfabético
    fixed = PREFIX + ["metric_family"] + POINT_CFG + IDX
    ordered = [c for c in fixed if c in allcols] + sorted(allcols - set(fixed))

    os.makedirs(OUTDIR, exist_ok=True)

    # 1) um arquivo por workload — sem a esparsidade de misturar schemas
    by_wl = {}
    for r in rows:
        by_wl.setdefault(r["workload"], []).append(r)

    print("por workload:")
    for wl, wrows in sorted(by_wl.items()):
        # serving é o único com repetições individuais, daí o nome distinto
        name = "full_raw_serving.csv" if wl == "serving" else f"raw_{wl}.csv"
        ncols = write_csv(os.path.join(OUTDIR, name), wrows, ordered)
        indiv = sum(1 for r in wrows if not r["is_aggregate"])
        tipo = f"{indiv} individuais" if indiv else "só agregados"
        print(f"  {OUTDIR}/{name:26} {len(wrows):5} linhas x {ncols:3} colunas  ({tipo})")

    # 2) o consolidado de tudo continua existindo, para quem quer uma tabela só
    ncols = write_csv(OUT, rows, ordered)
    indiv = sum(1 for r in rows if not r["is_aggregate"])
    print(f"\nconsolidado:\n  {OUT}: {len(rows)} linhas x {ncols} colunas "
          f"({indiv} individuais, {len(rows)-indiv} agregadas)")
    print(f"\nfontes: {n_json} JSON + {n_csv} CSV sem JSON par")


if __name__ == "__main__":
    main()