#!/usr/bin/env python
# encoding: utf-8

import argparse
import json
import os
from glob import glob


def load_json(path):
    with open(path, "r") as handle:
        return json.load(handle)


def summarize_trace(path):
    payload = load_json(path)
    metrics = payload["metrics"]
    base = metrics["base"]
    best_name, best_metrics = max(
        [(name, values) for name, values in metrics.items() if name != "base"],
        key=lambda item: item[1]["mAP"],
    )
    oracle = payload.get("oracle", {})
    usage = oracle.get("best_candidate_usage", {})
    base_best = usage.get("base", 0)
    query_count = oracle.get("query_count", 0)
    return {
        "dataset": payload.get("dataset", os.path.basename(path)),
        "base_rank1": base["Rank-1"],
        "base_map": base["mAP"],
        "best_fixed": best_name,
        "best_fixed_map": best_metrics["mAP"],
        "oracle_rank1": oracle.get("oracle_Rank1_by_query_rank1", 0.0),
        "oracle_map": oracle.get("oracle_mAP_by_query_ap", 0.0),
        "improved_queries": oracle.get("queries_improved_over_base", 0),
        "query_count": query_count,
        "base_best": base_best,
    }


def summarize_exchange(path, topk=8):
    payload = load_json(path)
    rows = []
    for name, values in payload.get("results", {}).items():
        row = {"candidate": name}
        row.update(values)
        rows.append(row)
    rows.sort(key=lambda item: item["ownership_gap"], reverse=True)
    return {
        "path": path,
        "num_samples": payload.get("num_samples", 0),
        "valid_anchors": payload.get("valid_anchors", 0),
        "top_positive": rows[:topk],
        "top_negative": list(reversed(rows[-topk:])),
    }


def summarize_crfa(path):
    payload = load_json(path)
    history = payload.get("history", [])
    if not history:
        return None
    last = history[-1]
    loss_cfg = payload.get("loss_cfg", {})
    weights = loss_cfg.get("weights") or payload.get("loss_weights", {})
    mode = loss_cfg.get("mode")
    if mode is None and weights:
        mode = "softplus"
    return {
        "file": os.path.basename(path),
        "mode": mode or "unknown",
        "same_weight": weights.get("same", 0.0),
        "diff_weight": weights.get("diff", 0.0),
        "view_weight": weights.get("view", 0.0),
        "iter": last.get("iter", payload.get("max_iters", 0)),
        "loss": last.get("loss", 0.0),
        "ownership_gap": last.get("ownership_gap", 0.0),
        "same_gain": last.get("same_gain", 0.0),
        "diff_gain": last.get("diff_gain", 0.0),
        "view_shift_abs": last.get("view_shift_abs", 0.0),
    }


def summarize_crfa_eval(path):
    payload = load_json(path)
    rows = []
    for name, values in payload.get("summary", {}).items():
        row = {"file": os.path.basename(path), "candidate": name}
        row.update(values)
        rows.append(row)
    return rows


def print_trace_summary(rows):
    print("Trace diagnostics")
    print(
        "dataset,base_rank1,base_mAP,best_fixed,best_fixed_mAP,"
        "oracle_rank1,oracle_mAP,improved_queries,base_best"
    )
    for row in rows:
        print(
            f"{row['dataset']},{row['base_rank1']:.2f},{row['base_map']:.2f},"
            f"{row['best_fixed']},{row['best_fixed_map']:.2f},"
            f"{row['oracle_rank1']:.2f},{row['oracle_map']:.2f},"
            f"{row['improved_queries']}/{row['query_count']},"
            f"{row['base_best']}/{row['query_count']}"
        )


def print_exchange_summary(summary):
    print("\nExchange diagnostics")
    print(f"path={summary['path']}")
    print(f"samples={summary['num_samples']} valid_anchors={summary['valid_anchors']}")
    print("top positive ownership gaps:")
    for row in summary["top_positive"]:
        print(
            f"  {row['candidate']}: gap={row['ownership_gap']:.6f}, "
            f"same={row['delta_same_mean']:.6f}, diff={row['delta_diff_mean']:.6f}, "
            f"gap_pos={row['gap_positive_ratio']:.3f}"
        )
    print("top negative ownership gaps:")
    for row in summary["top_negative"]:
        print(
            f"  {row['candidate']}: gap={row['ownership_gap']:.6f}, "
            f"same={row['delta_same_mean']:.6f}, diff={row['delta_diff_mean']:.6f}, "
            f"gap_pos={row['gap_positive_ratio']:.3f}"
        )


def print_crfa_summary(rows):
    print("\nCRFA training diagnostics")
    print("file,mode,same_w,diff_w,view_w,iter,loss,ownership_gap,same_gain,diff_gain,view_shift_abs")
    for row in rows:
        print(
            f"{row['file']},{row['mode']},{row['same_weight']:.2f},{row['diff_weight']:.2f},"
            f"{row['view_weight']:.2f},{row['iter']:.0f},{row['loss']:.6f},"
            f"{row['ownership_gap']:.6f},{row['same_gain']:.6f},"
            f"{row['diff_gain']:.6f},{row['view_shift_abs']:.6f}"
        )


def print_crfa_eval_summary(rows):
    print("\nCRFA held-out exchange diagnostics")
    print("file,candidate,valid_anchors,ownership_gap,same_gain,diff_gain,gap_pos,same_pos,diff_nonpos")
    for row in rows:
        print(
            f"{row['file']},{row['candidate']},{row['valid_anchors']},"
            f"{row['ownership_gap']:.6f},{row['same_gain']:.6f},"
            f"{row['diff_gain']:.6f},{row['gap_positive_ratio']:.3f},"
            f"{row['same_positive_ratio']:.3f},{row['diff_nonpositive_ratio']:.3f}"
        )


def parse_args():
    parser = argparse.ArgumentParser(description="Summarize CAVI diagnostic JSON files")
    parser.add_argument("--dir", default="logs/CARGO/CAVI_TRACE")
    parser.add_argument("--exchange", default=None)
    parser.add_argument("--crfa-glob", default="crfa_*.json")
    parser.add_argument("--crfa-eval-glob", default="crfa_eval*.json")
    parser.add_argument("--topk", type=int, default=8)
    return parser.parse_args()


def main():
    args = parse_args()
    trace_paths = sorted(
        path for path in glob(os.path.join(args.dir, "*_trace.json"))
        if not os.path.basename(path).startswith("smoke")
    )
    if trace_paths:
        print_trace_summary([summarize_trace(path) for path in trace_paths])
    exchange_path = args.exchange or os.path.join(args.dir, "exchange_smoke.json")
    if os.path.exists(exchange_path):
        print_exchange_summary(summarize_exchange(exchange_path, args.topk))
    crfa_rows = []
    for path in sorted(glob(os.path.join(args.dir, args.crfa_glob))):
        row = summarize_crfa(path)
        if row is not None:
            crfa_rows.append(row)
    if crfa_rows:
        print_crfa_summary(crfa_rows)
    eval_rows = []
    for path in sorted(glob(os.path.join(args.dir, args.crfa_eval_glob))):
        eval_rows.extend(summarize_crfa_eval(path))
    if eval_rows:
        print_crfa_eval_summary(eval_rows)


if __name__ == "__main__":
    main()