"""Generate a new batch of two-voice recordings with the teacher TTS. Cloud only.

Same recipe as the first batch (release/worker.py in the dataset repository):
Qwen3-TTS 1.7B Base cloning the two approved VoiceDesign references, batches of
eight, Whisper small.en screening at 15% normalized WER, one retry, peak
normalisation to 0.95. Differences: scripts come from a local JSONL, nothing is
uploaded from here (no token on the machine), and it stops at a budget deadline.

Resumable: every clip is recorded in a SQLite file; rerun the same command.
Output: <root>/audio/<id>.flac and <root>/manifest.jsonl (accepted clips, in the
JSONL form tiny_voca.prepare reads), <root>/review.jsonl (rejected clips).
"""

import argparse
import concurrent.futures
import json
import os
from pathlib import Path
import sqlite3
import time
import numpy as np
import soundfile as sf
import torch

MODEL = "Qwen/Qwen3-TTS-12Hz-1.7B-Base"
BATCH = 8


def main():
    parser = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)
    parser.add_argument("--scripts", type=Path, required=True)
    parser.add_argument("--root", type=Path, required=True)
    parser.add_argument("--references", type=Path, required=True, help="Directory with F2.wav, M2.wav")
    parser.add_argument("--voices", type=Path, required=True, help="voices.json of the first batch")
    parser.add_argument("--deadline-file", type=Path)
    parser.add_argument("--deadline-margin", type=float, default=600)
    parser.add_argument("--limit", type=int, help="Only the first N scripts (smoke test)")
    parser.add_argument("--seed", type=int, default=20261114)
    args = parser.parse_args()
    from faster_whisper import WhisperModel
    from jiwer import wer
    from qwen_tts import Qwen3TTSModel
    from scipy.signal import resample_poly
    from transformers.models.whisper.english_normalizer import EnglishTextNormalizer
    audio = args.root / "audio"
    audio.mkdir(parents=True, exist_ok=True)
    db = sqlite3.connect(args.root / "state.sqlite")
    db.execute("CREATE TABLE IF NOT EXISTS clips(id TEXT PRIMARY KEY, status TEXT, attempts INTEGER, payload TEXT)")
    db.commit()
    rows = [json.loads(line) for line in args.scripts.read_text(encoding="utf-8").splitlines() if line.strip()]
    rows = sorted(rows, key=lambda r: (r["character_count"], r["id"]))[:args.limit]
    jobs = [{"id": f"{row['id']}_{voice}", "voice": voice, "row": row} for row in rows for voice in ("F2", "M2")]
    references = json.loads(args.voices.read_text())
    started = time.time()

    def out_of_time():
        if (args.root / "STOP").exists():
            return True
        if not args.deadline_file:
            return False
        try:
            return time.time() >= json.loads(args.deadline_file.read_text())["deadline"] - args.deadline_margin
        except (OSError, ValueError, KeyError):
            return False

    def report(stage):
        counts = dict(db.execute("SELECT status, count(*) FROM clips GROUP BY status").fetchall())
        hours = sum(json.loads(p)["duration_seconds"] for (p,) in db.execute("SELECT payload FROM clips WHERE status='accepted'")) / 3600
        value = {"stage": stage, "target_clips": len(jobs), "counts": counts, "accepted_audio_hours": round(hours, 3),
                 "elapsed_seconds_this_run": round(time.time() - started), "updated": time.time()}
        temporary = args.root / "progress.json.tmp"
        temporary.write_text(json.dumps(value, indent=2))
        os.replace(temporary, args.root / "progress.json")
        print(json.dumps(value), flush=True)

    torch.set_num_threads(6)
    model = Qwen3TTSModel.from_pretrained(MODEL, device_map="cuda:0", dtype=torch.bfloat16, attn_implementation="sdpa")
    prompts = {v: model.create_voice_clone_prompt(ref_audio=str(args.references / f"{v}.wav"), ref_text=references[v]["text"],
                                                  x_vector_only_mode=False)[0] for v in ("F2", "M2")}
    asr = WhisperModel("small.en", device="cpu", compute_type="int8", cpu_threads=6)
    normalize = EnglishTextNormalizer({"cancelled": "canceled", "colour": "color", "favourite": "favorite", "centre": "center"})
    pool = concurrent.futures.ThreadPoolExecutor(max_workers=1)
    futures = []

    def analyze(batch, waves, rate, attempt, seed, batch_id, seconds):
        records = []
        for job, wave in zip(batch, waves):
            row, w = job["row"], np.asarray(wave)
            duration, peak, reasons = len(w) / rate, float(np.max(np.abs(w))) if len(w) else 0.0, []
            if not np.isfinite(w).all() or peak < 1e-5:
                reasons.append("invalid_or_silent_audio")
            if duration < 0.5 or duration > 35:
                reasons.append("duration")
            if duration > 0 and not 0.5 <= row["word_count"] / duration <= 7:
                reasons.append("speaking_rate")
            if len(w) and float(np.mean(np.abs(w) < 1e-4)) > 0.8:
                reasons.append("excessive_silence")
            transcript, error = "", 1.0
            if not reasons:
                segments, _ = asr.transcribe(resample_poly(w.astype("float32"), 2, 3), language="en", beam_size=3, condition_on_previous_text=False)
                transcript = " ".join(s.text.strip() for s in segments)
                error = wer(normalize(row["text"]), normalize(transcript) or "<empty>")
                if error > 0.15:
                    reasons.append("asr_mismatch")
            if np.isfinite(w).all() and peak > 0:
                sf.write(audio / (job["id"] + ".flac"), w * (0.95 / peak), rate, subtype="PCM_16")
            payload = {"id": job["id"], "text_id": row["id"], "voice_id": job["voice"], "text": row["text"], "split": row["split"],
                       "category": row["category"], "origin": row["origin"], "source_id": row["source_id"],
                       "source_license": row["source_license"], "source_url": row["source_url"], "teacher_model": MODEL,
                       "reference_audio": job["voice"] + ".wav", "audio": f"audio/{job['id']}.flac", "duration_seconds": round(duration, 3),
                       "generation_seed": seed, "generation_batch": batch_id, "attempt": attempt, "generation_seconds": seconds,
                       "asr_transcript": transcript, "normalized_wer": round(float(error), 4), "review_reasons": reasons}
            records.append((job["id"], "review" if reasons else "accepted", attempt, json.dumps(payload)))
        return records

    def collect(future):
        records = future.result()
        db.executemany("INSERT INTO clips(id, status, attempts, payload) VALUES(?,?,?,?) ON CONFLICT(id) DO UPDATE SET "
                       "status=excluded.status, attempts=excluded.attempts, payload=excluded.payload", records)
        db.commit()

    def generate(batch, attempt, batch_id):
        seed = args.seed + batch_id + attempt * 100000
        torch.manual_seed(seed)
        start = time.time()
        try:
            waves, rate = model.generate_voice_clone(text=[j["row"]["text"] for j in batch], language=["English"] * len(batch),
                                                     voice_clone_prompt=[prompts[j["voice"]] for j in batch], max_new_tokens=600)
        except torch.cuda.OutOfMemoryError:
            torch.cuda.empty_cache()
            if len(batch) == 1:
                raise
            middle = len(batch) // 2
            generate(batch[:middle], attempt, batch_id)
            generate(batch[middle:], attempt, batch_id + 50000)
            return
        futures.append(pool.submit(analyze, batch, waves, rate, attempt, seed, batch_id, round(time.time() - start, 3)))
        if len(futures) >= 2:
            collect(futures.pop(0))

    stopped = False
    for attempt in (1, 2):
        existing = {uid: (status, n) for uid, status, n in db.execute("SELECT id, status, attempts FROM clips")}
        pending = [j for j in jobs if (attempt == 1 and j["id"] not in existing)
                   or (attempt == 2 and j["id"] in existing and existing[j["id"]][0] == "review" and existing[j["id"]][1] < 2)]
        size = BATCH if attempt == 1 else 1
        for start in range(0, len(pending), size):
            if out_of_time():
                stopped = True
                break
            generate(pending[start:start + size], attempt, start // BATCH if attempt == 1 else start + 20000)
            if (start // size) % 16 == 15:
                report("generating")
        while futures:
            collect(futures.pop(0))
        if stopped:
            break
    pool.shutdown(wait=True)
    accepted = [json.loads(p) for (p,) in db.execute("SELECT payload FROM clips WHERE status='accepted' ORDER BY id")]
    (args.root / "manifest.jsonl").write_text("".join(json.dumps(r, ensure_ascii=False) + "\n" for r in accepted), encoding="utf-8")
    (args.root / "review.jsonl").write_text("".join(p + "\n" for (p,) in db.execute("SELECT payload FROM clips WHERE status!='accepted' ORDER BY id")), encoding="utf-8")
    report("paused" if stopped else "complete")


if __name__ == "__main__":
    main()