#!/usr/bin/env python3
import argparse
import hashlib
import json
import math
import os
from dataclasses import asdict, dataclass
from pathlib import Path
from typing import Dict, List, Tuple

import orjson
import soundfile as sf
import xxhash
from tqdm import tqdm


@dataclass
class Meta:
	id: str
	source: str
	speaker_role: str
	accent: str
	audio_length_sec: float
	domain: str
	quality: str
	audio_filepath: str
	category: str


def duration(path: Path) -> float:
	data = sf.info(str(path))
	return float(data.frames) / float(data.samplerate)


def infer_category(path: Path, audio_root: Path) -> str:
	try:
		rel = path.relative_to(audio_root)
		parts = rel.parts
		if len(parts) >= 2:
			return parts[0]
	except Exception:
		pass
	return "unknown"


def default_quality(dur: float) -> str:
	# Placeholder heuristic: use 'clean' for 16k mono segments between 2s and 30s
	if 2.0 <= dur <= 30.0:
		return "clean"
	return "medium"


def deterministic_id(path: Path) -> str:
	h = xxhash.xxh3_128_hexdigest(str(path).encode("utf-8"))
	return h


def load_source_hints(catalog_csv: Path) -> Dict[str, Dict[str, str]]:
	hints: Dict[str, Dict[str, str]] = {}
	if not catalog_csv.exists():
		return hints
	for line in catalog_csv.read_text(encoding="utf-8").splitlines():
		if not line or line.startswith("#") or line.startswith("url,"):
			continue
		parts = [p.strip() for p in line.split(",")]
		if not parts:
			continue
		url = parts[0]
		info = {
			"category": parts[1] if len(parts) > 1 else "",
			"domain": parts[2] if len(parts) > 2 else "",
			"expected_role": parts[3] if len(parts) > 3 else "",
			"license": parts[4] if len(parts) > 4 else "",
			"license_url": parts[5] if len(parts) > 5 else "",
		}
		hints[url] = info
	return hints


def main() -> None:
	parser = argparse.ArgumentParser(description="Scan audio tree and build metadata.json + {train,valid}.jsonl.")
	parser.add_argument("--audioroot", required=True, help="Root folder with audio subfolders by category")
	parser.add_argument("--outdir", required=True, help="Output folder for transcripts and metadata")
	parser.add_argument("--train-ratio", type=float, default=0.95, help="Train split ratio (rest is valid)")
	parser.add_argument("--catalog", default="sources.csv", help="Optional sources.csv for domain/role hints")
	args = parser.parse_args()

	audio_root = Path(args.audioroot)
	outdir = Path(args.outdir)
	outdir.mkdir(parents=True, exist_ok=True)

	wavs = sorted(audio_root.rglob("*_seg*.wav"))
	if not wavs:
		# fallback: any wav
		wavs = sorted(audio_root.rglob("*.wav"))

	# Build metadata
	metas: List[Meta] = []
	for w in tqdm(wavs, desc="Indexing audio"):
		dur = duration(w)
		cat = infer_category(w, audio_root)
		meta = Meta(
			id=deterministic_id(w),
			source="unknown",
			speaker_role="teacher",
			accent="",
			audio_length_sec=dur,
			domain="general",
			quality=default_quality(dur),
			audio_filepath=str(w.resolve()),
			category=cat,
		)
		metas.append(meta)

	# Balanced deterministic split by hashing id
	train_items: List[Dict] = []
	valid_items: List[Dict] = []
	for m in metas:
		h = int(m.id[:8], 16)
		r = (h % 10000) / 10000.0
		item = {
			"id": m.id,
			"audio": m.audio_filepath,
			"duration": m.audio_length_sec,
			"text": "",  # to be filled by ASR
			"source": m.source,
			"speaker_role": m.speaker_role,
			"accent": m.accent,
			"domain": m.domain,
			"quality": m.quality,
			"category": m.category,
		}
		if r < args.train_ratio:
			train_items.append(item)
		else:
			valid_items.append(item)

	with open(outdir / "train.jsonl", "w", encoding="utf-8") as f:
		for it in train_items:
			f.write(orjson.dumps(it).decode("utf-8") + "\n")
	with open(outdir / "valid.jsonl", "w", encoding="utf-8") as f:
		for it in valid_items:
			f.write(orjson.dumps(it).decode("utf-8") + "\n")

	# Global metadata.json
	with open(Path(audio_root).parent / "metadata.json", "w", encoding="utf-8") as f:
		f.write(orjson.dumps([asdict(m) for m in metas], option=orjson.OPT_INDENT_2).decode("utf-8"))

	print(f"Wrote {len(train_items)} train and {len(valid_items)} valid items.")


if __name__ == "__main__":
	main()