"""Testes do provider local de transcrição em lote."""

import sys
import tempfile
import types
import unittest
from pathlib import Path
from types import SimpleNamespace
from unittest.mock import patch

from engine.integracoes.whisper import ProviderDeTranscricaoLocal


class TesteDoProviderDeTranscricaoLocal(unittest.TestCase):
    """Verifica a configuração e a conversão dos segmentos do provider."""

    def test_usa_pipeline_em_lote_com_vad_e_timestamps_de_palavras(self):
        """Mantém as opções de qualidade ao usar inferência em lote."""
        chamadas = {}

        class ModeloFalso:
            """Representa o modelo externo durante o teste."""

            def __init__(self, *argumentos, **opcoes):
                chamadas["modelo"] = (argumentos, opcoes)

        class PipelineFalso:
            """Representa o pipeline em lote durante o teste."""

            def __init__(self, model):
                chamadas["pipeline_modelo"] = model

            def transcribe(self, *argumentos, **opcoes):
                chamadas["transcricao"] = (argumentos, opcoes)
                palavra = SimpleNamespace(word="Olá", start=0.0, end=0.5, probability=0.99)
                segmento = SimpleNamespace(start=0.0, end=0.5, text=" Olá ", words=[palavra])
                return iter([segmento]), SimpleNamespace(duration=0.5)

        modulo_falso = types.SimpleNamespace(
            BatchedInferencePipeline=PipelineFalso,
            WhisperModel=ModeloFalso,
        )
        with tempfile.TemporaryDirectory() as pasta:
            arquivo = Path(pasta) / "audio.wav"
            arquivo.write_bytes(b"audio")
            with patch.dict(sys.modules, {"faster_whisper": modulo_falso}):
                provider = ProviderDeTranscricaoLocal("small", tamanho_do_lote=8)
                resultado = provider.transcrever(SimpleNamespace(arquivo=str(arquivo)))

        self.assertEqual(resultado[0].texto, "Olá")
        self.assertEqual(chamadas["transcricao"][1]["batch_size"], 8)
        self.assertTrue(chamadas["transcricao"][1]["vad_filter"])
        self.assertTrue(chamadas["transcricao"][1]["word_timestamps"])

    def test_rejeita_tamanho_de_lote_invalido(self):
        """Impede configuração silenciosa de um lote inválido."""
        with self.assertRaises(ValueError):
            ProviderDeTranscricaoLocal("small", tamanho_do_lote=0)


if __name__ == "__main__":
    unittest.main()