#!/usr/bin/env python3
"""Create proposed Crown Key material datablocks; never assign or alter geometry.

Blender: blender --background --python build_blender_materials.py -- --output kit.blend
Python-only data check: python build_blender_materials.py --validate-only
The bpy execution path has not been run in the authoring environment.
"""
from __future__ import annotations

import argparse
import hashlib
import json
from pathlib import Path
import sys


ROOT = Path(__file__).resolve().parent
KIT_ID = "CK-MATERIAL-STARTER-R01"


def load_library(path: Path) -> tuple[dict, str]:
    raw = path.read_bytes()
    data = json.loads(raw)
    if data.get("id") != KIT_ID:
        raise ValueError("Unexpected material library identity")
    names = [m["id"] for m in data["materials"]]
    if len(set(names)) != len(names):
        raise ValueError("Duplicate material identifiers")
    for material in data["materials"]:
        for key in ("roughness", "metallic", "transmission_weight"):
            if not 0 <= material[key] <= 1:
                raise ValueError(f"{material['id']}: invalid {key}")
        if material["base_color"]["alpha"] != 1:
            raise ValueError("This kit uses opaque surfaces or alpha-one physical transmission")
    return data, hashlib.sha256(raw).hexdigest()


def set_socket(node, names: tuple[str, ...], value, required: bool = True) -> None:
    for name in names:
        socket = node.inputs.get(name)
        if socket is not None:
            socket.default_value = value
            return
    if required:
        raise RuntimeError(f"Missing shader input: {names}; inspect this Blender version")


def build_materials(data: dict, digest: str, bpy) -> list[str]:
    created = []
    # All validation/ownership checks precede mutations.
    for spec in data["materials"]:
        previous = bpy.data.materials.get(spec["id"])
        if previous and previous.get("ck_kit_id") != KIT_ID:
            raise RuntimeError(f"Refusing to replace unowned material {spec['id']}")
    for spec in data["materials"]:
        mat = bpy.data.materials.get(spec["id"]) or bpy.data.materials.new(spec["id"])
        mat.use_nodes = True
        mat.use_fake_user = True
        mat.diffuse_color = (*spec["base_color"]["linear_rgb"], 1.0)
        mat["ck_kit_id"] = KIT_ID
        mat["ck_data_sha256"] = digest
        mat["ck_status"] = spec["status"]
        mat["ck_units"] = "Object-local metres; apply geometry scale before material use"
        mat["ck_export_note"] = "Procedural nodes are not baked textures; engine setup remains untested"
        nodes, links = mat.node_tree.nodes, mat.node_tree.links
        nodes.clear()
        shader = nodes.new("ShaderNodeBsdfPrincipled")
        shader.name = "CK_Principled"
        shader.location = (300, 80)
        output = nodes.new("ShaderNodeOutputMaterial")
        output.name = "CK_Surface"
        output.location = (650, 80)
        links.new(shader.outputs["BSDF"], output.inputs["Surface"])
        set_socket(shader, ("Base Color",), (*spec["base_color"]["linear_rgb"], 1.0))
        set_socket(shader, ("Metallic",), spec["metallic"])
        set_socket(shader, ("Roughness",), spec["roughness"])
        set_socket(shader, ("IOR",), spec["ior"])
        set_socket(shader, ("Alpha",), 1.0)
        # Names are selected at runtime; unknown APIs fail visibly rather than silently dropping glass.
        set_socket(shader, ("Transmission Weight", "Transmission"), spec["transmission_weight"])
        if "emission" in spec:
            set_socket(shader, ("Emission Color", "Emission"), (*spec["emission"]["linear_rgb"], 1.0))
            set_socket(shader, ("Emission Strength",), spec["emission"]["strength"])
        normal = spec["normal"]
        if normal["procedural_bump_distance_m"] > 0:
            coords = nodes.new("ShaderNodeTexCoord")
            coords.name = "CK_ObjectMetres"
            coords.location = (-900, 0)
            scale = nodes.new("ShaderNodeVectorMath")
            scale.name = "CK_TileMetres"
            scale.operation = "MULTIPLY"
            scale.location = (-700, 0)
            tile = spec["uv"]["tile_size_m"]
            scale.inputs[1].default_value = (1 / tile[0], 1 / tile[1], 1 / tile[0])
            links.new(coords.outputs["Object"], scale.inputs[0])
            noise = nodes.new("ShaderNodeTexNoise")
            noise.name = "CK_Microvariation_NotBaked"
            noise.location = (-480, 0)
            noise.inputs["Scale"].default_value = normal["noise_scale_per_tile"]
            noise.inputs["Detail"].default_value = 2.0
            noise.inputs["Roughness"].default_value = 0.5
            links.new(scale.outputs["Vector"], noise.inputs["Vector"])
            bump = nodes.new("ShaderNodeBump")
            bump.name = "CK_ProposedMicroBump"
            bump.location = (20, -120)
            bump.inputs["Strength"].default_value = normal["procedural_bump_strength"]
            bump.inputs["Distance"].default_value = normal["procedural_bump_distance_m"]
            links.new(noise.outputs["Fac"], bump.inputs["Height"])
            links.new(bump.outputs["Normal"], shader.inputs["Normal"])
            rough = nodes.new("ShaderNodeMapRange")
            rough.name = "CK_RoughnessVariation"
            rough.location = (-170, 140)
            variation = spec["procedural"]["roughness_variation"] / 2
            rough.inputs["From Min"].default_value = 0
            rough.inputs["From Max"].default_value = 1
            rough.inputs["To Min"].default_value = max(0, spec["roughness"] - variation)
            rough.inputs["To Max"].default_value = min(1, spec["roughness"] + variation)
            links.new(noise.outputs["Fac"], rough.inputs["Value"])
            links.new(rough.outputs["Result"], shader.inputs["Roughness"])
        created.append(mat.name)
    return created


def main() -> None:
    argv = sys.argv[sys.argv.index("--") + 1:] if "--" in sys.argv else sys.argv[1:]
    parser = argparse.ArgumentParser(description=__doc__)
    parser.add_argument("--library", type=Path, default=ROOT / "material_library.json")
    parser.add_argument("--validate-only", action="store_true")
    parser.add_argument("--output", type=Path, help="Optional explicit .blend output; no file saved when omitted")
    args = parser.parse_args(argv)
    data, digest = load_library(args.library)
    if args.validate_only:
        print(json.dumps({"status": "DATA_VALIDATED_ONLY", "materials": len(data["materials"]), "sha256": digest, "blender_executed": False}, indent=2))
        return
    if args.output and args.output.suffix.lower() != ".blend":
        raise SystemExit("Output must have a .blend extension")
    if args.output and args.output.exists():
        raise SystemExit("Refusing to overwrite existing .blend; choose a fresh candidate output path")
    try:
        import bpy
    except ImportError as exc:
        raise SystemExit("bpy is unavailable. Run inside Blender or use --validate-only; no Blender work was performed.") from exc
    created = build_materials(data, digest, bpy)
    if args.output:
        args.output.parent.mkdir(parents=True, exist_ok=True)
        bpy.data.libraries.write(str(args.output.resolve()), {bpy.data.materials[name] for name in created}, fake_user=True, compress=True)
    print(json.dumps({"status": "MATERIAL_DATABLOCKS_CREATED_NOT_ENGINE_ACCEPTED", "blender_version": bpy.app.version_string, "materials": created, "output": str(args.output) if args.output else None}, indent=2))


if __name__ == "__main__":
    main()
