#!/usr/bin/env python3
"""Check integrity of icw_split dataset."""

import csv
import json
import os
from collections import defaultdict
from pathlib import Path

BASE = Path(__file__).resolve().parent
SPLITS = ["train", "val", "test"]

print("=" * 60)
print("DATASET INTEGRITY CHECK")
print("=" * 60)

# ── 1. Gather actual directories and files ───────────────────────────
actual_dirs_by_split = {}
actual_images_by_split = {}
all_actual_dirs = set()
all_actual_images = {}
total_images = 0

for split in SPLITS:
    split_path = BASE / split
    dirs = set()
    images = {}
    for d in sorted(split_path.iterdir()):
        if d.is_dir():
            dirs.add(d.name)
            imgs = sorted(f.name for f in d.iterdir() if f.is_file() and f.suffix.lower() == ".jpg")
            images[d.name] = imgs
            for img in imgs:
                all_actual_images[(d.name, img)] = split
            total_images += len(imgs)
    actual_dirs_by_split[split] = dirs
    actual_images_by_split[split] = images
    all_actual_dirs.update(dirs)

# Also check for non-.jpg files
non_jpg = []
for split in SPLITS:
    for d in (BASE / split).iterdir():
        if d.is_dir():
            for f in d.iterdir():
                if f.is_file() and f.suffix.lower() != ".jpg":
                    non_jpg.append(str(f.relative_to(BASE)))

print(f"\nActual directories: train={len(actual_dirs_by_split['train'])}, "
      f"val={len(actual_dirs_by_split['val'])}, "
      f"test={len(actual_dirs_by_split['test'])}")
print(f"Total unique dirs: {len(all_actual_dirs)}")
print(f"Total images: {total_images}")
print(f"Non-jpg files: {len(non_jpg)} {' '.join(non_jpg) if non_jpg else '(none)'}")

# ── 2. Check cross-split duplication ─────────────────────────────────
print("\n── Cross-split duplication ──")
train_set = set(actual_dirs_by_split["train"])
val_set   = set(actual_dirs_by_split["val"])
test_set  = set(actual_dirs_by_split["test"])

tv_overlap = train_set & val_set
tt_overlap = train_set & test_set
vt_overlap = val_set & test_set

if tv_overlap:
    print(f"WARNING: train ∩ val = {len(tv_overlap)} cats: {sorted(tv_overlap)[:20]}...")
if tt_overlap:
    print(f"WARNING: train ∩ test = {len(tt_overlap)} cats: {sorted(tt_overlap)[:20]}...")
if vt_overlap:
    print(f"WARNING: val ∩ test = {len(vt_overlap)} cats: {sorted(vt_overlap)[:20]}...")
if not tv_overlap and not tt_overlap and not vt_overlap:
    print("OK - no cross-split duplication")

# ── 3. Parse cats.csv ─────────────────────────────────────────────────
print("\n── cats.csv ──")
cats_csv_path = BASE / "cats.csv"
cats_csv_cats = set()
cats_csv_rows = 0
cats_csv_malformed = 0
cats_csv_extra_cols = []
cats_expected_cols = 9

with open(cats_csv_path, "r", encoding="utf-8-sig") as f:
    # Try csv module first
    reader = csv.reader(f)
    header = next(reader)
    expected_header = ["cat_folder","source","source_name","animal_id","name","breed","gender","referer_url","metadata_json"]
    if header != expected_header:
        print(f"WARNING: cats.csv header mismatch")
        print(f"  Expected: {expected_header}")
        print(f"  Got:      {header}")

    for i, row in enumerate(reader, start=1):
        if len(row) != cats_expected_cols:
            cats_csv_malformed += 1
            cats_csv_extra_cols.append((i, len(row)))
            continue
        cats_csv_cats.add(row[0])  # cat_folder
        cats_csv_rows += 1

print(f"Total rows (well-formed): {cats_csv_rows}")
print(f"Malformed rows (wrong col count): {cats_csv_malformed}")
if cats_csv_malformed:
    print(f"  First 10: {cats_csv_extra_cols[:10]}")
print(f"Unique cat_folders: {len(cats_csv_cats)}")

# ── 3b. Check cats.csv vs actual directories ─────────────────────────
print("\n── cats.csv vs actual dirs ──")
dirs_not_in_csv = all_actual_dirs - cats_csv_cats
csv_not_in_dirs = cats_csv_cats - all_actual_dirs

if dirs_not_in_csv:
    print(f"WARNING: {len(dirs_not_in_csv)} dir(s) exist but NOT in cats.csv:")
    for d in sorted(dirs_not_in_csv)[:30]:
        split = [s for s in SPLITS if d in actual_dirs_by_split[s]][0]
        print(f"  {d} (in {split})")
else:
    print("OK - all actual dirs found in cats.csv")

if csv_not_in_dirs:
    print(f"WARNING: {len(csv_not_in_dirs)} cat(s) in cats.csv but no directory:")
    for d in sorted(csv_not_in_dirs)[:30]:
        print(f"  {d}")
else:
    print("OK - all cats.csv entries have corresponding dirs")

# ── 4. Parse metadata.csv ────────────────────────────────────────────
print("\n── metadata.csv ──")
meta_csv_path = BASE / "metadata.csv"
meta_csv_entries = set()  # (cat_folder, image_filename)
meta_csv_rows = 0
meta_csv_malformed = 0
meta_csv_extra_cols = []
meta_expected_cols = 16
meta_cat_image_counts = defaultdict(int)

with open(meta_csv_path, "r", encoding="utf-8-sig") as f:
    reader = csv.reader(f)
    header = next(reader)
    expected_meta_header = [
        "cat_folder","image_filename","source","source_name","animal_id",
        "name","breed","gender","image_url","referer_url",
        "norm_x","norm_y","norm_w","norm_h","assignment_id","metadata_json"
    ]
    if header != expected_meta_header:
        print(f"WARNING: metadata.csv header mismatch")
        diff = [(i, a, b) for i, (a, b) in enumerate(zip(header, expected_meta_header)) if a != b]
        print(f"  Differences: {diff}")
    if len(header) != meta_expected_cols:
        print(f"WARNING: header has {len(header)} cols, expected {meta_expected_cols}")

    for i, row in enumerate(reader, start=1):
        if len(row) != meta_expected_cols:
            meta_csv_malformed += 1
            meta_csv_extra_cols.append((i, len(row)))
            continue
        meta_csv_entries.add((row[0], row[1]))
        meta_cat_image_counts[row[0]] += 1
        meta_csv_rows += 1

print(f"Total rows (well-formed): {meta_csv_rows}")
print(f"Malformed rows (wrong col count): {meta_csv_malformed}")
if meta_csv_malformed:
    print(f"  First 10: {meta_csv_extra_cols[:10]}")
print(f"Unique (cat_folder, image) pairs: {len(meta_csv_entries)}")
print(f"Unique cat_folders in metadata: {len(meta_cat_image_counts)}")

# ── 5. Check metadata.csv vs actual images ───────────────────────────
print("\n── metadata.csv vs actual images ──")
actual_image_set = set(all_actual_images.keys())  # (cat_folder, image_filename)

images_not_in_meta = actual_image_set - meta_csv_entries
meta_not_actual = meta_csv_entries - actual_image_set

if images_not_in_meta:
    print(f"WARNING: {len(images_not_in_meta)} image(s) exist on disk but NOT in metadata.csv:")
    for cat, img in sorted(images_not_in_meta)[:30]:
        split = all_actual_images[(cat, img)]
        print(f"  {cat}/{img} (in {split})")
else:
    print("OK - all actual images found in metadata.csv")

if meta_not_actual:
    print(f"WARNING: {len(meta_not_actual)} entry(s) in metadata.csv but no file on disk:")
    for cat, img in sorted(meta_not_actual)[:30]:
        print(f"  {cat}/{img}")
else:
    print("OK - all metadata.csv entries have corresponding files")

# ── 6. Check image counts match between actual and metadata per cat ──
print("\n── Image counts per cat: disk vs metadata.csv ──")
count_mismatches = []
for cat_id in all_actual_dirs:
    actual_count = 0
    for split in SPLITS:
        if cat_id in actual_images_by_split[split]:
            actual_count = len(actual_images_by_split[split][cat_id])
            break
    meta_count = meta_cat_image_counts.get(cat_id, 0)
    if actual_count != meta_count:
        count_mismatches.append((cat_id, actual_count, meta_count))

if count_mismatches:
    print(f"WARNING: {len(count_mismatches)} cat(s) have mismatched image counts:")
    for cat, a, m in sorted(count_mismatches)[:30]:
        print(f"  {cat}: disk={a}, metadata={m}")
else:
    print("OK - all image counts match")

# ── 7. Check image file integrity (corrupt JPGs) ─────────────────────
print("\n── Image file integrity ──")
corrupt_count = 0
corrupt_files = []
empty_files = 0

for (cat, img), split in all_actual_images.items():
    fpath = BASE / split / cat / img
    try:
        fsize = fpath.stat().st_size
        if fsize == 0:
            empty_files += 1
            corrupt_files.append(f"{split}/{cat}/{img} (empty)")
            continue
        # Check JPEG magic bytes
        with open(fpath, "rb") as ff:
            magic = ff.read(4)
        if magic[:2] != b'\xff\xd8':
            corrupt_count += 1
            corrupt_files.append(f"{split}/{cat}/{img} (bad magic: {magic.hex()})")
    except Exception as e:
        corrupt_count += 1
        corrupt_files.append(f"{split}/{cat}/{img} (error: {e})")

if empty_files > 0:
    print(f"WARNING: {empty_files} empty file(s)")
if corrupt_count > 0:
    print(f"WARNING: {corrupt_count} corrupt/readable JPG(s)")
    for f in corrupt_files[:30]:
        print(f"  {f}")
else:
    print(f"OK - all {total_images} images pass JPG magic byte check")

# ── 8. Spot-check bounding box values ────────────────────────────────
print("\n── Bounding box sanity check ──")
bb_out_of_range = 0
bb_zero_area = 0
with open(meta_csv_path, "r", encoding="utf-8-sig") as f:
    reader = csv.reader(f)
    next(reader)
    for i, row in enumerate(reader, start=1):
        if len(row) != meta_expected_cols:
            continue
        try:
            nx, ny, nw, nh = float(row[10]), float(row[11]), float(row[12]), float(row[13])
        except ValueError:
            continue
        if not (0 <= nx <= 1 and 0 <= ny <= 1 and 0 <= nw <= 1 and 0 <= nh <= 1):
            bb_out_of_range += 1
        if nw <= 0 or nh <= 0:
            bb_zero_area += 1

if bb_out_of_range:
    print(f"WARNING: {bb_out_of_range} rows have bbox values outside [0,1]")
else:
    print("OK - all bbox values in [0,1] range")
if bb_zero_area:
    print(f"WARNING: {bb_zero_area} rows have zero-area bbox")
else:
    print("OK - no zero-area bboxes")

# ── 9. Split ratios ─────────────────────────────────────────────────
print("\n── Split statistics ──")
for split in SPLITS:
    n_cats = len(actual_dirs_by_split[split])
    n_imgs = sum(len(v) for v in actual_images_by_split[split].values())
    print(f"  {split:6s}: {n_cats:>6} cats, {n_imgs:>6} images, "
          f"avg={n_imgs/n_cats:.1f} imgs/cat")

# ── 10. Summary ──────────────────────────────────────────────────────
print("\n" + "=" * 60)
print("SUMMARY")
print("=" * 60)
issues = []
if cats_csv_malformed: issues.append(f"{cats_csv_malformed} malformed rows in cats.csv")
if meta_csv_malformed: issues.append(f"{meta_csv_malformed} malformed rows in metadata.csv")
if dirs_not_in_csv: issues.append(f"{len(dirs_not_in_csv)} dirs missing from cats.csv")
if csv_not_in_dirs: issues.append(f"{len(csv_not_in_dirs)} cats.csv entries with no dir")
if images_not_in_meta: issues.append(f"{len(images_not_in_meta)} images missing from metadata.csv")
if meta_not_actual: issues.append(f"{len(meta_not_actual)} metadata entries with no file")
if count_mismatches: issues.append(f"{len(count_mismatches)} cats with mismatched image counts")
if corrupt_count: issues.append(f"{corrupt_count} corrupt JPGs")
if empty_files: issues.append(f"{empty_files} empty files")
if non_jpg: issues.append(f"{len(non_jpg)} non-JPG files")
if tv_overlap or tt_overlap or vt_overlap: issues.append("cross-split duplication detected")

if issues:
    print("ISSUES FOUND:")
    for iss in issues:
        print(f"  - {iss}")
else:
    print("Dataset is clean! No issues found.")