"""Resuelve las dependencias de un workflow ComfyUI ajeno antes de ejecutarlo.

Dado un workflow (p.ej. importado de internet con comfyui_import_workflow_json /
_png), lo valida contra el servidor y traduce lo que falta en acciones
concretas: nodos custom ausentes -> repos a instalar (comfyui_install_custom_node)
y modelos ausentes -> assets a descargar (comfyui_search_civitai_models +
comfyui_download_model). Asi un workflow desconocido se vuelve ejecutable sin
prueba y error.

Compone comfyui_validate_workflow (no reimplementa la consulta a /object_info).

Impura: red (HTTP GET via validate_workflow). Solo stdlib.
"""
import os
import sys

_THIS_DIR = os.path.dirname(os.path.abspath(__file__))
if _THIS_DIR not in sys.path:
    sys.path.insert(0, _THIS_DIR)

from comfyui_validate_workflow import comfyui_validate_workflow  # noqa: E402


def comfyui_resolve_workflow_deps(
    workflow: dict,
    server: str = "127.0.0.1:8188",
) -> dict:
    """Lista nodos y modelos faltantes de un workflow y sugiere como obtenerlos.

    Args:
        workflow: dict en API format ({node_id: {class_type, inputs}}).
        server: host:port del servidor ComfyUI (sin esquema). Debe estar vivo
            para consultar /object_info.

    Returns:
        dict {ok, missing_nodes, missing_models, suggestions, error}:
          - ok: la validacion se pudo ejecutar (el servidor respondio).
          - missing_nodes: class_type ausentes en el servidor (nodos custom).
          - missing_models: lista de {node, input, value} con modelos no
            presentes en el combo del nodo.
          - suggestions: lista de acciones {kind, name, action, hint, ...} — una
            por nodo o modelo faltante — describiendo que funcion usar.
          - error: motivo si no se pudo consultar el servidor (ok=False).
    """
    val = comfyui_validate_workflow(workflow, server=server)
    if not val.get("ok"):
        return {
            "ok": False,
            "missing_nodes": [],
            "missing_models": [],
            "suggestions": [],
            "error": val.get("error", "validacion fallida"),
        }

    missing_nodes = val.get("missing_nodes", [])
    missing_models = val.get("missing_models", [])
    suggestions = []
    for node in missing_nodes:
        suggestions.append({
            "kind": "node",
            "name": node,
            "action": "install_custom_node",
            "hint": (
                f"Nodo custom '{node}' ausente. Localiza su repo (ComfyUI-Manager "
                f"DB o GitHub por el class_type) e instala con "
                f"comfyui_install_custom_node('<repo_url>')."
            ),
        })
    for m in missing_models:
        value = m.get("value")
        suggestions.append({
            "kind": "model",
            "name": value,
            "input": m.get("input"),
            "node": m.get("node"),
            "action": "search_and_download",
            "hint": (
                f"Modelo '{value}' ausente (input {m.get('input')}). Busca con "
                f"comfyui_search_civitai_models(query='...') o en HuggingFace, "
                f"luego comfyui_download_model(url, dest_subdir=...)."
            ),
        })

    return {
        "ok": True,
        "missing_nodes": missing_nodes,
        "missing_models": missing_models,
        "suggestions": suggestions,
        "error": "",
    }


if __name__ == "__main__":
    import json

    # Workflow con un nodo inexistente -> debe aparecer en missing_nodes.
    wf = {
        "1": {"class_type": "CheckpointLoaderSimple",
              "inputs": {"ckpt_name": "IMG_dreamshaper_8.safetensors"}},
        "2": {"class_type": "NodoQueNoExiste_XYZ", "inputs": {}},
    }
    print(json.dumps(comfyui_resolve_workflow_deps(wf), indent=2))
