"""Score the YOLO11n playing-card detector (MIT, shrimantasatpati) on the
synthetic poker table dataset. Per-card class accuracy at IoU>=0.5 + timing."""
import argparse
import json
import time
from pathlib import Path

from huggingface_hub import hf_hub_download

WEIGHTS = "detect/yolo11_playing_cards/weights/best.pt"


def resolve_weights():
    try:
        return hf_hub_download("shrimantasatpati/yolov11_playing_cards_detection",
                               "detect/yolo11n_playing_cards/weights/best.pt")
    except Exception as e:
        print(f"weights download failed ({e}); trying resolve URL", flush=True)
        import urllib.request
        url = ("https://huggingface.co/shrimantasatpati/yolov11_playing_cards_detection"
               "/resolve/main/detect/yolo11n_playing_cards/weights/best.pt")
        dst = "yolo_cards.pt"
        urllib.request.urlretrieve(url, dst)
        return dst


def iou(a, b):
    ax0, ay0, ax1, ay1 = a
    bx0, by0, bx1, by1 = b
    ix = max(0, min(ax1, bx1) - max(ax0, bx0))
    iy = max(0, min(ay1, by1) - max(ay0, by0))
    inter = ix * iy
    if inter <= 0:
        return 0.0
    return inter / (((ax1 - ax0) * (ay1 - ay0)) + ((bx1 - bx0) * (by1 - by0)) - inter)


def main():
    ap = argparse.ArgumentParser()
    ap.add_argument("--images", default="dataset/images")
    ap.add_argument("--labels", default="dataset/labels")
    ap.add_argument("--limit", type=int, default=0, help="0 = all")
    ap.add_argument("--conf", type=float, default=0.1)
    ap.add_argument("--imgsz", type=int, default=1280)
    ap.add_argument("--out", default="results_yolo.json")
    args = ap.parse_args()

    from ultralytics import YOLO
    wpath = resolve_weights()
    model = YOLO(wpath)
    print("classes:", model.names, flush=True)

    img_dir, lbl_dir = Path(args.images), Path(args.labels)
    names = sorted(p.name for p in img_dir.glob("*.png"))
    if args.limit:
        names = names[: args.limit]

    correct = total = detected = 0
    correct_full = correct_glyph = det_full = det_glyph = 0
    per_image = []
    t_start = time.time()
    for name in names:
        lab = json.loads((lbl_dir / name.replace(".png", ".json")).read_text())
        t0 = time.time()
        r = model.predict(str(img_dir / name), conf=args.conf, imgsz=args.imgsz,
                          verbose=False)[0]
        dt = time.time() - t0
        dets = []
        for b, c in zip(r.boxes.xyxy.tolist(), r.boxes.cls.tolist()):
            dets.append((model.names[int(c)], b))
        img_correct = 0
        img_iou_only = 0
        img_det_full = img_det_glyph = 0
        img_correct_full = img_correct_glyph = 0
        gt_cards = lab["card_bboxes"]
        for gc in gt_cards:
            gt = gc["card"]
            # YOLO detects the corner rank/suit glyph patch, not the full card;
            # score against both the full card box and the glyph region.
            x0, y0, x1, y1 = gc["bbox"]
            glyph = [x0, y0, x0 + 0.65 * (x1 - x0), y0 + 0.45 * (y1 - y0)]
            best_cls, best_iou, best_glyph, best_bbox = None, 0.0, 0.0, None
            for cls, bb in dets:
                v = iou(gc["bbox"], bb)
                g = iou(glyph, bb)
                if g > best_glyph or (g == best_glyph and v > best_iou):
                    best_iou, best_glyph, best_cls, best_bbox = v, g, cls, bb
            hit = best_glyph >= 0.4 or best_iou >= 0.4
            cls_ok = hit and best_cls and class_matches(best_cls, gt)
            if best_iou >= 0.4:
                img_det_full += 1
                if cls_ok:
                    img_correct_full += 1
            if best_glyph >= 0.4:
                img_det_glyph += 1
                if cls_ok:
                    img_correct_glyph += 1
            if hit:
                detected += 1
                img_iou_only += 1
            if cls_ok:
                img_correct += 1
        correct += img_correct
        correct_full += img_correct_full
        correct_glyph += img_correct_glyph
        det_full += img_det_full
        det_glyph += img_det_glyph
        total += len(gt_cards)
        per_image.append({"image": name, "cards": len(gt_cards),
                          "correct": img_correct, "located": img_iou_only,
                          "sec": round(dt, 2)})
        if len(per_image) <= 3:
            print(f"[{name}] dets={[(c, [round(x) for x in b]) for c, b in dets][:5]} "
                  f"({dt:.2f}s)", flush=True)
    wall = time.time() - t_start
    summary = {
        "class_acc_iou40": round(correct / max(total, 1), 3),
        "class_acc_full_box": round(correct_full / max(total, 1), 3),
        "class_acc_glyph": round(correct_glyph / max(total, 1), 3),
        "detected_iou40": round(detected / max(total, 1), 3),
        "detected_full_box": round(det_full / max(total, 1), 3),
        "detected_glyph": round(det_glyph / max(total, 1), 3),
        "cards_total": total,
        "sec_per_image": round(wall / len(names), 2),
        "conf": args.conf,
    }
    Path(args.out).write_text(json.dumps(
        {"summary": summary, "per_image": per_image}, indent=1))
    print(json.dumps(summary, indent=2), flush=True)


def class_matches(cls, gt):
    """Map YOLO class name (e.g. 'AS', '10D') to our 'A♠' style.

    Model classes are rank+suit-letter: {0:'10C' ... 39:'AS' ... 51:'QS'}.
    """
    rank, suit = gt[:-1], gt[-1]
    suit_letter = {"♠": "S", "♥": "H", "♦": "D", "♣": "C"}[suit]
    c = cls.strip().upper()
    if len(c) < 2:
        return False
    mrank, msuit = c[:-1], c[-1]
    if msuit not in ("S", "H", "D", "C"):
        return False
    rank_ok = (mrank == rank) or (rank == "10" and mrank in ("10", "T"))
    return rank_ok and msuit == suit_letter


if __name__ == "__main__":
    main()