"""
AI Language Intelligence routes (OpenAI-backed).

All endpoints require auth. When OpenAI is not configured, endpoints return a
clear 503 (except /languages, /status, and /detect which degrade gracefully).
"""
from fastapi import APIRouter, Depends
from app.middleware.auth import require_auth
from app.utils.response import ok, err
from app.services import openai_service as ai
from app.config import cfg
from app.schemas.schemas import (
    AIScriptRequest, AIRewriteRequest, AITranslateRequest,
    AISummarizeRequest, AIPersonalizeRequest, AIDetectRequest, AIConverseRequest,
)

router = APIRouter()


def _guard():
    if not ai.is_enabled():
        return err("OpenAI is not configured. Add OPENAI_API_KEY to backend/.env "
                   "and restart the server.", 503)
    return None


@router.get("/status")
async def status(_: str = Depends(require_auth)):
    return ok({
        "enabled": ai.is_enabled(),
        "text_model": cfg.OPENAI_TEXT_MODEL,
        "tts_model": cfg.OPENAI_TTS_MODEL,
        "cache": ai.cache_stats(),
    })


@router.get("/languages")
async def languages(_: str = Depends(require_auth)):
    return ok([{"code": c, "name": n} for c, n in ai.SUPPORTED_LANGUAGES.items()])


@router.get("/engines")
async def engines(_: str = Depends(require_auth)):
    """Live diagnostic of every avatar engine so issues are visible in the app."""
    import os
    from app.services import did_service
    def present(p):
        return bool(p and os.path.isdir(p))
    return ok({
        "openai_tts": {"enabled": ai.is_enabled()},
        "did":        did_service.check(),
        "wav2lip":    {"installed": present(cfg.WAV2LIP_PATH),
                       "path": cfg.WAV2LIP_PATH},
        "musetalk":   {"installed": present(cfg.MUSETALK_PATH),
                       "note": "requires NVIDIA GPU"},
        "codeformer": {"installed": present(cfg.CODEFORMER_PATH)},
        "liveportrait": {"installed": present(cfg.LIVEPORTRAIT_PATH)},
    })


@router.post("/generate-script")
async def generate_script(body: AIScriptRequest, _: str = Depends(require_auth)):
    g = _guard()
    if g:
        return g
    try:
        text = ai.generate_script(
            body.prompt, content_type=body.content_type, language=body.language,
            tone=body.tone, length=body.length, emotion=body.emotion,
        )
        return ok({"script": text}, "Script generated")
    except ai.OpenAIServiceError as e:
        return err(str(e), 502)


@router.post("/rewrite")
async def rewrite(body: AIRewriteRequest, _: str = Depends(require_auth)):
    g = _guard()
    if g:
        return g
    try:
        if body.instruction:
            text = ai.rewrite_script(body.script, body.instruction, language=body.language)
        else:
            text = ai.improve_script(body.script, language=body.language, tone=body.tone)
        return ok({"script": text}, "Script rewritten")
    except ai.OpenAIServiceError as e:
        return err(str(e), 502)


@router.post("/translate")
async def translate(body: AITranslateRequest, _: str = Depends(require_auth)):
    g = _guard()
    if g:
        return g
    try:
        text = ai.translate_script(body.script, body.target_language)
        return ok({"script": text, "language": body.target_language}, "Translated")
    except ai.OpenAIServiceError as e:
        return err(str(e), 502)


@router.post("/summarize")
async def summarize(body: AISummarizeRequest, _: str = Depends(require_auth)):
    g = _guard()
    if g:
        return g
    try:
        text = ai.summarize_script(body.script, language=body.language)
        return ok({"script": text}, "Summarized")
    except ai.OpenAIServiceError as e:
        return err(str(e), 502)


@router.post("/personalize")
async def personalize(body: AIPersonalizeRequest, _: str = Depends(require_auth)):
    g = _guard()
    if g:
        return g
    try:
        text = ai.personalize_script(body.script, body.audience, language=body.language)
        return ok({"script": text}, "Personalized")
    except ai.OpenAIServiceError as e:
        return err(str(e), 502)


@router.post("/detect-language")
async def detect_language(body: AIDetectRequest, _: str = Depends(require_auth)):
    # Degrades gracefully (heuristic) when OpenAI is off.
    code = ai.detect_language(body.text)
    return ok({"language": code, "name": ai.lang_name(code)})


@router.post("/converse")
async def converse(body: AIConverseRequest, _: str = Depends(require_auth)):
    g = _guard()
    if g:
        return g
    try:
        reply = ai.converse([m.model_dump() for m in body.messages], language=body.language)
        return ok({"reply": reply}, "ok")
    except ai.OpenAIServiceError as e:
        return err(str(e), 502)