"""Telegram provider adapter for sealed weekly reminders."""

from __future__ import annotations

from dataclasses import dataclass
from typing import Protocol

from checkin_cli.weekly_operations_lifecycle import (
    ProviderDelivered,
    ProviderRejected,
    ReminderProviderUnknown,
)
from checkin_cli.weekly_reminder_authority import (
    BoundWeeklyReminderCustomer,
    reminder_template,
)


@dataclass(frozen=True, slots=True)
class TelegramReminderDelivered:
    provider_receipt: str
    message_id: str


@dataclass(frozen=True, slots=True)
class TelegramReminderRejected:
    reason: str


def reminder_provider_unknown() -> ReminderProviderUnknown:
    return ReminderProviderUnknown()


class TelegramReminderTransport(Protocol):
    async def send_weekly_reminder(
        self, chat_id: str, topic_id: str | None, text: str
    ) -> TelegramReminderDelivered | TelegramReminderRejected: ...


@dataclass(frozen=True, slots=True)
class TelegramWeeklyReminderProvider:
    """Use only the existing Telegram transport contract."""

    transport: TelegramReminderTransport

    async def send(
        self, bound_customer: BoundWeeklyReminderCustomer
    ) -> ProviderDelivered | ProviderRejected:
        bound_customer.route.verify()
        result = await self.transport.send_weekly_reminder(
            bound_customer.route.chat_id,
            bound_customer.route.topic_id,
            reminder_template(bound_customer),
        )
        if isinstance(result, TelegramReminderDelivered):
            return ProviderDelivered(result.provider_receipt, result.message_id)
        return ProviderRejected(result.reason)