"""Seed the real AGA proposal (``manage.py seed_aga_template``); see demo/aga_proposal.py."""

from __future__ import annotations

import io
from dataclasses import dataclass
from pathlib import Path
from typing import Any

from django.db import transaction
from PIL import Image

from demo.aga_proposal import build_scene, build_variables
from snapfile.assets.fonts import ensure_system_fonts
from snapfile.assets.images import upload_image
from snapfile.core import ids
from snapfile.core.audit import Actor
from snapfile.doctemplates import service as templates
from snapfile.doctemplates.models import Template, TemplateVersion

from .demo import system_principal
from .models import DEFAULT_SETTINGS, Project
from .variables import get_tree, replace_tree

SEED_ACTOR = Actor("system", "seed", "AGA seed")
TEMPLATE_KEY = "aga-proposal"
REF_PREFIX = "aga:"


@dataclass
class AgaSeed:
    project: Project
    template: Template
    version: TemplateVersion | None
    missing_assets: list[str]


def _placeholder() -> bytes:
    buf = io.BytesIO()
    Image.new("RGB", (16, 16), (176, 190, 197)).save(buf, "PNG")
    return buf.getvalue()


def _refs(node: Any, found: set[str]) -> None:
    if isinstance(node, dict):
        for value in node.values():
            _refs(value, found)
    elif isinstance(node, list):
        for value in node:
            _refs(value, found)
    elif isinstance(node, str) and node.startswith(REF_PREFIX):
        found.add(node)


def _swap(node: Any, mapping: dict[str, str]) -> Any:
    if isinstance(node, dict):
        return {k: _swap(v, mapping) for k, v in node.items()}
    if isinstance(node, list):
        return [_swap(v, mapping) for v in node]
    if isinstance(node, str):
        return mapping.get(node, node)
    return node


def _optional(var: dict[str, Any]) -> dict[str, Any]:
    out = {**var, "required": False}
    if isinstance(out.get("fields"), list):
        out["fields"] = [_optional(v) for v in out["fields"]]
    return out


def _merge_variables(project: Project) -> None:
    """Real keys win over a same-named demo variable; other keys stay, but must not block AGA payloads."""
    real = build_variables()
    names = {v["key"] for v in real}
    kept = [_optional(v) for v in get_tree(project) if v.get("key") not in names]
    replace_tree(project, [*kept, *real], int(project.setting("schema_revision") or 0), SEED_ACTOR.snapshot())


def seed_aga(slug: str, assets_dir: Path, sample_data: dict[str, Any] | None = None, publish: bool = True) -> AgaSeed:
    ensure_system_fonts()
    with transaction.atomic():
        project, _ = Project.objects.get_or_create(
            slug=slug,
            defaults={
                "name": "AGA — Accuvest Global Advisors",
                "client_name": "AGA CRM",
                "settings": {**DEFAULT_SETTINGS, "locale": "en", "currency": "USD"},
            },
        )
    _merge_variables(project)
    scene = build_scene()
    refs: set[str] = set()
    _refs(scene, refs)
    mapping: dict[str, str] = {}
    missing: list[str] = []
    for ref in sorted(refs):
        name = ref[len(REF_PREFIX) :]
        path = assets_dir / name
        if path.is_file():
            data = path.read_bytes()
        else:
            missing.append(name)
            data, name = _placeholder(), f"placeholder-{name}.png"
        asset, _ = upload_image(project, name, data, "aga", SEED_ACTOR.snapshot())
        mapping[ref] = ids.encode("ast", asset.id) or ""
    scene = _swap(scene, mapping)
    t = Template.objects.filter(project=project, key=TEMPLATE_KEY, deleted_at__isnull=True).first()
    if t is None:
        t = templates.create_template(
            project,
            SEED_ACTOR,
            key=TEMPLATE_KEY,
            name="AGA Proposal",
            description="Real AGA proposal rebuilt from the CKEditor template and mapping.py",
            tags=["aga", "proposal"],
            document=scene,
            sample_data=sample_data or {},
        )
    else:
        Template.objects.filter(pk=t.pk).update(
            draft_document=scene,
            draft_hash=templates.doc_hash(scene),
            sample_data=sample_data if sample_data is not None else t.sample_data,
        )
        t.refresh_from_db()
    version = None
    if publish:
        version = templates.publish(t, system_principal(project), base_revision=None, comment="AGA seed", check=False)
    t.refresh_from_db()
    return AgaSeed(project=project, template=t, version=version, missing_assets=missing)
