"""Author the unadopted Meadow scenery candidate with Blender's native meshes.

Blender --background --python tools/models/build_meadow.py -- --review-dir PATH
Blender --background --python tools/models/build_meadow.py -- --verify-only --review-dir PATH
No existing playground, scene, prefab, material, or stage asset is rewritten.
"""
import argparse
import hashlib
import json
import math
import random
import sys
from pathlib import Path

import bpy
from mathutils import Vector
from mathutils.bvhtree import BVHTree

ROOT = Path(__file__).resolve().parents[2]
SOURCE = ROOT / 'SourceAssets/Models/Meadow'
EXPORT = ROOT / 'Assets/MagnetismHeroes/UnityRuntime/Presentation/Models/Meadow'
DEFAULT_REVIEW = ROOT / 'artifacts/verification/VisualUpgrade/ModelReview/Meadow'
SETTINGS = dict(use_selection=True, object_types={'MESH'}, axis_forward='-Z', axis_up='Y',
                apply_unit_scale=True, apply_scale_options='FBX_SCALE_ALL',
                use_mesh_modifiers=True, bake_anim=False, add_leaf_bones=False,
                path_mode='AUTO')
ASSETS = {}
MATERIALS = {}
RNG = random.Random(20517)


def material(name, color, roughness=.68):
    srgb = color
    color = tuple(c / 12.92 if c <= .04045 else ((c + .055) / 1.055) ** 2.4 for c in color)
    mat = bpy.data.materials.new(name)
    mat.diffuse_color = (*color, 1)
    mat.use_nodes = True
    bsdf = mat.node_tree.nodes.get('Principled BSDF')
    bsdf.inputs['Base Color'].default_value = (*color, 1)
    bsdf.inputs['Roughness'].default_value = roughness
    mat['portableSurface'] = 'constant base color and roughness; no procedural texture dependency'
    mat['authoredSRGB'] = list(srgb)
    MATERIALS[name] = mat
    return mat


def mesh(name, vertices, faces, mats, indices=None, smooth=True):
    data = bpy.data.meshes.new(name + 'Mesh')
    data.from_pydata(vertices, [], faces)
    data.update()
    obj = bpy.data.objects.new(name, data)
    bpy.context.collection.objects.link(obj)
    for mat in mats:
        data.materials.append(MATERIALS[mat])
    uv = data.uv_layers.new(name='UVMap')
    # Dominant-normal box projection: every face has usable, nonzero UV area.
    for poly in data.polygons:
        poly.use_smooth = smooth
        poly.material_index = indices[poly.index] if indices else 0
        axis = max(range(3), key=lambda n: abs(poly.normal[n]))
        a, b = [n for n in range(3) if n != axis]
        for loop_index in poly.loop_indices:
            point = data.vertices[data.loops[loop_index].vertex_index].co
            uv.data[loop_index].uv = (point[a] * .25, point[b] * .25)
    return obj


def tube(name, points, radii, mat='BarkHoney', sides=10):
    verts, faces = [], []
    for i, p in enumerate(points):
        direction = Vector(points[min(i + 1, len(points) - 1)]) - Vector(points[max(0, i - 1)])
        direction.normalize()
        right = direction.cross(Vector((0, 1, 0))).normalized()
        if right.length < .1:
            right = direction.cross(Vector((1, 0, 0))).normalized()
        up = direction.cross(right).normalized()
        for j in range(sides):
            a = math.tau * j / sides
            q = Vector(p) + radii[i] * (right * math.cos(a) + up * math.sin(a))
            verts.append(tuple(q))
    faces.extend([tuple(reversed(range(sides))), tuple((len(points) - 1) * sides + j for j in range(sides))])
    for i in range(len(points) - 1):
        for j in range(sides):
            k = i * sides + j
            next_k = i * sides + (j + 1) % sides
            faces.append((k, next_k, next_k + sides, k + sides))
    return mesh(name, verts, faces, [mat])


def leaf(name, start, direction, length, width, mat='LeafLight', bend=.14):
    """Thick curved lance/oval leaf with an explicit raised midrib and tapered tip."""
    origin = Vector(start)
    forward = Vector(direction).normalized()
    side = forward.cross(Vector((0, 0, 1))).normalized()
    if side.length < .1:
        side = Vector((1, 0, 0))
    normal = side.cross(forward).normalized()
    verts, faces = [], []
    for layer in (0, 1):
        for i in range(9):
            t = i / 8
            half = max(.007, width * math.sin(math.pi * t) ** .7)
            center = origin + forward * length * t + normal * (bend * math.sin(math.pi * t) - layer * .022)
            for s in (-1, 0, 1):
                verts.append(tuple(center + side * s * half + normal * (.025 * (1 - abs(s)) * math.sin(math.pi * t))))
    for i in range(8):
        for j in range(2):
            k = i * 3 + j
            faces.append((k, k + 3, k + 4, k + 1))
            faces.append((k + 27, k + 28, k + 31, k + 30))
        for j in (0, 2):
            k = i * 3 + j
            faces.append((k, k + 27, k + 30, k + 3) if j == 0 else (k, k + 3, k + 30, k + 27))
    faces.extend([(0, 1, 2, 29, 28, 27), (24, 51, 52, 53, 26, 25)])
    return mesh(name, verts, [tuple(reversed(f)) for f in faces], [mat])


def organic(name, center, size, mats, seed=0, rock=False, segments=24, rings=12):
    """Authored asymmetric section mesh; foliage lobes and rock planes have different profiles."""
    verts, faces, indices = [], [], []
    cx, cy, cz = center
    sx, sy, sz = size
    for k in range(rings + 1):
        phi = math.pi * k / rings
        ring_radius = max(.015, math.sin(phi))
        for j in range(segments):
            theta = math.tau * j / segments
            lobes = .10 * math.sin(5 * theta + seed + phi * 2) + .06 * math.cos(3 * theta - phi * 4)
            shape = 1 + lobes * math.sin(phi)
            if rock:
                shape += .08 * math.sin(theta * 2 + seed)
            z = math.cos(phi)
            if rock:
                z = math.copysign(abs(z) ** .70, z)
            verts.append((cx + sx * ring_radius * math.cos(theta) * shape + .13 * sx * math.sin(phi * 2),
                          cy + sy * ring_radius * math.sin(theta) * shape,
                          cz + sz * z * (1 + .035 * math.sin(theta * 3 + seed) * math.sin(phi))))
    for k in range(rings):
        for j in range(segments):
            faces.append((k * segments + j, k * segments + (j + 1) % segments,
                          (k + 1) * segments + (j + 1) % segments, (k + 1) * segments + j))
            # Broad intentional colored planes, rather than isolated checkerboard faces.
            band = (j + seed) % segments
            accent = (1 if band < segments // 4 and k < rings * .6 else (2 if band > segments * .72 and k > rings * .3 else 0)) if rock else 0
            indices.append(min(len(mats) - 1, accent))
    faces.extend([tuple(reversed(range(segments))), tuple(rings * segments + j for j in range(segments))])
    indices.extend([0, 0])
    return mesh(name, verts, [tuple(reversed(f)) for f in faces], mats, indices, smooth=not rock)


def terrain(name, rx, ry, height, hill=False):
    verts = [(0, 0, height if hill else .14)]
    segments, rings = 64, 16
    for k in range(1, rings + 1):
        r = k / rings
        for j in range(segments):
            a = math.tau * j / segments
            warp = 1 + .045 * math.sin(3 * a) + .025 * math.sin(7 * a + 1)
            z = height * (math.cos(r * math.pi / 2) ** 2) if hill else .14 + .035 * math.sin(a * 3) * r ** 3
            verts.append((rx * r * math.cos(a) * warp, ry * r * math.sin(a) * warp, max(.015, z)))
    faces, indices = [], []
    for j in range(segments):
        faces.append((0, 1 + j, 1 + (j + 1) % segments))
        indices.append(0)
    for k in range(rings - 1):
        for j in range(segments):
            p = 1 + k * segments + j
            q = 1 + k * segments + (j + 1) % segments
            faces.append((p, p + segments, q + segments, q))
            indices.append(0)
    bottom = len(verts)
    verts.extend([(verts[1 + (rings - 1) * segments + j][0], verts[1 + (rings - 1) * segments + j][1], 0) for j in range(segments)])
    for j in range(segments):
        p = 1 + (rings - 1) * segments + j
        q = 1 + (rings - 1) * segments + (j + 1) % segments
        faces.append((p, bottom + j, bottom + (j + 1) % segments, q))
        indices.append(2)
    faces.append(tuple(reversed(range(bottom, bottom + segments))))
    indices.append(2)
    return mesh(name, verts, faces, ['GroundMint', 'GroundSage', 'SoilWarm'], indices)


def finish(name, parts, role, collider='none'):
    bpy.ops.object.select_all(action='DESELECT')
    for obj in parts:
        obj.select_set(True)
    bpy.context.view_layer.objects.active = parts[0]
    if len(parts) > 1:
        bpy.ops.object.join()
    obj = bpy.context.object
    obj.name = name
    # FBX consolidates identical material pointers: make the native slot contract
    # equally explicit before export instead of treating consolidation as loss.
    old_materials = list(obj.data.materials)
    unique_materials = list(dict.fromkeys(old_materials))
    remap = [unique_materials.index(m) for m in old_materials]
    indices = [remap[p.material_index] for p in obj.data.polygons]
    obj.data.materials.clear()
    for mat in unique_materials:
        obj.data.materials.append(mat)
    for polygon, index in zip(obj.data.polygons, indices):
        polygon.material_index = index
    min_z = min(v.co.z for v in obj.data.vertices)
    for vertex in obj.data.vertices:
        vertex.co.z -= min_z
    bpy.context.scene.cursor.location = (0, 0, 0)
    bpy.ops.object.origin_set(type='ORIGIN_CURSOR')
    obj['role'] = role
    obj['colliderGuidance'] = collider
    obj['candidateStatus'] = 'USER_REVIEW_REQUIRED_NOT_ADOPTED'
    obj['nativeGeometry'] = 'custom section surfaces, curved tubes, thick curved leaves; no external meshes'
    obj.data.update()
    ASSETS[name] = obj
    return obj


def tree(name, kind):
    parts = []
    if kind == 'tall':
        parts.append(tube('TaperedTrunk', [(0, 0, 0), (.08, 0, 1), (-.1, .08, 2.2), (.03, 0, 3.8)], [.24, .18, .10, .025]))
        for i, (z, radius) in enumerate([(1.45, .87), (2.15, .76), (2.85, .58), (3.45, .36)]):
            parts.append(organic('SweptCrownTier', (0, 0, z), (radius, radius * .76, .84), ['PineMint', 'LeafLight', 'LeafShade'], i))
        for i in range(12):
            a = i * 2.4
            z = 1.5 + (i % 4) * .46
            parts.append(leaf('CrownTip', (.36 * math.cos(a), .3 * math.sin(a), z), (math.cos(a), math.sin(a), .4), .57, .12, 'LeafLight'))
    else:
        parts.append(tube('BentTrunk', [(0, 0, 0), (-.13, .03, .6), (-.03, 0, 1.25), (.22, .06, 2.15), (.35, .12, 2.7)], [.35, .27, .21, .13, .055]))
        for j, (end, radius) in enumerate([((-1, .05, 2.45), .87), ((1.08, .1, 2.8), .92), ((.1, .70, 3.15), .93), ((-.45, -.52, 2.95), .80)]):
            parts.append(tube('VisibleBranch', [(-.04, 0, 1.25), (end[0] * .5, end[1] * .5, 1.85), end], [.13, .09, .025]))
            palette = ['LeafMint', 'LeafLight', 'LeafShade'] if kind == 'round' else ['LeafSage', 'LeafLight', 'LeafShade']
            if j == 2:
                palette[0] = 'LeafLight'
            parts.append(organic('SculptedCanopy', end, (radius, radius * .82, radius * .77), palette, j + 4))
        # Root flares and long bark ridges keep the trunk readable in a closeup.
        for j in range(5):
            a = math.tau * j / 5
            parts.append(tube('RootFlare', [(.59 * math.cos(a), .5 * math.sin(a), .05), (.27 * math.cos(a), .25 * math.sin(a), .20), (0, 0, .55)], [.035, .10, .09]))
        for j in range(3):
            a = j * 2.1
            parts.append(tube('BarkRibbon', [(.29 * math.cos(a), .29 * math.sin(a), .2), (-.12 + .22 * math.cos(a), .23 * math.sin(a), .7), (.18 * math.cos(a), .18 * math.sin(a), 1.3)], [.012, .018, .012], 'BarkLight', 6))
        for j in range(16):
            a = j * 2.4
            start = (1.06 * math.cos(a), .83 * math.sin(a), 2.7 + .25 * math.sin(j))
            parts.append(leaf('CanopyLeafAccent', start, (.35 * math.cos(a), .35 * math.sin(a), .35), .40, .13, 'LeafLight'))
    return finish(name, parts, 'near tree with visible branched trunk and separate foliage', 'mesh on visible near tree only; no enclosing canopy box')


def flower_cluster(name, variety, count, seed):
    rng = random.Random(seed)
    parts = []
    for n in range(count):
        x, y = rng.uniform(-.58, .58), rng.uniform(-.4, .4)
        h = rng.uniform(.54, .92) if variety != 'spike' else rng.uniform(.85, 1.22)
        tip = Vector((x + .09, y, h))
        parts.append(tube('CurvedStem', [(x, y, .025), (x - .035, y, h * .4), tuple(tip)], [.023, .019, .012], 'Stem', 7))
        for j in range(2):
            a = n * 1.7 + j * math.pi
            parts.append(leaf('StemLeaf', (x, y, h * (.28 + j * .19)), (math.cos(a), math.sin(a), .25), .32, .085, 'LeafSage'))
        if variety == 'spike':
            for row in range(5):
                for j in range(4):
                    a = math.tau * j / 4 + row * .6
                    base = tip + Vector((0, 0, -.37 + row * .085))
                    parts.append(leaf('LupineFloret', tuple(base), (math.cos(a), math.sin(a), .65), .16 - row * .016, .063, 'PetalLavender', .05))
        else:
            petal_mat = 'PetalCream' if variety == 'daisy' else 'PetalPink'
            petals = 8 if variety == 'daisy' else 6
            for j in range(petals):
                a = math.tau * j / petals + n * .3
                parts.append(leaf('SpoonPetal', tuple(tip), (math.cos(a), math.sin(a), .10), .25, .10, petal_mat, .09))
            parts.append(organic('RecessedFlowerCenter', tuple(tip + Vector((0, 0, .025))), (.079, .079, .036), ['PollenHoney'], n, segments=12, rings=6))
    return finish(name, parts, 'flower colony with petals, stems, leaves; no faces', 'none: small decorative vegetation')


def build_assets():
    palette = {
        'GroundMint': (.53, .74, .50), 'GroundSage': (.59, .77, .49), 'SoilWarm': (.52, .42, .29),
        'LeafMint': (.45, .67, .44), 'LeafSage': (.53, .69, .41), 'LeafLight': (.62, .77, .46),
        'LeafShade': (.31, .56, .45), 'PineMint': (.38, .66, .55), 'BarkHoney': (.52, .36, .21),
        'BarkLight': (.68, .49, .30), 'Stem': (.32, .52, .27), 'GrassMint': (.49, .73, .46),
        'GrassGold': (.69, .80, .46), 'PetalCream': (.98, .88, .59), 'PetalPink': (.90, .43, .56),
        'PetalLavender': (.54, .42, .77), 'PollenHoney': (.94, .58, .13),
        'StoneCream': (.59, .64, .57), 'StoneLight': (.75, .76, .65), 'StoneShade': (.42, .53, .49),
        'StoneBlue': (.58, .70, .71), 'PathSand': (.76, .77, .57), 'RidgeTeal': (.54, .73, .72),
        'RidgeLight': (.61, .78, .74), 'RidgeFar': (.66, .82, .83),
    }
    for name, color in palette.items():
        material(name, color, .78 if name.startswith('Stone') else .67)
    finish('MeadowClearing', [terrain('OpenPlayGround', 6.2, 5.0, .15)], 'flat playable clearing; arrange outside existing sphere positions', 'future gameplay floor only; top .14m authored, placement must align existing floor')
    finish('GentleHill', [terrain('SoftSlopingLand', 5.5, 4.3, 1.55, True)], 'surrounding rolling terrain', 'none: peripheral scenery')
    ridge = terrain('DistantRollingRidge', 12, 6, 4.0, True)
    ridge.data.materials[0] = MATERIALS['RidgeTeal']
    ridge.data.materials[1] = MATERIALS['RidgeLight']
    finish('DistantRidge', [ridge], 'far terrain; atmospheric teal', 'none: distant decoration')
    far = terrain('FarHorizon', 15, 7, 5.0, True)
    far.data.materials[0] = MATERIALS['RidgeFar']
    far.data.materials[1] = MATERIALS['RidgeFar']
    finish('FarHorizon', [far], 'distant skyline terrain', 'none: distant decoration')
    tree('RoundCanopyTree', 'round')
    tree('SageCanopyTree', 'sage')
    tree('TallWindTree', 'tall')
    for name, color, seed in [('SageShrub', 'LeafSage', 8), ('MintShrub', 'LeafMint', 16)]:
        parts = []
        for n in range(4):
            a = n * 2.4
            end = (.35 * math.cos(a), .3 * math.sin(a), .52 + (n % 2) * .18)
            parts.append(tube('ShrubWoodyBranch', [(0, 0, 0), (end[0] * .5, end[1] * .5, .35), end], [.085, .045, .015], 'BarkHoney', 7))
            parts.append(organic('ShrubLeafMass', end, (.46, .36, .39), [color, 'LeafLight', 'LeafShade'], seed + n, segments=18, rings=10))
        for n in range(12):
            a = n * 2.4
            parts.append(leaf('ReadableShrubLeaf', (.40 * math.cos(a), .35 * math.sin(a), .58), (math.cos(a), math.sin(a), .3), .27, .10, 'LeafLight'))
        finish(name, parts, 'branched near shrub', 'none: small decorative vegetation')
    fern_parts = []
    for n in range(7):
        a = n * math.tau / 7
        direction = Vector((math.cos(a), math.sin(a), .55))
        for j in range(5):
            p = direction * (.10 + j * .12)
            for side in (-1, 1):
                sideways = Vector((-math.sin(a) * side, math.cos(a) * side, .15))
                fern_parts.append(leaf('FernLeaflet', tuple(p), tuple(direction * .3 + sideways), .20 - .019 * j, .060, 'LeafSage'))
        fern_parts.append(tube('FernSpine', [(0, 0, .02), tuple(direction * .30), tuple(direction * .70)], [.016, .011, .005], 'Stem', 6))
    finish('FernCluster', fern_parts, 'individual curved fern fronds and leaflets', 'none: small decorative vegetation')
    for name, seed in [('GrassTuftMint', 1), ('GrassTuftGold', 2)]:
        rng = random.Random(seed)
        parts = []
        for n in range(19):
            a = rng.random() * math.tau
            length = rng.uniform(.21, .48)
            parts.append(leaf('CurvedGrassBlade', (rng.uniform(-.28, .28), rng.uniform(-.22, .22), .025),
                              (.55 * math.cos(a), .55 * math.sin(a), 1), length, rng.uniform(.02, .043),
                              'GrassMint' if n % 3 else 'GrassGold', .04))
        finish(name, parts, 'small grass colony with tapered curved blades', 'none: small decorative vegetation')
    flower_cluster('DaisyColony', 'daisy', 5, 11)
    flower_cluster('PinkCosmosColony', 'cosmos', 5, 21)
    flower_cluster('LavenderLupineColony', 'spike', 4, 31)
    for name, size, seed, blue in [('RoundLimestone', (1.12, .78, .73), 3, False), ('SlateBoulder', (1.0, .72, 1.15), 7, True),
                                  ('LowLimestone', (.72, .52, .32), 9, False)]:
        obj = organic('CarvedStone', (0, 0, size[2]), size, ['StoneBlue' if blue else 'StoneCream', 'StoneLight', 'StoneShade'], seed, rock=True, segments=16, rings=10)
        bevel = obj.modifiers.new('SoftStoneEdges', 'BEVEL')
        bevel.width = .035
        bevel.segments = 2
        bevel.angle_limit = .35
        bpy.context.view_layer.objects.active = obj
        bpy.ops.object.modifier_apply(modifier=bevel.name)
        finish(name, [obj], 'soft rock silhouette with readable broad planes', 'mesh on visible near rock only')
    pebbles = []
    for n, (x, y, s) in enumerate([(-.36, -.10, .22), (.20, .14, .29), (.46, -.14, .15), (-.06, -.25, .12)]):
        pebbles.append(organic('RoundedPebble', (x, y, s * .43), (s, s * .75, s * .43), ['StoneCream', 'StoneLight'], n, rock=True, segments=12, rings=6))
    finish('PebbleScatter', pebbles, 'small pebble scatter', 'none: small distant or ground decoration')
    # One continuous tunnel surface, with an open center and non-box collider contract.
    points, radii = [], []
    for i in range(33):
        a = math.pi - math.pi * i / 32
        points.append((1.18 * math.cos(a), 0, .04 + 1.72 * math.sin(a)))
        radii.append(.30 + .035 * math.sin(i * .8))
    arch = tube('OpenStoneTunnel', points, radii, 'StoneCream', 12)
    arch.data.materials.append(MATERIALS['StoneLight'])
    arch.data.materials.append(MATERIALS['StoneShade'])
    for face in arch.data.polygons:
        face.material_index = 0
    finish('OpenStoneArch', [arch], 'natural stone discovery arch with a physically open hole', 'nonconvex visible mesh collider; NEVER enclosing BoxCollider; do not ignore front raycast hits')
    parts = []
    for n in range(3):
        slab = terrain('StoneTerrace', .76, .57, .15)
        for v in slab.data.vertices:
            v.co.x += (n - 1) * .76
            v.co.z = v.co.z * (1.5 + n * 1.6)
        for j in range(3):
            slab.data.materials[j] = MATERIALS[['StoneCream', 'StoneLight', 'StoneShade'][j]]
        parts.append(slab)
    finish('MossStoneSteps', parts, 'three rounded stone terraces retaining stage discovery height differences', 'nonconvex mesh matching terraces; integration must preserve existing sphere positions')


def scene_setup(name):
    scene = bpy.data.scenes.new(name)
    scene.unit_settings.system = 'METRIC'
    scene.unit_settings.scale_length = 1
    scene.render.engine = 'CYCLES'
    scene.cycles.samples = 32
    scene.cycles.use_denoising = True
    preferences = bpy.context.preferences.addons['cycles'].preferences
    preferences.compute_device_type = 'OPTIX'
    preferences.get_devices()
    for device in preferences.devices:
        device.use = device.type == 'OPTIX'
    assert any(d.use and d.type == 'OPTIX' for d in preferences.devices), 'Expected coordinated RTX OPTIX render device'
    scene.cycles.device = 'GPU'
    scene.render.resolution_x = 1600
    scene.render.resolution_y = 900
    scene.render.resolution_percentage = 100
    scene.render.image_settings.file_format = 'PNG'
    scene.view_settings.view_transform = 'AgX'
    scene.view_settings.look = 'AgX - Medium High Contrast'
    world = bpy.data.worlds.new(name + '_CyanDay')
    world.use_nodes = True
    world.node_tree.nodes['Background'].inputs['Color'].default_value = (.40, .76, .85, 1)
    world.node_tree.nodes['Background'].inputs['Strength'].default_value = .45
    # Lighting stays physical; the visible cyan sky keeps its bright art direction.
    nodes, links = world.node_tree.nodes, world.node_tree.links
    sky = nodes.new('ShaderNodeBackground')
    sky.name = 'VisibleCyanSky'
    sky.inputs['Color'].default_value = (.12, .67, .85, 1)
    sky.inputs['Strength'].default_value = 1
    ray = nodes.new('ShaderNodeLightPath')
    mix = nodes.new('ShaderNodeMixShader')
    links.new(ray.outputs['Is Camera Ray'], mix.inputs[0])
    links.new(nodes['Background'].outputs[0], mix.inputs[1])
    links.new(sky.outputs[0], mix.inputs[2])
    links.new(mix.outputs[0], nodes['World Output'].inputs['Surface'])
    scene.world = world
    for label, light_type, location, energy, size, color in [
        ('WarmSoftSun', 'AREA', (-10, -8, 18), 3800, 10, (1.0, .89, .72)),
        ('SkyFill', 'AREA', (8, -1, 12), 2200, 14, (.76, .91, 1.0)),
    ]:
        data = bpy.data.lights.new(label, light_type)
        data.energy, data.shape, data.size, data.color = energy, 'DISK', size, color
        obj = bpy.data.objects.new(label, data)
        scene.collection.objects.link(obj)
        obj.location = location
        obj.rotation_euler = (Vector((0, 3, 0)) - obj.location).to_track_quat('-Z', 'Y').to_euler()
    sun = bpy.data.lights.new('Daylight', 'SUN')
    sun.energy, sun.angle, sun.color = 2.0, .18, (1.0, .92, .79)
    obj = bpy.data.objects.new('Daylight', sun)
    scene.collection.objects.link(obj)
    obj.rotation_euler = (.42, -.55, -.45)
    return scene


def camera(scene, position, target, lens=44, ortho=None):
    data = bpy.data.cameras.new(scene.name + '_ReviewCamera')
    obj = bpy.data.objects.new(data.name, data)
    scene.collection.objects.link(obj)
    obj.location = position
    obj.rotation_euler = (Vector(target) - obj.location).to_track_quat('-Z', 'Y').to_euler()
    data.lens = lens
    data.clip_end = 250
    if ortho:
        data.type, data.ortho_scale = 'ORTHO', ortho
    scene.camera = obj
    scene['cameraPurpose'] = 'slightly elevated three-quarter puzzle-compatible review; does not change game camera'


def instance(scene, name, loc, scale=1, rotation=0):
    obj = ASSETS[name].copy()
    obj.data = ASSETS[name].data
    obj.name = name + '_SetDress'
    scene.collection.objects.link(obj)
    obj.location = loc
    obj.scale = (scale,) * 3 if isinstance(scale, (float, int)) else scale
    obj.rotation_euler.z = rotation
    return obj


def landscape(name, theme):
    scene = scene_setup(name)
    scene['themeRuntimeIdentifier'] = ['Garden', 'Cloud', 'Workshop'][theme]
    scene['stageRange'] = ['01-10', '11-20', '21-30'][theme]
    scene['layoutStatus'] = 'concept preview only; original sphere positions and discoveries must be preserved during later integration'
    # Continuous terrain continues behind the play area and to the horizon.
    instance(scene, 'MeadowClearing', (0, 8, -.14), (9, 8, 1))
    for i in range(8):
        a = math.pi * .04 + math.pi * .92 * i / 7
        instance(scene, 'DistantRidge', (math.cos(a) * 33, 25 + math.sin(a) * 18, -.2), 1.1 + .15 * math.sin(i), i * .7)
    for i in range(6):
        instance(scene, 'FarHorizon', (-44 + i * 17, 57 + (i % 2) * 4, -1.5), 1.3, i * .4)
    for x, y, s in [(-10, 9, 1.2), (10, 13, 1.3), (-14, 19, 1.6), (18, 20, 1.5), (0, 22, 1.8)]:
        instance(scene, 'GentleHill', (x, y, -.05), s)
    if theme == 1:
        for x, y in [(-8, 4), (9, 8), (-4, 13)]:
            instance(scene, 'GentleHill', (x, y, -.03), .9)
    positions = [(-7.6, 1, 1.3), (7.6, 5, 1.25), (-10, 13, 1.5), (11, 16, 1.55), (-4, 19, 1.4), (5, 24, 1.4), (-16, 21, 1.2), (20, 25, 1.8)]
    for i, (x, y, s) in enumerate(positions):
        instance(scene, ['RoundCanopyTree', 'SageCanopyTree', 'TallWindTree'][(i + theme) % 3], (x, y, .03), s, i * .9)
    for i in range(24):
        a = i * math.tau / 24
        x, y = 8.4 * math.cos(a), 4 + 8 * math.sin(a)
        if -4 < y < 2 and abs(x) < 6:
            continue
        instance(scene, 'MintShrub' if i % 2 else 'SageShrub', (x, y, .02), .7 + (i % 3) * .13, a)
    # Irregular colonies, no luminous spherical decorations or face plants.
    rng = random.Random(120 + theme)
    for i in range(145 if theme == 1 else 100):
        x, y = rng.uniform(-15, 15), rng.uniform(-9, 24)
        if (x / 6.1) ** 2 + (y / 4.9) ** 2 < 1.1:
            continue
        obj_name = ['GrassTuftMint', 'GrassTuftGold', 'FernCluster'][i % 3]
        instance(scene, obj_name, (x, y, .015), rng.uniform(.7, 1.25), rng.random() * math.tau)
        if i % (2 if theme == 1 else 6) == 0:
            flower_name = ['DaisyColony', 'PinkCosmosColony', 'LavenderLupineColony'][i % 3]
            instance(scene, flower_name, (x + .45, y + .2, .02), rng.uniform(.7, 1.2), rng.random() * math.tau)
    for i in range(14 if theme == 2 else 6):
        a = i * 2.4
        r = 7 + (i % 3) * 2.2
        x, y = r * math.cos(a), 4 + r * math.sin(a)
        instance(scene, ['RoundLimestone', 'SlateBoulder', 'LowLimestone'][i % 3], (x, y, .02), 1.0 + (.6 if theme == 2 else .1) * (i % 2), a)
        instance(scene, 'PebbleScatter', (x + .65, y - .75, .02), .9, -a)
    instance(scene, 'OpenStoneArch', (-5.5, 5.8, .03), 1.15, -.22)
    instance(scene, 'MossStoneSteps', (5.0, 3.6, .03), 1.25, .36)
    scene.view_layers[0].update()
    ground_names = {'MeadowClearing', 'GentleHill', 'DistantRidge', 'FarHorizon'}
    grounds = [o for o in scene.objects if o.get('role') and any(o.name.startswith(n + '_SetDress') for n in ground_names)]
    terrain_bvhs = {g: BVHTree.FromPolygons([v.co for v in g.data.vertices], [list(p.vertices) for p in g.data.polygons]) for g in grounds}
    for obj in list(scene.objects):
        if obj.type != 'MESH' or obj in grounds:
            continue
        x, y = obj.location.x, obj.location.y
        high = Vector((x, y, 40))
        ground_z = 0
        for ground in grounds:
            inverse = ground.matrix_world.inverted()
            point, _, _, _ = terrain_bvhs[ground].ray_cast(inverse @ high, (inverse.to_3x3() @ Vector((0, 0, -1))).normalized())
            if point is not None:
                ground_z = max(ground_z, (ground.matrix_world @ point).z)
        obj.location.z = ground_z + .008
    camera(scene, (17, -25, 16), (0, 7, 1.8), lens=34)
    return scene


def catalog_scene(name, assets):
    scene = scene_setup(name)
    for i, asset_name in enumerate(assets):
        obj = ASSETS[asset_name]
        width = max(obj.dimensions.x, obj.dimensions.y)
        scale = min(2.6, 2.8 / max(width, .1))
        x, y = (i % 3 - 1) * 4.8, (i // 3) * 5.2
        instance(scene, asset_name, (x, y, 0), scale)
        data = bpy.data.curves.new(asset_name + '_Label', 'FONT')
        data.body, data.size, data.align_x = asset_name, .23, 'CENTER'
        data.extrude = .002
        data.materials.append(MATERIALS['BarkHoney'])
        label = bpy.data.objects.new(data.name, data)
        scene.collection.objects.link(label)
        label.location = (x, y - 1.8, .03)
    instance(scene, 'MeadowClearing', (0, 4, -.14), (4, 4, 1))
    camera(scene, (12, -20, 19), (0, 2.5, .85), ortho=18)
    return scene


def closeup_scene(name, asset_names, positions, target, ortho):
    scene = scene_setup(name)
    for asset_name, position in zip(asset_names, positions):
        instance(scene, asset_name, position)
    instance(scene, 'MeadowClearing', (0, 0, -.14), 3)
    camera(scene, (7, -12, 8), target, ortho=ortho)
    return scene


def validate_source():
    result = []
    candidates = [o for o in bpy.data.objects if o.get('candidateStatus') and not o.name.endswith('_SetDress') and o.name in ASSETS]
    assert len(candidates) == 21, f'Expected 21 authored candidate assets, found {len(candidates)}'
    for obj in candidates:
        assert obj.type == 'MESH' and obj.data.polygons, obj.name
        assert obj.location.length < 1e-6, f'Nonzero native pivot: {obj.name}'
        assert all(abs(s - 1) < 1e-6 for s in obj.scale), obj.name
        assert abs(min(v.co.z for v in obj.data.vertices)) < .0001, f'Not floor pivot: {obj.name}'
        assert all(math.isfinite(c) for v in obj.data.vertices for c in v.co), obj.name
        assert obj.data.uv_layers.active and len(obj.data.uv_layers.active.data) == len(obj.data.loops), obj.name
        assert all(math.isfinite(c) for loop in obj.data.uv_layers.active.data for c in loop.uv), obj.name
        assert all(poly.area > 1e-10 for poly in obj.data.polygons), f'Degenerate face: {obj.name}'
        if obj.name in {'MeadowClearing', 'GentleHill', 'DistantRidge', 'FarHorizon'}:
            top = [p for p in obj.data.polygons if p.index < 1024]
            assert all(p.normal.z > 0 for p in top), f'Inverted terrain top normals: {obj.name}'
        assert obj.data.materials and all(m and m.use_nodes for m in obj.data.materials), obj.name
        assert all(m.node_tree.nodes.get('Principled BSDF') for m in obj.data.materials), obj.name
        triangles = sum(len(p.vertices) - 2 for p in obj.data.polygons)
        assert triangles <= 16000, f'Excessive mobile candidate mesh: {obj.name} ({triangles})'
        result.append(dict(name=obj.name, vertices=len(obj.data.vertices), triangles=triangles,
                           materials=[m.name for m in obj.data.materials], colliderGuidance=obj['colliderGuidance'],
                           boundsMin=[min(v.co[i] for v in obj.data.vertices) for i in range(3)],
                           boundsMax=[max(v.co[i] for v in obj.data.vertices) for i in range(3)]))
    arch = bpy.data.objects['OpenStoneArch']
    bvh = BVHTree.FromPolygons([v.co for v in arch.data.vertices], [list(p.vertices) for p in arch.data.polygons])
    assert bvh.ray_cast(Vector((0, -2, .8)), Vector((0, 1, 0)), 4)[0] is None, 'Arch center hole blocked'
    assert bvh.ray_cast(Vector((1.18, -2, .3)), Vector((0, 1, 0)), 4)[0] is not None, 'Arch side must occlude'
    assert all(name in bpy.data.scenes for name in ['Preview_ClearMeadow', 'Preview_FlowerHills', 'Preview_StoneHills']), 'Missing assembled landscape previews'
    return result


def verify_fbx_roundtrip(names):
    """Read the actual exported bytes; source mesh checks alone cannot validate FBX."""
    scene = bpy.data.scenes.new('TemporaryFBXVerification')
    bpy.context.window.scene = scene
    results = []
    for name in names:
        previous = set(bpy.data.objects)
        bpy.ops.import_scene.fbx(filepath=str(EXPORT / (name + '.fbx')))
        imported = set(bpy.data.objects) - previous
        imported_meshes = [o for o in imported if o.type == 'MESH']
        assert len(imported_meshes) == 1, f'FBX must contain one mesh: {name}'
        obj = imported_meshes[0]
        native = ASSETS[name]
        points = [obj.matrix_world @ v.co for v in obj.data.vertices]
        for axis in range(3):
            expected_min = min(v.co[axis] for v in native.data.vertices)
            expected_max = max(v.co[axis] for v in native.data.vertices)
            assert abs(min(p[axis] for p in points) - expected_min) < .005, f'FBX axis/pivot min mismatch: {name}'
            assert abs(max(p[axis] for p in points) - expected_max) < .005, f'FBX axis/scale max mismatch: {name}'
        assert obj.data.uv_layers.active, f'FBX UV lost: {name}'
        assert len(obj.data.materials) == len(native.data.materials), f'FBX material slots lost: {name}'
        results.append(dict(asset=name, importedMeshCount=1, worldBoundsMatchNative=True,
                            uvPresent=True, materialSlots=len(obj.data.materials)))
        for item in imported:
            bpy.data.objects.remove(item, do_unlink=True)
    bpy.data.scenes.remove(scene)
    bpy.context.window.scene = bpy.data.scenes['Preview_ClearMeadow']
    return results


def file_record(path):
    return dict(path=path.relative_to(ROOT).as_posix(), bytes=path.stat().st_size,
                sha256=hashlib.sha256(path.read_bytes()).hexdigest())


def organize_collections(library, scenes):
    terrain_names = {'MeadowClearing', 'GentleHill', 'DistantRidge', 'FarHorizon'}
    tree_names = {'RoundCanopyTree', 'SageCanopyTree', 'TallWindTree'}
    stone_names = {'RoundLimestone', 'SlateBoulder', 'LowLimestone', 'PebbleScatter', 'OpenStoneArch', 'MossStoneSteps'}
    for scene in [library] + scenes:
        groups = {}
        for obj in list(scene.objects):
            name = obj.name.split('_SetDress')[0]
            group = ('01_Terrain' if name in terrain_names else '02_Trees' if name in tree_names else
                     '04_StoneDiscovery' if name in stone_names else '03_SmallVegetation' if obj.type == 'MESH' else '05_LightingCameraLabels')
            if group not in groups:
                collection = bpy.data.collections.new(scene.name + '_' + group)
                scene.collection.children.link(collection)
                groups[group] = collection
            groups[group].objects.link(obj)
            for collection in list(obj.users_collection):
                if collection != groups[group]:
                    collection.objects.unlink(obj)


def verify_existing(review):
    blend = SOURCE / 'MeadowCandidates.blend'
    assert blend.is_file(), f'Missing native source: {blend}'
    manifest_path = SOURCE / 'provenance.json'
    assert manifest_path.is_file(), f'Missing provenance: {manifest_path}'
    manifest = json.loads(manifest_path.read_text(encoding='utf-8'))
    for record in manifest['files']:
        path = ROOT / record['path']
        assert path.is_file(), f'Missing resource: {path}'
        assert path.stat().st_size == record['bytes'], f'Byte mismatch: {path}'
        assert hashlib.sha256(path.read_bytes()).hexdigest() == record['sha256'], f'Hash mismatch: {path}'
    bpy.ops.wm.open_mainfile(filepath=str(blend))
    for obj in bpy.data.objects:
        if obj.name in manifest['assetNames']:
            ASSETS[obj.name] = obj
    meshes = validate_source()
    for name in manifest['assetNames']:
        path = EXPORT / (name + '.fbx')
        assert path.is_file() and path.stat().st_size > 8000, f'Missing/empty export: {path}'
    for name in manifest['reviewRenders']:
        path = review / name
        assert path.is_file() and path.stat().st_size > 10000, f'Missing review render: {path}'
    roundtrip = verify_fbx_roundtrip(manifest['assetNames'])
    report = dict(status='PASS', sourceReopened=True, meshContracts=meshes, fbxRoundtrip=roundtrip,
                  resourcesAndHashesChecked=len(manifest['files']),
                  archHoleRayPass=True, archSideRayOccludes=True,
                  unityImportAndGameplay='NOT_RUN; user candidate review required')
    (review / 'source-verification.json').write_text(json.dumps(report, indent=2), encoding='utf-8')
    print('MEADOW_VERIFY_PASS ' + json.dumps(dict(assets=len(meshes), sourceReopened=True, resources=len(manifest['files']))))


def main():
    argv = sys.argv[sys.argv.index('--') + 1:] if '--' in sys.argv else []
    parser = argparse.ArgumentParser()
    parser.add_argument('--review-dir', type=Path, default=DEFAULT_REVIEW)
    parser.add_argument('--verify-only', action='store_true')
    args = parser.parse_args(argv)
    review = args.review_dir.resolve()
    assert not any(p.resolve() == review or p.resolve() in review.parents for p in [SOURCE, EXPORT]), 'Review renders must not overwrite authored source or FBX export folders'
    review.mkdir(parents=True, exist_ok=True)
    if args.verify_only:
        verify_existing(review)
        return
    SOURCE.mkdir(parents=True, exist_ok=True)
    EXPORT.mkdir(parents=True, exist_ok=True)
    bpy.ops.wm.read_factory_settings(use_empty=True)
    library = bpy.context.scene
    library.name = 'AssetLibrary_21NativeCandidates'
    library.unit_settings.system = 'METRIC'
    library.unit_settings.scale_length = 1
    collection = bpy.data.collections.new('Meadow_NativeAssetLibrary')
    library.collection.children.link(collection)
    bpy.context.view_layer.active_layer_collection = bpy.context.view_layer.layer_collection.children[collection.name]
    build_assets()
    previews = [landscape('Preview_ClearMeadow', 0), landscape('Preview_FlowerHills', 1), landscape('Preview_StoneHills', 2)]
    catalogs = [
        catalog_scene('Catalog_TerrainDiscovery', ['MeadowClearing', 'GentleHill', 'DistantRidge', 'FarHorizon', 'OpenStoneArch', 'MossStoneSteps']),
        catalog_scene('Catalog_TreesShrubs', ['RoundCanopyTree', 'SageCanopyTree', 'TallWindTree', 'MintShrub', 'SageShrub', 'FernCluster']),
        catalog_scene('Catalog_FlowersGrass', ['DaisyColony', 'PinkCosmosColony', 'LavenderLupineColony', 'GrassTuftMint', 'GrassTuftGold']),
        catalog_scene('Catalog_RockPlanes', ['RoundLimestone', 'SlateBoulder', 'LowLimestone', 'PebbleScatter']),
        closeup_scene('Closeup_BranchesAndLeaves', ['RoundCanopyTree', 'FernCluster', 'SageShrub'], [(0, 0, 0), (-1.4, -.9, 0), (1.6, .6, 0)], (0, 0, 1.95), 9.6),
        closeup_scene('Closeup_PetalsStemsLeaves', ['DaisyColony', 'PinkCosmosColony', 'LavenderLupineColony'], [(-1, 0, 0), (.5, .15, 0), (1.6, .5, 0)], (.2, 0, .6), 4.4),
        closeup_scene('Closeup_OpenArchAndTerraces', ['OpenStoneArch', 'MossStoneSteps', 'SlateBoulder'], [(-1.5, .4, 0), (1.5, 0, 0), (2.1, 1.5, 0)], (0, .4, .8), 8),
    ]
    mesh_report = validate_source()
    organize_collections(library, previews + catalogs)
    bpy.context.window.scene = library
    for name, obj in ASSETS.items():
        bpy.ops.object.select_all(action='DESELECT')
        obj.select_set(True)
        bpy.context.view_layer.objects.active = obj
        bpy.ops.export_scene.fbx(filepath=str(EXPORT / (name + '.fbx')), **SETTINGS)
        print('EXPORTED ' + name)
    # Asset library objects stay at their native pivots. Separate linked preview scenes
    # provide layout without sacrificing reusable asset transforms.
    bpy.context.window.scene = previews[0]
    bpy.context.preferences.filepaths.save_version = 0
    blend = SOURCE / 'MeadowCandidates.blend'
    bpy.ops.wm.save_as_mainfile(filepath=str(blend))
    render_names, render_records = [], []
    for scene in previews + catalogs:
        filename = scene.name + '.png'
        scene.render.filepath = str(review / filename)
        bpy.ops.render.render(write_still=True, scene=scene.name)
        assert (review / filename).is_file(), f'Render not saved: {filename}'
        render_names.append(filename)
        render_records.append(dict(file=filename, scene=scene.name, frame=scene.frame_current,
                                   source=file_record(blend), camera=scene.camera.name,
                                   cameraLocation=list(scene.camera.location), cameraEuler=list(scene.camera.rotation_euler),
                                   cameraType=scene.camera.data.type, lens=scene.camera.data.lens,
                                   orthoScale=scene.camera.data.ortho_scale,
                                   resolution=[scene.render.resolution_x, scene.render.resolution_y],
                                   engine=scene.render.engine, device=scene.cycles.device,
                                   samples=scene.cycles.samples, denoise=scene.cycles.use_denoising,
                                   bytes=(review / filename).stat().st_size,
                                   sha256=hashlib.sha256((review / filename).read_bytes()).hexdigest()))
        print('REVIEW_RENDER ' + filename)
    files = [file_record(blend), file_record(Path(__file__))] + [file_record(EXPORT / (name + '.fbx')) for name in sorted(ASSETS)]
    manifest = dict(schemaVersion=1, status='CANDIDATE_USER_REVIEW_REQUIRED_NOT_ADOPTED',
                    creator='MagnetismHeroes project-authored native Blender geometry via tools/models/build_meadow.py',
                    license='Self-created project artwork; no third-party mesh or texture assets; no copied reference characters, guns, UI, or composition',
                    reference='cartoon-landscape.png viewed only for cyan sky, rounded nature, pastel vegetation, warm soft daylight',
                    tool='Blender ' + bpy.app.version_string, toolBuildHash=bpy.app.build_hash.decode(),
                    source='SourceAssets/Models/Meadow/MeadowCandidates.blend',
                    coordinateConvention='meters Z-up native; FBX -Z forward/Y-up; applied unit scale; floor pivots; later Unity globalScale=1 bakeAxisConversion=true and preserve imported root rotation',
                    exportSettings={k: sorted(v) if isinstance(v, set) else v for k, v in SETTINGS.items()},
                    materialTransfer='native named material slots; constant Base Color and Roughness; UVMap; no Blender-only procedural surface or external texture dependency',
                    materials=[dict(name=m.name, authoredSRGB=list(m['authoredSRGB']), linearBaseColor=list(m.diffuse_color),
                                    roughness=m.node_tree.nodes.get('Principled BSDF').inputs['Roughness'].default_value) for m in MATERIALS.values()],
                    assetNames=sorted(ASSETS), meshContracts=mesh_report,
                    previewScenes=[s.name for s in previews], reviewRenders=render_names,
                    reviewState=dict(blender='native source contracts and saved review renders; visual inspection recorded separately',
                                     userApproval='PENDING', unityImport='NOT_RUN', gameplayDiscovery='NOT_RUN', mobilePerformance='NOT_RUN'), files=files)
    (SOURCE / 'provenance.json').write_text(json.dumps(manifest, indent=2, ensure_ascii=False) + '\n', encoding='utf-8')
    (review / 'render-manifest.json').write_text(json.dumps(render_records, indent=2) + '\n', encoding='utf-8')
    verify_existing(review)


if __name__ == '__main__':
    main()