from __future__ import annotations

import unittest
from datetime import UTC, datetime

from govoplan_core.core.postbox import (
    PostboxDeliveryCatalogRef,
    PostboxDirectoryEntryRef,
    PostboxDeliveryRequest,
    PostboxDeliveryReceiptSummaryRef,
    PostboxDeliveryResult,
    PostboxTargetRef,
)
from govoplan_campaign.backend.integrations import (
    PostboxCampaignIntegration,
    PostboxDeliveryUnavailable,
)


class _PostboxDelivery:
    def __init__(self) -> None:
        self.requests = []

    def deliver(self, session, request):
        self.requests.append((session, request))
        return PostboxDeliveryResult(
            delivery_id="delivery-1",
            postbox_id="postbox-1",
            message_id="message-1",
            address="intake@postbox",
            status="accepted",
            vacant=False,
            holder_count=1,
        )

    def delivery_catalog(self, session, *, tenant_id):
        return PostboxDeliveryCatalogRef()

    def list_visible_postboxes(self, session, *, tenant_id, actor):
        return ()

    def resolve_postbox(
        self,
        session,
        *,
        tenant_id,
        target,
        materialize=False,
    ):
        return PostboxDirectoryEntryRef(
            id=target.postbox_id or "postbox-1",
            tenant_id=tenant_id,
            address="intake@postbox",
            address_key="intake",
            name="Intake",
            status="active",
            classification="internal",
        )

    def link_evidence(self, session, *, tenant_id, message_id, attachment):
        del session, tenant_id, message_id, attachment
        return None

    def delivery_receipt_summaries(
        self,
        session,
        *,
        tenant_id,
        producer_module,
        delivery_ids,
    ):
        del session
        assert tenant_id == "tenant-1"
        assert producer_module == "campaigns"
        return {
            delivery_id: PostboxDeliveryReceiptSummaryRef(
                delivery_id=delivery_id,
                message_id="message-1",
                postbox_id="postbox-1",
                delivery_status="accepted",
                accepted_at=datetime(2026, 7, 30, tzinfo=UTC),
                currently_readable=True,
                read_receipt_count=1,
            )
            for delivery_id in delivery_ids
        }


class PostboxCampaignIntegrationTests(unittest.TestCase):
    def test_optional_delivery_boundary_is_typed_and_explicit(self) -> None:
        delegate = _PostboxDelivery()
        integration = PostboxCampaignIntegration(delegate, delegate, delegate)
        request = PostboxDeliveryRequest(
            tenant_id="tenant-1",
            target=PostboxTargetRef(postbox_id="postbox-1"),
            producer_module="campaigns",
            producer_resource_type="campaign_job",
            producer_resource_id="job-1",
            idempotency_key="campaign-1:job-1:postbox-1",
            subject="Decision",
        )

        result = integration.deliver(object(), request)

        self.assertTrue(integration.available)
        self.assertTrue(integration.receipt_evidence_available)
        self.assertEqual("delivery-1", result.delivery_id)
        self.assertEqual(request, delegate.requests[0][1])
        summaries = integration.delivery_receipt_summaries(
            object(),
            tenant_id="tenant-1",
            delivery_ids=["delivery-1"],
        )
        self.assertEqual(1, summaries["delivery-1"].read_receipt_count)

    def test_missing_postbox_is_reported_without_importing_module_code(
        self,
    ) -> None:
        integration = PostboxCampaignIntegration()
        request = PostboxDeliveryRequest(
            tenant_id="tenant-1",
            target=PostboxTargetRef(postbox_id="postbox-1"),
            producer_module="campaigns",
            producer_resource_type="campaign_job",
            producer_resource_id="job-1",
            idempotency_key="campaign-1:job-1:postbox-1",
            subject="Decision",
        )

        self.assertFalse(integration.available)
        self.assertFalse(integration.receipt_evidence_available)
        self.assertEqual(
            {},
            integration.delivery_receipt_summaries(
                object(),
                tenant_id="tenant-1",
                delivery_ids=["delivery-1"],
            ),
        )
        with self.assertRaises(PostboxDeliveryUnavailable):
            integration.deliver(object(), request)


if __name__ == "__main__":
    unittest.main()