"""Robot Framework helper for UKO ontology integration tests.

Subcommands:
    load-ttl          -- load docs/ontology/uko.ttl, print ``uko-load-ok``
    validate          -- load and validate, print ``uko-validate-ok``
    resolve-inheritance -- resolve uko-oo:Class chain, print ``uko-inheritance-ok``
    layer-nodes       -- get layer 0 nodes, print ``uko-layer-nodes-ok``
"""

from __future__ import annotations

import sys
from collections.abc import Callable
from pathlib import Path

_SRC = str(Path(__file__).resolve().parents[1] / "src")
if _SRC not in sys.path:
    sys.path.insert(0, _SRC)

from cleveragents.application.services.uko_loader import UKOLoader  # noqa: E402

_TTL_PATH = Path(__file__).resolve().parents[1] / "docs" / "ontology" / "uko.ttl"


def _cmd_load_ttl() -> int:
    """Load the TTL file and verify basic parsing."""
    try:
        loader = UKOLoader()
        ontology = loader.load(_TTL_PATH)
    except Exception as exc:
        print(f"uko-fail: {exc}")
        return 1

    if not ontology.nodes:
        print("uko-fail: no nodes parsed")
        return 1

    print(
        f"uko-load-ok: {len(ontology.nodes)} nodes, {len(ontology.prefixes)} prefixes"
    )
    return 0


def _cmd_validate() -> int:
    """Load and validate the ontology."""
    try:
        loader = UKOLoader()
        ontology = loader.load(_TTL_PATH)
        errors = loader.validate(ontology)
    except Exception as exc:
        print(f"uko-fail: {exc}")
        return 1

    if errors:
        print(f"uko-fail: validation errors: {errors}")
        return 1

    print(f"uko-validate-ok: version={ontology.version.version}")
    return 0


def _cmd_resolve_inheritance() -> int:
    """Resolve uko-oo:Class inheritance chain (Layer 2 -> 1 -> 0)."""
    try:
        loader = UKOLoader()
        ontology = loader.load(_TTL_PATH)
        chain = loader.resolve_inheritance(
            ontology,
            "https://cleveragents.ai/ontology/uko/oo#Class",
        )
    except Exception as exc:
        print(f"uko-fail: {exc}")
        return 1

    if len(chain) < 3:
        print(f"uko-fail: chain too short ({len(chain)} nodes)")
        return 1

    print(f"uko-inheritance-ok: {len(chain)} nodes")
    for node in chain:
        print(f"  layer={node.layer} label={node.label}")
    return 0


def _cmd_layer_nodes() -> int:
    """Get all Layer 0 nodes."""
    try:
        loader = UKOLoader()
        ontology = loader.load(_TTL_PATH)
        nodes = loader.get_layer_nodes(ontology, 0)
    except Exception as exc:
        print(f"uko-fail: {exc}")
        return 1

    if len(nodes) < 18:
        print(f"uko-fail: expected >= 18 layer-0 nodes, got {len(nodes)}")
        return 1

    print(f"uko-layer-nodes-ok: {len(nodes)} nodes")
    for node in nodes:
        print(f"  {node.label} ({node.uri})")
    return 0


_COMMANDS: dict[str, Callable[[], int]] = {
    "load-ttl": _cmd_load_ttl,
    "validate": _cmd_validate,
    "resolve-inheritance": _cmd_resolve_inheritance,
    "layer-nodes": _cmd_layer_nodes,
}


def main() -> int:
    """Entry point called by Robot Framework ``Run Process``."""
    if len(sys.argv) < 2:
        print(
            "Usage: helper_uko_ontology.py "
            "<load-ttl|validate|resolve-inheritance|layer-nodes>"
        )
        return 1

    command = sys.argv[1]
    handler = _COMMANDS.get(command)
    if handler is None:
        print(f"Unknown command: {command}")
        return 1

    return handler()


if __name__ == "__main__":
    sys.exit(main())
