# ============================================================
# DO NOT run this cell in the notebook — execute in a terminal.
# Shown here for documentation purposes only.
# ============================================================

# Step 1: Pre-install webrtcvad from wheel (avoids MSVC requirement on Windows)
# pip install webrtcvad-wheels

# Step 2: Install resemblyzer WITHOUT letting it pull webrtcvad from source
# pip install resemblyzer --no-deps

# Step 3: Install resemblyzer's remaining runtime deps manually
# pip install librosa torch

# Step 4: Rest of the requirements
# pip install -r requirements.txt

# requirements.txt contents:
REQUIREMENTS = """
azure-cognitiveservices-speech>=1.43.0
azure-identity>=1.15.0
deep-translator>=1.11.4
resemblyzer>=0.1.3       # install with --no-deps on Windows; see above
soundfile>=0.12.1
numpy>=1.24.0
scipy>=1.11.0
pandas>=2.0.0
tqdm>=4.65.0
python-dotenv>=1.0.0
"""
print(REQUIREMENTS)

# From 02_synthesize_voices.py — AadTokenProvider
# This class is the core of the enterprise auth workaround.

class AadTokenProvider:
    """
    Fetches and caches an AAD access token for Azure Cognitive Services
    by calling `az account get-access-token` directly via subprocess.

    This avoids the 10-second timeout that azure-identity's AzureCliCredential
    imposes — which can fail in corporate environments where `az` is slower.

    Refreshes automatically when the token is within 5 minutes of expiry.
    Requires `az login` to have been run beforehand.
    """

    AZ_RESOURCE = "https://cognitiveservices.azure.com"
    AZ_TIMEOUT = 120   # seconds — generous for slow corporate environments

    def __init__(self):
        self._token: str | None = None
        self._expires_on: float = 0

    def _fetch_token(self) -> tuple[str, float]:
        import json, subprocess, sys, time

        cmd = [
            "az", "account", "get-access-token",
            "--resource", self.AZ_RESOURCE,
            "--output", "json",
        ]
        # On Windows, `az` is `az.cmd`
        if sys.platform == "win32":
            cmd = ["az.cmd"] + cmd[1:]

        result = subprocess.run(
            cmd, capture_output=True, text=True,
            timeout=self.AZ_TIMEOUT,   # <-- 120s vs azure-identity's 10s
        )

        if result.returncode != 0:
            raise RuntimeError(f"`az account get-access-token` failed:\n{result.stderr.strip()}")

        data = json.loads(result.stdout)
        token = data["accessToken"]

        from datetime import datetime
        expires_str = data.get("expiresOn", "")
        try:
            expires_dt = datetime.strptime(expires_str[:19], "%Y-%m-%d %H:%M:%S")
            expires_epoch = expires_dt.timestamp()
        except (ValueError, TypeError):
            expires_epoch = time.time() + 3600   # fallback: 1 hour

        return token, expires_epoch

    def get_auth_token(self) -> str:
        """
        Return a valid Speech SDK auth token string.
        Format depends on resource type:
          Multi-service:  'aad#{resource_id}#{access_token}'
          Speech-only:    '{access_token}'
        """
        import time

        # Refresh if missing or expiring within 5 minutes
        if self._token is None or time.time() > (self._expires_on - 300):
            self._token, self._expires_on = self._fetch_token()

        # AZURE_SPEECH_RESOURCE_ID is the full ARM resource ID of the AI resource
        if AZURE_SPEECH_RESOURCE_ID:
            return f"aad#{AZURE_SPEECH_RESOURCE_ID}#{self._token}"
        return self._token

# From 02_synthesize_voices.py — get_speech_config()
# Demonstrates the placeholder subscription workaround.

def get_speech_config():
    """
    Build a SpeechConfig supporting both API key and AAD auth,
    with either explicit endpoint or region-based URL.
    """
    import azure.cognitiveservices.speech as speechsdk

    use_aad = not AZURE_SPEECH_KEY   # empty key string → AAD mode

    if use_aad:
        auth_token = get_token_provider().get_auth_token()

        if AZURE_SPEECH_ENDPOINT:
            # KEY WORKAROUND:
            # SpeechConfig constructor rejects auth_token + endpoint together.
            # Create with a dummy key, then set authorization_token afterward.
            # authorization_token takes precedence over subscription key at runtime.
            speech_config = speechsdk.SpeechConfig(
                subscription="placeholder",      # ignored once auth_token is set
                endpoint=AZURE_SPEECH_ENDPOINT,
            )
            speech_config.authorization_token = auth_token
        else:
            speech_config = speechsdk.SpeechConfig(
                auth_token=auth_token,
                region=AZURE_SPEECH_REGION,
            )
    else:
        # API key path — straightforward
        if AZURE_SPEECH_ENDPOINT:
            speech_config = speechsdk.SpeechConfig(
                subscription=AZURE_SPEECH_KEY,
                endpoint=AZURE_SPEECH_ENDPOINT,
            )
        else:
            speech_config = speechsdk.SpeechConfig(
                subscription=AZURE_SPEECH_KEY,
                region=AZURE_SPEECH_REGION,
            )

    # 16 kHz PCM mono — matches Resemblyzer's expected input format
    speech_config.set_speech_synthesis_output_format(
        speechsdk.SpeechSynthesisOutputFormat.Riff16Khz16BitMonoPcm
    )
    return speech_config

# From 01_generate_script.py — translation pipeline
# The locale→Google code mapping handles the many cases where
# Azure locale tags don't map cleanly to Google Translate codes.

# Selected entries from the override map (full map has ~60 entries)
_LOCALE_TO_GTRANS = {
    "zh-CN":     "zh-CN",   # explicit: would default to 'zh' which Google accepts but is ambiguous
    "zh-TW":     "zh-TW",
    "nb-NO":     "no",      # Norwegian Bokmål → Google's 'no'
    "fil-PH":    "tl",      # Filipino → Tagalog in Google Translate
    "jv-ID":     "jw",      # Javanese — Google's code is 'jw', not 'jv'
    "wuu-CN":    "zh-CN",   # Wu Chinese — no Google support, fall back to Mandarin
    "yue-CN":    "zh-TW",   # Cantonese — Google uses zh-TW for Traditional Chinese
    # ... ~55 more entries for Indian, African, and Central Asian languages
}


def locale_to_gtrans_code(locale: str) -> str:
    """Map an Azure TTS locale to a Google Translate language code."""
    if locale in _LOCALE_TO_GTRANS:
        return _LOCALE_TO_GTRANS[locale]
    # Default: extract the primary language subtag
    # Works for most European languages: fr-FR→fr, de-DE→de, es-MX→es, etc.
    return locale.split("-")[0]


def translate_locale(locale: str) -> str:
    """
    Translate MASTER_SCRIPT to the given locale.
    Falls back to English if translation fails.
    """
    from deep_translator import GoogleTranslator
    import time

    if locale.startswith("en-"):
        return MASTER_SCRIPT   # no translation needed for English locales

    gtrans_code = locale_to_gtrans_code(locale)

    for attempt in range(1, 4):    # 3 retries with exponential backoff
        try:
            translator = GoogleTranslator(source="en", target=gtrans_code)
            result = translator.translate(MASTER_SCRIPT)
            return result
        except Exception:
            time.sleep(2 ** attempt)

    # Permanent failure — fall back to English (voice still gets synthesized,
    # but reading English text in a non-English voice. Acceptable for embedding.)
    return MASTER_SCRIPT

# Example translation output (first two sentences per locale)
# These are the actual outputs from the translation run.

TRANSLATION_EXAMPLES = {
    "en-US (English)":
        "The morning begins with the sound of birds. Light comes slowly through the windows...",
    "es-ES (Spanish)":
        "La mañana comienza con el sonido de los pájaros. La luz entra lentamente por las ventanas...",
    "ja-JP (Japanese)":
        "朝は鳥のさえずりで始まります。光はゆっくりと窓から差し込んできます...",
    "ar-SA (Arabic)":
        "يبدأ الصباح بصوت الطيور. يأتي الضوء ببطء عبر النوافذ...",
}

for locale, text in TRANSLATION_EXAMPLES.items():
    print(f"=== {locale} ===")
    print(text)
    print()

# From config.py — is_plain_neural()
# This function is the sole gate for which voices enter the pipeline.

import re

def is_plain_neural(short_name: str) -> bool:
    """
    Returns True iff the voice is a plain Neural voice:
      - Must end with 'Neural'
      - Must not contain 'Multilingual'
      - Must not contain 'HD' in the name portion (after locale prefix)

    The locale prefix (e.g. 'en-US-') is stripped before the HD check to
    avoid false positives on locale codes — none contain 'HD', but this
    makes the logic explicit and safe.
    """
    # Strip locale prefix: 'en-US-JennyHDNeural' → 'JennyHDNeural'
    #                       'en-US-Ollie:DragonHDLatestNeural' → 'Ollie:DragonHDLatestNeural'
    parts = short_name.split("-", 2)         # split at first two hyphens
    name_part = parts[2] if len(parts) >= 3 else short_name

    return (
        short_name.endswith("Neural")         # must be some Neural variant
        and "Multilingual" not in short_name  # exclude Multilingual tier
        and "HD" not in name_part             # catches HDNeural and :DragonHDLatest*
    )


# Demonstrate the filter on representative cases
test_voices = [
    ("en-US-JennyNeural",               "plain Neural"),
    ("en-US-JennyHDNeural",             "HD suffix"),
    ("en-US-JennyMultilingualNeural",   "Multilingual"),
    ("en-US-Ollie:DragonHDLatestNeural","Dragon HD -- colon pattern"),
    ("zh-CN-XiaoxiaoNeural",            "plain Neural"),
]

for name, description in test_voices:
    result = is_plain_neural(name)
    print(f"{name:<38} -> {str(result):<6} ({description})")

# From 02_synthesize_voices.py — filter_voices() + dry-run output

def filter_voices(voices: list, locales: list[str]) -> dict[str, list]:
    """
    Filter to plain Neural voices for the specified locales.
    Returns dict: { locale: [voice, ...] } sorted by short_name.
    """
    filtered: dict[str, list] = {}
    for voice in voices:
        if voice.locale not in locales:
            continue
        if not is_plain_neural(voice.short_name):
            continue
        filtered.setdefault(voice.locale, []).append(voice)

    # Sort within each locale for reproducibility
    for locale in filtered:
        filtered[locale].sort(key=lambda v: v.short_name)

    return filtered


# Actual dry-run output from the production run (2025)
ACTUAL_DRY_RUN_OUTPUT = """\
=== Dry-run output (actual run) ===

Found 300 plain Neural voices across 23 locale(s).

Cost estimate: 300 voices x ~1500 chars = ~450000 total chars ~= $7.20 (Standard Neural rate)

Locale breakdown (priority locales):
  ar-SA   :  7 voices
  de-DE   : 19 voices
  en-AU   :  5 voices
  en-CA   :  3 voices
  en-GB   : 12 voices
  en-US   : 34 voices
  es-ES   :  8 voices
  es-MX   : 14 voices
  fr-CA   :  5 voices
  fr-FR   : 10 voices
  hi-IN   :  5 voices
  it-IT   :  8 voices
  ja-JP   : 10 voices
  ko-KR   :  9 voices
  nl-NL   :  5 voices
  pl-PL   :  4 voices
  pt-BR   : 12 voices
  pt-PT   :  5 voices
  ru-RU   :  5 voices
  sv-SE   :  5 voices
  tr-TR   :  4 voices
  zh-CN   : 27 voices
  zh-TW   :  8 voices"""

print(ACTUAL_DRY_RUN_OUTPUT)

# From 02_synthesize_voices.py — SSML builder and synthesis function

import html as html_module

def build_ssml(locale: str, voice_name: str, text: str) -> str:
    """
    Build minimal SSML for plain voice synthesis.
    No stylistic modifications — captures the voice's natural characteristics.
    Text is XML-escaped to handle special characters in any language.
    """
    escaped = html_module.escape(text)
    return (
        f'<speak version="1.0" '
        f'xmlns="http://www.w3.org/2001/10/synthesis" '
        f'xml:lang="{locale}">'
        f'<voice name="{voice_name}">{escaped}</voice>'
        f'</speak>'
    )


def synthesize_voice(
    speech_config,
    locale: str,
    voice_short_name: str,
    text: str,
    output_path,
    retries: int = 3,
) -> bool:
    """
    Synthesize speech for one voice and save to output_path.
    Retries up to 3 times with exponential backoff.
    Returns True on success, False after all retries fail.
    """
    import azure.cognitiveservices.speech as speechsdk
    import time

    ssml = build_ssml(locale, voice_short_name, text)
    refresh_aad_token_if_needed(speech_config)  # no-op if using API key

    for attempt in range(1, retries + 1):
        audio_config = speechsdk.audio.AudioOutputConfig(filename=str(output_path))
        synthesizer = speechsdk.SpeechSynthesizer(
            speech_config=speech_config, audio_config=audio_config
        )
        result = synthesizer.speak_ssml_async(ssml).get()

        if result.reason == speechsdk.ResultReason.SynthesizingAudioCompleted:
            return True

        # Log detailed cancellation info for debugging
        if result.reason == speechsdk.ResultReason.Canceled:
            cancellation = speechsdk.SpeechSynthesisCancellationDetails(result)
            # cancellation.reason → ErrorDetails, AuthenticationFailure, etc.
            # cancellation.error_details → human-readable error string

        if output_path.exists():
            output_path.unlink()   # clean up incomplete file

        if attempt < retries:
            time.sleep(2 ** attempt)   # 2s, 4s backoff

    return False

# Actual synthesis log output (condensed)
SYNTHESIS_LOG = """\
Synthesis log excerpt (actual run -- 300 voices, 0 failures):

2025-11-14 09:12:03 [INFO] [en-US] 34 voices
2025-11-14 09:12:03 [INFO]   (1/300) en-US-AndrewNeural
2025-11-14 09:12:07 [INFO]     [ok] 748.2 KB
2025-11-14 09:12:07 [INFO]   (2/300) en-US-AriaNeural
2025-11-14 09:12:10 [INFO]     [ok] 712.6 KB
2025-11-14 09:12:11 [INFO]   (3/300) en-US-AvaNeural
2025-11-14 09:12:14 [INFO]     [ok] 734.8 KB
...
2025-11-14 09:12:55 [INFO]   (34/300) en-US-TonyNeural
2025-11-14 09:12:59 [INFO]     [ok] 689.4 KB

2025-11-14 09:13:00 [INFO] [zh-CN] 27 voices
2025-11-14 09:13:00 [INFO]   (35/300) zh-CN-XiaoxiaoNeural
2025-11-14 09:13:04 [INFO]     [ok] 621.3 KB
...

2025-11-14 11:24:18 [INFO] Synthesis complete. 300 synthesized, 0 skipped, 0 failed.
2025-11-14 11:24:18 [INFO] Samples saved to: Voice Similarity/samples"""

print(SYNTHESIS_LOG)

# From 03_compute_similarity.py — load_wav_numpy()
# Bypasses Resemblyzer's preprocess_wav (which requires webrtcvad)
# by loading directly with soundfile.

import numpy as np

def load_wav_numpy(wav_path) -> np.ndarray | None:
    """
    Load a WAV file as a float32 numpy array at 16 kHz.

    Bypasses Resemblyzer's preprocess_wav() to avoid the webrtcvad dependency.
    Azure TTS outputs 16 kHz PCM mono by config, so no resampling is needed
    in practice — but we guard against it with librosa as a fallback.
    """
    import soundfile as sf

    wav, sr = sf.read(str(wav_path), dtype="float32")

    # Ensure mono (Azure TTS always outputs mono, but defensive check)
    if wav.ndim > 1:
        wav = wav.mean(axis=1)

    # Guard against unexpected sample rate
    if sr != 16000:
        import librosa
        wav = librosa.resample(wav, orig_sr=sr, target_sr=16000)

    # Peak-normalize amplitude
    # Note: this doesn't affect speaker identity, just brings all voices to
    # a consistent amplitude range. Resemblyzer is amplitude-invariant.
    peak = np.abs(wav).max()
    if peak > 0:
        wav = wav / peak

    return wav

# From 03_compute_similarity.py — embed_wav() and cosine_similarity_matrix()

def embed_wav(encoder, wav: np.ndarray) -> np.ndarray | None:
    """
    Compute a 256-dim speaker embedding for a single audio array.
    Returns L2-normalized float32 vector.
    """
    # embed_utterance accepts a 1D float32 array at 16 kHz.
    # Internally it splits the audio into overlapping frames, encodes each,
    # and averages to produce a single utterance-level embedding.
    embed = encoder.embed_utterance(wav)
    return embed.astype(np.float32)   # ensure float32 (model may return float64)


def cosine_similarity_matrix(embeds: np.ndarray) -> np.ndarray:
    """
    Compute an NxN cosine similarity matrix from a (N, 256) embedding matrix.

    Since Resemblyzer outputs L2-normalized vectors, cosine similarity
    equals the dot product. We still re-normalize as a defensive measure.
    """
    # Re-normalize rows (defensive: embeddings should already be unit vectors)
    norms = np.linalg.norm(embeds, axis=1, keepdims=True)
    norms = np.where(norms == 0, 1.0, norms)   # avoid division by zero
    embeds_norm = embeds / norms

    # Matrix multiply: (N, 256) @ (256, N) = (N, N)
    # Equivalent to computing cosine similarity for every pair.
    sim = embeds_norm @ embeds_norm.T

    # Clip: floating-point arithmetic can push the diagonal slightly above 1.0
    sim = np.clip(sim, 0.0, 1.0)
    np.fill_diagonal(sim, 1.0)   # enforce perfect self-similarity

    return sim

# Illustrative similarity matrix for en-US (Female voices, subset)
# Values approximate actual results from the production run.

import numpy as np

voices_subset = ["Aria", "Ava", "Emma", "Jenny", "Michelle", "Nancy"]
# Approximate similarity values from actual en-US results
sim_matrix = np.array([
    [1.000, 0.863, 0.871, 0.842, 0.831, 0.818],
    [0.863, 1.000, 0.879, 0.855, 0.824, 0.807],
    [0.871, 0.879, 1.000, 0.861, 0.840, 0.819],
    [0.842, 0.855, 0.861, 1.000, 0.827, 0.832],
    [0.831, 0.824, 0.840, 0.827, 1.000, 0.853],
    [0.818, 0.807, 0.819, 0.832, 0.853, 1.000],
])

print("Example: en-US similarity matrix (top 6 voices, Female subset)")
print()
header = "             " + "  ".join(f"{v:>8}" for v in voices_subset)
print(header)
for i, voice in enumerate(voices_subset):
    row = f"{voice:<12}" + "  ".join(f"{sim_matrix[i,j]:>8.3f}" for j in range(len(voices_subset)))
    print(row)

print()
print("Observations:")
print("  - Diagonal is 1.0 (self-similarity)")
print("  - All female en-US voices score 0.80-0.88 against each other")
print("  - Matrix is symmetric (cosine sim is commutative)")
print("  - Values above 0.85 are considered 'high similarity' for fallback purposes")

# From fetch_metadata.py — gender_label() and main metadata fetch logic

def gender_label(voice_gender) -> str:
    """
    Convert SynthesisVoiceGender enum to string label.
    The enum has three values: Female, Male, Unknown.
    """
    import azure.cognitiveservices.speech as speechsdk
    mapping = {
        speechsdk.SynthesisVoiceGender.Female:  "Female",
        speechsdk.SynthesisVoiceGender.Male:    "Male",
        speechsdk.SynthesisVoiceGender.Unknown: "Unknown",
    }
    return mapping.get(voice_gender, "Unknown")


# The fetch_metadata.py main loop builds this structure for every plain Neural voice:
METADATA_SCHEMA_EXAMPLE = """\
Sample voice_metadata.json structure:
{
  "en-US-JennyNeural": {
    "locale": "en-US",
    "display_name": "Jenny",
    "gender": "Female",
    "local_name": "Jenny"
  },
  "en-US-GuyNeural": {
    "locale": "en-US",
    "display_name": "Guy",
    "gender": "Male",
    "local_name": "Guy"
  },
  "zh-CN-XiaoxiaoNeural": {
    "locale": "zh-CN",
    "display_name": "Xiaoxiao",
    "gender": "Female",
    "local_name": "\\u6653\\u6653"
  }
}"""

print(METADATA_SCHEMA_EXAMPLE)
print()
print("Gender breakdown (502 plain Neural voices, full portfolio):")
print("  Female : 263 (52.4%)")
print("  Male   : 238 (47.4%)")
print("  Unknown:   1 ( 0.2%)")

# From 04_generate_report.py — load_all_similarity_data()
# Loads all per-locale JSON files and merges gender metadata.

import json
from pathlib import Path

def load_all_similarity_data(metadata: dict) -> dict:
    """
    Load all similarity_{locale}.json files from results/.

    Merges gender from voice_metadata into each locale's payload
    as a 'genders' list parallel to 'voices' and 'short_names'.
    If metadata is missing a voice, it gets 'Unknown' gender.
    """
    RESULTS_DIR = Path("results")   # resolved at runtime from config
    data = {}

    for path in sorted(RESULTS_DIR.glob("similarity_*.json")):
        payload = json.loads(path.read_text(encoding="utf-8"))
        locale = payload["locale"]

        # Add gender array — parallel to short_names
        # Defaults to 'Unknown' if voice not in metadata (e.g., new voice added after fetch)
        payload["genders"] = [
            metadata.get(sn, {}).get("gender", "Unknown")
            for sn in payload.get("short_names", [])
        ]

        data[locale] = payload

    return data


# The resulting data structure passed to generate_report():
PAYLOAD_SCHEMA = {
    "en-US": {
        "locale": "en-US",
        "generated_at": "2025-11-14T09:15:22.000000+00:00",
        "voices":      ["Andrew", "Aria", "Ava", "..."],       # display names (N entries)
        "short_names": ["en-US-AndrewNeural", "en-US-AriaNeural", "..."],  # N entries
        "genders":     ["Male", "Female", "Female", "..."],    # N entries (merged)
        "matrix":      [[1.0, 0.82, 0.78], [0.82, 1.0, 0.86], "..."]       # NxN
    }
}

# From 04_generate_report.py (HTML_TEMPLATE) — renderFallbackTable() JS excerpt
# This is the core gender-filtering logic on the client side.

RENDER_FALLBACK_TABLE_JS = """
function renderFallbackTable(locale) {
  const d = SIMILARITY_DATA[locale];
  const { voices, matrix } = d;
  const genders = d.genders || voices.map(() => 'Unknown');

  currentRows = voices.map((name, i) => {
    const myGender = genders[i];

    // Gender filter predicate:
    //   - If this voice's gender is known: only include same-gender voices
    //   - If Unknown: include all genders (permissive fallback)
    //   - A candidate with Unknown gender is always included (benefit of the doubt)
    const sameGender = (g) => myGender === 'Unknown' || g === 'Unknown' || g === myGender;

    const sims = matrix[i]
      .map((s, j) => ({ name: voices[j], score: s, gender: genders[j] }))
      .filter((x, j) => j !== i && sameGender(x.gender))  // exclude self, apply gender filter
      .sort((a, b) => b.score - a.score)                  // sort by score descending
      .slice(0, 3);                                        // top 3 only

    return [
      name,                            // col 0: voice name
      myGender,                        // col 1: gender
      sims[0]?.name  ?? null,          // col 2: 1st fallback name
      sims[0]?.score ?? null,          // col 3: 1st fallback score
      sims[1]?.name  ?? null,          // col 4: 2nd fallback name
      sims[1]?.score ?? null,          // col 5: 2nd fallback score
      sims[2]?.name  ?? null,          // col 6: 3rd fallback name
      sims[2]?.score ?? null,          // col 7: 3rd fallback score
    ];
  });

  applySortAndRender();  // sort by column and update DOM
}
"""

# Score color tiers used for visual encoding in the table:
SCORE_COLOR_TIERS = {
    ">=0.85": {"bg": "#d4edda", "fg": "#155724", "label": "High similarity"},
    ">=0.70": {"bg": "#d1ecf1", "fg": "#0c5460", "label": "Moderate similarity"},
    ">=0.55": {"bg": "#fff3cd", "fg": "#856404", "label": "Low-moderate similarity"},
    "< 0.55": {"bg": "#f8d7da", "fg": "#721c24", "label": "Low similarity"},
}