import asyncio
from types import SimpleNamespace

from app.auto.controller import AutoController


class FakeScheduleService:

    def __init__(self):
        self.paused = True
        self.override_active = False

    def resolve(self, now):
        return SimpleNamespace(
            enabled=True,
            auto_active=True,
            auto_fallback_speed=1,
            auto_target_temp=20,
        )


class FakeQingpingService:

    def __init__(self):
        self.online = True

        self.state = SimpleNamespace(
            co2=1200,
            temperature=19.0,
        )


class FakeTionController:

    def __init__(self):
        self.calls = []

    async def set_speed(self, speed):
        self.calls.append(
            ("set_speed", speed)
        )

    async def heater_on(self):
        self.calls.append(
            ("heater_on", None)
        )

    async def heater_off(self):
        self.calls.append(
            ("heater_off", None)
        )

    async def set_target_temperature(
        self,
        temperature,
    ):
        self.calls.append(
            (
                "set_target_temperature",
                temperature,
            )
        )


class FakeTionService:

    def __init__(self):
        self.online = True

        self.state = SimpleNamespace(
            in_temp=19,
        )

        self.controller = FakeTionController()

    async def execute(
        self,
        operation,
    ):
        return await operation(
            self.controller
        )


async def test_paused_schedule_suspends_auto():

    schedule = FakeScheduleService()
    qingping = FakeQingpingService()
    tion = FakeTionService()

    controller = AutoController(
        schedule_service=schedule,
        qingping_service=qingping,
        tion_service=tion,
    )

    # Имитируем состояние,
    # которое AUTO помнил до pause.
    controller._target_speed = 3
    controller._auto_speed = 3

    controller._target_heater = True
    controller._auto_heater = True

    controller._target_temperature = 30

    controller._temperature = 19.0
    controller._temperature_source = (
        "qingping"
    )

    await controller._process()

    status = controller.status()

    # AUTO должен быть остановлен.
    assert (
        status["state"]
        == "suspended"
    )

    assert (
        status["reason"]
        == "schedule_paused"
    )

    # Никаких команд Tion.
    assert tion.controller.calls == []

    # Старое владение AUTO забыто.
    assert (
        controller._target_speed
        is None
    )

    assert (
        controller._auto_speed
        is None
    )

    assert (
        controller._target_heater
        is None
    )

    assert (
        controller._auto_heater
        is None
    )

    assert (
        controller._target_temperature
        is None
    )

    assert (
        controller._temperature
        is None
    )

    assert (
        controller._temperature_source
        is None
    )


async def main():

    await test_paused_schedule_suspends_auto()

    print()
    print("=" * 70)
    print(
        "ALL AUTO SCHEDULE PAUSE "
        "TESTS PASSED"
    )
    print("=" * 70)


if __name__ == "__main__":
    asyncio.run(main())