"""Project Cloud capability entitlements. Config rows are not grants."""
from __future__ import annotations

from uuid import UUID

from fastapi import APIRouter, Depends
from pydantic import BaseModel
from sqlalchemy.ext.asyncio import AsyncSession

from src.core.database import get_db
from src.core.dependencies import require_active_billing_for_project_id
from src.core.exceptions import NotFoundError
from src.domain.auth.models import User
from src.domain.auth.router import get_current_user
from src.domain.cloud.service import _enabled_project_capabilities
from src.domain.projects.repository import ProjectRepository, ProjectSettingsRepository
from src.integrations.cloud_control_client import CloudControlClient

router = APIRouter(prefix="/api/projects/{project_id}/cloud", tags=["cloud-capabilities"])

_EDITABLE = ("livechat.enabled", "voice.enabled")


class CloudCapabilitiesResponse(BaseModel):
    project_id: UUID
    capabilities: dict[str, bool]


class CloudCapabilitiesUpdate(BaseModel):
    capabilities: dict[str, bool]


@router.get("/capabilities", response_model=CloudCapabilitiesResponse)
async def get_capabilities(
    project_id: UUID = Depends(require_active_billing_for_project_id),
    _: User = Depends(get_current_user),
    db: AsyncSession = Depends(get_db),
) -> CloudCapabilitiesResponse:
    settings = await ProjectSettingsRepository(db).get_or_create(project_id)
    enabled = _enabled_project_capabilities(settings.settings or {})
    caps = {key: key in enabled for key in ("livechat.enabled", "voice.enabled", "query_dsl_v1", "bulk_import", "integrations.execute")}
    return CloudCapabilitiesResponse(project_id=project_id, capabilities=caps)


@router.patch("/capabilities", response_model=CloudCapabilitiesResponse)
async def patch_capabilities(
    body: CloudCapabilitiesUpdate,
    project_id: UUID = Depends(require_active_billing_for_project_id),
    _: User = Depends(get_current_user),
    db: AsyncSession = Depends(get_db),
) -> CloudCapabilitiesResponse:
    project = await ProjectRepository(db).get_by_id(project_id)
    if not project:
        raise NotFoundError("Project not found")
    repo = ProjectSettingsRepository(db)
    settings_row = await repo.get_or_create(project_id)
    merged = {**(settings_row.settings or {})}
    caps = dict(merged.get("cloud_capabilities") or {})
    for key, value in body.capabilities.items():
        if key in _EDITABLE:
            caps[key] = bool(value)
    merged["cloud_capabilities"] = caps
    from sqlalchemy import update as sa_update
    from src.domain.projects.models import ProjectSettings
    await db.execute(
        sa_update(ProjectSettings).where(ProjectSettings.project_id == project_id).values(settings=merged)
    )
    await db.flush()
    enabled = _enabled_project_capabilities(merged)
    cloud_caps = {
        "query_dsl_v1": "query_dsl_v1" in enabled,
        "bulk_import": "bulk_import" in enabled,
        "integrations.execute": "integrations.execute" in enabled,
        "livechat.enabled": "livechat.enabled" in enabled,
        "voice.enabled": "voice.enabled" in enabled,
    }
    await CloudControlClient().upsert_capabilities(str(project_id), version=1, capabilities=cloud_caps)
    return CloudCapabilitiesResponse(project_id=project_id, capabilities=cloud_caps)