import uuid
from typing import Any, Optional
from sqlalchemy import select
from sqlalchemy.ext.asyncio import AsyncSession
from modules.plugins.models import Plugin, TenantPlugin


class PluginRepository:
    def __init__(self, db: AsyncSession):
        self.db = db

    async def list_plugins(self) -> list[Plugin]:
        res = await self.db.execute(select(Plugin).where(Plugin.is_active.is_(True)).order_by(Plugin.name.asc()))
        return list(res.scalars().all())

    async def get_plugin_by_id(self, plugin_id: str) -> Optional[Plugin]:
        res = await self.db.execute(select(Plugin).where(Plugin.id == plugin_id))
        return res.scalar_one_or_none()

    async def upsert_plugin(self, plugin: Plugin) -> Plugin:
        existing = await self.get_plugin_by_id(plugin.id)
        if existing:
            for k, v in plugin.__dict__.items():
                if not k.startswith("_") and k != "id":
                    setattr(existing, k, v)
            await self.db.commit()
            await self.db.refresh(existing)
            return existing
        self.db.add(plugin)
        await self.db.commit()
        await self.db.refresh(plugin)
        return plugin

    async def get_tenant_plugin(
        self,
        tenant_id: uuid.UUID,
        plugin_id: str,
        bot_id: Optional[uuid.UUID] = None,
    ) -> Optional[TenantPlugin]:
        stmt = select(TenantPlugin).where(
            TenantPlugin.tenant_id == tenant_id,
            TenantPlugin.plugin_id == plugin_id,
        )
        if bot_id:
            stmt = stmt.where(TenantPlugin.bot_id == bot_id)
        res = await self.db.execute(stmt)
        return res.scalar_one_or_none()

    async def get_tenant_plugin_by_id(
        self,
        tenant_id: uuid.UUID,
        tenant_plugin_id: uuid.UUID,
    ) -> Optional[TenantPlugin]:
        res = await self.db.execute(
            select(TenantPlugin).where(
                TenantPlugin.id == tenant_plugin_id,
                TenantPlugin.tenant_id == tenant_id,
            )
        )
        return res.scalar_one_or_none()

    async def list_tenant_plugins(self, tenant_id: uuid.UUID) -> list[TenantPlugin]:
        res = await self.db.execute(
            select(TenantPlugin).where(TenantPlugin.tenant_id == tenant_id).order_by(TenantPlugin.created_at.desc())
        )
        return list(res.scalars().all())

    async def create_tenant_plugin(
        self,
        tenant_id: uuid.UUID,
        plugin_id: str,
        bot_id: Optional[uuid.UUID],
        config: dict[str, Any],
        installed_version: str,
        granted_permissions: list[str],
    ) -> TenantPlugin:
        tp = TenantPlugin(
            id=uuid.uuid4(),
            tenant_id=tenant_id,
            plugin_id=plugin_id,
            bot_id=bot_id,
            is_enabled=True,
            config=config,
            installed_version=installed_version,
            granted_permissions=granted_permissions,
        )
        self.db.add(tp)
        await self.db.commit()
        await self.db.refresh(tp)
        return tp

    async def update_tenant_plugin(self, tp: TenantPlugin, **updates: Any) -> TenantPlugin:
        for k, v in updates.items():
            if v is not None:
                setattr(tp, k, v)
        await self.db.commit()
        await self.db.refresh(tp)
        return tp

    async def delete_tenant_plugin(self, tp: TenantPlugin) -> None:
        await self.db.delete(tp)
        await self.db.commit()
