Azornes-Comfyui-Model-Resolver/core/workflow_analyzer.py

"""
Workflow Analyzer Module

Extracts model references from workflow JSON and identifies missing models.
"""

import os
import re
import threading
from typing import List, Dict, Any, Optional, Set, Callable

from .log_system import create_module_logger
log = create_module_logger(__name__)


# Import folder_paths lazily - it may not be available until ComfyUI is initialized
try:
    import folder_paths
except ImportError:
    folder_paths = None
    log.warning("Model Resolver: folder_paths not available yet - will retry later")


from .type_utils import URN_TYPE_MAP, MODEL_EXTENSIONS, unique_ordered_strings

URN_REGEX = re.compile(r"^urn:air:([^:]+):([^:]+):([^:]+):(\d+)@(\d+)$")

# Mapping of common node types to their expected model category
# This is used as hints but we don't rely solely on this
# UNETLoader uses 'diffusion_models' category (folder_paths maps 'unet' to 'diffusion_models')
NODE_TYPE_TO_CATEGORY_HINTS = {}

# Workflow widget_values do not always include file extensions. ComfyUI still
# validates these combo widgets against folder_paths by exact value at queue time.
NODE_TYPE_MODEL_WIDGET_CATEGORIES = {
    "CheckpointLoaderSimple": {0: "checkpoints"},
    "CheckpointLoader": {1: "checkpoints"},
    "DiffusersLoader": {0: "diffusers"},
    "unCLIPCheckpointLoader": {0: "checkpoints"},
    "ImageOnlyCheckpointLoader": {0: "checkpoints"},
    "VAELoader": {0: "vae"},
    "VAELoaderKJ": {0: "vae"},
    "LoraLoader": {0: "loras"},
    "LoraLoaderModelOnly": {0: "loras"},
    "LoraLoaderBypass": {0: "loras"},
    "LoraLoaderBypassModelOnly": {0: "loras"},
    "CreateHookLora": {0: "loras"},
    "CreateHookLoraModelOnly": {0: "loras"},
    "CreateHookModelAsLora": {0: "checkpoints"},
    "CreateHookModelAsLoraModelOnly": {0: "checkpoints"},
    "UNETLoader": {0: "diffusion_models"},
    "LoaderGGUF": {0: "diffusion_models"},
    "LoaderGGUFAdvanced": {0: "diffusion_models"},
    "UnetLoaderGGUF": {0: "diffusion_models"},
    "UnetLoaderGGUFAdvanced": {0: "diffusion_models"},
    "LatentUpscaleModelLoader": {0: "latent_upscale_models"},
    "CLIPLoader": {0: "text_encoders"},
    "DualCLIPLoader": {0: "text_encoders", 1: "text_encoders"},
    "CLIPLoaderGGUF": {0: "text_encoders"},
    "ClipLoaderGGUF": {0: "text_encoders"},
    "DualCLIPLoaderGGUF": {0: "text_encoders", 1: "text_encoders"},
    "DualClipLoaderGGUF": {0: "text_encoders", 1: "text_encoders"},
    "TripleCLIPLoader": {
        0: "text_encoders",
        1: "text_encoders",
        2: "text_encoders",
    },
    "TripleClipLoader": {
        0: "text_encoders",
        1: "text_encoders",
        2: "text_encoders",
    },
    "TripleCLIPLoaderGGUF": {
        0: "text_encoders",
        1: "text_encoders",
        2: "text_encoders",
    },
    "TripleClipLoaderGGUF": {
        0: "text_encoders",
        1: "text_encoders",
        2: "text_encoders",
    },
    "QuadrupleCLIPLoader": {
        0: "text_encoders",
        1: "text_encoders",
        2: "text_encoders",
        3: "text_encoders",
    },
    "QuadrupleClipLoader": {
        0: "text_encoders",
        1: "text_encoders",
        2: "text_encoders",
        3: "text_encoders",
    },
    "QuadrupleCLIPLoaderGGUF": {
        0: "text_encoders",
        1: "text_encoders",
        2: "text_encoders",
        3: "text_encoders",
    },
    "QuadrupleClipLoaderGGUF": {
        0: "text_encoders",
        1: "text_encoders",
        2: "text_encoders",
        3: "text_encoders",
    },
    "ControlNetLoader": {0: "controlnet"},
    "DiffControlNetLoader": {0: "controlnet"},
    "ControlNetLoaderAdvanced": {0: "controlnet"},
    "ACN_ControlNetLoaderAdvanced": {0: "controlnet"},
    "ACN_DiffControlNetLoaderAdvanced": {0: "controlnet"},
    "CLIPVisionLoader": {0: "clip_vision"},
    "StyleModelLoader": {0: "style_models"},
    "GLIGENLoader": {0: "gligen"},
    "UpscaleModelLoader": {0: "upscale_models"},
    "SAMLoader": {0: "sams"},
    "UltralyticsDetectorProvider": {0: "ultralytics"},
    "AudioEncoderLoader": {0: "audio_encoders"},
    "LoadBackgroundRemovalModel": {0: "background_removal"},
    "LoadDA3Model": {0: "geometry_estimation"},
    "FrameInterpolationModelLoader": {0: "frame_interpolation"},
    "LoadMediaPipeFaceLandmarker": {0: "detection"},
    "ModelPatchLoader": {0: "model_patches"},
    "LoadMoGeModel": {0: "geometry_estimation"},
    "PhotoMakerLoader": {0: "photomaker"},
    "OpticalFlowLoader": {0: "optical_flow"},
    "HypernetworkLoader": {0: "hypernetworks"},
    "EmbeddingLoader": {0: "embeddings"},
    "LTXVAudioVAELoader": {0: "checkpoints"},
    "LowVRAMAudioVAELoader": {0: "checkpoints"},
    "LTXVGemmaCLIPModelLoader": {0: "text_encoders"},
    "LTXAVTextEncoderLoader": {0: "text_encoders", 1: "checkpoints"},
}

# Mapping of common node types to their expected model category.
# Derived dynamically from NODE_TYPE_MODEL_WIDGET_CATEGORIES.
NODE_TYPE_TO_CATEGORY_HINTS = {
    node_type: widget_map[min(widget_map.keys())]
    for node_type, widget_map in NODE_TYPE_MODEL_WIDGET_CATEGORIES.items()
    if widget_map
}

# Fallbacks and overrides for custom nodes that do not use standard model widget indices
NODE_TYPE_TO_CATEGORY_HINTS.update({
    "LoraLoaderV2": "loras",
    "Lora Loader (LoraManager)": "loras",
    "Lora Stacker (LoraManager)": "loras",
    "Power Lora Loader (rgthree)": "loras",
})

# Model category hints by widget/input name. Workflow JSON does not always preserve
# widget names, but when it does this catches custom loaders without a node-type entry.
MODEL_WIDGET_NAME_TO_CATEGORY = {
    "ckpt_name": "checkpoints",
    "checkpoint": "checkpoints",
    "model_name": "diffusion_models",
    "unet_name": "diffusion_models",
    "gguf_name": "diffusion_models",
    "vae_name": "vae",
    "clip_name": "text_encoders",
    "clip_name1": "text_encoders",
    "clip_name2": "text_encoders",
    "clip_name3": "text_encoders",
    "clip_name4": "text_encoders",
    "clip_vision_name": "clip_vision",
    "lora_name": "loras",
    "existing_lora": "loras",
    "control_net_name": "controlnet",
    "cnet": "controlnet",
    "style_model_name": "style_models",
    "upscale_model_name": "upscale_models",
    "gligen_name": "gligen",
    "audio_encoder_name": "audio_encoders",
    "bg_removal_name": "background_removal",
    "photomaker_model_name": "photomaker",
    "sam_model_name": "sams",
    "text_encoder": "text_encoders",
    "hypernetwork_name": "hypernetworks",
}

MODEL_OUTPUT_TYPE_TO_CATEGORY = {
    "UPSCALE_MODEL": "upscale_models",
    "LATENT_UPSCALE_MODEL": "latent_upscale_models",
    "CONTROL_NET": "controlnet",
    "CLIP_VISION": "clip_vision",
    "STYLE_MODEL": "style_models",
    "GLIGEN": "gligen",
    "AUDIO_ENCODER": "audio_encoders",
    "BACKGROUND_REMOVAL": "background_removal",
    "DA3_MODEL": "geometry_estimation",
    "MOGE_MODEL": "geometry_estimation",
    "INTERP_MODEL": "frame_interpolation",
    "FACE_DETECTION_MODEL": "detection",
    "MODEL_PATCH": "model_patches",
    "PHOTOMAKER": "photomaker",
    "OPTICAL_FLOW": "optical_flow",
    "SEEDVR2_DIT": "seedvr2",
    "SEEDVR2_VAE": "seedvr2",
}

# Keys within dict-type widget values that contain model file references.
# Some nodes (e.g. rgthree Power Lora Loader) store model info as objects like
# {"on": true, "lora": "name.safetensors", "strength": 1.0} inside widgets_values.
# Maps nested key name -> category hint.
NESTED_MODEL_KEYS = {
    "lora": "loras",
    "ckpt_name": "checkpoints",
    "checkpoint": "checkpoints",
    "vae_name": "vae",
    "clip_name": "text_encoders",
    "clip_name1": "text_encoders",
    "clip_name2": "text_encoders",
    "clip_name3": "text_encoders",
    "clip_name4": "text_encoders",
    "control_net_name": "controlnet",
    "cnet": "controlnet",
    "model_name": "diffusion_models",
    "unet_name": "diffusion_models",
    "gguf_name": "diffusion_models",
    "gligen_name": "gligen",
    "audio_encoder_name": "audio_encoders",
    "bg_removal_name": "background_removal",
    "photomaker_model_name": "photomaker",
    "text_encoder": "text_encoders",
}

_DYNAMIC_CATEGORY_SENTINEL_PREFIX = "__model_resolver_folder_category__"
_DYNAMIC_NODE_WIDGET_CATEGORY_CACHE: Dict[str, Dict[str, Any]] = {}
_DYNAMIC_NODE_WIDGET_CATEGORY_LOCK = threading.RLock()

# These ComfyUI INPUT_TYPES entries become widgets in widgets_values. Typed graph
# inputs like MODEL or CLIP are links, so they should not shift widget indexes.
_WIDGET_INPUT_TYPES = {"BOOLEAN", "COMBO", "FLOAT", "INT", "STRING"}
WORKFLOW_MODEL_WIDGET_NAMES = {
    "model",
    "model_name",
    "model_file",
    "file_name",
    "filename",
}


def normalize_widget_name(value: Any) -> str:
    return re.sub(r"[_\s-]+", "_", str(value or "").strip().lower()).strip("_")


def _widget_item_name_candidates(item: Any) -> List[str]:
    if not isinstance(item, dict):
        return []

    candidates = []
    for key in ("name", "label", "localized_name"):
        if item.get(key):
            candidates.append(item.get(key))

    widget = item.get("widget")
    if isinstance(widget, dict):
        for key in ("name", "label"):
            if widget.get(key):
                candidates.append(widget.get(key))
    elif widget:
        candidates.append(widget)

    return unique_ordered_strings(candidates)


def _has_widget_input(item: Any) -> bool:
    return isinstance(item, dict) and item.get("widget") is not None


def _get_widget_inputs(node: Dict[str, Any]) -> List[Dict[str, Any]]:
    return [
        item
        for item in node.get("inputs", [])
        if _has_widget_input(item)
    ]


def _get_proxy_widget_entry(node: Dict[str, Any], widget_index: int) -> Any:
    properties = node.get("properties", {})
    proxy_widgets = properties.get("proxyWidgets", [])
    if isinstance(proxy_widgets, list) and widget_index < len(proxy_widgets):
        return proxy_widgets[widget_index]
    return None


def _proxy_widget_name(proxy_entry: Any) -> str:
    if isinstance(proxy_entry, (list, tuple)) and len(proxy_entry) >= 2:
        return str(proxy_entry[1] or "").strip()
    if isinstance(proxy_entry, dict):
        for key in ("name", "widget_name", "widgetName", "targetWidgetName", "inputName"):
            if proxy_entry.get(key):
                return str(proxy_entry.get(key)).strip()
    return ""


def _proxy_widget_node_id(proxy_entry: Any) -> str:
    if isinstance(proxy_entry, (list, tuple)) and proxy_entry:
        return str(proxy_entry[0] or "").strip()
    if isinstance(proxy_entry, dict):
        for key in ("node_id", "nodeId", "target_node_id", "targetNodeId"):
            if proxy_entry.get(key) is not None:
                return str(proxy_entry.get(key)).strip()
    return ""


def get_widget_name_candidates(node: Dict[str, Any], widget_index: int) -> List[str]:
    candidates = []

    proxy_name = _proxy_widget_name(_get_proxy_widget_entry(node, widget_index))
    if proxy_name:
        candidates.append(proxy_name)

    widgets = node.get("widgets", [])
    if isinstance(widgets, list) and widget_index < len(widgets):
        candidates.extend(_widget_item_name_candidates(widgets[widget_index]))

    widget_inputs = _get_widget_inputs(node)
    if widget_index < len(widget_inputs):
        candidates.extend(_widget_item_name_candidates(widget_inputs[widget_index]))

    inputs = node.get("inputs", [])
    if isinstance(inputs, list) and widget_index < len(inputs):
        candidates.extend(_widget_item_name_candidates(inputs[widget_index]))

    return unique_ordered_strings(candidates)


def get_widget_name_hint(node: Dict[str, Any], widget_index: int) -> str:
    candidates = get_widget_name_candidates(node, widget_index)
    return candidates[0] if candidates else ""


def is_workflow_model_widget_candidate(node: Dict[str, Any], widget_index: int) -> bool:
    return any(
        normalize_widget_name(candidate) in WORKFLOW_MODEL_WIDGET_NAMES
        for candidate in get_widget_name_candidates(node, widget_index)
    )


def _ordered_unique_categories(values: List[Any]) -> List[str]:
    return unique_ordered_strings([value for value in values if value])


def _merge_category_hints(
    target: Dict[Any, List[str]], key: Any, categories: List[str]
) -> None:
    if not categories:
        return

    target[key] = _ordered_unique_categories(target.get(key, []) + categories)


def _merge_choice_info(target: Dict[Any, Dict[str, Any]], key: Any, info: Dict[str, Any]) -> None:
    if not isinstance(info, dict):
        return

    current = target.get(key, {})
    sources = _ordered_unique_categories(
        [
            source
            for source in [current.get("source"), info.get("source")]
            if str(source or "").lower() != "unknown"
        ]
    )
    if "hybrid" in sources or ("folder_paths" in sources and "static" in sources):
        source = "hybrid"
    else:
        source = sources[0] if sources else "unknown"

    target[key] = {
        "source": source,
        "choices": _ordered_unique_categories(
            list(current.get("choices") or []) + list(info.get("choices") or [])
        ),
    }


def _summarize_choice_info_for_log(info_by_key: Dict[Any, Dict[str, Any]]) -> Dict[Any, Dict[str, Any]]:
    summary: Dict[Any, Dict[str, Any]] = {}
    if not isinstance(info_by_key, dict):
        return summary

    for key, info in info_by_key.items():
        if not isinstance(info, dict):
            continue
        summary[key] = {
            "source": info.get("source", "unknown"),
            "choice_count": len(info.get("choices") or []),
        }
    return summary


def _summarize_dynamic_hints_for_log(hints: Dict[str, Any]) -> Dict[str, Any]:
    return {
        "by_name": hints.get("by_name", {}),
        "by_index": hints.get("by_index", {}),
        "choice_info_by_name": _summarize_choice_info_for_log(
            hints.get("choice_info_by_name", {})
        ),
        "choice_info_by_index": _summarize_choice_info_for_log(
            hints.get("choice_info_by_index", {})
        ),
    }


def _get_folder_paths_module() -> Any:
    global folder_paths
    if folder_paths is not None:
        return folder_paths

    try:
        import folder_paths as fp

        folder_paths = fp
        return folder_paths
    except Exception:
        return None


def _get_comfy_node_class(node_type: str) -> Any:
    if not node_type:
        return None

    try:
        import nodes as comfy_nodes
    except Exception:
        return None

    node_class_mappings = getattr(comfy_nodes, "NODE_CLASS_MAPPINGS", {}) or {}
    if not isinstance(node_class_mappings, dict):
        return None

    return node_class_mappings.get(node_type)


def _extract_categories_from_value(
    value: Any,
    sentinel_to_category: Dict[str, str],
    depth: int = 0,
    seen: Optional[Set[int]] = None,
) -> List[str]:
    if depth > 8 or not sentinel_to_category:
        return []

    if isinstance(value, str):
        return _ordered_unique_categories(
            [
                category
                for sentinel, category in sentinel_to_category.items()
                if category and sentinel in value
            ]
        )

    if not isinstance(value, (dict, list, tuple, set)):
        return []

    if seen is None:
        seen = set()

    value_id = id(value)
    if value_id in seen:
        return []
    seen.add(value_id)

    categories: List[str] = []
    if isinstance(value, dict):
        for key, nested_value in value.items():
            categories.extend(
                _extract_categories_from_value(
                    key, sentinel_to_category, depth + 1, seen
                )
            )
            categories.extend(
                _extract_categories_from_value(
                    nested_value, sentinel_to_category, depth + 1, seen
                )
            )
    else:
        for item in value:
            categories.extend(
                _extract_categories_from_value(
                    item, sentinel_to_category, depth + 1, seen
                )
            )

    return _ordered_unique_categories(categories)


def _flatten_combo_choice_values(
    value: Any,
    depth: int = 0,
    seen: Optional[Set[int]] = None,
) -> List[str]:
    if depth > 6:
        return []

    if isinstance(value, str):
        return [value]

    if not isinstance(value, (list, tuple, set)):
        return []

    if seen is None:
        seen = set()

    value_id = id(value)
    if value_id in seen:
        return []
    seen.add(value_id)

    choices: List[str] = []
    for item in value:
        choices.extend(_flatten_combo_choice_values(item, depth + 1, seen))
    return _ordered_unique_categories(choices)


def _get_combo_choice_values(spec: Any) -> List[str]:
    if not isinstance(spec, (list, tuple)) or not spec:
        return []

    input_type = spec[0]
    if not isinstance(input_type, (list, tuple, set)):
        return []

    return _flatten_combo_choice_values(input_type)


def _choice_contains_category_sentinel(
    value: Any,
    sentinel_to_category: Dict[str, str],
) -> bool:
    text = str(value or "")
    return any(sentinel and sentinel in text for sentinel in sentinel_to_category)


def _get_widget_choice_info_from_spec(
    spec: Any,
    sentinel_to_category: Dict[str, str],
) -> Dict[str, Any]:
    choices = _get_combo_choice_values(spec)
    if not choices:
        return {}

    has_folder_choices = any(
        _choice_contains_category_sentinel(choice, sentinel_to_category)
        for choice in choices
    )
    static_choices = [
        choice
        for choice in choices
        if not _choice_contains_category_sentinel(choice, sentinel_to_category)
    ]

    if has_folder_choices and static_choices:
        source = "hybrid"
    elif has_folder_choices:
        source = "folder_paths"
    else:
        source = "static"

    return {
        "source": source,
        "choices": static_choices,
    }


def _is_input_type_widget_spec(spec: Any) -> bool:
    if not isinstance(spec, (list, tuple)) or not spec:
        return False

    input_type = spec[0]
    if isinstance(input_type, (list, tuple)):
        return True

    if isinstance(input_type, str):
        return input_type.strip().upper() in _WIDGET_INPUT_TYPES

    return False


def _iter_widget_input_type_entries(
    input_types: Dict[str, Any],
) -> List[tuple[str, Any]]:
    entries: List[tuple[str, Any]] = []
    if not isinstance(input_types, dict):
        return entries

    for section_name in ("required", "optional"):
        section = input_types.get(section_name, {})
        if not isinstance(section, dict):
            continue
        entries.extend(section.items())

    return entries


def _empty_dynamic_hints() -> Dict[str, Any]:
    return {
        "by_name": {},
        "by_index": {},
        "choice_info_by_name": {},
        "choice_info_by_index": {},
    }


def _schema_input_name(input_obj: Any) -> str:
    for key in ("id", "name", "display_name"):
        value = getattr(input_obj, key, None)
        if value:
            return str(value).strip()
    return ""


def _schema_input_io_type(input_obj: Any) -> str:
    get_io_type = getattr(input_obj, "get_io_type", None)
    if callable(get_io_type):
        try:
            return str(get_io_type() or "").strip().upper()
        except Exception:
            pass
    return str(getattr(input_obj, "io_type", "") or "").strip().upper()


def _is_schema_input_widget(input_obj: Any) -> bool:
    io_type = _schema_input_io_type(input_obj)
    return io_type in _WIDGET_INPUT_TYPES


def _iter_schema_input_entries(schema: Any) -> List[tuple[str, Any, bool]]:
    inputs = getattr(schema, "inputs", None)
    if not isinstance(inputs, list):
        return []

    entries: List[tuple[str, Any, bool]] = []
    for input_obj in inputs:
        expanded_inputs = []
        get_all = getattr(input_obj, "get_all", None)
        if callable(get_all):
            try:
                expanded_inputs = get_all()
            except Exception:
                expanded_inputs = []
        if not expanded_inputs:
            expanded_inputs = [input_obj]

        for expanded_input in expanded_inputs:
            entries.append(
                (
                    _schema_input_name(expanded_input),
                    expanded_input,
                    _is_schema_input_widget(expanded_input),
                )
            )
    return entries


def _schema_input_choice_info(
    input_obj: Any,
    sentinel_to_category: Dict[str, str],
) -> Dict[str, Any]:
    options = getattr(input_obj, "options", None)
    if not isinstance(options, (list, tuple, set)):
        return {}
    return _get_widget_choice_info_from_spec((list(options),), sentinel_to_category)


def _merge_dynamic_hint_entry(
    hints: Dict[str, Any],
    normalized_name: str,
    widget_index: Optional[int],
    categories: List[str],
    choice_info: Dict[str, Any],
) -> None:
    if normalized_name:
        _merge_category_hints(hints["by_name"], normalized_name, categories)
        if choice_info:
            _merge_choice_info(
                hints["choice_info_by_name"],
                normalized_name,
                choice_info,
            )

    if widget_index is not None:
        if categories:
            _merge_category_hints(hints["by_index"], widget_index, categories)
        if choice_info:
            _merge_choice_info(
                hints["choice_info_by_index"],
                widget_index,
                choice_info,
            )


def _build_dynamic_node_widget_category_hints(node_type: str) -> Dict[str, Any]:
    empty_hints = _empty_dynamic_hints()
    node_class = _get_comfy_node_class(node_type)
    if node_class is None:
        return empty_hints

    input_types_getter = getattr(node_class, "INPUT_TYPES", None)
    schema_getter = getattr(node_class, "define_schema", None)
    if not callable(input_types_getter) and not callable(schema_getter):
        return empty_hints

    folder_paths_module = _get_folder_paths_module()
    get_filename_list = getattr(folder_paths_module, "get_filename_list", None)

    sentinel_to_category: Dict[str, str] = {}

    def traced_get_filename_list(category: Any, *args: Any, **kwargs: Any) -> List[str]:
        category_name = str(category or "").strip()
        sentinel = f"{_DYNAMIC_CATEGORY_SENTINEL_PREFIX}{len(sentinel_to_category)}"
        sentinel_to_category[sentinel] = category_name
        return [sentinel]

    input_types_func = getattr(input_types_getter, "__func__", input_types_getter)
    schema_func = getattr(schema_getter, "__func__", schema_getter)
    patched_globals: List[tuple[Dict[str, Any], str, Any]] = []
    patched_folder_paths = False

    def patch_get_filename_list_global(callable_obj: Any) -> None:
        if not callable(callable_obj) or not callable(get_filename_list):
            return

        globals_dict = getattr(callable_obj, "__globals__", {})
        if not isinstance(globals_dict, dict):
            return

        for global_name, global_value in list(globals_dict.items()):
            if global_value is get_filename_list:
                globals_dict[global_name] = traced_get_filename_list
                patched_globals.append((globals_dict, global_name, global_value))

    try:
        if folder_paths_module is not None and callable(get_filename_list):
            setattr(folder_paths_module, "get_filename_list", traced_get_filename_list)
            patched_folder_paths = True
            patch_get_filename_list_global(input_types_func)
            patch_get_filename_list_global(schema_func)

        input_types = input_types_getter() if callable(input_types_getter) else None
        schema = schema_getter() if callable(schema_getter) else None
    except Exception as exc:
        log.debug(
            f"Could not infer dynamic model widget categories for {node_type}: {exc}"
        )
        return empty_hints
    finally:
        for global_scope, global_name, global_value in patched_globals:
            global_scope[global_name] = global_value
        if patched_folder_paths:
            setattr(folder_paths_module, "get_filename_list", get_filename_list)

    if not isinstance(input_types, dict) and schema is None:
        return empty_hints

    hints = _empty_dynamic_hints()
    widget_index = 0

    for input_name, spec in _iter_widget_input_type_entries(input_types):
        categories = _extract_categories_from_value(spec, sentinel_to_category)
        choice_info = _get_widget_choice_info_from_spec(spec, sentinel_to_category)
        normalized_name = normalize_widget_name(input_name)
        entry_widget_index = widget_index if _is_input_type_widget_spec(spec) else None
        _merge_dynamic_hint_entry(
            hints,
            normalized_name,
            entry_widget_index,
            categories,
            choice_info,
        )
        if _is_input_type_widget_spec(spec):
            widget_index += 1

    for input_name, input_obj, is_widget in _iter_schema_input_entries(schema):
        categories = _extract_categories_from_value(
            getattr(input_obj, "options", None),
            sentinel_to_category,
        )
        choice_info = _schema_input_choice_info(input_obj, sentinel_to_category)
        normalized_name = normalize_widget_name(input_name)
        _merge_dynamic_hint_entry(
            hints,
            normalized_name,
            widget_index if is_widget else None,
            categories,
            choice_info,
        )
        if is_widget:
            widget_index += 1

    if (
        hints["by_name"]
        or hints["by_index"]
        or hints["choice_info_by_name"]
        or hints["choice_info_by_index"]
    ):
        log.debug(
            "Inferred dynamic model widget categories for "
            f"{node_type}: {_summarize_dynamic_hints_for_log(hints)}"
        )

    return hints


def get_dynamic_node_widget_category_hints(node_type: str) -> Dict[str, Any]:
    if not node_type:
        return {"by_name": {}, "by_index": {}}

    with _DYNAMIC_NODE_WIDGET_CATEGORY_LOCK:
        cached = _DYNAMIC_NODE_WIDGET_CATEGORY_CACHE.get(node_type)
        if cached is not None:
            return cached

        hints = _build_dynamic_node_widget_category_hints(node_type)

        # Only cache after ComfyUI has exposed the node class and folder_paths. If
        # analysis runs unusually early, a later call can still infer the hints.
        if _get_comfy_node_class(node_type) is not None and _get_folder_paths_module():
            _DYNAMIC_NODE_WIDGET_CATEGORY_CACHE[node_type] = hints

        return hints


def get_dynamic_widget_category_hints(
    node: Dict[str, Any], widget_index: int
) -> List[str]:
    hints = get_dynamic_node_widget_category_hints(str(node.get("type", "") or ""))

    categories: List[str] = []
    by_name = hints.get("by_name", {})
    if isinstance(by_name, dict):
        for candidate in get_widget_name_candidates(node, widget_index):
            categories.extend(by_name.get(normalize_widget_name(candidate), []))

    by_index = hints.get("by_index", {})
    if isinstance(by_index, dict):
        categories.extend(by_index.get(widget_index, []))

    return _ordered_unique_categories(categories)


def _normalize_choice_for_match(value: Any) -> str:
    return (
        str(value or "")
        .strip()
        .replace("\\", "/")
        .lower()
    )


def _merge_widget_choice_info_values(
    current: Dict[str, Any],
    candidate: Dict[str, Any],
) -> Dict[str, Any]:
    if not isinstance(candidate, dict):
        return current

    sources = _ordered_unique_categories(
        [
            source
            for source in [current.get("source"), candidate.get("source")]
            if str(source or "").lower() != "unknown"
        ]
    )
    if "hybrid" in sources or ("folder_paths" in sources and "static" in sources):
        source = "hybrid"
    else:
        source = sources[0] if sources else "unknown"

    return {
        "source": source,
        "choices": _ordered_unique_categories(
            list(current.get("choices") or []) + list(candidate.get("choices") or [])
        ),
    }


def get_dynamic_widget_choice_info(
    node: Dict[str, Any], widget_index: int
) -> Dict[str, Any]:
    hints = get_dynamic_node_widget_category_hints(str(node.get("type", "") or ""))
    info: Dict[str, Any] = {"source": "unknown", "choices": []}

    by_name = hints.get("choice_info_by_name", {})
    if isinstance(by_name, dict):
        for candidate in get_widget_name_candidates(node, widget_index):
            candidate_info = by_name.get(normalize_widget_name(candidate), {})
            info = _merge_widget_choice_info_values(info, candidate_info)

    by_index = hints.get("choice_info_by_index", {})
    if isinstance(by_index, dict):
        info = _merge_widget_choice_info_values(info, by_index.get(widget_index, {}))

    return info


def is_static_or_hybrid_widget_choice(value: Any, choice_info: Dict[str, Any]) -> bool:
    source = str(choice_info.get("source") or "").strip().lower()
    if source not in {"static", "hybrid"}:
        return False

    target = _normalize_choice_for_match(value)
    if not target:
        return False

    choices = choice_info.get("choices") or []
    return any(_normalize_choice_for_match(choice) == target for choice in choices)


def static_or_hybrid_choice_looks_like_model(
    value: Any, choice_info: Dict[str, Any]
) -> bool:
    if is_model_filename(value):
        return True

    if not isinstance(value, str):
        return False

    value_text = value.strip()
    if not value_text:
        return False

    if "/" in value_text or "\\" in value_text:
        return True

    target = _normalize_choice_for_match(value_text)
    choices = choice_info.get("choices") or []
    for choice in choices:
        if _normalize_choice_for_match(choice) == target and is_model_filename(choice):
            return True

    return False


MODEL_WIDGET_PLACEHOLDERS = {
    "",
    "none",
    "[none]",
    "null",
    "undefined",
    "default",
    "auto",
    "baked vae",
    "included",
    "(use same)",
    "select the lora to add to the text",
    "esam",
    "pixel_space",
    "taesd",
    "taesdxl",
    "taesd3",
    "taef1",
    "taef2",
}


def get_widget_category_hint(node: Dict[str, Any], widget_index: int) -> Optional[str]:
    """
    Best-effort category hint for a widget index based on saved input/widget names.

    ComfyUI workflows usually store only widget values, but some node/workflow formats
    include input/widget metadata. Use it when present; otherwise callers fall back to
    node-type hints and folder_paths resolution.
    """
    for candidate in get_widget_name_candidates(node, widget_index):
        category = MODEL_WIDGET_NAME_TO_CATEGORY.get(normalize_widget_name(candidate))
        if category:
            return category

    return None


def get_node_model_widget_category_hint(
    node_type: str, widget_index: int
) -> Optional[str]:
    """Return the model category for known model selector widget indices."""
    return NODE_TYPE_MODEL_WIDGET_CATEGORIES.get(node_type, {}).get(widget_index)


def get_node_output_category_hint(node: Dict[str, Any]) -> Optional[str]:
    """Return a model category hint from strongly typed loader outputs."""
    outputs = node.get("outputs", [])
    if not isinstance(outputs, list):
        return None

    for output in outputs:
        if not isinstance(output, dict):
            continue
        for key in ("type", "name", "label"):
            token = str(output.get(key, "") or "").strip().upper()
            category = MODEL_OUTPUT_TYPE_TO_CATEGORY.get(token)
            if category:
                return category
    return None


def get_model_widget_category_hint(
    node: Dict[str, Any], widget_index: int
) -> Optional[str]:
    category_hints = get_model_widget_category_hints(node, widget_index)
    return category_hints[0] if category_hints else None


def get_model_widget_category_hints(
    node: Dict[str, Any], widget_index: int
) -> List[str]:
    node_type = node.get("type", "")
    indexed_category_hint = get_node_model_widget_category_hint(node_type, widget_index)
    widget_category_hint = get_widget_category_hint(node, widget_index)
    dynamic_category_hints = get_dynamic_widget_category_hints(node, widget_index)

    output_category_hint = get_node_output_category_hint(node)
    widgets_values = node.get("widgets_values", [])
    has_single_widget_value = len(widgets_values) == 1
    output_widget_category_hint = (
        output_category_hint
        if (
            not dynamic_category_hints
            and (
                indexed_category_hint
                or widget_category_hint
                or has_single_widget_value
            )
        )
        else None
    )

    hints_list = []
    for h in dynamic_category_hints:
        if h:
            hints_list.append(h)

    if dynamic_category_hints:
        return _ordered_unique_categories(hints_list)

    if indexed_category_hint:
        hints_list.append(indexed_category_hint)
    
    # If the widget category hint is just "diffusion_models", and we have a more specific output hint,
    # let the output hint take priority.
    if widget_category_hint == "diffusion_models" and output_widget_category_hint and output_widget_category_hint != "diffusion_models":
        hints_list.append(output_widget_category_hint)
        hints_list.append(widget_category_hint)
    else:
        if widget_category_hint:
            hints_list.append(widget_category_hint)
        if output_widget_category_hint:
            hints_list.append(output_widget_category_hint)
            
    return _ordered_unique_categories(hints_list)


def get_effective_model_category_hint(
    node: Dict[str, Any], widget_index: int
) -> Optional[str]:
    return get_model_widget_category_hint(
        node, widget_index
    ) or NODE_TYPE_TO_CATEGORY_HINTS.get(node.get("type", ""))


def is_placeholder_model_value(value: Any) -> bool:
    if not isinstance(value, str):
        return False

    return value.strip().lower() in MODEL_WIDGET_PLACEHOLDERS


def should_scan_as_model_reference(value: Any, declared_model_widget: bool) -> bool:
    """Detect model references, including extensionless known model widgets."""
    if is_model_filename(value):
        return True

    if not declared_model_widget or not isinstance(value, str):
        return False

    return bool(value.strip()) and not is_placeholder_model_value(value)


def is_model_filename(value: Any) -> bool:
    """
    Check if a value looks like a model filename or URN.

    Args:
        value: The value to check

    Returns:
        True if it looks like a model filename or URN
    """
    if not isinstance(value, str):
        return False

    # Check model extension
    _, ext = os.path.splitext(value.lower())
    if ext in MODEL_EXTENSIONS:
        return True

    # Check URN format
    return bool(URN_REGEX.match(value.strip()))


def _normalize_model_path_for_lookup(value: str) -> str:
    """Normalize separators for comparison while preserving letter case."""
    if not isinstance(value, str):
        return ""

    normalized = os.path.normpath(value.strip())
    if normalized == ".":
        return ""

    return normalized.replace("\\", "/").strip("/")


def _resolve_from_available_models(
    filename: str,
    categories: Optional[List[str]],
    available_models: Optional[List[Dict[str, Any]]],
) -> Optional[tuple[str, str]]:
    """
    Resolve using scanner data with case-sensitive relative path matching.

    Windows accepts case-mismatched paths in os.path.exists(), but ComfyUI workflow
    values need to match the actual folder/file casing to be safely reusable.
    """
    if not available_models:
        return None

    requested_key = _normalize_model_path_for_lookup(filename)
    if not requested_key:
        return None

    requested_is_absolute = os.path.isabs(filename)
    if requested_is_absolute:
        requested_key = _normalize_model_path_for_lookup(os.path.abspath(filename))

    if categories is None:
        category_order = []
        seen_categories = set()
        for model in available_models:
            category = model.get("category")
            if category and category not in seen_categories:
                seen_categories.add(category)
                category_order.append(category)
    else:
        category_order = categories

    if not category_order:
        return None

    for category in category_order:
        for model in available_models:
            if model.get("category") != category:
                continue

            if requested_is_absolute:
                model_path = model.get("path") or ""
            else:
                model_path = model.get("relative_path") or model.get("filename") or ""

            if _normalize_model_path_for_lookup(model_path) != requested_key:
                continue

            full_path = model.get("path")
            if full_path and os.path.exists(full_path):
                return (category, full_path)

    return None


def _category_has_exact_filename(category: str, filename: str) -> Optional[bool]:
    """
    Check ComfyUI's filename list for an exact-case relative path match.

    Returns None when the filename list is unavailable, allowing callers to fall
    back to the older filesystem existence path.
    """
    if os.path.isabs(filename):
        return None

    requested_key = _normalize_model_path_for_lookup(filename)
    if not requested_key:
        return False

    try:
        available_filenames = folder_paths.get_filename_list(category) or []
    except Exception:
        return None

    return any(
        _normalize_model_path_for_lookup(available_filename) == requested_key
        for available_filename in available_filenames
        if isinstance(available_filename, str)
    )


def try_resolve_model_path(
    value: str,
    categories: List[str] = None,
    available_models: Optional[List[Dict[str, Any]]] = None,
) -> Optional[tuple[str, str]]:
    """
    Try to resolve a model path using folder_paths.

    Args:
        value: The model filename/path to resolve
        categories: Optional list of categories to try (if None, tries all)
        available_models: Optional scanner results used for exact-case matching

    Returns:
        Tuple of (category, full_path) if found, None otherwise
    """
    if not isinstance(value, str) or not value.strip():
        return None

    # Remove any path separators that might indicate an absolute path prefix
    # Workflows should store relative paths, but handle both cases
    filename = value.strip()

    if categories is not None:
        skip_categories = {"custom_nodes", "configs"}
        categories = [c for c in categories if c not in skip_categories]

    resolved = _resolve_from_available_models(filename, categories, available_models)
    if resolved:
        return resolved

    if available_models is not None:
        return None

    # Ensure folder_paths is available
    global folder_paths
    if folder_paths is None:
        try:
            import folder_paths as fp

            folder_paths = fp
        except ImportError:
            log.error("Model Resolver: folder_paths not available")
            return None

    # If categories not provided, try all categories
    if categories is None:
        categories = list(folder_paths.folder_names_and_paths.keys())

    # Skip non-model categories
    skip_categories = {"custom_nodes", "configs"}
    categories = [c for c in categories if c not in skip_categories]

    for category in categories:
        try:
            exact_filename = _category_has_exact_filename(category, filename)
            if exact_filename is False:
                continue

            full_path = folder_paths.get_full_path(category, filename)
            if full_path and os.path.exists(full_path):
                return (category, full_path)
        except Exception:
            continue

    return None


def get_node_model_info(
    node: Dict[str, Any], available_models: Optional[List[Dict[str, Any]]] = None
) -> List[Dict[str, Any]]:
    """
    Extract model references from a single node.

    This scans all widgets_values entries and tries to identify which ones
    are model file references by attempting to resolve them.

    Args:
        node: Node dictionary from workflow JSON

    Returns:
        List of model reference dictionaries:
        {
            'node_id': node id,
            'node_type': node type,
            'widget_index': index in widgets_values,
            'original_path': original path from workflow,
            'category': model category (if found),
            'exists': True if model exists,
            'connected': True if node has any connected inputs/outputs
        }
    """
    model_refs = []
    node_id = node.get("id")
    node_type = node.get("type", "")
    node_title = str(node.get("title", "") or "").strip()
    widgets_values = node.get("widgets_values", [])

    # Check if node is connected (has any inputs or outputs with links)
    inputs = node.get("inputs", [])
    outputs = node.get("outputs", [])
    is_connected = any(inp.get("link") is not None for inp in inputs) or any(
        out.get("links") and len(out.get("links", [])) > 0 for out in outputs
    )

    # Check if node is in bypass mode (mode 4)
    node_mode = node.get("mode", 0)
    is_bypassed = node_mode == 4

    # Node is active if connected AND not bypassed
    is_active = is_connected and not is_bypassed

    if not widgets_values:
        return model_refs

    # Special handling for text-based lora loaders (LoraLoaderV2, LoraManager, etc.)
    lora_text_types = [
        "LoraLoaderV2",
        "Lora Loader (LoraManager)",
        "Lora Stacker (LoraManager)",
    ]
    is_lora_text = node_type in lora_text_types
    if is_lora_text and len(widgets_values) >= 3:
        # widgets_values[0] = {"version": 1, "textWidgetName": "text"}
        # widgets_values[1] = "<lora:name1:strength> <lora:name2:strength>"
        # widgets_values[2] = [{"name": "...", "strength": 1, "active": true}, ...]

        # Get all lora files using scanner for recursive search
        from .scanner import get_model_files

        all_loras = available_models if available_models is not None else get_model_files()
        lora_files = [m for m in all_loras if m.get("category") == "loras"]

        # Build a lookup by filename (without extension)
        lora_lookup = {}
        for lf in lora_files:
            fname = lf.get("filename", "")
            if fname:
                # Get name without extension for matching
                base_name = os.path.splitext(fname)[0]
                if base_name not in lora_lookup:
                    lora_lookup[base_name] = []
                lora_lookup[base_name].append(lf)

        lora_list = widgets_values[2]
        if isinstance(lora_list, list):
            for lora_item in lora_list:
                if isinstance(lora_item, dict):
                    name = lora_item.get("name", "")
                    strength = lora_item.get("strength", 1.0)
                    active = lora_item.get("active", True)

                    if name:
                        # Check if lora exists locally using scanner data (recursive search)
                        lora_exists = False
                        lora_full_path = None

                        # Try exact name first (without extension)
                        if name in lora_lookup:
                            lora_full_path = lora_lookup[name][0].get("path")
                            lora_exists = (
                                os.path.exists(lora_full_path)
                                if lora_full_path
                                else False
                            )
                        else:
                            # Try with common extensions
                            for ext in [".safetensors", ".ckpt", ".pt", ".pth"]:
                                test_name = name + ext
                                if test_name in lora_lookup:
                                    lora_full_path = lora_lookup[test_name][0].get(
                                        "path"
                                    )
                                    lora_exists = (
                                        os.path.exists(lora_full_path)
                                        if lora_full_path
                                        else False
                                    )
                                    if lora_exists:
                                        break

                        log.debug(
                            f"Lora {name}: exists={lora_exists}, path={lora_full_path}"
                        )

                        model_refs.append(
                            {
                                "node_id": node_id,
                                "node_type": node_type,
                                "widget_index": 2,  # Index in lora list
                                "widget_name": get_widget_name_hint(node, 2),
                                "original_path": name,
                                "name": name,
                                "strength": float(strength),
                                "active": active,
                                "node_title": node_title,
                                "category": "loras",
                                "category_hints": ["loras"],
                                "folder_key_hints": ["loras"],
                                "full_path": lora_full_path,
                                "exists": lora_exists,
                                "is_urn": False,
                                "is_lora_v2": is_lora_text,
                                "connected": is_active,
                            }
                        )
        return model_refs

    # For each widget value, check if it looks like a model file or URN
    for idx, value in enumerate(widgets_values):
        widget_name = get_widget_name_hint(node, idx)
        model_widget_folder_key_hints = get_dynamic_widget_category_hints(node, idx)
        model_widget_choice_info = get_dynamic_widget_choice_info(node, idx)
        model_widget_category_hints = get_model_widget_category_hints(node, idx)
        model_widget_category_hint = (
            model_widget_category_hints[0] if model_widget_category_hints else None
        )
        input_choice_source = str(
            model_widget_choice_info.get("source") or "unknown"
        ).strip().lower()
        static_input_choice_matches_value = is_static_or_hybrid_widget_choice(
            value,
            model_widget_choice_info,
        )
        static_input_choice_looks_like_model = static_or_hybrid_choice_looks_like_model(
            value,
            model_widget_choice_info,
        )
        output_category_hint = get_node_output_category_hint(node)
        workflow_schema_model_candidate = bool(
            input_choice_source == "unknown"
            and output_category_hint
            and is_workflow_model_widget_candidate(node, idx)
            and is_model_filename(value)
        )
        if workflow_schema_model_candidate:
            input_choice_source = "workflow_schema"
        input_choice_matches_value = bool(
            static_input_choice_matches_value or workflow_schema_model_candidate
        )
        input_choice_looks_like_model = bool(
            static_input_choice_looks_like_model or workflow_schema_model_candidate
        )
        schema_output_category_hint = (
            output_category_hint
            if input_choice_matches_value
            and input_choice_source in {"static", "hybrid", "workflow_schema"}
            and input_choice_looks_like_model
            else None
        )
        effective_category_hint = (
            model_widget_category_hint
            or NODE_TYPE_TO_CATEGORY_HINTS.get(node_type)
            or schema_output_category_hint
        )
        categories_to_try_for_widget = (
            model_widget_category_hints
            if model_widget_category_hints
            else ([effective_category_hint] if effective_category_hint else None)
        )

        if not should_scan_as_model_reference(
            value,
            declared_model_widget=bool(
                model_widget_category_hint or schema_output_category_hint
            ),
        ):
            # Check for dict-type widget values containing model references (e.g. Power Lora Loader)
            # Some nodes store model info as objects like {"on": true, "lora": "name.safetensors", "strength": 1.0}
            if isinstance(value, dict):
                for nested_key, nested_category_hint in NESTED_MODEL_KEYS.items():
                    nested_value = value.get(nested_key)
                    if (
                        not nested_value
                        or not isinstance(nested_value, str)
                        or not should_scan_as_model_reference(
                            nested_value, declared_model_widget=True
                        )
                    ):
                        continue

                    value_str = nested_value.strip()
                    nested_categories = (
                        [nested_category_hint] if nested_category_hint else None
                    )

                    resolved = try_resolve_model_path(
                        value_str,
                        nested_categories,
                        available_models=available_models,
                    )
                    if resolved:
                        category, full_path = resolved
                        exists = os.path.exists(full_path)
                    else:
                        category = nested_category_hint or "unknown"
                        full_path = None
                        exists = False

                    ref = {
                        "node_id": node_id,
                        "node_type": node_type,
                        "widget_index": idx,
                        "widget_name": widget_name,
                        "original_path": value_str,
                        "node_title": node_title,
                        "category": category,
                        "category_hints": nested_categories or ([category] if category else []),
                        "folder_key_hints": nested_categories or ([category] if category else []),
                        "full_path": full_path,
                        "exists": exists,
                        "is_urn": False,
                        "connected": is_active,
                        "nested_key": nested_key,  # Track nested key for updates
                    }

                    if nested_key == "lora":
                        strength = value.get("strength")
                        if strength is not None:
                            try:
                                ref["strength"] = float(strength)
                            except (TypeError, ValueError):
                                pass

                        if isinstance(value.get("on"), bool):
                            ref["active"] = value.get("on")

                    model_refs.append(ref)
            continue

        value_str = str(value).strip()

        # Check if URN
        urn_match = URN_REGEX.match(value_str)
        if urn_match:
            base, typ, provider, model_id, version_id = urn_match.groups()
            category = (
                effective_category_hint
                or URN_TYPE_MAP.get(typ.lower(), "unknown")
            )
            urn_category_hints = (
                categories_to_try_for_widget
                if categories_to_try_for_widget
                else ([category] if category else [])
            )
            urn_folder_key_hints = (
                model_widget_folder_key_hints
                if model_widget_folder_key_hints
                else urn_category_hints
            )

            model_refs.append(
                {
                    "node_id": node_id,
                    "node_type": node_type,
                    "widget_index": idx,
                    "widget_name": widget_name,
                    "original_path": value_str,
                    "urn": {
                        "full": value_str,
                        "base": base,
                        "type": typ,
                        "provider": provider,
                        "model_id": int(model_id),
                        "version_id": int(version_id),
                    },
                    "node_title": node_title,
                    "category": category,
                    "category_hints": urn_category_hints,
                    "folder_key_hints": urn_folder_key_hints,
                    "full_path": None,
                    "exists": False,
                    "is_urn": True,
                    "connected": is_active,
                }
            )
            continue

        # Existing logic for local filenames
        resolved = try_resolve_model_path(
            value_str,
            categories_to_try_for_widget,
            available_models=available_models,
        )

        if resolved:
            category, full_path = resolved
            exists = os.path.exists(full_path)
        else:
            category = effective_category_hint or "unknown"
            full_path = None
            exists = False

        auto_download_capable = bool(
            input_choice_matches_value
            and input_choice_source in {"static", "hybrid", "workflow_schema"}
            and input_choice_looks_like_model
        )
        auto_download_candidate = bool(not exists and auto_download_capable)

        model_refs.append(
            {
                "node_id": node_id,
                "node_type": node_type,
                "widget_index": idx,
                "widget_name": widget_name,
                "original_path": value_str,
                "node_title": node_title,
                "category": category,
                "category_hints": categories_to_try_for_widget or ([category] if category else []),
                "folder_key_hints": model_widget_folder_key_hints
                or categories_to_try_for_widget
                or ([category] if category else []),
                "full_path": full_path,
                "exists": exists,
                "input_choice_source": input_choice_source,
                "input_choice_matches_value": input_choice_matches_value,
                "auto_download_capable": auto_download_capable,
                "auto_download_candidate": auto_download_candidate,
                "is_urn": False,
                "connected": is_active,
            }
        )

    return model_refs


def _get_node_by_id(nodes: List[Dict[str, Any]], node_id: Any) -> Optional[Dict[str, Any]]:
    node_id_text = str(node_id)
    for node in nodes:
        if str(node.get("id")) == node_id_text:
            return node
    return None


def _get_widget_index_for_input_index(
    node: Dict[str, Any], input_index: int
) -> Optional[int]:
    widget_index = -1
    for idx, item in enumerate(node.get("inputs", [])):
        if _has_widget_input(item):
            widget_index += 1
        if idx == input_index:
            return widget_index if _has_widget_input(item) else None
    return None


def _get_widget_index_by_name(
    node: Dict[str, Any], widget_name: str
) -> Optional[int]:
    target_name = normalize_widget_name(widget_name)
    if not target_name:
        return None

    widgets_values = node.get("widgets_values", [])
    for widget_index in range(len(widgets_values)):
        candidates = get_widget_name_candidates(node, widget_index)
        if any(normalize_widget_name(candidate) == target_name for candidate in candidates):
            return widget_index

    for input_index, item in enumerate(node.get("inputs", [])):
        if not _has_widget_input(item):
            continue
        candidates = _widget_item_name_candidates(item)
        if any(normalize_widget_name(candidate) == target_name for candidate in candidates):
            return _get_widget_index_for_input_index(node, input_index)

    return None


def _get_subgraph_input_link_ids(subgraph: Dict[str, Any], input_name: str) -> set:
    target_name = normalize_widget_name(input_name)
    if not target_name:
        return set()

    link_ids = set()
    for subgraph_input in subgraph.get("inputs", []):
        candidates = _widget_item_name_candidates(subgraph_input)
        if not any(normalize_widget_name(candidate) == target_name for candidate in candidates):
            continue
        for link_id in subgraph_input.get("linkIds", []) or []:
            link_ids.add(str(link_id))
    return link_ids


def _promoted_widget_target_info(
    node: Dict[str, Any], widget_index: int, proxy_widget_name: str = ""
) -> Dict[str, Any]:
    widget_name = get_widget_name_hint(node, widget_index) or proxy_widget_name
    return {
        "node_id": node.get("id"),
        "node_type": node.get("type", ""),
        "node_title": str(node.get("title", "") or "").strip(),
        "widget_index": widget_index,
        "widget_name": widget_name,
        "category": get_effective_model_category_hint(node, widget_index),
    }


def _find_promoted_widget_targets(
    subgraph: Dict[str, Any], proxy_node_id: str, proxy_widget_name: str
) -> List[Dict[str, Any]]:
    nodes = subgraph.get("nodes", [])
    targets: List[Dict[str, Any]] = []
    seen = set()

    def add_target(node: Optional[Dict[str, Any]], widget_index: Optional[int]):
        if node is None or widget_index is None:
            return
        key = (str(node.get("id")), int(widget_index))
        if key in seen:
            return
        seen.add(key)
        targets.append(_promoted_widget_target_info(node, widget_index, proxy_widget_name))

    if proxy_node_id and proxy_node_id != "-1":
        target_node = _get_node_by_id(nodes, proxy_node_id)
        add_target(target_node, _get_widget_index_by_name(target_node or {}, proxy_widget_name))
        return targets

    link_ids = _get_subgraph_input_link_ids(subgraph, proxy_widget_name)
    if link_ids:
        for node in nodes:
            for input_index, item in enumerate(node.get("inputs", [])):
                if not _has_widget_input(item):
                    continue
                if str(item.get("link")) not in link_ids:
                    continue
                add_target(node, _get_widget_index_for_input_index(node, input_index))

    if targets:
        return targets

    for node in nodes:
        add_target(node, _get_widget_index_by_name(node, proxy_widget_name))

    return targets


def _build_promoted_widget_contexts(
    workflow_json: Dict[str, Any], subgraphs: List[Dict[str, Any]]
) -> Dict[str, Dict[Any, Any]]:
    subgraphs_by_id = {str(sg.get("id")): sg for sg in subgraphs if sg.get("id")}
    subgraph_names = {
        str(sg.get("id")): sg.get("name", sg.get("id"))
        for sg in subgraphs
        if sg.get("id")
    }
    contexts = {
        "instance_widgets": {},
        "inner_widgets": {},
        "inner_widget_names": {},
    }

    for instance_node in workflow_json.get("nodes", []):
        subgraph_id = str(instance_node.get("type", ""))
        subgraph = subgraphs_by_id.get(subgraph_id)
        if not subgraph:
            continue

        proxy_widgets = instance_node.get("properties", {}).get("proxyWidgets", [])
        if not isinstance(proxy_widgets, list):
            continue

        widgets_values = instance_node.get("widgets_values", [])
        for proxy_index, proxy_entry in enumerate(proxy_widgets):
            proxy_widget_name = _proxy_widget_name(proxy_entry)
            if not proxy_widget_name:
                continue

            targets = _find_promoted_widget_targets(
                subgraph,
                _proxy_widget_node_id(proxy_entry),
                proxy_widget_name,
            )
            if not targets:
                continue

            promoted_value = (
                widgets_values[proxy_index]
                if isinstance(widgets_values, list) and proxy_index < len(widgets_values)
                else None
            )
            instance_context = {
                **targets[0],
                "subgraph_id": subgraph_id,
                "subgraph_name": subgraph_names.get(subgraph_id, subgraph_id),
                "proxy_widget_index": proxy_index,
                "proxy_widget_name": proxy_widget_name,
                "promoted_value": promoted_value,
            }
            contexts["instance_widgets"][(str(instance_node.get("id")), proxy_index)] = (
                instance_context
            )

            locator = {
                "node_id": instance_node.get("id"),
                "node_type": instance_node.get("type", ""),
                "node_title": str(instance_node.get("title", "") or "").strip(),
                "subgraph_id": subgraph_id,
                "subgraph_name": subgraph_names.get(subgraph_id, subgraph_id),
                "is_top_level": True,
                "proxy_widget_index": proxy_index,
                "proxy_widget_name": proxy_widget_name,
                "promoted_value": promoted_value,
            }

            for target in targets:
                exact_key = (
                    subgraph_id,
                    str(target.get("node_id")),
                    target.get("widget_index"),
                )
                contexts["inner_widgets"].setdefault(exact_key, []).append(locator)

                widget_name = normalize_widget_name(target.get("widget_name"))
                if widget_name:
                    name_key = (subgraph_id, str(target.get("node_id")), widget_name)
                    contexts["inner_widget_names"].setdefault(name_key, []).append(locator)

    return contexts


def _apply_instance_promoted_widget_context(
    ref: Dict[str, Any],
    context: Optional[Dict[str, Any]],
    available_models: Optional[List[Dict[str, Any]]],
) -> None:
    if not context:
        return

    ref["promoted_widget_name"] = context.get("proxy_widget_name", "")
    ref["promoted_inner_node_id"] = context.get("node_id")
    ref["promoted_inner_node_type"] = context.get("node_type", "")
    ref["promoted_inner_node_title"] = context.get("node_title", "")
    ref["promoted_inner_widget_index"] = context.get("widget_index")
    ref["promoted_inner_widget_name"] = context.get("widget_name", "")

    category = context.get("category")
    original_path = ref.get("original_path", "")
    if not category or not original_path:
        return

    resolved = try_resolve_model_path(
        original_path,
        [category],
        available_models=available_models,
    )
    ref["category"] = category
    if resolved:
        _, full_path = resolved
        ref["full_path"] = full_path
        ref["exists"] = os.path.exists(full_path)
    else:
        ref["full_path"] = None
        ref["exists"] = False


def _select_promoted_locator(
    locators: List[Dict[str, Any]], original_path: str
) -> Optional[Dict[str, Any]]:
    if not locators:
        return None

    for locator in locators:
        if locator.get("promoted_value") == original_path:
            return locator
    return locators[0]


def _apply_promoted_widget_locator(
    ref: Dict[str, Any], contexts: Dict[str, Dict[Any, Any]]
) -> None:
    subgraph_id = str(ref.get("subgraph_id") or "")
    if not subgraph_id:
        return

    exact_key = (subgraph_id, str(ref.get("node_id")), ref.get("widget_index"))
    locators = contexts.get("inner_widgets", {}).get(exact_key, [])
    if not locators and ref.get("widget_name"):
        name_key = (
            subgraph_id,
            str(ref.get("node_id")),
            normalize_widget_name(ref.get("widget_name")),
        )
        locators = contexts.get("inner_widget_names", {}).get(name_key, [])

    locator = _select_promoted_locator(locators, ref.get("original_path", ""))
    if not locator:
        return

    ref["locate_node_id"] = locator.get("node_id")
    ref["locate_node_type"] = locator.get("node_type", "")
    ref["locate_node_title"] = locator.get("node_title", "")
    ref["locate_subgraph_id"] = ""
    ref["locate_subgraph_name"] = locator.get("subgraph_name", "")
    ref["locate_is_top_level"] = True
    ref["locate_via_promoted_widget"] = True


def analyze_workflow_models(
    workflow_json: Dict[str, Any],
    available_models: Optional[List[Dict[str, Any]]] = None,
    progress_callback: Optional[Callable[[Dict[str, Any]], None]] = None,
) -> List[Dict[str, Any]]:
    """
    Extract all model references from a workflow, including nested subgraphs.

    Args:
        workflow_json: Complete workflow JSON dictionary
        available_models: Optional list of local model records for existence checks
        progress_callback: Optional callback called while workflow nodes are scanned

    Returns:
        List of model reference dictionaries (same format as get_node_model_info)
        Each dict includes 'subgraph_id' if the model is in a subgraph
    """
    all_model_refs = []

    # Get subgraph definitions first to check if node types are subgraph UUIDs
    definitions = workflow_json.get("definitions", {})
    subgraphs = definitions.get("subgraphs", [])
    if not isinstance(subgraphs, list):
        subgraphs = []
    subgraph_lookup = {
        sg.get("id"): sg.get("name", sg.get("id"))
        for sg in subgraphs
        if isinstance(sg, dict)
    }
    promoted_widget_contexts = _build_promoted_widget_contexts(
        workflow_json, subgraphs
    )

    # Analyze top-level nodes
    nodes = workflow_json.get("nodes", [])
    if not isinstance(nodes, list):
        nodes = []
    total_nodes = len(nodes) + sum(
        len(subgraph_nodes)
        for subgraph in subgraphs
        if isinstance(subgraph, dict)
        for subgraph_nodes in [subgraph.get("nodes", [])]
        if isinstance(subgraph_nodes, list)
    )
    processed_nodes = 0

    def report_node_progress(node: Dict[str, Any], subgraph_name: Optional[str] = None) -> None:
        nonlocal processed_nodes
        processed_nodes += 1
        if not progress_callback:
            return

        node_type = node.get("type", "")
        payload = {
            "stage": "analyzing",
            "message": f"Analyzing workflow node {processed_nodes} of {total_nodes}",
            "current": processed_nodes,
            "total": total_nodes,
            "node_id": node.get("id"),
            "node_type": node_type,
        }
        if subgraph_name:
            payload["subgraph_name"] = subgraph_name
            payload["message"] = (
                f"Analyzing subgraph node {processed_nodes} of {total_nodes}"
            )

        try:
            progress_callback(payload)
        except Exception as e:
            log.debug(f"Workflow analysis progress callback failed: {e}")

    for node in nodes:
        try:
            report_node_progress(node)
            model_refs = get_node_model_info(node, available_models=available_models)
            node_type = node.get("type", "")

            # Check if node type is a subgraph UUID
            subgraph_name = None
            subgraph_id = None
            if node_type in subgraph_lookup:
                subgraph_name = subgraph_lookup[node_type]
                subgraph_id = node_type

            # Mark with subgraph info if it's a subgraph node
            # For top-level subgraph instance nodes, subgraph_path is None
            # This distinguishes them from nodes within subgraph definitions
            for ref in model_refs:
                ref["subgraph_id"] = subgraph_id
                ref["subgraph_name"] = subgraph_name
                ref["subgraph_path"] = None  # Top-level, not in definitions.subgraphs
                ref["is_top_level"] = True  # Flag to indicate this is a top-level node
                if subgraph_id:
                    context = promoted_widget_contexts.get(
                        "instance_widgets", {}
                    ).get((str(node.get("id")), ref.get("widget_index")))
                    _apply_instance_promoted_widget_context(
                        ref, context, available_models
                    )
            all_model_refs.extend(model_refs)
        except Exception as e:
            log.warning(f"Error analyzing node {node.get('id', 'unknown')}: {e}")
            continue

    # Recursively analyze subgraphs
    for subgraph in subgraphs:
        if not isinstance(subgraph, dict):
            continue
        subgraph_id = subgraph.get("id")
        subgraph_name = subgraph.get("name", subgraph_id)
        subgraph_nodes = subgraph.get("nodes", [])
        if not isinstance(subgraph_nodes, list):
            subgraph_nodes = []

        log.debug(
            f"Analyzing subgraph: {subgraph_name} (ID: {subgraph_id}) with {len(subgraph_nodes)} nodes"
        )

        for node in subgraph_nodes:
            try:
                report_node_progress(node, subgraph_name)
                model_refs = get_node_model_info(node, available_models=available_models)
                # Mark as belonging to this subgraph definition
                for ref in model_refs:
                    ref["subgraph_id"] = subgraph_id
                    ref["subgraph_name"] = subgraph_name
                    ref["subgraph_path"] = [
                        "definitions",
                        "subgraphs",
                        subgraph_id,
                        "nodes",
                    ]
                    ref["is_top_level"] = False  # This is inside a subgraph definition
                    _apply_promoted_widget_locator(ref, promoted_widget_contexts)
                all_model_refs.extend(model_refs)
            except Exception as e:
                log.warning(
                    f"Error analyzing subgraph node {node.get('id', 'unknown')}: {e}"
                )
                continue

    return all_model_refs


def identify_missing_models(
    workflow_models: List[Dict[str, Any]], available_models: List[Dict[str, str]] = None
) -> List[Dict[str, Any]]:
    """
    Identify which models from the workflow are missing.
    Deduplicates by category and filename - same model file only appears once even if
    referenced by multiple nodes.

    Args:
        workflow_models: List of model references from analyze_workflow_models
        available_models: Optional list of available models (if None, checks via folder_paths)

    Returns:
        List of missing model references (deduplicated by category and filename).
        Each entry has 'all_node_refs' containing all node references for that model.
    """
    # Group missing models by category and filename to deduplicate workflow
    # references without merging unrelated model folders that happen to share a name.
    missing_by_model: Dict[tuple[str, str], Dict[str, Any]] = {}

    for model_ref in workflow_models:
        # If exists is False, it's missing
        if not model_ref.get("exists", False):
            filename = model_ref.get("original_path", "")
            category = model_ref.get("category", "")
            group_key = (str(category or ""), str(filename or ""))

            if group_key not in missing_by_model:
                # First occurrence - use this as the primary entry
                missing_by_model[group_key] = {
                    **model_ref,
                    "reference_count": 1,
                    "all_node_refs": [
                        model_ref.copy()
                    ],  # Track all nodes needing this model
                }
            else:
                # Duplicate - just add to the node refs list
                existing = missing_by_model[group_key]
                existing["all_node_refs"].append(model_ref.copy())
                existing["reference_count"] = len(existing["all_node_refs"])
                if model_ref.get("auto_download_capable"):
                    existing["auto_download_capable"] = True
                if model_ref.get("auto_download_candidate"):
                    existing["auto_download_candidate"] = True
                if model_ref.get("input_choice_matches_value"):
                    existing["input_choice_matches_value"] = True
                existing_source = str(existing.get("input_choice_source") or "").lower()
                model_source = str(model_ref.get("input_choice_source") or "").lower()
                if existing_source != "hybrid" and model_source in {
                    "static",
                    "hybrid",
                    "workflow_schema",
                }:
                    existing["input_choice_source"] = model_source

    # Return deduplicated list
    return list(missing_by_model.values())