admin / Apex

"""Anthropic AI service with graceful degradation.

When ANTHROPIC_API_KEY is unset the service returns clearly-labelled
placeholder output so the whole app remains usable offline (blueprint §10).
All AI output is a *draft* for human review (blueprint §7 guardrails).
"""
from __future__ import annotations

import json
import time

from app.core.config import settings

PROMPT_VERSION = "v1"

try:  # SDK optional at import time
    import anthropic
except Exception:  # pragma: no cover
    anthropic = None


def ai_available() -> bool:
    return settings.ai_enabled and anthropic is not None


def _client():
    return anthropic.Anthropic(api_key=settings.anthropic_api_key)


def _extract_text(message) -> str:
    parts = []
    for block in message.content:
        if getattr(block, "type", None) == "text":
            parts.append(block.text)
    return "".join(parts).strip()


def _usage(message) -> dict:
    u = getattr(message, "usage", None)
    if not u:
        return {}
    return {
        "input_tokens": getattr(u, "input_tokens", 0),
        "output_tokens": getattr(u, "output_tokens", 0),
        "cache_read_input_tokens": getattr(u, "cache_read_input_tokens", 0),
    }


def _classify_error(exc: Exception) -> str:
    """Turn an SDK/API exception into a short human-readable reason."""
    if anthropic is not None:
        if isinstance(exc, getattr(anthropic, "AuthenticationError", ())):
            return "Invalid API key (authentication failed)."
        if isinstance(exc, getattr(anthropic, "PermissionDeniedError", ())):
            return "API key lacks permission for this model."
        if isinstance(exc, getattr(anthropic, "NotFoundError", ())):
            return f"Model '{settings.anthropic_model}' not found for this key."
        if isinstance(exc, getattr(anthropic, "RateLimitError", ())):
            return "Rate limited — try again shortly."
        if isinstance(exc, getattr(anthropic, "APIConnectionError", ())):
            return "Cannot reach the Anthropic API (network/connectivity)."
    return f"{type(exc).__name__}: {exc}"


# --- health / status ------------------------------------------------------
_status_cache: dict = {"ts": 0.0, "result": None}
_STATUS_TTL = 60.0


def check_status(force: bool = False) -> dict:
    """Actively verify the AI is connected and working with a tiny live call.

    Returns {status: connected|disabled|error, model, detail}. Cached ~60s.
    """
    if not settings.ai_enabled:
        return {"status": "disabled", "model": settings.anthropic_model,
                "detail": "No ANTHROPIC_API_KEY configured."}
    if anthropic is None:
        return {"status": "error", "model": settings.anthropic_model,
                "detail": "anthropic SDK is not installed."}

    now = time.time()
    if not force and _status_cache["result"] and (now - _status_cache["ts"] < _STATUS_TTL):
        return _status_cache["result"]

    try:
        client = _client()
        # Minimal, cheap live call — proves key + model + connectivity end to end.
        client.messages.create(
            model=settings.anthropic_model,
            max_tokens=8,
            messages=[{"role": "user", "content": "ping"}],
        )
        result = {"status": "connected", "model": settings.anthropic_model,
                  "detail": "Connected and responding."}
    except Exception as exc:  # noqa: BLE001
        result = {"status": "error", "model": settings.anthropic_model,
                  "detail": _classify_error(exc)}

    _status_cache.update(ts=now, result=result)
    return result


def invalidate_status() -> None:
    _status_cache.update(ts=0.0, result=None)


# --- generation -----------------------------------------------------------
def generate_text(system: str, prompt: str, max_tokens: int = 4000,
                  effort: str = "high") -> tuple[str, dict]:
    """Long-form generation. Returns (text, meta). Raises on real API errors."""
    if not ai_available():
        return (
            "[AI unavailable — placeholder draft. Configure ANTHROPIC_API_KEY to "
            "generate real content. A human author should complete this section.]",
            {"model": "none", "prompt_version": PROMPT_VERSION, "usage": {}},
        )
    client = _client()
    with client.messages.stream(
        model=settings.anthropic_model,
        max_tokens=max_tokens,
        system=system,
        thinking={"type": "adaptive"},
        output_config={"effort": effort},
        messages=[{"role": "user", "content": prompt}],
    ) as stream:
        message = stream.get_final_message()
    return _extract_text(message), {
        "model": settings.anthropic_model,
        "prompt_version": PROMPT_VERSION,
        "usage": _usage(message),
    }


def assistant_json(system: str, prompt: str, max_tokens: int = 6000) -> tuple[dict, dict]:
    """Assistant advisory call → JSON object. Placeholder when AI unavailable.

    Uses lower effort for snappier interactive responses.
    """
    if not ai_available():
        return (
            {
                "advice": [
                    "AI Assistant is unavailable because no ANTHROPIC_API_KEY is configured. "
                    "Guidance and hallucination self-checking cannot run until AI is connected."
                ],
                "enhanced_text": "",
                "unsupported_claims": [],
                "cleaned_text": "",
            },
            {"model": "none", "prompt_version": PROMPT_VERSION, "usage": {}},
        )
    data, meta = extract_json(system, prompt, max_tokens=max_tokens, effort="medium")
    if not isinstance(data, dict):
        data = {"advice": [], "enhanced_text": "", "unsupported_claims": [], "cleaned_text": ""}
    return data, meta


def extract_json(system: str, prompt: str, max_tokens: int = 8000,
                 effort: str = "high") -> tuple[list | dict, dict]:
    """Structured extraction. Asks the model for strict JSON and parses it.

    Streams so large max_tokens don't hit HTTP timeouts. Raises on real errors.
    """
    if not ai_available():
        return [], {"model": "none", "prompt_version": PROMPT_VERSION, "usage": {}}
    client = _client()
    guard = (
        system
        + "\n\nRespond with ONLY valid JSON — no prose, no markdown fences. "
        "If a list is requested, return a JSON array."
    )
    with client.messages.stream(
        model=settings.anthropic_model,
        max_tokens=max_tokens,
        system=guard,
        thinking={"type": "adaptive"},
        output_config={"effort": effort},
        messages=[{"role": "user", "content": prompt}],
    ) as stream:
        message = stream.get_final_message()
    raw = _extract_text(message)
    data: list | dict = []
    try:
        data = json.loads(raw)
    except Exception:
        start = raw.find("[")
        if start == -1:
            start = raw.find("{")
        end = max(raw.rfind("]"), raw.rfind("}"))
        if start != -1 and end != -1:
            try:
                data = json.loads(raw[start : end + 1])
            except Exception:
                data = []
    return data, {
        "model": settings.anthropic_model,
        "prompt_version": PROMPT_VERSION,
        "usage": _usage(message),
    }