from __future__ import annotations

from copy import deepcopy
from typing import Any

from app.core.process_steps import StepName


WorkflowPresetType = str

_PRESET_TYPES = {
    "still",
    "turntable",
    "multi_angle",
    "still_with_exports",
    "custom",
}

_STEP_TO_NODE_TYPE: dict[str, str] = {
    StepName.RESOLVE_STEP_PATH.value: "inputNode",
    StepName.STL_CACHE_GENERATE.value: "convertNode",
    StepName.BLENDER_STILL.value: "renderNode",
    StepName.BLENDER_TURNTABLE.value: "renderFramesNode",
    StepName.OUTPUT_SAVE.value: "outputNode",
    StepName.EXPORT_BLEND.value: "outputNode",
}

_NODE_TYPE_TO_STEP: dict[str, str] = {
    "inputNode": StepName.RESOLVE_STEP_PATH.value,
    "convertNode": StepName.STL_CACHE_GENERATE.value,
    "renderNode": StepName.BLENDER_STILL.value,
    "renderFramesNode": StepName.BLENDER_TURNTABLE.value,
    "ffmpegNode": StepName.OUTPUT_SAVE.value,
    "outputNode": StepName.OUTPUT_SAVE.value,
}


def _make_node(
    node_id: str,
    step: StepName,
    x: int,
    y: int,
    *,
    params: dict[str, Any] | None = None,
    node_type: str | None = None,
    label: str | None = None,
) -> dict[str, Any]:
    return {
        "id": node_id,
        "step": step.value,
        "params": deepcopy(params or {}),
        "ui": {
            "type": node_type or _STEP_TO_NODE_TYPE.get(step.value),
            "position": {"x": x, "y": y},
            "label": label,
        },
    }


def _resolution_to_dimensions(params: dict[str, Any]) -> dict[str, Any]:
    merged = deepcopy(params)
    resolution = merged.pop("resolution", None)
    if isinstance(resolution, (list, tuple)) and len(resolution) == 2:
        merged.setdefault("width", int(resolution[0]))
        merged.setdefault("height", int(resolution[1]))
    return merged


def build_preset_workflow_config(
    preset_type: WorkflowPresetType,
    params: dict[str, Any] | None = None,
) -> dict[str, Any]:
    if preset_type not in _PRESET_TYPES:
        raise ValueError(f"Unknown workflow preset type: {preset_type!r}")

    params = deepcopy(params or {})
    render_params = _resolution_to_dimensions(params)

    if preset_type == "still":
        nodes = [
            _make_node("setup", StepName.ORDER_LINE_SETUP, 0, 100, label="Order Line Setup"),
            _make_node("template", StepName.RESOLVE_TEMPLATE, 220, 100, label="Resolve Template"),
            _make_node(
                "render",
                StepName.BLENDER_STILL,
                440,
                100,
                params=render_params,
                node_type="renderNode",
                label="Still Render",
            ),
            _make_node("output", StepName.OUTPUT_SAVE, 660, 100, label="Save Output"),
        ]
        edges = [
            {"from": "setup", "to": "template"},
            {"from": "template", "to": "render"},
            {"from": "render", "to": "output"},
        ]
    elif preset_type == "turntable":
        nodes = [
            _make_node("setup", StepName.ORDER_LINE_SETUP, 0, 100, label="Order Line Setup"),
            _make_node("template", StepName.RESOLVE_TEMPLATE, 220, 100, label="Resolve Template"),
            _make_node(
                "turntable",
                StepName.BLENDER_TURNTABLE,
                440,
                100,
                params=render_params,
                node_type="renderFramesNode",
                label="Turntable Render",
            ),
            _make_node("output", StepName.OUTPUT_SAVE, 660, 100, label="Save Output"),
        ]
        edges = [
            {"from": "setup", "to": "template"},
            {"from": "template", "to": "turntable"},
            {"from": "turntable", "to": "output"},
        ]
    elif preset_type == "multi_angle":
        angles = params.get("angles") or [0, 45, 90]
        shared = deepcopy(render_params)
        shared.pop("angles", None)
        nodes = [
            _make_node("setup", StepName.ORDER_LINE_SETUP, 0, 195, label="Order Line Setup"),
            _make_node("template", StepName.RESOLVE_TEMPLATE, 220, 195, label="Resolve Template"),
        ]
        edges = [
            {"from": "setup", "to": "template"},
        ]
        for index, angle in enumerate(angles):
            node_id = f"render_{index}"
            node_params = {**shared, "rotation_z": float(angle)}
            nodes.append(
                _make_node(
                    node_id,
                    StepName.BLENDER_STILL,
                    440,
                    index * 130,
                    params=node_params,
                    node_type="renderNode",
                    label=f"Render {angle}°",
                )
            )
            edges.append({"from": "template", "to": node_id})
        nodes.append(_make_node("output", StepName.OUTPUT_SAVE, 700, 195, label="Save Output"))
        edges.extend({"from": f"render_{index}", "to": "output"} for index, _ in enumerate(angles))
    elif preset_type == "still_with_exports":
        nodes = [
            _make_node("setup", StepName.ORDER_LINE_SETUP, 0, 100, label="Order Line Setup"),
            _make_node("template", StepName.RESOLVE_TEMPLATE, 220, 100, label="Resolve Template"),
            _make_node(
                "render",
                StepName.BLENDER_STILL,
                440,
                100,
                params=render_params,
                node_type="renderNode",
                label="Still Render",
            ),
            _make_node("output", StepName.OUTPUT_SAVE, 660, 70, label="Save Output"),
            _make_node("blend", StepName.EXPORT_BLEND, 660, 160, label="Export Blend"),
        ]
        edges = [
            {"from": "setup", "to": "template"},
            {"from": "template", "to": "render"},
            {"from": "render", "to": "output"},
            {"from": "render", "to": "blend"},
        ]
    else:
        nodes = [
            _make_node("setup", StepName.ORDER_LINE_SETUP, 120, 140, label="Order Line Setup"),
        ]
        edges = []

    return {
        "version": 1,
        "nodes": nodes,
        "edges": edges,
        "ui": {"preset": preset_type},
    }


def _canonicalize_legacy_custom_config(raw: dict[str, Any]) -> dict[str, Any]:
    legacy_nodes = raw.get("nodes") or []
    legacy_edges = raw.get("edges") or []
    nodes: list[dict[str, Any]] = []
    for legacy_node in legacy_nodes:
        data = legacy_node.get("data") or {}
        node_type = legacy_node.get("type")
        step_name = data.get("pipeline_step") or _NODE_TYPE_TO_STEP.get(node_type) or StepName.BLENDER_STILL.value
        nodes.append(
            {
                "id": legacy_node["id"],
                "step": step_name,
                "params": deepcopy(data.get("params") or {}),
                "ui": {
                    "type": node_type,
                    "position": deepcopy(legacy_node.get("position") or {"x": 0, "y": 0}),
                    "label": data.get("label"),
                },
            }
        )

    edges: list[dict[str, Any]] = []
    for index, legacy_edge in enumerate(legacy_edges):
        source = legacy_edge.get("source") or legacy_edge.get("from")
        target = legacy_edge.get("target") or legacy_edge.get("to")
        if not source or not target:
            continue
        edges.append(
            {
                "id": legacy_edge.get("id") or f"edge_{index}",
                "from": source,
                "to": target,
            }
        )

    return {
        "version": 1,
        "nodes": nodes,
        "edges": edges,
        "ui": {"preset": "custom"},
    }


def canonicalize_workflow_config(raw: dict[str, Any]) -> dict[str, Any]:
    if not isinstance(raw, dict):
        raise ValueError("Workflow config must be a JSON object")

    if "version" in raw and "nodes" in raw:
        normalized = deepcopy(raw)
        normalized.setdefault("edges", [])
        return normalized

    workflow_type = raw.get("type")
    if workflow_type in _PRESET_TYPES:
        if workflow_type == "custom":
            return _canonicalize_legacy_custom_config(raw)
        return build_preset_workflow_config(workflow_type, raw.get("params") or {})

    raise ValueError("Unsupported workflow config format")


def get_workflow_preset_type(config: dict[str, Any]) -> str | None:
    canonical = canonicalize_workflow_config(config)
    ui = canonical.get("ui") or {}
    preset = ui.get("preset")
    if preset in _PRESET_TYPES:
        return preset
    return None


def extract_runtime_workflow(config: dict[str, Any]) -> tuple[str | None, dict[str, Any]]:
    canonical = canonicalize_workflow_config(config)
    preset = get_workflow_preset_type(canonical)
    if preset is None or preset == "custom":
        return preset, {}

    nodes = canonical.get("nodes") or []

    if preset in {"still", "still_with_exports"}:
        for node in nodes:
            if node.get("step") == StepName.BLENDER_STILL.value:
                return preset, _resolution_to_dimensions(node.get("params") or {})
        return preset, {}

    if preset == "turntable":
        for node in nodes:
            if node.get("step") == StepName.BLENDER_TURNTABLE.value:
                return preset, _resolution_to_dimensions(node.get("params") or {})
        return preset, {}

    if preset == "multi_angle":
        render_nodes = [node for node in nodes if node.get("step") == StepName.BLENDER_STILL.value]
        if not render_nodes:
            return preset, {}
        first_params = _resolution_to_dimensions(render_nodes[0].get("params") or {})
        angles = [
            float((node.get("params") or {}).get("rotation_z", 0))
            for node in render_nodes
        ]
        first_params["angles"] = angles
        first_params.pop("rotation_z", None)
        return preset, first_params

    return preset, {}