"""Per-plugin migration runner + install/uninstall lifecycle (SPEC §11.1, §12 M3).

The runner drives Alembic synchronously (env.py calls asyncio.run), so it's
invoked via ``asyncio.to_thread`` from these async tests to avoid a nested loop.
"""

from __future__ import annotations

import asyncio
from pathlib import Path

import pytest
from sqlalchemy import text
from sqlalchemy.ext.asyncio import create_async_engine
from sqlalchemy.pool import NullPool

from app.config import get_settings
from app.plugins import loader, migrate
from app.plugins.sdk import Plugin

_VERSIONS = str(Path(__file__).parent.parent / "fixtures" / "plugin_demo" / "versions")


async def _scalar(sql: str, **params: str) -> object:
    engine = create_async_engine(get_settings().database_url, poolclass=NullPool)
    try:
        async with engine.connect() as conn:
            return (await conn.execute(text(sql), params)).scalar()
    finally:
        await engine.dispose()


async def _regclass(name: str) -> object:
    return await _scalar("SELECT to_regclass(:n)", n=name)


async def _cleanup() -> None:
    engine = create_async_engine(get_settings().database_url, poolclass=NullPool)
    try:
        async with engine.begin() as conn:
            await conn.execute(text("DROP TABLE IF EXISTS plg_demo_note"))
            await conn.execute(text("DROP TABLE IF EXISTS alembic_version_plg_demo"))
    finally:
        await engine.dispose()


async def test_install_run_uninstall_dropdata_roundtrip() -> None:
    loader.set_plugins_for_test([Plugin(name="demo", version="1.0", migrations=_VERSIONS)])
    try:
        await asyncio.to_thread(migrate.install, "demo")

        # Table exists, RLS is enabled on it, and the per-plugin version table is present.
        assert await _regclass("plg_demo_note") == "plg_demo_note"
        assert await _scalar(
            "SELECT relrowsecurity FROM pg_class WHERE relname = 'plg_demo_note'"
        ) is True
        assert await _regclass("alembic_version_plg_demo") == "alembic_version_plg_demo"

        # --drop-data removes the table AND the version table: zero residue.
        await asyncio.to_thread(migrate.uninstall, "demo", drop_data=True)
        assert await _regclass("plg_demo_note") is None
        assert await _regclass("alembic_version_plg_demo") is None
    finally:
        await _cleanup()


async def test_uninstall_without_drop_data_keeps_the_table() -> None:
    loader.set_plugins_for_test([Plugin(name="demo", version="1.0", migrations=_VERSIONS)])
    try:
        await asyncio.to_thread(migrate.install, "demo")
        await asyncio.to_thread(migrate.uninstall, "demo", drop_data=False)
        assert await _regclass("plg_demo_note") == "plg_demo_note"  # data preserved
    finally:
        await asyncio.to_thread(migrate.uninstall, "demo", drop_data=True)
        await _cleanup()


async def test_uninstall_refuses_builtin_plugin() -> None:
    loader.set_plugins_for_test(
        [Plugin(name="calendar", version="1", builtin=True, migrations=_VERSIONS)]
    )
    with pytest.raises(loader.PluginRemovalError, match="builtin"):
        await asyncio.to_thread(migrate.uninstall, "calendar", drop_data=True)


async def test_install_unknown_plugin_errors() -> None:
    loader.set_plugins_for_test([])
    with pytest.raises(migrate.PluginMigrationError, match="unknown"):
        await asyncio.to_thread(migrate.install, "nope")