"""Regression tests for speech server API compatibility."""

from __future__ import annotations

import pytest

from cthulhu import speechserver
from cthulhu.acss import ACSS


class DummySpeechServer(speechserver.SpeechServer):
    factory_calls = []
    active_servers_shutdown = False

    @staticmethod
    def getFactoryName():
        return "Dummy"

    @staticmethod
    def getSpeechServers():
        return ["server-a"]

    @staticmethod
    def getSpeechServer(info=None):
        DummySpeechServer.factory_calls.append(info)
        return DummySpeechServer()

    @staticmethod
    def shutdownActiveServers():
        DummySpeechServer.active_servers_shutdown = True

    def __init__(self):
        self.calls = []
        self._current_voice_properties = {}

    def getInfo(self):
        return ["Dummy", "dummy"]

    def getVoiceFamilies(self):
        return ["voice-a"]

    def getVoiceFamiliesForLanguage(self, language, dialect="", maximum=None):
        return [(language, dialect, maximum)]

    def getOutputModule(self):
        return "module-a"

    def setOutputModule(self, module):
        self.calls.append(("setOutputModule", module))

    def updateCapitalizationStyle(self):
        self.calls.append(("updateCapitalizationStyle",))

    def updatePunctuationLevel(self):
        self.calls.append(("updatePunctuationLevel",))

    def increaseSpeechRate(self, step=5):
        self.calls.append(("increaseSpeechRate", step))

    def decreaseSpeechVolume(self, step=0.5):
        self.calls.append(("decreaseSpeechVolume", step))


@pytest.mark.unit
def test_snake_case_factory_methods_delegate_to_legacy_methods():
    DummySpeechServer.factory_calls.clear()
    DummySpeechServer.active_servers_shutdown = False

    server = DummySpeechServer.get_speech_server(("Dummy", "dummy"))

    assert isinstance(server, DummySpeechServer)
    assert DummySpeechServer.factory_calls == [("Dummy", "dummy")]
    assert DummySpeechServer.get_speech_servers() == ["server-a"]
    assert DummySpeechServer.get_factory_name() == "Dummy"

    DummySpeechServer.shutdown_active_servers()

    assert DummySpeechServer.active_servers_shutdown is True


@pytest.mark.unit
def test_snake_case_instance_methods_delegate_to_legacy_methods():
    server = DummySpeechServer()

    assert server.get_info() == ["Dummy", "dummy"]
    assert server.get_voice_families() == ["voice-a"]
    assert server.get_voice_families_for_language("en", variant="us") == [("en", "us", None)]
    assert server.get_output_module() == "module-a"

    server.set_output_module("module-b")
    server.update_capitalization_style("none")
    server.update_punctuation_level(speechserver.PunctuationStyle.SOME)
    server.increase_speech_rate(9)
    server.decrease_speech_volume(1.5)

    assert server.calls == [
        ("setOutputModule", "module-b"),
        ("updateCapitalizationStyle",),
        ("updatePunctuationLevel",),
        ("increaseSpeechRate", 9),
        ("decreaseSpeechVolume", 1.5),
    ]


@pytest.mark.unit
def test_voice_property_helpers_store_and_clear_default_voice():
    server = DummySpeechServer()
    default_voice = {ACSS.FAMILY: {speechserver.VoiceFamily.NAME: "Voice A"}}
    next_family = {speechserver.VoiceFamily.NAME: "Voice B"}

    server.set_default_voice(default_voice)

    assert server.get_voice_family() == default_voice[ACSS.FAMILY]

    server.set_voice_family(next_family)

    assert server.get_voice_family() == next_family

    server.clear_cached_voice_properties()

    assert server.get_voice_family() is None