"""Internal API: project settings and the variable schema (TZ I4-I5, I26-I27)."""

from __future__ import annotations

from typing import Any

from django.http import HttpRequest
from ninja import Field, Router, Schema

from snapfile.auth_sso.auth import EditorJwtAuth, require
from snapfile.core import ids
from snapfile.core.audit import audit

from .variables import build_json_schema, example_data, get_tree, replace_tree

router = Router(auth=EditorJwtAuth(), tags=["internal: project"])
EDITABLE_SETTINGS = {
    "locale",
    "timezone",
    "currency",
    "file_ttl_hours",
    "kerning",
    "editors_can_publish",
    "store_payload",
    "strict_payload",
    "default_output",
}


class SettingsPatch(Schema):
    settings: dict[str, Any]


class VariablesPut(Schema):
    base_revision: int | None = None
    variables: list[dict[str, Any]] = Field(default_factory=list)


def _project_dict(p: Any) -> dict[str, Any]:
    from django.db.models import Max

    s = p.effective_settings
    last = p.api_keys.aggregate(m=Max("last_used_at"))["m"]
    return {
        "client": {
            "name": p.client_name or p.name,
            "base_url": p.client_base_url or "",
            "connected": p.status == "active",
            "last_request_at": last.isoformat() if last else None,
        },
        "id": ids.encode("prj", p.id),
        "slug": p.slug,
        "name": p.name,
        "client_name": p.client_name,
        "client_base_url": p.client_base_url,
        "settings": s,
        "status": p.status,
    }


def _stats(p: Any) -> dict[str, Any]:
    """Dashboard tiles (03_frontend 3.4.6): template counts by status, renders per day (7 d), p95, errors 24 h."""
    from collections import Counter
    from datetime import timedelta

    from django.utils import timezone

    from snapfile.doctemplates.models import Template
    from snapfile.doctemplates.service import template_status
    from snapfile.jobs.models import RenderJob

    statuses = Counter(
        template_status(t)
        for t in Template.objects.select_related("current_version")
        .filter(project=p, deleted_at__isnull=True)
        .only("draft_hash", "current_version__document_hash")
    )
    today = timezone.localdate()
    start = today - timedelta(days=6)
    per_day = dict.fromkeys(((start + timedelta(days=i)).isoformat() for i in range(7)), 0)
    durations: list[int] = []
    since = timezone.now() - timedelta(days=7)
    jobs = RenderJob.objects.filter(project=p, kind="render", created_at__gte=since)
    for created, timings in jobs.values_list("created_at", "timings").iterator():
        day = timezone.localtime(created).date().isoformat()
        if day in per_day:
            per_day[day] += 1
        total = (timings or {}).get("total_ms")
        if isinstance(total, int | float):
            durations.append(int(total))
    durations.sort()
    p95 = durations[min(len(durations) - 1, int(len(durations) * 0.95))] if durations else 0
    errors = Counter(
        RenderJob.objects.filter(
            project=p, kind="render", status="failed", created_at__gte=timezone.now() - timedelta(hours=24)
        ).values_list("error_code", flat=True)
    )
    return {
        "templates": sum(statuses.values()),
        "published": statuses["published"],
        "drafts": statuses["draft"],
        "modified": statuses["modified"],
        "generations_7d": list(per_day.values()),
        "p95_ms": p95,
        "errors_24h": sum(errors.values()),
        "errors_summary": " · ".join(f"{n} × {code or 'error'}" for code, n in errors.most_common(3)) or None,
    }


@router.get("project", summary="I4. Project settings, limits and dashboard stats")
def get_project(request: HttpRequest) -> dict[str, Any]:
    p = request.project  # type: ignore[attr-defined]
    return {"project": {**_project_dict(p), "stats": _stats(p)}}


@router.patch("project/settings", summary="I5. Update project settings (admin)")
def patch_settings(request: HttpRequest, body: SettingsPatch) -> dict[str, Any]:
    principal = require(request, "admin")
    p = request.project  # type: ignore[attr-defined]
    changes = {k: v for k, v in body.settings.items() if k in EDITABLE_SETTINGS}
    p.settings = {**(p.settings or {}), **changes}
    p.save(update_fields=["settings", "updated_at"])
    audit(
        "project.settings",
        principal.actor,
        project_id=p.id,
        subject_type="project",
        subject_id=p.id,
        changes=changes,
        request=request,
    )
    return {"project": _project_dict(p)}


@router.get("variables", summary="I26. Project variable schema (tree)")
def get_variables(request: HttpRequest) -> dict[str, Any]:
    p = request.project  # type: ignore[attr-defined]
    tree = get_tree(p)
    return {
        "revision": int(p.setting("schema_revision") or 0),
        "variables": tree,
        "json_schema": build_json_schema(tree),
        "example": example_data(tree),
    }


@router.put("variables", summary="I27. Replace the variable schema (revision-checked)")
def put_variables(request: HttpRequest, body: VariablesPut) -> dict[str, Any]:
    principal = require(request, "edit_schema")
    p = request.project  # type: ignore[attr-defined]
    revision = replace_tree(p, body.variables, body.base_revision, principal.snapshot())
    audit(
        "variables.replace",
        principal.actor,
        project_id=p.id,
        subject_type="project",
        subject_id=p.id,
        changes={"revision": revision},
        request=request,
    )
    tree = get_tree(p)
    return {"revision": revision, "variables": tree, "json_schema": build_json_schema(tree)}
