"""Ciclo 83 (i20): mide QUÉ escribe el exportador FBX de Blender en el archivo con cada combinación de opciones.

Uso (desde ~/motor-ingresos):
  herramientas/blender -b --factory-startup --python proyectos/blender-export-check/guias/medir_fbx.py -- salida.json

Escena: una caja de 1 x 2 x 3 m (ancho X, fondo Y, ALTO Z en Blender; escala aplicada) llamada Crate_1x2x3, y otra
igual pero hecha con una malla de 2 x 4 x 6 y escala de objeto 0,5 SIN aplicar (Crate_unapplied_0.5, en x = 3 m).
Para cada combinación exporta un FBX y lo lee con el lector de FBX que trae Blender (io_scene_fbx.parse_fbx):
GlobalSettings (UnitScaleFactor y ejes) y, por modelo, Lcl Translation / Lcl Rotation / Lcl Scaling y la caja de los
vértices en unidades del archivo. Con eso calcula lo que un importador que respeta el archivo debería mostrar:
tamaño final en metros por eje del archivo (rotación XYZ × escala × caja × UnitScaleFactor / 100) y qué eje queda
como alto (el UpAxis declarado). Solo mide el archivo: lo de Unity/Unreal se cita de su documentación.
"""
import json
import math
import os
import sys
import tempfile

import bpy
from mathutils import Euler, Vector

from io_scene_fbx import parse_fbx

salida = sys.argv[sys.argv.index("--") + 1] if "--" in sys.argv else "/tmp/medir_fbx.json"

COMBOS = [
    ("default", dict()),
    ("scale_all", dict(apply_scale_options="FBX_SCALE_ALL")),
    ("scale_units", dict(apply_scale_options="FBX_SCALE_UNITS")),
    ("scale_custom", dict(apply_scale_options="FBX_SCALE_CUSTOM")),
    ("no_unit_scale", dict(apply_unit_scale=False)),
    ("default_apply_transform", dict(bake_space_transform=True)),
    ("scale_all_apply_transform", dict(apply_scale_options="FBX_SCALE_ALL", bake_space_transform=True)),
    ("scale_all_no_space_transform", dict(apply_scale_options="FBX_SCALE_ALL", use_space_transform=False)),
    ("scale_all_z_up", dict(apply_scale_options="FBX_SCALE_ALL", axis_up="Z", axis_forward="Y")),
]


def escena():
    bpy.ops.wm.read_factory_settings(use_empty=True)
    bpy.ops.mesh.primitive_cube_add(size=1.0, location=(0, 0, 0))
    a = bpy.context.active_object
    a.name = "Crate_1x2x3"
    a.scale = (1, 2, 3)
    bpy.ops.object.transform_apply(location=False, rotation=False, scale=True)
    bpy.ops.mesh.primitive_cube_add(size=2.0, location=(3, 0, 0))
    b = bpy.context.active_object
    b.name = "Crate_unapplied_0.5"
    b.scale = (1, 2, 3)
    bpy.ops.object.transform_apply(location=False, rotation=False, scale=True)
    b.scale = (0.5, 0.5, 0.5)
    bpy.context.view_layer.update()
    return {o.name: [round(x, 6) for x in o.dimensions] for o in (a, b)}


def props70(elem):
    out = {}
    for sub in elem.elems:
        if sub.id == b"Properties70":
            for p in sub.elems:
                if p.id == b"P":
                    nombre = p.props[0].decode("utf-8", "replace")
                    vals = list(p.props[4:])
                    out[nombre] = [v.decode("utf-8", "replace") if isinstance(v, bytes) else v for v in vals]
    return out


def buscar(elem, ident):
    for sub in elem.elems:
        if sub.id == ident:
            return sub
    return None


def tam_final(caja_min, caja_max, rot_grados, escala, usf):
    """Tamaño en metros por eje del ARCHIVO tras aplicar escala y rotación del nodo (orden XYZ de FBX)."""
    e = Euler([math.radians(r) for r in rot_grados], "XYZ")
    m = e.to_matrix()
    pts = []
    for x in (caja_min[0], caja_max[0]):
        for y in (caja_min[1], caja_max[1]):
            for z in (caja_min[2], caja_max[2]):
                v = Vector((x * escala[0], y * escala[1], z * escala[2]))
                pts.append(m @ v)
    f = usf / 100.0  # unidades del archivo -> metros (UnitScaleFactor = cm por unidad)
    return [round((max(p[i] for p in pts) - min(p[i] for p in pts)) * f, 4) for i in range(3)]


def leer(ruta):
    raiz, version = parse_fbx.parse(ruta)
    gs = props70(buscar(raiz, b"GlobalSettings"))
    usf = gs.get("UnitScaleFactor", [1.0])[0]
    objetos = buscar(raiz, b"Objects")
    geoms = {}
    modelos = {}
    for e in objetos.elems:
        if e.id == b"Geometry":
            vert = buscar(e, b"Vertices")
            if vert is not None:
                v = list(vert.props[0])
                xs, ys, zs = v[0::3], v[1::3], v[2::3]
                geoms[e.props[0]] = ([min(xs), min(ys), min(zs)], [max(xs), max(ys), max(zs)])
        elif e.id == b"Model":
            nombre = e.props[1].split(b"\x00")[0].decode("utf-8", "replace")
            p = props70(e)
            modelos[e.props[0]] = {
                "nombre": nombre,
                "Lcl Translation": [round(x, 6) for x in p.get("Lcl Translation", [0, 0, 0])],
                "Lcl Rotation": [round(x, 6) for x in p.get("Lcl Rotation", [0, 0, 0])],
                "Lcl Scaling": [round(x, 6) for x in p.get("Lcl Scaling", [1, 1, 1])],
                "PreRotation": [round(x, 6) for x in p["PreRotation"]] if "PreRotation" in p else None,
                "RotationOrder": p.get("RotationOrder", [0])[0],
            }
    con = buscar(raiz, b"Connections")
    for c in con.elems:
        if c.id == b"C" and c.props[0] == b"OO" and c.props[1] in geoms and c.props[2] in modelos:
            mn, mx = geoms[c.props[1]]
            m = modelos[c.props[2]]
            m["caja_vertices"] = [round(mx[i] - mn[i], 6) for i in range(3)]
            m["tam_final_m"] = tam_final(mn, mx, m["Lcl Rotation"], m["Lcl Scaling"], usf)
    claves = ["UnitScaleFactor", "OriginalUnitScaleFactor", "UpAxis", "UpAxisSign", "FrontAxis", "FrontAxisSign",
              "CoordAxis", "CoordAxisSign"]
    g = {k: gs.get(k, [None])[0] for k in claves}
    for m in modelos.values():
        if "tam_final_m" in m:
            m["alto_final_m"] = m["tam_final_m"][g["UpAxis"]]
    return {"fbx_version": version, "global": g, "modelos": sorted(modelos.values(), key=lambda m: m["nombre"])}


def main():
    res = {"blender": bpy.app.version_string, "combos": {}}
    tmp = tempfile.mkdtemp(prefix="medir_fbx_")
    for nombre, opciones in COMBOS:
        dims = escena()
        ruta = os.path.join(tmp, nombre + ".fbx")
        kw = dict(filepath=ruta, use_selection=False, object_types={"MESH"})
        kw.update(opciones)
        bpy.ops.export_scene.fbx(**kw)
        datos = leer(ruta)
        datos["opciones"] = opciones
        datos["dimensiones_en_blender_m"] = dims
        res["combos"][nombre] = datos
    json.dump(res, open(salida, "w"), indent=1)
    print("MEDIDO", bpy.app.version_string, len(res["combos"]), "combinaciones ->", salida)


main()
