signal-bot/signal_bot/app.py

# Copyright (c) 2026 Krzysztof Rudnicki. MIT licence.
"""Application wiring and the ASGI entrypoint."""

from __future__ import annotations

import asyncio
import contextlib
import datetime as dt
import logging
from dataclasses import dataclass, field
from typing import TYPE_CHECKING

if TYPE_CHECKING:
    from collections.abc import AsyncIterator

    from signal_bot.transport_base import Transport

import httpx
from fastapi import FastAPI

from signal_bot.animals import register_animal_commands
from signal_bot.config import Config, load_config
from signal_bot.counting import format_tally
from signal_bot.decorators import cooldown
from signal_bot.dispatcher import Dispatcher
from signal_bot.http_client import ImageFetcher
from signal_bot.registry import CommandRegistry
from signal_bot.scheduler import DailyScheduler
from signal_bot.store import Store
from signal_bot.transport_rest import RestTransport

logger = logging.getLogger(__name__)

COOLDOWN_MESSAGE = "BEEP BOOP POCZEKAJ {seconds} SEKUND."
HTTP_TIMEOUT_SECONDS = 30.0


def now_local() -> dt.datetime:
    """Current local time, timezone-aware."""
    return dt.datetime.now().astimezone()


@dataclass
class Bot:
    """The wired-up bot and its two long-running loops."""

    config: Config
    store: Store
    transport: Transport
    dispatcher: Dispatcher

    async def publish_report(self) -> None:
        """Post each group's own tally into that group, and reset it.

        Each group is isolated on purpose. One group refusing the report --
        the bot removed from it, a transient send failure -- must not cost
        every other group its report, and a tally is cleared only after its
        report has actually gone out, so a failed send loses nothing.
        """
        for group_id in self.config.group_ids:
            rows = [(t.display_name or t.uuid, t.count) for t in self.store.tallies(group_id)]
            try:
                await self.transport.send_text(format_tally(rows), group_id)
            except Exception:
                logger.exception("daily report failed for group %s", group_id)
                continue
            self.store.reset_tallies(group_id)

    async def listen(self) -> None:
        """Consume frames forever, handing each to the dispatcher."""
        async for frame in self.transport.receive():
            await self.dispatcher.handle(frame)


def build_bot(config: Config, client: httpx.AsyncClient, store: Store, transport: Transport) -> Bot:
    """Assemble the object graph from its injected dependencies."""
    registry = CommandRegistry()
    register_animal_commands(
        registry,
        ImageFetcher(client),
        decorate=cooldown(config.cooldown_seconds, COOLDOWN_MESSAGE),
        endpoints={"cat": config.cat_api_url, "dog": config.dog_api_url},
    )
    dispatcher = Dispatcher(
        config=config,
        registry=registry,
        store=store,
        transport=transport,
        clock=now_local,
    )
    return Bot(config=config, store=store, transport=transport, dispatcher=dispatcher)


@dataclass
class Runtime:
    """Owns everything that must be torn down when the app stops."""

    bot: Bot
    client: httpx.AsyncClient
    store: Store
    tasks: list[asyncio.Task[None]] = field(default_factory=list)

    def start(self) -> None:
        """Spawn the listener and the daily scheduler as background tasks."""
        scheduler = DailyScheduler(
            self.bot.config.report_hour,
            self.bot.config.report_minute,
            self.bot.publish_report,
            now_local,
            asyncio.sleep,
        )
        self.tasks = [
            asyncio.create_task(self.bot.listen()),
            asyncio.create_task(scheduler.run()),
        ]

    async def stop(self) -> None:
        """Cancel the background tasks and close every resource."""
        for task in self.tasks:
            task.cancel()
        for task in self.tasks:
            with contextlib.suppress(asyncio.CancelledError):
                await task
        await self.client.aclose()
        self.store.close()


async def create_runtime(config: Config, client: httpx.AsyncClient) -> Runtime:
    """Build a Runtime, verifying the container exposes a WebSocket first."""
    store = Store(config.database_path)
    transport = RestTransport(config, client)
    await transport.verify_mode()
    await transport.verify_membership()
    return Runtime(bot=build_bot(config, client, store, transport), client=client, store=store)


@contextlib.asynccontextmanager
async def lifespan(app: FastAPI) -> AsyncIterator[None]:
    """Start the background tasks without blocking ASGI startup.

    The previous version awaited asyncio.gather() on two infinite tasks inside
    an on_event("startup") handler, so uvicorn never finished starting up and
    the HTTP app never began serving.
    """
    config = load_config()
    client = httpx.AsyncClient(timeout=HTTP_TIMEOUT_SECONDS)
    runtime = await create_runtime(config, client)
    runtime.start()
    logger.info(
        "listening as %s, watching %d group(s): %r",
        config.phone_number,
        len(config.group_ids),
        list(config.group_ids),
    )
    app.state.runtime = runtime
    try:
        yield
    finally:
        await runtime.stop()


app = FastAPI(lifespan=lifespan)


@app.get("/healthz")
async def healthz() -> dict[str, str]:
    """Liveness probe. The old app defined no routes at all."""
    return {"status": "ok"}