#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
Modul: app/core/note_payload.py
Version: 2.0.0

Zweck
-----
Erzeugt ein robustes Note-Payload. Werte wie `retriever_weight`, `chunk_profile`
und `edge_defaults` werden in folgender Priorität bestimmt:
1) Frontmatter (Note)
2) Typ-Registry (config/types.yaml: types.<type>.*)
3) Registry-Defaults (config/types.yaml: defaults.*)
4) ENV-Defaults (MINDNET_DEFAULT_RETRIEVER_WEIGHT / MINDNET_DEFAULT_CHUNK_PROFILE)
"""

from __future__ import annotations

from typing import Any, Dict, Tuple, Optional
import os
import json
import pathlib

try:
    import yaml  # type: ignore
except Exception:
    yaml = None


# ---------------------------------------------------------------------------
# Helper
# ---------------------------------------------------------------------------

def _as_dict(x) -> Dict[str, Any]:
    """Versucht, ein ParsedMarkdown-ähnliches Objekt in ein Dict zu überführen."""
    if isinstance(x, dict):
        return dict(x)

    out: Dict[str, Any] = {}
    # bekannte Attribute übernehmen, sofern vorhanden
    for attr in (
        "frontmatter",
        "body",
        "id",
        "note_id",
        "title",
        "path",
        "tags",
        "type",
        "created",
        "modified",
        "date",
    ):
        if hasattr(x, attr):
            val = getattr(x, attr)
            if val is not None:
                out[attr] = val

    # Fallback: wenn immer noch leer, raw speichern
    if not out:
        out["raw"] = str(x)

    return out


def _pick_args(*args, **kwargs) -> Tuple[Optional[str], Optional[dict]]:
    """Extrahiert optionale Zusatzargumente wie path und types_cfg."""
    path = kwargs.get("path") or (args[0] if args else None)
    types_cfg = kwargs.get("types_cfg") or kwargs.get("types") or None
    return path, types_cfg


def _env_float(name: str, default: float) -> float:
    """Liest einen Float-Wert aus der Umgebung, mit robustem Fallback."""
    try:
        return float(os.environ.get(name, default))
    except Exception:
        return default


def _ensure_list(x) -> list:
    """Garantiert eine String-Liste."""
    if x is None:
        return []
    if isinstance(x, list):
        return [str(i) for i in x]
    if isinstance(x, (set, tuple)):
        return [str(i) for i in x]
    return [str(x)]


# ---------------------------------------------------------------------------
# Type-Registry laden
# ---------------------------------------------------------------------------

def _load_types_config(explicit_cfg: Optional[dict] = None) -> dict:
    """Lädt die Type-Registry aus YAML/JSON oder nutzt ein explizit übergebenes Dict."""
    if explicit_cfg and isinstance(explicit_cfg, dict):
        return explicit_cfg

    path = os.getenv("MINDNET_TYPES_FILE") or "./config/types.yaml"
    if not os.path.isfile(path) or yaml is None:
        return {}

    try:
        with open(path, "r", encoding="utf-8") as f:
            data = yaml.safe_load(f) or {}
        return data if isinstance(data, dict) else {}
    except Exception:
        return {}


def _cfg_for_type(note_type: str, reg: dict) -> dict:
    """Liefert die Konfiguration für einen konkreten Notiztyp aus der Registry."""
    if not isinstance(reg, dict):
        return {}
    types = reg.get("types") if isinstance(reg.get("types"), dict) else reg
    return types.get(note_type, {}) if isinstance(types, dict) else {}


def _cfg_defaults(reg: dict) -> dict:
    """Liefert den Default-Block aus der Registry (defaults/global)."""
    if not isinstance(reg, dict):
        return {}
    for key in ("defaults", "default", "global"):
        v = reg.get(key)
        if isinstance(v, dict):
            return v
    return {}


# ---------------------------------------------------------------------------
# Haupt-API
# ---------------------------------------------------------------------------

def make_note_payload(note: Any, *args, **kwargs) -> Dict[str, Any]:
    """
    Baut das Note-Payload für mindnet_notes auf.

    Erwartete Felder im Payload:
    - note_id:      stabile ID aus Frontmatter (id) oder Note-Objekt
    - title:        Titel der Notiz
    - type:         Notiztyp (z. B. concept, project, journal, ...)
    - path:         Pfad im Vault
    - retriever_weight: effektives Gewicht für den Retriever
    - chunk_profile:     Profil für Chunking (short|medium|long|default|...)
    - edge_defaults:     Liste von Kanten-Typen, die als Defaults gelten
    """
    n = _as_dict(note)
    path_arg, types_cfg_explicit = _pick_args(*args, **kwargs)
    reg = _load_types_config(types_cfg_explicit)

    fm = n.get("frontmatter") or {}
    fm_type = fm.get("type") or n.get("type") or "concept"
    note_type = str(fm_type)

    cfg_type = _cfg_for_type(note_type, reg)
    cfg_def = _cfg_defaults(reg)

    # --- retriever_weight: Frontmatter > Typ-Config > Registry-Defaults > ENV ---
    default_rw = _env_float("MINDNET_DEFAULT_RETRIEVER_WEIGHT", 1.0)
    retriever_weight = fm.get("retriever_weight")
    if retriever_weight is None:
        retriever_weight = cfg_type.get(
            "retriever_weight",
            cfg_def.get("retriever_weight", default_rw),
        )
    try:
        retriever_weight = float(retriever_weight)
    except Exception:
        retriever_weight = default_rw

    # --- chunk_profile: Frontmatter > Typ-Config > Registry-Defaults > ENV ---
    chunk_profile = fm.get("chunk_profile")
    if chunk_profile is None:
        chunk_profile = cfg_type.get(
            "chunk_profile",
            cfg_def.get(
                "chunk_profile",
                os.environ.get("MINDNET_DEFAULT_CHUNK_PROFILE", "medium"),
            ),
        )
    if not isinstance(chunk_profile, str):
        chunk_profile = "medium"

    # --- edge_defaults: Frontmatter > Typ-Config > Registry-Defaults ---
    edge_defaults = fm.get("edge_defaults")
    if edge_defaults is None:
        edge_defaults = cfg_type.get(
            "edge_defaults",
            cfg_def.get("edge_defaults", []),
        )
    edge_defaults = _ensure_list(edge_defaults)

    # --- Basis-Metadaten (IDs, Titel, Pfad) ---
    note_id = n.get("note_id") or n.get("id") or fm.get("id")
    title = n.get("title") or fm.get("title") or ""
    path = n.get("path") or path_arg
    if isinstance(path, pathlib.Path):
        path = str(path)

    payload: Dict[str, Any] = {
        "note_id": note_id,
        "title": title,
        "type": note_type,
        "path": path or "",
        "retriever_weight": retriever_weight,
        "chunk_profile": chunk_profile,
        "edge_defaults": edge_defaults,
    }

    # Tags / Keywords übernehmen
    tags = fm.get("tags") or fm.get("keywords") or n.get("tags")
    if tags:
        payload["tags"] = _ensure_list(tags)

    # Zeitliche Metadaten (sofern vorhanden)
    for k in ("created", "modified", "date"):
        v = fm.get(k) or n.get(k)
        if v:
            payload[k] = str(v)

    # JSON-Roundtrip zur harten Validierung (ASCII beibehalten)
    json.loads(json.dumps(payload, ensure_ascii=False))

    return payload