"""Read-only audit of uncompressed GLB triangle meshes; requires numpy.

Report mode exits 0 even with findings. --strict exits 1 for findings.
Invalid or unsupported input exits 2. This is not a complete glTF validator.
"""
import argparse
import hashlib
import json
from pathlib import Path
import struct
import sys

import numpy as np


def audit(path):
    data = Path(path).read_bytes()
    if len(data) < 20 or struct.unpack_from('<4sII', data) != (b'glTF', 2, len(data)):
        raise ValueError('Invalid GLB v2 header/length')
    chunks = {}
    offset = 12
    while offset < len(data):
        if offset + 8 > len(data):
            raise ValueError('Truncated chunk header')
        length, kind = struct.unpack_from('<II', data, offset)
        offset += 8
        if length % 4 or offset + length > len(data) or kind in chunks:
            raise ValueError('Invalid, duplicate or truncated GLB chunk')
        chunks[kind] = data[offset:offset + length]
        offset += length
    g = json.loads(chunks[0x4E4F534A])
    binary = chunks.get(0x004E4942, b'')
    compressed = {'KHR_draco_mesh_compression', 'EXT_meshopt_compression'}
    if compressed.intersection(g.get('extensionsUsed', []) + g.get('extensionsRequired', [])):
        raise ValueError('Compressed geometry: audit the uncompressed export')
    buffers = g.get('buffers', [])
    if len(buffers) != 1 or 'uri' in buffers[0] or buffers[0]['byteLength'] > len(binary):
        raise ValueError('Expected one embedded geometry buffer')
    dtypes = {5120: 'i1', 5121: 'u1', 5122: '<i2', 5123: '<u2', 5125: '<u4', 5126: '<f4'}
    widths = {'SCALAR': 1, 'VEC2': 2, 'VEC3': 3, 'VEC4': 4}

    def accessor(index):
        q = g['accessors'][index]
        if 'sparse' in q or 'bufferView' not in q:
            raise ValueError('Sparse or implicit accessor unsupported')
        v = g['bufferViews'][q['bufferView']]
        if v.get('buffer', 0) != 0 or 'EXT_meshopt_compression' in v.get('extensions', {}):
            raise ValueError('Unsupported buffer view')
        dtype = np.dtype(dtypes[q['componentType']])
        width = widths[q['type']]
        stride = v.get('byteStride', dtype.itemsize * width)
        count = q['count']
        start = q.get('byteOffset', 0)
        end = start + (count - 1) * stride + width * dtype.itemsize if count else start
        base = v.get('byteOffset', 0)
        if count < 0 or start < 0 or base < 0 or stride < dtype.itemsize * width or end > v['byteLength'] or base + v['byteLength'] > buffers[0]['byteLength']:
            raise ValueError('Accessor exceeds declared buffer bounds')
        return np.ndarray((count, width), dtype=dtype, buffer=binary,
                          offset=base + start, strides=(stride, dtype.itemsize))

    rows = []
    for mi, mesh in enumerate(g.get('meshes', [])):
        for pi, primitive in enumerate(mesh['primitives']):
            if primitive.get('mode', 4) != 4 or primitive.get('targets') or 'KHR_draco_mesh_compression' in primitive.get('extensions', {}):
                raise ValueError('Only uncompressed TRIANGLES without morph targets supported')
            attrs = {name: accessor(i) for name, i in primitive['attributes'].items()}
            pos = attrs['POSITION']
            if pos.shape[1] != 3 or g['accessors'][primitive['attributes']['POSITION']].get('normalized'):
                raise ValueError('Expected non-normalized VEC3 positions')
            idx = np.arange(len(pos))
            if 'indices' in primitive:
                q = g['accessors'][primitive['indices']]
                if q['type'] != 'SCALAR' or q['componentType'] not in (5121, 5123, 5125):
                    raise ValueError('Invalid index accessor')
                idx = accessor(primitive['indices']).ravel()
            if len(idx) % 3 or (len(idx) and int(idx.max()) >= len(pos)):
                raise ValueError('Invalid triangle indices')
            t = pos[idx.reshape(-1, 3)].astype(np.float64)
            area2 = np.linalg.norm(np.cross(t[:, 1] - t[:, 0], t[:, 2] - t[:, 0]), axis=1)
            rows.append({'mesh': mesh.get('name', str(mi)), 'primitive': pi,
                         'triangles': len(idx) // 3,
                         'zero_area_triangles': int((area2 < 1e-12).sum()),
                         'nonfinite_attribute_components': sum(int((~np.isfinite(a)).sum()) for a in attrs.values())})
    if not rows:
        raise ValueError('No triangle primitives to audit')
    # Rig report and duplicate-primitive detection (2026-09-21, after the MengTo rejection gates):
    # duplicate = two primitives whose POSITION and index buffers hash identically (an action file
    # carrying a second render mesh); the rig report lists skins, joint names and their parents.
    seen, duplicates = {}, []
    for mi, mesh in enumerate(g.get('meshes', [])):
        for pi, primitive in enumerate(mesh['primitives']):
            key = hashlib.sha1(accessor(primitive['attributes']['POSITION']).tobytes()
                               + (accessor(primitive['indices']).tobytes() if 'indices' in primitive else b'')).hexdigest()
            here = f"{mesh.get('name', str(mi))}[{pi}]"
            if key in seen:
                duplicates.append({'primitive': here, 'same_as': seen[key]})
            else:
                seen[key] = here
    nodes = g.get('nodes', [])
    parent_of = {}
    for ni, n in enumerate(nodes):
        for ch in n.get('children', []):
            parent_of[ch] = ni
    skins = []
    for sk in g.get('skins', []):
        joints = sk.get('joints', [])
        names = [nodes[j].get('name', str(j)) for j in joints]
        rooted = sum(1 for j in joints if j not in parent_of)
        skins.append({'name': sk.get('name', ''), 'joints': len(joints), 'joint_names': names,
                      'root_joints': rooted, 'flat_pivot_list': rooted > 1})
    node_names = {n.get('name', '') for n in nodes}
    result = {'file': Path(path).name, 'sha256': hashlib.sha256(data).hexdigest(),
              'bytes': len(data), 'primitive_count': len(rows),
              'material_count': len(g.get('materials', [])),
              'embedded_images': sum('bufferView' in i for i in g.get('images', [])),
              'external_uris': [i['uri'] for i in g.get('images', []) if 'uri' in i and not i['uri'].startswith('data:')],
              'primitives': rows,
              'duplicate_primitives': duplicates,
              'skins': skins,
              'node_names': sorted(n for n in node_names if n),
              'note': 'Mesh-local counts, before node transforms/instances. Degenerate threshold: cross-product magnitude < 1e-12 in asset units squared. Not a source-topology or visual-quality verdict.'}
    for key in ['triangles', 'zero_area_triangles', 'nonfinite_attribute_components']:
        result[key] = sum(r[key] for r in rows)
    result['findings'] = [key for key in ['zero_area_triangles', 'nonfinite_attribute_components', 'external_uris', 'duplicate_primitives'] if result[key]]
    if any(sk['flat_pivot_list'] for sk in skins):
        result['findings'].append('flat_pivot_list_rig')
    return result


def main():
    parser = argparse.ArgumentParser(description=__doc__)
    parser.add_argument('glb', type=Path)
    parser.add_argument('--strict', action='store_true')
    parser.add_argument('--rig', action='store_true', help='print the skin/joint report (always computed; this only keeps it in the output)')
    parser.add_argument('--require-sockets', default='', help='comma-separated node names that must exist (e.g. target,ground,vfx-hit,vfx-death)')
    args = parser.parse_args()
    try:
        result = audit(args.glb)
        required = [x.strip() for x in args.require_sockets.split(',') if x.strip()]
        missing = [x for x in required if x not in result['node_names']]
        if missing:
            result['missing_sockets'] = missing
            result['findings'].append('missing_sockets')
        if not args.rig:
            result.pop('skins', None); result.pop('node_names', None)
    except (ValueError, KeyError, IndexError, TypeError, OSError, struct.error) as exc:
        print(json.dumps({'status': 'unsupported_or_invalid', 'error': str(exc)}))
        return 2
    print(json.dumps(result, indent=2))
    return 1 if args.strict and result['findings'] else 0


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