import logging

from fastapi import APIRouter, Depends, HTTPException
from sqlalchemy.ext.asyncio import AsyncSession

from db.models import AgentConfig
from db.session import get_session
from models.requests import AgentConfigCreateRequest
from models.responses import (
    AgentConfigDeleteResponse,
    AgentConfigInfo,
    AgentConfigListResponse,
)
from services import config_service

logger = logging.getLogger(__name__)

router = APIRouter(prefix="/configs", tags=["configs"])


def _to_info(cfg: AgentConfig) -> AgentConfigInfo:
    return AgentConfigInfo(
        id=cfg.id,
        version=cfg.version,
        name=cfg.name,
        system_prompt=cfg.system_prompt,
        rules_text=cfg.rules_text or "",
        is_active=cfg.is_active,
        created_at=cfg.created_at.isoformat(),
    )


@router.get("", response_model=AgentConfigListResponse)
async def list_configs(session: AsyncSession = Depends(get_session)):
    configs = await config_service.list_configs(session)
    return AgentConfigListResponse(configs=[_to_info(c) for c in configs], total=len(configs))


@router.get("/active", response_model=AgentConfigInfo)
async def get_active(session: AsyncSession = Depends(get_session)):
    cfg = await config_service.get_active_config(session)
    if cfg is None:
        raise HTTPException(status_code=404, detail="No active config")
    return _to_info(cfg)


@router.get("/{config_id}", response_model=AgentConfigInfo)
async def get_config(config_id: int, session: AsyncSession = Depends(get_session)):
    cfg = await config_service.get_config(session, config_id)
    if cfg is None:
        raise HTTPException(status_code=404, detail="Config not found")
    return _to_info(cfg)


@router.post("", response_model=AgentConfigInfo)
async def create_config(
    req: AgentConfigCreateRequest,
    session: AsyncSession = Depends(get_session),
):
    cfg = await config_service.create_config(
        session=session,
        system_prompt=req.system_prompt,
        rules_text=req.rules_text,
        name=req.name,
        activate=req.activate,
    )
    return _to_info(cfg)


@router.post("/{config_id}/activate", response_model=AgentConfigInfo)
async def activate_config(config_id: int, session: AsyncSession = Depends(get_session)):
    cfg = await config_service.activate_config(session, config_id)
    if cfg is None:
        raise HTTPException(status_code=404, detail="Config not found")
    return _to_info(cfg)


@router.delete("/{config_id}", response_model=AgentConfigDeleteResponse)
async def delete_config(config_id: int, session: AsyncSession = Depends(get_session)):
    ok, reason = await config_service.delete_config(session, config_id)
    if not ok:
        if reason == "not_found":
            raise HTTPException(status_code=404, detail="Config not found")
        if reason == "active":
            raise HTTPException(
                status_code=400,
                detail="Нельзя удалить активную версию — сначала активируйте другую",
            )
    return AgentConfigDeleteResponse(ok=True)