from __future__ import annotations

import unittest
from types import SimpleNamespace
from unittest.mock import patch

from govoplan_core.core.modules import MigrationRetirementPlan, ModuleManifest
from govoplan_mail.backend.manifest import _mail_retirement_provider, get_manifest


class MailManifestTests(unittest.TestCase):
    def test_mail_quick_access_can_return_exact_message_references(self) -> None:
        frontend = get_manifest().frontend
        self.assertIsNotNone(frontend)
        tool = next(
            item for item in frontend.quick_access_tools if item.id == "mail.messages"  # type: ignore[union-attr]
        )
        self.assertIn("select", tool.modes)
        self.assertEqual(("mail.message",), tool.returned_reference_kinds)

    def test_manifest_declares_optional_addresses_lookup(self) -> None:
        manifest = get_manifest()

        self.assertIsInstance(manifest, ModuleManifest)
        self.assertEqual(manifest.id, "mail")
        self.assertIn("addresses", manifest.optional_dependencies)
        self.assertIn("addresses.lookup", {interface.name for interface in manifest.requires_interfaces})
        self.assertIn("addresses.contact_writer", {interface.name for interface in manifest.requires_interfaces})
        self.assertIn(
            {
                "name": "campaigns.access",
                "version_min": "0.1.0",
                "version_max_exclusive": "0.2.0",
                "optional": True,
            },
            [
                {
                    "name": interface.name,
                    "version_min": interface.version_min,
                    "version_max_exclusive": interface.version_max_exclusive,
                    "optional": interface.optional,
                }
                for interface in manifest.requires_interfaces
            ],
        )
        self.assertIn(
            {"name": "mail.campaign_delivery", "version": "0.2.0"},
            [
                {"name": interface.name, "version": interface.version}
                for interface in manifest.provides_interfaces
            ],
        )
        permissions = {permission.scope for permission in manifest.permissions}
        self.assertIn("mail:profile:write_own", permissions)
        self.assertIn("mail:secret:manage_own", permissions)
        self.assertTrue(
            {"mail:pop3:manage", "mail:pop3:import", "mail:pop3:delete"}.issubset(
                permissions
            )
        )
        roles = {template.slug: template for template in manifest.role_templates}
        self.assertIn("mail:pop3:delete", roles["mail_profile_admin"].permissions)
        self.assertEqual(
            set(roles["mail_legacy_import_operator"].permissions),
            {
                "mail:profile:read",
                "mail:profile:use",
                "mail:profile:test",
                "mail:pop3:import",
            },
        )
        self.assertEqual(
            set(roles["mail_profile_self_service"].permissions),
            {
                "mail:profile:read",
                "mail:profile:use",
                "mail:profile:test",
                "mail:mailbox:read",
                "mail:profile:write_own",
                "mail:secret:manage_own",
            },
        )
        topics = {topic.id: topic for topic in manifest.documentation}
        self.assertTrue(
            {
                "mail.workflow.choose-and-test-profile",
                "mail.workflow.read-mailbox",
                "mail.reference.credentials-egress-retirement",
                "mail.reference.campaign-delivery-contract",
                "mail.address-book-integration",
                "mail.workflow.legacy-pop3-import",
            }.issubset(topics)
        )
        pop3_topic = topics["mail.workflow.legacy-pop3-import"]
        self.assertEqual(("user", "admin"), pop3_topic.documentation_types)
        self.assertIn("mail:pop3:import", pop3_topic.conditions[0].any_scopes)

        pop3_provider = next(
            item
            for item in manifest.external_providers
            if item.id == "mail.pop3_legacy_import"
        )
        self.assertIn("delete", pop3_provider.operations)
        self.assertTrue(pop3_provider.behavior.outcome_unknown_supported)
        self.assertIn("mail.pop3.source_deletion", pop3_provider.behavior.audit_event_types)
        self.assertTrue(
            any(
                route.path == "/mail/legacy-import"
                for route in manifest.frontend.routes  # type: ignore[union-attr]
            )
        )
        ownership = topics["mail.profile-ownership-and-consumers"]
        self.assertEqual(ownership.metadata["kind"], "reference")
        self.assertEqual(ownership.metadata["route"], "/settings?section=mail-profiles")
        self.assertIn("campaigns.mail-profile-user-journey", ownership.metadata["related_topic_ids"])

        mailbox = topics["mail.workflow.read-mailbox"]
        self.assertEqual(mailbox.metadata["route"], "/mail")
        self.assertIn("mail.mailbox", mailbox.metadata["help_contexts"])
        self.assertEqual(
            mailbox.conditions[0].required_scopes,
            ("mail:mailbox:read", "mail:profile:use"),
        )

        campaign_contract = topics["mail.reference.campaign-delivery-contract"]
        self.assertEqual(campaign_contract.conditions[0].required_modules, ("mail", "campaigns"))

        profile_policy = topics["mail.profiles-and-policy"]
        self.assertIn("mail.admin.profiles", profile_policy.metadata["help_contexts"])
        bounce_processing = topics["mail.bounce-processing"]
        self.assertIn("mail.bounce-processing", bounce_processing.metadata["help_contexts"])

    def test_retirement_scrubs_credentials_before_dropping_mail_tables(self) -> None:
        events: list[str] = []

        def table_provider(_session, _module_id):
            return MigrationRetirementPlan(
                supported=True,
                summary="Mail tables",
                destroy_data_supported=True,
                destroy_data_executor=lambda _execute_session, _execute_module_id: events.append("drop"),
            )

        session = SimpleNamespace(get_bind=lambda: object(), query=lambda *_args: None)
        inspector = SimpleNamespace(has_table=lambda _name: True)
        with (
            patch("govoplan_mail.backend.manifest._mail_table_retirement_provider", table_provider),
            patch("govoplan_mail.backend.manifest.inspect", return_value=inspector),
            patch(
                "govoplan_mail.backend.mail_profiles.delete_mail_profile_credentials_for_retirement",
                side_effect=lambda _session: events.append("scrub"),
            ),
        ):
            plan = _mail_retirement_provider(session, "mail")
            assert plan.destroy_data_executor is not None
            plan.destroy_data_executor(session, "mail")

        self.assertEqual(events, ["scrub", "drop"])
        self.assertTrue(any("audit" in warning for warning in plan.destroy_data_warnings))

        events.clear()
        with (
            patch("govoplan_mail.backend.manifest._mail_table_retirement_provider", table_provider),
            patch("govoplan_mail.backend.manifest.inspect", return_value=inspector),
            patch(
                "govoplan_mail.backend.mail_profiles.delete_mail_profile_credentials_for_retirement",
                side_effect=RuntimeError("audit unavailable"),
            ),
        ):
            blocked_plan = _mail_retirement_provider(session, "mail")
            assert blocked_plan.destroy_data_executor is not None
            with self.assertRaisesRegex(RuntimeError, "audit unavailable"):
                blocked_plan.destroy_data_executor(session, "mail")

        self.assertEqual(events, [])


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