#!/usr/bin/env python3
"""
Quranic Recitation Audio Standardizer
======================================
Converts 14 reciters' verse-level MP3 audio into Opus format and generates
word-by-word (WBW) timing JSON metadata from individual word MP3 segments.

Source structure:
  audio/ayahs/{reciter_slug}/{surahId}{verseId}.mp3   (verse audio)
  audio/words/{surahId}_{verseId}_{wordPos}.mp3        (word-level audio)

Target structure (matches reference: abdul-basit-abdul-samad-mujawwad-hafs-949/):
  {reciter_slug}/{surahId_3digit}/{surahId_3digit}{verseId_3digit}.opus
  {reciter_slug}/{surahId_3digit}/{surahId_3digit}{verseId_3digit}.json

JSON format: [[word_idx, word_id, start_ms, end_ms], ...]
"""

import json
import os
import struct
import subprocess
import sys
import glob
import time
from pathlib import Path
from collections import defaultdict
from concurrent.futures import ProcessPoolExecutor, as_completed

# ─── Configuration ─────────────────────────────────────────────────────────
BASE_DIR = Path(__file__).resolve().parent
AUDIO_DIR = BASE_DIR / "audio"
AYAHS_DIR = AUDIO_DIR / "ayahs"
WORDS_DIR = AUDIO_DIR / "words"
DATA_DIR = AUDIO_DIR / "data"

# Opus encoding settings (matching reference: mono, 16kHz input sample rate)
OPUS_BITRATE = "32k"
OPUS_SAMPLE_RATE = "16000"

# Parallelism for ffmpeg conversions
MAX_WORKERS = min(os.cpu_count() or 4, 8)


# ─── MP3 Duration Calculator (no ffprobe needed) ──────────────────────────
# MP3 bitrate lookup tables
BITRATE_TABLE_V1_L3 = [0, 32, 40, 48, 56, 64, 80, 96, 112, 128, 160, 192, 224, 256, 320, 0]
SAMPLE_RATE_TABLE_V1 = [44100, 48000, 32000, 0]

def get_mp3_duration_ms_fast(filepath: Path) -> int:
    """
    Estimate MP3 duration from file size and bitrate header.
    Much faster than calling ffprobe for each file.
    Falls back to file-size-based estimation for CBR files.
    """
    try:
        file_size = filepath.stat().st_size
        with open(filepath, 'rb') as f:
            # Skip ID3v2 tag if present
            header = f.read(10)
            offset = 0
            if header[:3] == b'ID3':
                tag_size = (header[6] << 21) | (header[7] << 14) | (header[8] << 7) | header[9]
                offset = tag_size + 10
                f.seek(offset)
            else:
                f.seek(0)
            
            # Find sync word (0xFFE0 or higher)
            data = f.read(4)
            attempts = 0
            while len(data) == 4 and attempts < 2048:
                if data[0] == 0xFF and (data[1] & 0xE0) == 0xE0:
                    break
                f.seek(f.tell() - 3)
                data = f.read(4)
                attempts += 1
            
            if len(data) < 4 or data[0] != 0xFF or (data[1] & 0xE0) != 0xE0:
                # Fallback: assume 64kbps CBR
                return int((file_size * 8) / 64)
            
            # Parse MPEG frame header
            version = (data[1] >> 3) & 0x03  # 00=2.5, 01=reserved, 10=2, 11=1
            layer = (data[1] >> 1) & 0x03     # 01=III, 10=II, 11=I
            bitrate_idx = (data[2] >> 4) & 0x0F
            srate_idx = (data[2] >> 2) & 0x03
            
            if version == 0x03 and layer == 0x01:  # MPEG1 Layer III
                bitrate = BITRATE_TABLE_V1_L3[bitrate_idx]
                srate = SAMPLE_RATE_TABLE_V1[srate_idx]
            else:
                # Fallback for other MPEG versions
                bitrate = 64
                srate = 44100
            
            if bitrate == 0:
                bitrate = 64  # fallback
            
            # audio_size = file_size - offset (roughly)
            audio_size = file_size - offset
            duration_ms = int((audio_size * 8) / bitrate)
            return duration_ms
    except Exception:
        return 0


# ─── Pre-compute all word durations ────────────────────────────────────────
def build_word_duration_cache() -> dict:
    """
    Scan all word MP3 files once and build a lookup:
      (surah_id, verse_id) -> [(word_pos, duration_ms), ...]
    Sorted by word_pos.
    """
    print("  Building word duration cache from MP3 headers...")
    start = time.time()
    
    cache = defaultdict(list)
    word_files = sorted(WORDS_DIR.glob("*.mp3"))
    total = len(word_files)
    
    for i, wf in enumerate(word_files):
        # Parse filename: {surah}_{verse}_{word}.mp3
        parts = wf.stem.split("_")
        if len(parts) != 3:
            continue
        
        surah_id = int(parts[0])
        verse_id = int(parts[1])
        word_pos = int(parts[2])
        
        duration_ms = get_mp3_duration_ms_fast(wf)
        cache[(surah_id, verse_id)].append((word_pos, duration_ms))
        
        if (i + 1) % 20000 == 0:
            print(f"    Scanned {i+1}/{total} word files...")
    
    # Sort each verse's words by position
    for key in cache:
        cache[key].sort(key=lambda x: x[0])
    
    elapsed = time.time() - start
    print(f"  ✓ Cached {total} word durations for {len(cache)} verses in {elapsed:.1f}s")
    
    return dict(cache)


# ─── Load metadata ─────────────────────────────────────────────────────────
def load_number_of_ayahs():
    """Load the number of ayahs per surah from metadata."""
    with open(DATA_DIR / "number_of_ayahs.json", "r") as f:
        data = json.load(f)
    return {int(k): int(v) for k, v in data.items()}


# ─── Conversion functions ──────────────────────────────────────────────────
def convert_mp3_to_opus(input_mp3: Path, output_opus: Path) -> bool:
    """Convert an MP3 file to Opus format matching reference specs."""
    try:
        result = subprocess.run(
            [
                "ffmpeg", "-y", "-hide_banner", "-loglevel", "error",
                "-i", str(input_mp3),
                "-c:a", "libopus",
                "-b:a", OPUS_BITRATE,
                "-ac", "1",
                "-ar", OPUS_SAMPLE_RATE,
                "-vbr", "on",
                "-application", "audio",
                str(output_opus)
            ],
            capture_output=True, text=True, timeout=60
        )
        return output_opus.exists()
    except (subprocess.TimeoutExpired, FileNotFoundError) as e:
        return False


def generate_wbw_json_from_cache(surah_id: int, verse_id: int, word_cache: dict) -> list:
    """Generate WBW timing data from pre-computed word durations."""
    words = word_cache.get((surah_id, verse_id), [])
    if not words:
        return []
    
    wbw_data = []
    cumulative_ms = 0
    
    for idx, (word_pos, duration_ms) in enumerate(words):
        start_ms = cumulative_ms
        end_ms = cumulative_ms + duration_ms
        wbw_data.append([idx, idx + 1, start_ms, end_ms])
        cumulative_ms = end_ms
    
    return wbw_data


def convert_single_verse(args):
    """Worker function for parallel opus conversion."""
    input_mp3, output_opus = args
    if output_opus.exists():
        return True
    output_opus.parent.mkdir(parents=True, exist_ok=True)
    return convert_mp3_to_opus(input_mp3, output_opus)


def process_reciter(reciter_slug: str, ayahs_per_surah: dict, word_cache: dict) -> dict:
    """Process all surahs for a given reciter."""
    output_base = BASE_DIR / reciter_slug
    
    total_verses = sum(ayahs_per_surah.values())
    
    print(f"\n{'='*60}")
    print(f"Processing: {reciter_slug}")
    print(f"  Output: {output_base}")
    print(f"  Total verses: {total_verses}")
    print(f"{'='*60}")
    
    start_time = time.time()
    
    # Compute global offsets per surah based on ayahs_per_surah
    # global_offset[1] = 0 (Surah 1 starts at 1)
    # global_offset[2] = 7 (Surah 2 starts at 8)
    global_offsets = {}
    current_offset = 0
    for s_id in range(1, 115):
        global_offsets[s_id] = current_offset
        current_offset += ayahs_per_surah.get(s_id, 0)
    
    # ── Phase 1: Generate all JSON files (fast, single-threaded) ──
    print(f"  Phase 1/2: Generating WBW JSON metadata...")
    json_ok = 0
    json_errors = []
    
    for surah_id in range(1, 115):
        num_verses = ayahs_per_surah.get(surah_id, 0)
        if num_verses == 0:
            continue
        
        surah_str = f"{surah_id:03d}"
        surah_dir = output_base / surah_str
        surah_dir.mkdir(parents=True, exist_ok=True)
        
        offset = global_offsets[surah_id]
        
        for verse_id in range(1, num_verses + 1):
            global_verse_id = offset + verse_id
            
            # Source uses surahId+verseId: 001001
            source_base = f"{surah_str}{verse_id:03d}"
            # Output uses surahId+globalVerseId: 001001, 002008, etc.
            output_base_name = f"{surah_str}{global_verse_id:03d}"
            
            output_json = surah_dir / f"{output_base_name}.json"
            
            if output_json.exists():
                json_ok += 1
                continue
            
            wbw_data = generate_wbw_json_from_cache(surah_id, verse_id, word_cache)
            with open(output_json, "w") as f:
                json.dump(wbw_data, f, separators=(",", ":"))
            json_ok += 1
            
            if not wbw_data:
                json_errors.append(f"{surah_id}:{verse_id}")
    
    json_elapsed = time.time() - start_time
    print(f"  ✓ JSON: {json_ok}/{total_verses} in {json_elapsed:.1f}s"
          f" ({len(json_errors)} empty)")
    
    # ── Phase 2: Convert all MP3 → Opus (parallel) ──
    print(f"  Phase 2/2: Converting MP3 → Opus ({MAX_WORKERS} workers)...")
    
    conversion_tasks = []
    for surah_id in range(1, 115):
        num_verses = ayahs_per_surah.get(surah_id, 0)
        if num_verses == 0:
            continue
        
        surah_str = f"{surah_id:03d}"
        offset = global_offsets[surah_id]
        
        for verse_id in range(1, num_verses + 1):
            global_verse_id = offset + verse_id
            
            source_base = f"{surah_str}{verse_id:03d}"
            output_base_name = f"{surah_str}{global_verse_id:03d}"
            
            input_mp3 = AYAHS_DIR / reciter_slug / f"{source_base}.mp3"
            output_opus = output_base / surah_str / f"{output_base_name}.opus"
            
            if not input_mp3.exists():
                continue
            
            if not output_opus.exists():
                conversion_tasks.append((input_mp3, output_opus))
    
    already_done = total_verses - len(conversion_tasks)
    opus_ok = already_done
    opus_errors = 0
    
    if conversion_tasks:
        print(f"    {already_done} already converted, {len(conversion_tasks)} remaining...")
        
        with ProcessPoolExecutor(max_workers=MAX_WORKERS) as executor:
            futures = {executor.submit(convert_single_verse, task): task 
                      for task in conversion_tasks}
            
            done_count = 0
            for future in as_completed(futures):
                done_count += 1
                if future.result():
                    opus_ok += 1
                else:
                    opus_errors += 1
                
                if done_count % 500 == 0 or done_count == len(conversion_tasks):
                    elapsed = time.time() - start_time
                    rate = done_count / (time.time() - start_time - json_elapsed) if (time.time() - start_time - json_elapsed) > 0 else 0
                    print(f"    Converted {done_count}/{len(conversion_tasks)} "
                          f"({opus_ok} ok, {opus_errors} err) "
                          f"[{rate:.0f} files/s, {elapsed:.0f}s elapsed]")
    else:
        print(f"    All {total_verses} already converted!")
    
    total_elapsed = time.time() - start_time
    
    print(f"\n  ── Summary for {reciter_slug} ──")
    print(f"  Opus: {opus_ok}/{total_verses} | JSON: {json_ok}/{total_verses}")
    print(f"  Time: {total_elapsed:.1f}s")
    
    return {
        "reciter": reciter_slug,
        "total_verses": total_verses,
        "opus_ok": opus_ok,
        "json_ok": json_ok,
        "opus_errors": opus_errors,
        "json_empty": len(json_errors),
        "time_s": total_elapsed
    }


def main():
    print("╔══════════════════════════════════════════════════════╗")
    print("║   Quranic Recitation Audio Standardizer             ║")
    print("║   MP3 → Opus + WBW JSON                             ║")
    print("╚══════════════════════════════════════════════════════╝")
    
    # Verify directories
    if not AYAHS_DIR.exists():
        print(f"✗ Ayahs directory not found: {AYAHS_DIR}")
        sys.exit(1)
    if not WORDS_DIR.exists():
        print(f"✗ Words directory not found: {WORDS_DIR}")
        sys.exit(1)
    
    # Verify ffmpeg
    try:
        subprocess.run(["ffmpeg", "-version"], capture_output=True, timeout=5)
    except FileNotFoundError:
        print("✗ ffmpeg not found. Please install ffmpeg.")
        sys.exit(1)
    
    # Load surah metadata
    ayahs_per_surah = load_number_of_ayahs()
    total_quran_verses = sum(ayahs_per_surah.values())
    print(f"\n✓ Loaded surah metadata: {len(ayahs_per_surah)} surahs, {total_quran_verses} total verses")
    
    # Discover reciters
    reciters = sorted([d.name for d in AYAHS_DIR.iterdir() if d.is_dir()])
    print(f"✓ Found {len(reciters)} reciters: {', '.join(reciters)}")
    
    # Allow filtering via CLI
    if len(sys.argv) > 1:
        filter_reciters = sys.argv[1:]
        reciters = [r for r in reciters if r in filter_reciters]
        print(f"  Filtered to: {', '.join(reciters)}")
    
    if not reciters:
        print("✗ No reciters to process.")
        sys.exit(1)
    
    # Pre-compute word durations (single pass, shared across all reciters)
    word_cache = build_word_duration_cache()
    
    # Process each reciter
    overall_start = time.time()
    all_results = []
    
    for reciter_slug in reciters:
        result = process_reciter(reciter_slug, ayahs_per_surah, word_cache)
        all_results.append(result)
    
    # Final summary
    overall_elapsed = time.time() - overall_start
    
    print(f"\n{'='*60}")
    print(f"  FINAL SUMMARY")
    print(f"{'='*60}")
    print(f"{'Reciter':<40} {'Opus':>6} {'JSON':>6} {'Errs':>5} {'Time':>7}")
    print(f"{'-'*40} {'-'*6} {'-'*6} {'-'*5} {'-'*7}")
    
    grand_opus = 0
    grand_json = 0
    grand_err = 0
    
    for r in all_results:
        name = r["reciter"][:39]
        print(f"{name:<40} {r['opus_ok']:>6} {r['json_ok']:>6} "
              f"{r['opus_errors']:>5} {r['time_s']:>6.1f}s")
        grand_opus += r["opus_ok"]
        grand_json += r["json_ok"]
        grand_err += r["opus_errors"]
    
    expected = total_quran_verses * len(all_results)
    print(f"{'-'*40} {'-'*6} {'-'*6} {'-'*5} {'-'*7}")
    print(f"{'TOTAL':<40} {grand_opus:>6} {grand_json:>6} {grand_err:>5} {overall_elapsed:>6.1f}s")
    print(f"\nExpected: {expected} opus + {expected} json")
    print(f"Rate: {grand_opus/expected*100:.1f}% opus, {grand_json/expected*100:.1f}% json")
    print(f"\n✓ Done!")


if __name__ == "__main__":
    main()