"""Graph plus image in, numbers out.

The one implementation of vision execution: the worker beside the server and
the station agent both call this, and they must agree to the digit. No HTTP, no
database, no filesystem beyond reading the pinned submodule's commit.
"""
from __future__ import annotations

import math
import os
import subprocess
import tempfile
import time
from dataclasses import dataclass, field
from functools import lru_cache
from pathlib import Path
from typing import Any

import numpy as np
from visionsuite.core.image import Image
from visionsuite.task import Task
from visionsuite.task.graph import RecipeError  # #46: errori di ricetta v2
from visionsuite.task.registry import load_tools
from visionsuite.task.session import Session

_SUBMODULE = Path(__file__).resolve().parents[2] / "vendor" / "visionsuite"


class GraphBuildError(ValueError):
    """`Task.from_dict` refused the graph itself - a bad request, not a
    server fault (a missing "kind", an unknown schema version, a graph that
    is not even a dict). Kept apart from an error raised once the task is
    actually running: the worker maps this one to 422, everything else that
    can go wrong inside `task.run()` to 500."""


@dataclass
class ToolFailure:
    tool_id: str
    tool_name: str
    error: str


@dataclass
class RunOutcome:
    outputs: dict[str, float] = field(default_factory=dict)
    failures: list[ToolFailure] = field(default_factory=list)
    engine_version: str = ""
    duration_ms: int = 0
    # A tool that "succeeded" but handed back NaN/inf (vs-measure emits NaN on
    # an empty slice - see caliper.py:112) or a bool (a subclass of int, so
    # `isinstance(x, (int, float))` alone would let it through as a quote).
    # Kept apart from `failures`: the tool did not raise, it just produced a
    # number the caller must not measure a part by. Value is the reason.
    invalid_outputs: dict[str, str] = field(default_factory=dict)
    # #46: contorni di tutti gli strumenti (px immagine, con tool_id) e esito
    # del TaskReport (informativo: il verdetto quote lo dà il backend).
    overlay: list[dict] = field(default_factory=list)
    outcome: str | None = None


@lru_cache(maxsize=1)
def _engine_version_from_git() -> str:
    """Read the pinned commit from the submodule checkout.

    Cached because the subprocess call is not free and the answer cannot
    change within a run. Kept separate from `engine_version()` so that the
    (cheap) environment-variable check below is never served a stale answer,
    and so a test can force this path to fail without poisoning the cache
    for real callers.
    """
    try:
        return subprocess.check_output(
            ["git", "-C", str(_SUBMODULE), "rev-parse", "HEAD"],
            text=True,
            stderr=subprocess.PIPE,
        ).strip()
    except (OSError, subprocess.CalledProcessError) as exc:
        raise RuntimeError(
            "engine_version: cannot determine which VisionSuite commit this "
            "process is running. VISION_ENGINE_VERSION is not set, and "
            f"`git -C {_SUBMODULE} rev-parse HEAD` failed ({exc}). "
            "In the vision worker container this is expected - it has no "
            "usable .git for the vendored submodule - so the image must be "
            "built with `--build-arg VISION_ENGINE_VERSION=<commit>` "
            "(see Dockerfile.vision). In a development checkout, make sure "
            "the vendor/visionsuite submodule is initialised. Refusing to "
            "guess: a station must not measure with an engine it cannot name."
        ) from exc


def engine_version() -> str:
    """The pinned VisionSuite commit: stamped on every number produced.

    Resolution order: the VISION_ENGINE_VERSION environment variable (set at
    container build time - Ruling R8, see Dockerfile.vision) if set and
    non-empty; otherwise `git rev-parse HEAD` on the vendored submodule,
    which works in a development checkout. Never falls back to a guess, an
    empty string, or "unknown" - a station running an engine it cannot name
    must refuse to measure rather than produce numbers nobody can trace.
    """
    stamped = os.environ.get("VISION_ENGINE_VERSION", "").strip()
    if stamped:
        return stamped
    return _engine_version_from_git()


def _scale_calibration(calibration: dict | None):
    """Dict {"mm_per_px"|"px_per_mm"} -> ScaleCalibration (gli strumenti di
    quota convertono con `in_millimetres`, che non accetta un dict)."""
    if calibration is None:
        return None
    from visionsuite.calibration import ScaleCalibration

    if not isinstance(calibration, dict) or not (
        calibration.get("mm_per_px") or calibration.get("px_per_mm")
    ):
        raise GraphBuildError(
            "calibration must be {'mm_per_px': float} or {'px_per_mm': float}"
        )
    key = "mm_per_px" if calibration.get("mm_per_px") else "px_per_mm"
    return ScaleCalibration(**{key: float(calibration[key])})


def _open_session(graph: dict, recipe_dir: Any, calibration: dict | None,
                  workdir: str) -> Session:
    """Costruisce la Session v2; RecipeError e grafo malformato -> GraphBuildError."""
    cal = _scale_calibration(calibration)
    try:
        return Session.from_dict(
            graph, Path(recipe_dir) if recipe_dir else Path(workdir), cal,
        )
    except RecipeError as exc:
        raise GraphBuildError(f"malformed graph: {exc}") from exc
    except (KeyError, TypeError, AttributeError, ValueError) as exc:
        raise GraphBuildError(
            f"malformed graph: {type(exc).__name__}: {exc}"
        ) from exc


def run_graph(
    image: Any,
    graph: dict,
    calibration: dict | None = None,
    recipe_dir: Any = None,
) -> RunOutcome:
    """Run a serialised vs-task v2 graph against one image.

    A tool that fails does not stop the others - on a crooked piece an edge may
    simply not be there, and the other quotes are still wanted. Failures come
    back named, they are not swallowed.

    `image` is whatever the caller already has in hand: a plain numpy array is
    wrapped into the `visionsuite.core.image.Image` that vs-measure's tools
    actually read via `.pixels`; an `Image` passed in is used as-is.

    `recipe_dir` is the folder of the recipe's files (meta.dxf, meta.models,
    ...); without it an empty temporary folder is used, so a recipe that needs
    a file fails as a malformed graph instead of reading from the CWD.

    Two phases, on purpose: building the session can fail on nothing but the
    caller's input (a bad schema version, a tool with no "kind", a missing
    file) - that is `GraphBuildError`, a 422 for the worker. Once it exists,
    running is the engine's own business; an exception from there is not the
    caller's mistake, and the worker must not call it one.
    """
    load_tools()  # #46: registra gli strumenti degli entry point di vs-tools
    with tempfile.TemporaryDirectory() as empty_dir:
        session = _open_session(graph, recipe_dir, calibration, empty_dir)
        wrapped_image = (
            image if isinstance(image, Image) else Image(pixels=np.asarray(image))
        )
        started = time.monotonic()
        report = session.run(wrapped_image)
        elapsed_ms = int((time.monotonic() - started) * 1000)

    outputs: dict[str, float] = {}
    failures: list[ToolFailure] = []
    invalid_outputs: dict[str, str] = {}
    overlay: list[dict] = []
    for result in report:
        # #46: overlay di ogni strumento, con il tool_id di chi lo ha prodotto
        for item in result.overlay or []:
            if isinstance(item, dict):
                overlay.append({**item, "tool_id": result.tool_id})
        if not result.ok:
            failures.append(ToolFailure(
                tool_id=result.tool_id,
                tool_name=result.tool_name,
                error=result.error or "unknown failure",
            ))
            continue
        for name, value in result.outputs.items():
            key = f"{result.tool_id}.{name}"
            # bool is a subclass of int - a tool that outputs a flag must not
            # be read as a quote.
            if isinstance(value, bool) or not isinstance(value, (int, float)):
                continue
            value = float(value)
            if not math.isfinite(value):
                invalid_outputs[key] = "nan" if value != value else "infinite"
                continue
            outputs[key] = value

    return RunOutcome(
        outputs=outputs,
        failures=failures,
        engine_version=engine_version(),
        duration_ms=elapsed_ms,
        invalid_outputs=invalid_outputs,
        overlay=overlay,
        outcome=report.outcome,
    )


def _is_number(value: Any) -> bool:
    return isinstance(value, (int, float)) and not isinstance(value, bool)


def validate_graph(
    graph: dict, recipe_dir: Any = None
) -> tuple[bool, list[str], list[dict]]:
    """Validate a v2 recipe without an image: (ok, errors, numeric outputs).

    Not a draft: a missing meta file is an error. `outputs` lists the numeric
    outputs the tools declare (OUT properties with a numeric default, plus the
    `values` of dimension tools), with quantity/unit when declared.
    """
    load_tools()
    if not isinstance(graph, dict):
        return False, ["graph must be a JSON object"], []
    try:
        task = Task.from_dict(
            graph, recipe_dir=Path(recipe_dir) if recipe_dir else None
        )
    except RecipeError as exc:
        return False, list(exc.errors), []
    except (KeyError, TypeError, AttributeError, ValueError) as exc:
        return False, [f"{type(exc).__name__}: {exc}"], []

    outputs: list[dict] = []
    for tool in task.tools:
        value_quantities = getattr(tool, "value_quantities", None) or {}
        values = tuple(getattr(tool, "values", ()) or ())
        for prop in tool.outputs():
            if not (_is_number(prop.default) or prop.name in values):
                continue
            quantity = value_quantities.get(prop.name, getattr(tool, "quantity", None))
            if not isinstance(quantity, str):
                quantity = None
            unit = None
            if quantity == "length":
                nominal_unit = getattr(tool, "nominal_unit", None)
                unit = nominal_unit if isinstance(nominal_unit, str) else None
            elif quantity == "angle":
                unit = "deg"
            outputs.append({
                "key": f"{tool.id}.{prop.name}",
                "quantity": quantity,
                "unit": unit,
            })
    return True, [], outputs