"""Load YAML technology manifests into typed technology model objects."""

from dataclasses import dataclass
from pathlib import Path
from typing import Any, Dict, Optional, Tuple

import yaml

from .layer_models import LayerSpec, MaterialSpec, XSectionLayerSpec, XSectionSpec


TECHNOLOGIES_ROOT = Path(__file__).resolve().parent


@dataclass(frozen=True)
class TechnologyManifest:
    """Parsed technology manifest with typed runtime specs."""

    path: Path
    raw: Dict[str, Any]
    constants: Dict[str, Any]
    layers: Dict[str, LayerSpec]
    xsections: Dict[str, XSectionSpec]
    materials: Dict[str, MaterialSpec]


def load_technology_manifest(manifest: str) -> TechnologyManifest:
    """Read a YAML manifest and convert it to typed technology specs."""
    manifest_path = _manifest_path(manifest)
    with manifest_path.open("r", encoding="utf-8") as file:
        raw = yaml.safe_load(file) or {}

    if not isinstance(raw, dict):
        raise TypeError("Technology manifest must contain a YAML mapping.")

    return TechnologyManifest(
        path=manifest_path,
        raw=raw,
        constants=dict(raw.get("constants", {})),
        layers=_load_layers(raw.get("layers", {})),
        xsections=_load_xsections(raw.get("xsections", {})),
        materials=_load_materials(raw.get("materials", {}), manifest_path.parent),
    )


def _manifest_path(manifest: str) -> Path:
    """Resolve a manifest path relative to mxpic/technologies."""
    path = Path(manifest)
    if not path.is_absolute():
        path = TECHNOLOGIES_ROOT / path

    path = path.resolve()
    if not path.exists():
        raise FileNotFoundError(f"Technology manifest not found: {path}")
    return path


def _load_layers(entries: Dict[str, Any]) -> Dict[str, LayerSpec]:
    """Convert manifest layer mappings to LayerSpec objects."""
    layers: Dict[str, LayerSpec] = {}
    for name, entry in entries.items():
        if not isinstance(entry, dict):
            raise TypeError(f"Layer '{name}' must be a mapping.")

        layer = entry.get("layer")
        if not isinstance(layer, list) or len(layer) != 2:
            raise TypeError(f"Layer '{name}' must define layer as [layer, datatype].")

        layers[name] = LayerSpec(
            name=name,
            layer=(int(layer[0]), int(layer[1])),
            aliases=tuple(entry.get("aliases", ())),
            material=entry.get("material"),
            z_start=entry.get("z_start"),
            thickness=entry.get("thickness"),
            sidewall_angle=entry.get("sidewall_angle"),
            process=entry.get("process"),
            description=entry.get("description", ""),
        )
    return layers


def _load_xsections(entries: Dict[str, Any]) -> Dict[str, XSectionSpec]:
    """Convert manifest xsection mappings to XSectionSpec objects."""
    xsections: Dict[str, XSectionSpec] = {}
    for name, entry in entries.items():
        if not isinstance(entry, dict):
            raise TypeError(f"Xsection '{name}' must be a mapping.")

        xsection_layers = tuple(
            _load_xsection_layer(name, layer_entry)
            for layer_entry in entry.get("layers", ())
        )
        xsections[name] = XSectionSpec(name=name, layers=xsection_layers)
    return xsections


def _load_xsection_layer(xsection_name: str, entry: Dict[str, Any]) -> XSectionLayerSpec:
    """Convert one manifest xsection-layer entry."""
    if not isinstance(entry, dict):
        raise TypeError(f"Xsection '{xsection_name}' layer entry must be a mapping.")

    return XSectionLayerSpec(
        layer=entry["layer"],
        growx=entry.get("growx"),
        growy=entry.get("growy"),
        leftedge=_optional_tuple(entry.get("leftedge")),
        rightedge=_optional_tuple(entry.get("rightedge")),
        overwrite=entry.get("overwrite", True),
    )


def _optional_tuple(value: Optional[list]) -> Optional[Tuple[Any, ...]]:
    """Normalize optional YAML lists used by Nazca edge definitions."""
    if value is None:
        return None
    return tuple(value)


def _load_materials(entries: Dict[str, Any], base_path: Path) -> Dict[str, MaterialSpec]:
    """Convert material metadata and resolve relative material data paths."""
    materials: Dict[str, MaterialSpec] = {}
    for name, entry in entries.items():
        if not isinstance(entry, dict):
            raise TypeError(f"Material '{name}' must be a mapping.")

        data_file = entry.get("data_file")
        if data_file is not None:
            data_file = str((base_path / data_file).resolve())

        materials[name] = MaterialSpec(
            name=name,
            display_name=entry.get("display_name"),
            source_file=entry.get("source_file"),
            source_revision=entry.get("source_revision"),
            data_file=data_file,
            notes=entry.get("notes", ""),
        )
    return materials