from datetime import UTC, datetime
from uuid import uuid4

import pytest
from sqlalchemy import delete, select

from app.infrastructure.db import SessionFactory
from app.model.audit import InteractionAudit
from app.model.configuration import ConfigRelease
from app.model.platform import DomainEventOutbox
from app.service.config_release_service import ConfigReleaseError, ConfigReleaseService


@pytest.mark.integration
@pytest.mark.asyncio
async def test_config_release_lifecycle_is_versioned_and_audited() -> None:
    now = datetime.now(UTC).replace(tzinfo=None)
    release_no = f"it-{uuid4().hex}"
    release_id = 0
    rollback_id = 0
    # 本测试会激活临时版本，把平台当前生效的版本顶成 superseded。先记下它是谁，
    # 清理时恢复——否则平台会静默停在"零个 active 版本"（见 finally 的说明）。
    async with SessionFactory() as session:
        original_active_id = await session.scalar(
            select(ConfigRelease.id).where(ConfigRelease.status == "active")
        )
    try:
        async with SessionFactory() as session:
            release = ConfigRelease(
                release_no=release_no,
                title="integration",
                change_summary="integration",
                status="draft",
                created_by=101,
                created_at=now,
                updated_at=now,
            )
            session.add(release)
            await session.flush()
            release_id = release.id
            service = ConfigReleaseService(session)
            # 草稿不能直接审核：审核节点不可跳过。
            with pytest.raises(ConfigReleaseError, match="not pending review"):
                await service.approve(release_id, 101)
            await service.submit_for_review(release_id, 101)
            # 单人复核：创建人 101 自己审核通过。库侧的
            # chk_config_release_separation 已由迁移 20260910_drop_review_separation 撤下，
            # 因此自审与多人复核一样**如实写入** reviewer_id（列含义就是"审核人"）。
            approved = await service.approve(release_id, 101)
            assert approved.reviewer_id == 101
            assert approved.reviewed_at is not None
            await service.activate(release_id, 101)
            await session.commit()

        async with SessionFactory() as session:
            service = ConfigReleaseService(session)
            rollback = await service.rollback(release_id, 101)
            rollback_id = rollback.id
            await session.commit()

        async with SessionFactory() as session:
            release = await session.get(ConfigRelease, release_id)
            rollback = await session.get(ConfigRelease, rollback_id)
            events = list(
                await session.scalars(
                    select(DomainEventOutbox).where(
                        DomainEventOutbox.event_type == "config.cache_invalidate_requested",
                        DomainEventOutbox.aggregate_id.in_([str(release_id), str(rollback_id)]),
                    )
                )
            )
            audits = list(
                await session.scalars(
                    select(InteractionAudit).where(
                        InteractionAudit.action_type.in_(
                            [
                                "config.submit_review",
                                "config.approve",
                                "config.activate",
                                "config.rollback",
                            ]
                        ),
                        InteractionAudit.detail["release_id"].in_([release_id, rollback_id]),
                    )
                )
            )
            assert release is not None and release.status == "superseded"
            assert rollback is not None and rollback.status == "active"
            assert rollback.rollback_of_release_id == release_id
            assert len(events) == 2
            assert len(audits) == 4
    finally:
        async with SessionFactory() as session:
            await session.execute(
                delete(InteractionAudit).where(
                    InteractionAudit.detail["release_id"].in_([release_id, rollback_id])
                )
            )
            await session.execute(
                delete(DomainEventOutbox).where(
                    DomainEventOutbox.aggregate_id.in_([str(release_id), str(rollback_id)]),
                    # 必须限定 event_type：`aggregate_id` 是字符串列，`release_id` 是自增小整数，
                    # 与其它域用小整数做 `aggregate_id` 的记录（例如知识库的
                    # `knowledge.vector_sync_requested`，aggregate_id = fin_knowledge_meta.id）
                    # 数值上会碰撞。只按 aggregate_id 删会**误删其它域的 outbox 行**，
                    # 表现为那些知识行永远拿不到向量同步事件、静默不被索引。
                    DomainEventOutbox.event_type == "config.cache_invalidate_requested",
                )
            )
            await session.execute(
                delete(ConfigRelease).where(ConfigRelease.release_no.like("it-%"))
            )
            # 回滚记录的 release_no 是 rollback-*，不在 it-* 前缀内。不删会留下一个
            # 没有配置项的 active 版本，污染后续脚本读取的"当前生效版本"。
            await session.execute(
                delete(ConfigRelease).where(ConfigRelease.rollback_of_release_id == release_id)
            )
            # 删除临时版本只是清理的一半。本测试期间的激活已经把**平台原有的** active 版本
            # 顶成了 superseded（activate 顶替当前 active），只删自己的版本会让平台静默停在
            # "零个 active 版本"：工具白名单随之变成空集，所有 Agent 工具按 fail-closed 被拒，
            # 而这种故障没有任何报错，只在真正调用工具时才暴露（曾实际发生过）。因此删完后
            # 必须把原先生效的版本恢复为 active——此时临时版本已删除，不会撞唯一键
            # uk_config_release_active_one。
            if original_active_id is not None:
                original = await session.get(ConfigRelease, original_active_id)
                if original is not None and original.status == "superseded":
                    original.status = "active"
                    original.updated_at = datetime.now(UTC).replace(tzinfo=None)
            await session.commit()