# Copyright (c) 2026 Krzysztof Rudnicki. MIT licence.
"""The nightly report: which day, which groups, and catching up after an outage."""

from __future__ import annotations

import datetime as dt
from dataclasses import dataclass
from typing import TYPE_CHECKING

import httpx

from signal_bot.bot import Bot, build_bot
from signal_bot.discovery import GroupDirectory
from signal_bot.liveness import Liveness
from signal_bot.mute import mute, unmute
from signal_bot.stats.events import MessageEvent
from signal_bot.stats.nightly import LAST_REPORTED_KEY
from signal_bot.stats.periods import WARSAW
from signal_bot.transport_fake import FakeTransport
from signal_bot.trust import InviteTrust
from tests.conftest import (
    SECOND_GROUP,
    WATCHED_GROUP,
    group_entry,
    listing_client,
    mock_client,
)

if TYPE_CHECKING:
    from signal_bot.config import Config
    from signal_bot.store import Store

# The report covers the day it runs on, so the tests freeze "now" and write
# their events into that same day. YESTERDAY is what the catch-up tests use
# for a day the bot still owes.
NOW = dt.datetime(2026, 9, 2, 21, 37, tzinfo=WARSAW)
TODAY = "2026-09-02"
YESTERDAY = "2026-09-01"


def _bot(config: Config, store: Store, transport: FakeTransport, directory: GroupDirectory) -> Bot:
    client = mock_client(lambda r: httpx.Response(200))
    return build_bot(
        config, client, store, transport, directory, Liveness(config, client), clock=lambda: NOW
    )


def wrote(
    store: Store, group_id: str, uuid: str, name: str, times: int, *, day: str = TODAY
) -> None:
    """Put ``times`` messages from one person into one group on one day."""
    for i in range(times):
        store.events.record(
            MessageEvent(
                group_id=group_id,
                uuid=uuid,
                display_name=name,
                sent_at_ms=i + 1,
                day=day,
                local_hour=12,
                char_len=5,
            )
        )
    store.events.note_person(group_id, uuid, name, "", day)


async def test_publish_report_posts_each_group_its_own_tally(
    config: Config, store: Store, transport: FakeTransport, directory: GroupDirectory
) -> None:
    """Every group gets its own counts, in its own chat, and only its own."""
    wrote(store, WATCHED_GROUP, "u1", "Alice", 1)
    wrote(store, SECOND_GROUP, "u2", "Bob", 2)
    await _bot(config, store, transport, directory).publish_report()
    assert [m.recipient for m in transport.sent] == [WATCHED_GROUP, SECOND_GROUP]
    assert "Alice" in transport.texts[0]
    assert "Bob" in transport.texts[1]
    assert "Alice" not in transport.texts[1]


async def test_the_report_covers_today_not_yesterday(
    config: Config, store: Store, transport: FakeTransport, directory: GroupDirectory
) -> None:
    """21:37 posts the day the group is living through, not the one before."""
    wrote(store, WATCHED_GROUP, "u1", "Alice", 1, day=TODAY)
    wrote(store, WATCHED_GROUP, "u2", "Bob", 9, day=YESTERDAY)
    await _bot(config, store, transport, directory).publish_report()
    assert "Alice" in transport.texts[0]
    assert "Bob" not in transport.texts[0]


async def test_a_still_open_day_says_when_its_count_stopped(
    config: Config, store: Store, transport: FakeTransport, directory: GroupDirectory
) -> None:
    """A partial day must not be presented as a whole one."""
    wrote(store, WATCHED_GROUP, "u1", "Alice", 1)
    await _bot(config, store, transport, directory).publish_report()
    assert "licznik zamknięty o 21:37" in transport.texts[0]


async def test_a_caught_up_day_carries_no_closing_caveat(
    config: Config, store: Store, transport: FakeTransport, directory: GroupDirectory
) -> None:
    """That day is over; its count is complete and needs no excuse."""
    wrote(store, WATCHED_GROUP, "u1", "Alice", 1, day=YESTERDAY)
    store.set_meta(WATCHED_GROUP, LAST_REPORTED_KEY, "2026-08-31")
    await _bot(config, store, transport, directory).publish_report()
    assert "licznik zamknięty" not in transport.texts[0]


async def test_nothing_is_deleted_after_publishing(
    config: Config, store: Store, transport: FakeTransport, directory: GroupDirectory
) -> None:
    """The log is append-only; a second run renders the same day again."""
    wrote(store, WATCHED_GROUP, "u1", "Alice", 3)
    bot = _bot(config, store, transport, directory)
    await bot.publish_report()
    first = transport.texts[0]
    store.set_meta(WATCHED_GROUP, LAST_REPORTED_KEY, YESTERDAY)
    await bot.publish_report()
    assert transport.texts[1] == first


async def test_publish_report_falls_back_to_uuid_when_unnamed(
    config: Config, store: Store, transport: FakeTransport, directory: GroupDirectory
) -> None:
    wrote(store, WATCHED_GROUP, "u1", "u1", 1)
    await _bot(config, store, transport, directory).publish_report()
    assert "u1" in transport.texts[0]


@dataclass
class RefusingTransport(FakeTransport):
    """A transport that rejects one group, the way a removal from it would."""

    refuses: str = ""

    async def send_text(self, text: str, recipient: str) -> None:
        """Record the send, unless this is the group that refuses them."""
        if recipient == self.refuses:
            msg = "removed from the group"
            raise RuntimeError(msg)
        await super().send_text(text, recipient)


async def test_one_group_failing_its_report_does_not_cost_the_others(
    config: Config, store: Store, directory: GroupDirectory
) -> None:
    """A failed send must not skip the next group."""
    wrote(store, WATCHED_GROUP, "u1", "Alice", 1)
    wrote(store, SECOND_GROUP, "u2", "Bob", 1)
    transport = RefusingTransport(refuses=WATCHED_GROUP)

    await _bot(config, store, transport, directory).publish_report()

    assert [m.recipient for m in transport.sent] == [SECOND_GROUP]
    assert "Bob" in transport.texts[0]


async def test_a_quiet_group_is_logged_rather_than_posted_into(
    config: Config, store: Store, transport: FakeTransport, directory: GroupDirectory
) -> None:
    """The bot sits in every group it was added to; a nightly ping is noise."""
    wrote(store, SECOND_GROUP, "u2", "Bob", 1)
    await _bot(config, store, transport, directory).publish_report()
    assert [m.recipient for m in transport.sent] == [SECOND_GROUP]


async def test_the_report_follows_the_live_group_set(
    config: Config, store: Store, transport: FakeTransport
) -> None:
    """Groups come from the directory, not from .env, so a new one is included."""
    client = listing_client([group_entry(WATCHED_GROUP), group_entry(SECOND_GROUP)])
    directory = GroupDirectory(config, client, store, InviteTrust(()))
    await directory.refresh()
    wrote(store, WATCHED_GROUP, "u1", "Alice", 1)
    wrote(store, SECOND_GROUP, "u2", "Bob", 1)
    await _bot(config, store, transport, directory).publish_report()
    assert [m.recipient for m in transport.sent] == [WATCHED_GROUP, SECOND_GROUP]


async def test_a_muted_group_has_its_report_held_back_not_lost(
    config: Config, store: Store, transport: FakeTransport, directory: GroupDirectory
) -> None:
    """Nothing is sent and nothing is marked, so the next run still owes the day."""
    wrote(store, WATCHED_GROUP, "u1", "Alice", 1)
    wrote(store, SECOND_GROUP, "u2", "Bob", 1)
    mute(store, WATCHED_GROUP, NOW.timestamp() + 60)
    bot = _bot(config, store, transport, directory)

    await bot.publish_report()
    assert [m.recipient for m in transport.sent] == [SECOND_GROUP]
    assert store.meta(WATCHED_GROUP, LAST_REPORTED_KEY) is None

    unmute(store, WATCHED_GROUP)
    await bot.publish_report()
    assert [m.recipient for m in transport.sent] == [SECOND_GROUP, WATCHED_GROUP]
    assert "Alice" in transport.texts[1]