"""Node.js TTS Bridge — Persistent Process Manager.

Starts a long-lived Node.js subprocess running tts_bridge.js. Communication uses
stdin/stdout with temporary files for text and WAV data.

Protocol:
  Python → writes kana text to temp file
  Python → sends  "INPUT_FILE_PATH|OUTPUT_FILE_PATH\n"  to bridge's stdin
  Bridge → reads text, synthesizes, writes WAV to output path
  Bridge → prints "OK:OUTPUT_FILE_PATH\n" to stdout (or "ERR:message\n" on error)
"""

import asyncio
import os
import pathlib
import tempfile
import logging

logger = logging.getLogger(__name__)


class TTSBridge:
    """Manages a persistent Node.js subprocess for aquestalk.js TTS synthesis."""

    def __init__(self, voice: str = "f1", speed: int = 100, bridge_script: str | None = None):
        self._voice = voice
        self._speed = speed
        self._process: asyncio.subprocess.Process | None = None
        self._bridge_script = bridge_script

    @property
    def bridge_script_path(self) -> str:
        if self._bridge_script:
            return self._bridge_script
        return str(pathlib.Path(__file__).parent / "tts_bridge.js")

    async def start(self) -> None:
        """Launch the Node.js bridge process and wait for it to be ready."""
        script = self.bridge_script_path
        if not pathlib.Path(script).exists():
            raise FileNotFoundError(f"Bridge script not found: {script}")

        logger.info("Starting Node.js TTS bridge (voice=%s, speed=%d)...", self._voice, self._speed)

        self._process = await asyncio.create_subprocess_exec(
            "node",
            script,
            "--voice", self._voice,
            "--speed", str(self._speed),
            stdin=asyncio.subprocess.PIPE,
            stdout=asyncio.subprocess.PIPE,
            stderr=asyncio.subprocess.PIPE,
        )

        line = await asyncio.wait_for(self._process.stdout.readline(), timeout=60)
        line_str = line.decode("utf-8").strip()

        if "READY" not in line_str:
            stderr_data = await self._process.stderr.read()
            raise RuntimeError(
                f"Bridge failed to start. Got: {line_str}. Stderr: {stderr_data.decode('utf-8', errors='replace')}"
            )

        logger.info("Node.js TTS bridge ready.")

    async def synthesize(self, kana_text: str) -> bytes:
        """Synthesize kana text to WAV audio.

        Args:
            kana_text: Japanese kana text to synthesize.

        Returns:
            Raw WAV audio bytes.
        """
        if self._process is None or self._process.stdin is None:
            raise RuntimeError("Bridge not started. Call start() first.")

        tmpdir = pathlib.Path(tempfile.mkdtemp(prefix="tts_"))
        try:
            input_path = tmpdir / "input.txt"
            output_path = tmpdir / "output.wav"

            input_path.write_text(kana_text, encoding="utf-8")

            cmd_line = f"{input_path}|{output_path}\n"
            self._process.stdin.write(cmd_line.encode("utf-8"))
            await self._process.stdin.drain()

            line = await asyncio.wait_for(self._process.stdout.readline(), timeout=120)
            line_str = line.decode("utf-8").strip()

            if line_str.startswith("ERR:"):
                raise RuntimeError(f"TTS synthesis error: {line_str[4:]}")

            if not line_str.startswith("OK:") or line_str[3:] != str(output_path):
                raise RuntimeError(f"Unexpected bridge response: {line_str}")

            wav_data = output_path.read_bytes()
            return wav_data

        finally:
            for f in tmpdir.iterdir():
                try:
                    f.unlink()
                except OSError:
                    pass
            try:
                tmpdir.rmdir()
            except OSError:
                pass

    async def stop(self) -> None:
        """Stop the bridge process."""
        if self._process is not None:
            logger.info("Stopping TTS bridge...")
            try:
                if self._process.stdin is not None:
                    self._process.stdin.close()
            except OSError:
                pass
            try:
                self._process.terminate()
                await asyncio.wait_for(self._process.wait(), timeout=5)
            except asyncio.TimeoutError:
                self._process.kill()
                await self._process.wait()
            logger.info("TTS bridge stopped.")
            self._process = None