"""Cloud Blender render: stills + 13s flythrough for one site, from the lite mesh.
Runs on x86 GPU (Cycles OptiX/CUDA). Usage: blender -b -P render_cloud.py -- <site>"""
import bpy, math, os, sys
from mathutils import Vector

BASE = os.environ.get("RENDER_BASE", "/workspace")
argv = sys.argv[sys.argv.index("--") + 1:]
SITE = argv[0]
PLY = os.path.join(BASE, "meshes", f"{SITE}_crop.ply")
OUT = os.path.join(BASE, "out", SITE)
os.makedirs(OUT, exist_ok=True)
FPS, SECONDS = 24, 10
N = FPS * SECONDS

bpy.ops.object.select_all(action="SELECT")
bpy.ops.object.delete()
bpy.ops.wm.ply_import(filepath=PLY)
ob = bpy.context.selected_objects[0]

bb = [ob.matrix_world @ Vector(c) for c in ob.bound_box]
center = sum(bb, Vector()) / 8
dims = Vector((max(v.x for v in bb) - min(v.x for v in bb),
               max(v.y for v in bb) - min(v.y for v in bb),
               max(v.z for v in bb) - min(v.z for v in bb)))
size = max(dims.x, dims.y)
print(f"{SITE}: verts={len(ob.data.vertices)} size={size:.2f}")

mat = bpy.data.materials.new("m"); mat.use_nodes = True
nt = mat.node_tree
bsdf = nt.nodes["Principled BSDF"]
attr = nt.nodes.new("ShaderNodeVertexColor")
if ob.data.color_attributes:
    attr.layer_name = ob.data.color_attributes[0].name
nt.links.new(attr.outputs["Color"], bsdf.inputs["Base Color"])
nt.links.new(attr.outputs["Color"], bsdf.inputs["Emission Color"])
bsdf.inputs["Emission Strength"].default_value = 0.85
if SITE == "williams_tower":
    bsdf.inputs["Roughness"].default_value = 0.15
    bsdf.inputs["Metallic"].default_value = 0.4
    bsdf.inputs["Emission Strength"].default_value = 0.65
else:
    bsdf.inputs["Roughness"].default_value = 0.9
ob.data.materials.clear(); ob.data.materials.append(mat)

world = bpy.data.worlds.new("sky"); world.use_nodes = True
bg = world.node_tree.nodes["Background"]
bg.inputs[0].default_value = (0.55, 0.66, 0.82, 1.0)
bg.inputs[1].default_value = 0.8
bpy.context.scene.world = world
sun = bpy.data.objects.new("sun", bpy.data.lights.new("s", "SUN"))
sun.data.energy = 2.0; sun.rotation_euler = (0.85, 0.15, 2.2)
bpy.context.collection.objects.link(sun)

target = bpy.data.objects.new("t", None)
target.location = center + Vector((0, 0, dims.z * 0.12))
bpy.context.collection.objects.link(target)
cam = bpy.data.objects.new("cam", bpy.data.cameras.new("c"))
cam.data.lens = 32
bpy.context.collection.objects.link(cam)
tr = cam.constraints.new("TRACK_TO"); tr.target = target
sc = bpy.context.scene
sc.camera = cam

orad = size * 0.55
oalt = center.z + dims.z * 0.55
sc.frame_start, sc.frame_end = 1, N
for f in range(1, N + 1):
    th = math.radians(-135) + 2 * math.pi * (f - 1) / N
    cam.location = (center.x + orad * math.cos(th), center.y + orad * math.sin(th), oalt)
    cam.keyframe_insert("location", frame=f)

sc.view_settings.view_transform = "Standard"
sc.render.engine = "CYCLES"
sc.render.use_persistent_data = True
sc.cycles.samples = 24
sc.cycles.use_denoising = True
sc.render.resolution_x = 1600
sc.render.resolution_y = 900

prefs = bpy.context.preferences.addons["cycles"].preferences
dev_ok = False
for dtype in ("OPTIX", "CUDA"):
    try:
        prefs.compute_device_type = dtype
        prefs.get_devices()
        if any(d.type == dtype for d in prefs.devices):
            for d in prefs.devices: d.use = True
            sc.cycles.device = "GPU"
            dev_ok = True
            print("cycles device:", dtype)
            break
    except Exception as e:
        print(dtype, "unavailable:", e)
if not dev_ok:
    print("WARNING: rendering on CPU")

# stills: hero / high / low (failure floor)
views = [("hero", orad, oalt), ("high", orad * 1.15, center.z + dims.z * 1.1),
         ("low", orad * 0.45, center.z + dims.z * 0.12)]
sc.render.image_settings.file_format = "PNG"
for name, r, alt in views:
    cam.location = (center.x + r * math.cos(math.radians(-120)),
                    center.y + r * math.sin(math.radians(-120)), alt)
    sc.render.filepath = os.path.join(OUT, f"still_{name}.png")
    bpy.ops.render.render(write_still=True)
    print("STILL", name, flush=True)

os.system(f"hf upload portneymk/city3d {OUT} renders/{SITE} --repo-type dataset")
print("STILLS-UPLOADED", flush=True)

# flythrough: straight to H.264
sc.render.image_settings.file_format = "FFMPEG"
sc.render.ffmpeg.format = "MPEG4"
sc.render.ffmpeg.codec = "H264"
sc.render.ffmpeg.constant_rate_factor = "HIGH"
sc.render.ffmpeg.ffmpeg_preset = "GOOD"
sc.render.fps = FPS
sc.render.filepath = os.path.join(OUT, f"{SITE}_flythrough.mp4")
bpy.ops.render.render(animation=True)
print(f"FLYTHROUGH-DONE {SITE}")