import uuid
from typing import Any, Optional
from sqlalchemy.ext.asyncio import AsyncSession
from core.exceptions import ConflictError, NotFoundError, ValidationError
from modules.plugins.executor import PluginExecutor
from modules.plugins.models import Plugin, TenantPlugin
from modules.plugins.repository import PluginRepository
from modules.plugins.schemas import (
    ActivatePluginRequest,
    ExecutePluginHookRequest,
    ExecutePluginHookResponse,
    PluginResponse,
    TenantPluginResponse,
    UpdatePluginConfigRequest,
)


class PluginService:
    """Manages the plugin catalog, tenant installation, and sandboxed hook execution."""

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

    async def seed_default_plugins(self) -> None:
        """Populates the platform with 4 official plugins."""
        official_plugins = [
            Plugin(
                id="welcome_captcha",
                name="Anti-Spam Welcome Captcha",
                description="Prompts new group or private chat members with a math captcha before unmuting.",
                version="1.0.0",
                author="Platform Security Team",
                category="security",
                required_permissions=["messages:read", "messages:write", "users:read"],
                default_config={"timeout_seconds": 60, "action_on_fail": "kick"},
                is_official=True,
                is_active=True,
            ),
            Plugin(
                id="crypto_price_tracker",
                name="Crypto Price & Alert Tracker",
                description="Live real-time cryptocurrency price quotes, charting alerts, and conversion commands.",
                version="1.2.0",
                author="Platform Financial Labs",
                category="utility",
                required_permissions=["messages:read", "messages:write", "external:http"],
                default_config={"default_symbol": "BTC", "fiat_currency": "USD"},
                is_official=True,
                is_active=True,
            ),
            Plugin(
                id="sentiment_analyzer",
                name="User Chat Sentiment Classifier",
                description="Classifies chat messages in real time into positive, neutral, or angry for admin escalation.",
                version="1.0.0",
                author="AI Platform Labs",
                category="ai",
                required_permissions=["messages:read"],
                default_config={"alert_on_negative": True, "escalate_threshold": -0.7},
                is_official=True,
                is_active=True,
            ),
            Plugin(
                id="auto_support_router",
                name="Automated Support Ticket Router",
                description="Routes incoming user queries to support channels or creates CRM tickets automatically.",
                version="2.0.0",
                author="Platform Integrations",
                category="integration",
                required_permissions=["messages:read", "messages:write", "external:http"],
                default_config={"support_group_id": -100123456789, "auto_tag": True},
                is_official=True,
                is_active=True,
            ),
        ]
        for p in official_plugins:
            await self.repo.upsert_plugin(p)

    async def list_available_plugins(self) -> list[PluginResponse]:
        plugins = await self.repo.list_plugins()
        if not plugins:
            await self.seed_default_plugins()
            plugins = await self.repo.list_plugins()
        return [PluginResponse.model_validate(p) for p in plugins]

    async def activate_plugin(
        self,
        tenant_id: uuid.UUID,
        req: ActivatePluginRequest,
    ) -> TenantPluginResponse:
        plugin = await self.repo.get_plugin_by_id(req.plugin_id)
        if not plugin:
            raise NotFoundError(f"Plugin '{req.plugin_id}' not found in registry")

        # Check if already installed
        existing = await self.repo.get_tenant_plugin(tenant_id, req.plugin_id, req.bot_id)
        if existing:
            raise ConflictError(f"Plugin '{plugin.name}' is already installed for this tenant/bot")

        # Default permissions granted = required permissions unless customized
        permissions = req.granted_permissions or plugin.required_permissions
        merged_config = {**plugin.default_config, **(req.config or {})}

        tp = await self.repo.create_tenant_plugin(
            tenant_id=tenant_id,
            plugin_id=plugin.id,
            bot_id=req.bot_id,
            config=merged_config,
            installed_version=plugin.version,
            granted_permissions=permissions,
        )

        return TenantPluginResponse(
            id=tp.id,
            tenant_id=tp.tenant_id,
            bot_id=tp.bot_id,
            plugin_id=tp.plugin_id,
            plugin_name=plugin.name,
            is_enabled=tp.is_enabled,
            config=tp.config,
            installed_version=tp.installed_version,
            granted_permissions=tp.granted_permissions,
            created_at=tp.created_at,
        )

    async def list_tenant_plugins(self, tenant_id: uuid.UUID) -> list[TenantPluginResponse]:
        installed = await self.repo.list_tenant_plugins(tenant_id)
        res = []
        for tp in installed:
            plugin = await self.repo.get_plugin_by_id(tp.plugin_id)
            res.append(
                TenantPluginResponse(
                    id=tp.id,
                    tenant_id=tp.tenant_id,
                    bot_id=tp.bot_id,
                    plugin_id=tp.plugin_id,
                    plugin_name=plugin.name if plugin else tp.plugin_id,
                    is_enabled=tp.is_enabled,
                    config=tp.config,
                    installed_version=tp.installed_version,
                    granted_permissions=tp.granted_permissions,
                    created_at=tp.created_at,
                )
            )
        return res

    async def update_tenant_plugin(
        self,
        tenant_id: uuid.UUID,
        tenant_plugin_id: uuid.UUID,
        req: UpdatePluginConfigRequest,
    ) -> TenantPluginResponse:
        tp = await self.repo.get_tenant_plugin_by_id(tenant_id, tenant_plugin_id)
        if not tp:
            raise NotFoundError("Installed plugin not found")

        updates: dict[str, Any] = {}
        if req.config is not None:
            updates["config"] = {**tp.config, **req.config}
        if req.is_enabled is not None:
            updates["is_enabled"] = req.is_enabled

        updated = await self.repo.update_tenant_plugin(tp, **updates)
        plugin = await self.repo.get_plugin_by_id(updated.plugin_id)
        return TenantPluginResponse(
            id=updated.id,
            tenant_id=updated.tenant_id,
            bot_id=updated.bot_id,
            plugin_id=updated.plugin_id,
            plugin_name=plugin.name if plugin else updated.plugin_id,
            is_enabled=updated.is_enabled,
            config=updated.config,
            installed_version=updated.installed_version,
            granted_permissions=updated.granted_permissions,
            created_at=updated.created_at,
        )

    async def deactivate_plugin(
        self,
        tenant_id: uuid.UUID,
        tenant_plugin_id: uuid.UUID,
    ) -> None:
        tp = await self.repo.get_tenant_plugin_by_id(tenant_id, tenant_plugin_id)
        if not tp:
            raise NotFoundError("Installed plugin not found")
        await self.repo.delete_tenant_plugin(tp)

    async def execute_hook(
        self,
        tenant_id: uuid.UUID,
        tenant_plugin_id: uuid.UUID,
        req: ExecutePluginHookRequest,
    ) -> ExecutePluginHookResponse:
        tp = await self.repo.get_tenant_plugin_by_id(tenant_id, tenant_plugin_id)
        if not tp:
            raise NotFoundError("Installed plugin not found")
        if not tp.is_enabled:
            raise ValidationError("Plugin is currently disabled")

        plugin = await self.repo.get_plugin_by_id(tp.plugin_id)
        if not plugin:
            raise NotFoundError("Base plugin definition not found")

        return await PluginExecutor.execute_hook(
            tenant_plugin=tp,
            plugin_meta=plugin,
            hook_name=req.hook_name,
            payload=req.payload,
        )
