use helio::{
    required_wgpu_features, required_wgpu_limits,
    Camera, Renderer, RendererConfig, ShadowQuality,
};

// Pass these to request_device so the required extensions are available.
let features = required_wgpu_features(adapter.features());
let limits   = required_wgpu_limits(adapter.limits());

let mut renderer = Renderer::new(
    device.clone(),
    queue.clone(),
    RendererConfig::new(width, height, surface_format),
);

renderer.set_editor_mode(true);                     // enable grid + editor icons
renderer.set_clear_color([0.08, 0.09, 0.12, 1.0]);
renderer.set_ambient([0.12, 0.14, 0.18], 0.25);

use helio::{
    Camera, GpuMaterial, GroupMask, Movability, MeshUpload,
    ObjectDescriptor, PackedVertex, SceneActor,
};
use glam::{Mat4, Vec3};

// 1. Upload a mesh (returns SceneActorId::Mesh — call .as_mesh() for the MeshId).
let mesh_id = renderer
    .scene_mut()
    .insert_actor(SceneActor::mesh(MeshUpload { vertices, indices }))
    .as_mesh()
    .unwrap();

// 2. Create a PBR material.
let mat_id = renderer.scene_mut().insert_material(GpuMaterial {
    base_color:         [0.9, 0.15, 0.15, 1.0],
    emissive:           [0.0, 0.0, 0.0, 0.0],
    roughness_metallic: [0.5, 0.0, 1.5, 0.5],
    tex_base_color:     GpuMaterial::NO_TEXTURE,
    tex_normal:         GpuMaterial::NO_TEXTURE,
    tex_roughness:      GpuMaterial::NO_TEXTURE,
    tex_emissive:       GpuMaterial::NO_TEXTURE,
    tex_occlusion:      GpuMaterial::NO_TEXTURE,
    workflow: 0,
    flags:    0,
    _pad:     0,
});

let transform = Mat4::from_translation(Vec3::new(0.0, 1.0, -3.0));

// 3. Place an object in the scene.
let obj_id = renderer
    .scene_mut()
    .insert_actor(SceneActor::object(ObjectDescriptor {
        mesh:       mesh_id,
        material:   mat_id,
        transform,
        bounds:     [0.0, 1.0, -3.0, 1.5],   // [cx, cy, cz, radius]
        flags:      0,
        groups:     GroupMask::NONE,
        movability: Some(Movability::Movable),
    }))
    .as_object()
    .unwrap();

// 4. Add a point light.
let _light_id = renderer
    .scene_mut()
    .insert_actor(SceneActor::light(GpuLight {
        position_range:  [0.0, 4.0, 0.0, 20.0],
        direction_outer: [0.0, -1.0, 0.0, 0.0],
        color_intensity: [1.0, 0.9, 0.8, 12.0],
        shadow_index:    0,
        light_type:      LightType::Point as u32,
        inner_angle:     0.0,
        _pad:            0,
    }))
    .as_light()
    .unwrap();

// 5. Render.
let camera = Camera::perspective_look_at(eye, target, Vec3::Y, fov_y, aspect, 0.1, 1000.0);
renderer.render(&camera, &surface_view)?;

renderer.set_shadow_quality(ShadowQuality::Ultra);
renderer.set_render_size(width, height);
renderer.set_clear_color([0.05, 0.05, 0.08, 1.0]);
renderer.set_ambient([0.12, 0.14, 0.18], 0.25);
renderer.set_editor_mode(true);    // enables grid + billboarded light icons
renderer.set_debug_mode(0);        // 0=off  10=shadow heatmap  11=light depth

use helio::{MeshUpload, PackedVertex, SceneActor};

// Build a MeshUpload from packed vertices + u32 indices.
let upload = MeshUpload { vertices: vec![...], indices: vec![0, 1, 2] };

// Upload — returns SceneActorId; use .as_mesh() for the stable MeshId.
let mesh_id = renderer
    .scene_mut()
    .insert_actor(SceneActor::mesh(upload))
    .as_mesh()
    .unwrap();

// Remove
renderer.scene_mut().remove_mesh(mesh_id)?;

use helio::GpuMaterial;

let mat_id = renderer.scene_mut().insert_material(GpuMaterial {
    base_color:         [0.55, 0.55, 0.55, 1.0],  // linear RGBA
    emissive:           [0.0, 0.0, 0.0, 0.0],     // xyz=color, w=strength
    roughness_metallic: [0.8, 0.0, 1.5, 0.5],     // roughness, metallic, IOR, specular_tint
    tex_base_color:     GpuMaterial::NO_TEXTURE,
    tex_normal:         GpuMaterial::NO_TEXTURE,
    tex_roughness:      GpuMaterial::NO_TEXTURE,
    tex_emissive:       GpuMaterial::NO_TEXTURE,
    tex_occlusion:      GpuMaterial::NO_TEXTURE,
    workflow: 0,   // 0 = Metallic-Roughness
    flags:    0,   // bit0=double-sided  bit1=alpha-blend  bit2=alpha-test
    _pad:     0,
});

renderer.scene_mut().update_material(mat_id, updated_material)?;
renderer.scene_mut().remove_material(mat_id)?;

use helio::TextureUpload;

let tex_id = renderer.scene_mut().insert_texture(TextureUpload {
    data:   rgba_bytes,
    width:  1024,
    height: 1024,
    format: wgpu::TextureFormat::Rgba8UnormSrgb,
})?;

renderer.scene_mut().remove_texture(tex_id)?;

use helio::{GpuLight, LightType, SceneActor};

let light_id = renderer
    .scene_mut()
    .insert_actor(SceneActor::light(GpuLight {
        position_range:  [2.0, 3.0, 0.0, 15.0],      // xyz=pos, w=range (m)
        direction_outer: [0.0, -1.0, 0.0, 0.0],
        color_intensity: [1.0, 0.85, 0.6, 80.0],     // xyz=linear sRGB, w=intensity
        shadow_index:    0,                            // 0=shadowed, u32::MAX=shadowless
        light_type:      LightType::Point as u32,
        inner_angle:     0.0,
        _pad:            0,
    }))
    .as_light()
    .unwrap();

renderer.scene_mut().update_light(light_id, updated_gpu_light)?;
renderer.scene_mut().remove_light(light_id)?;

use helio::{GroupMask, Movability, ObjectDescriptor, SceneActor};

let obj_id = renderer
    .scene_mut()
    .insert_actor(SceneActor::object(ObjectDescriptor {
        mesh:       mesh_id,
        material:   mat_id,
        transform:  Mat4::from_translation(Vec3::new(1.0, 0.0, -2.0)),
        bounds:     [1.0, 0.0, -2.0, 1.2],  // [cx, cy, cz, radius]
        flags:      0,
        groups:     GroupMask::NONE,
        movability: Some(Movability::Movable),
    }))
    .as_object()
    .unwrap();

renderer.scene_mut().update_object_transform(obj_id, new_transform)?;
renderer.scene_mut().remove_object(obj_id)?;

use helio::{Movability, SectionedMeshUpload};
use helio_asset_compat::{
    load_scene_bytes_with_config, upload_sectioned_scene, LoadConfig,
};

// Load an FBX with merge_meshes=true to produce a ConvertedSectionedMesh.
let scene = load_scene_bytes_with_config(
    include_bytes!("model.fbx"),
    "fbx",
    None,
    LoadConfig::default()
        .with_merge_meshes(true)
        .with_import_scale(glam::Vec3::splat(1.0 / 100.0)),
)?;

// Upload textures, materials, and the shared vertex buffer in one call.
let (multi_mesh_id, section_mat_ids) = upload_sectioned_scene(&mut renderer, &scene)?;

// Place an instance — returns a Copy SectionedInstanceId handle.
let sm = scene.sectioned_mesh.as_ref().unwrap();
let inst_id = renderer.scene_mut().insert_sectioned_object(
    multi_mesh_id,
    &section_mat_ids,
    glam::Mat4::IDENTITY,           // world transform
    [0.0, 0.0, 0.0, 2.0],          // bounding sphere [cx, cy, cz, radius]
    Some(Movability::Movable),
)?;

// Move the whole instance — all N sections update atomically (O(N sections)).
renderer.scene_mut().update_sectioned_object_transform(inst_id, new_transform)?;

// Register each section's geometry with the picker for accurate BVH ray-casting.
if let Some(section_ids) = renderer.scene().sectioned_section_mesh_ids(multi_mesh_id) {
    let section_ids: Vec<_> = section_ids.to_vec();
    for (section_mesh_id, sec) in section_ids.iter().zip(sm.sections.iter()) {
        picker.register_mesh(*section_mesh_id, &helio::MeshUpload {
            vertices: sm.vertices.clone(),
            indices:  sec.indices.clone(),
        });
    }
}

// Remove
renderer.scene_mut().remove_sectioned_object(inst_id)?;

renderer.add_pass(Box::new(MyPass::new(&device)));
renderer.use_default_graph();   // resets to built-in deferred pipeline

use helio::Camera;
use glam::Vec3;

let camera = Camera::perspective_look_at(
    Vec3::new(0.0, 2.0, 6.0),  // eye
    Vec3::ZERO,                  // target
    Vec3::Y,                     // up
    60_f32.to_radians(),         // fov_y
    width as f32 / height as f32,
    0.1, 1000.0,
);

pub struct ObjectDescriptor {
    pub mesh:       MeshId,
    pub material:   MaterialId,
    pub transform:  Mat4,
    pub bounds:     [f32; 4],            // [cx, cy, cz, radius] world-space bounding sphere
    pub flags:      u32,                 // reserved — pass 0
    pub groups:     GroupMask,           // GroupMask::NONE = always visible
    pub movability: Option<Movability>,  // None = static, Some(Movable) = dynamic
}

use helio::{GpuLight, LightType};

// Point light
GpuLight {
    position_range:  [x, y, z, range_metres],
    direction_outer: [0.0, -1.0, 0.0, 0.0],
    color_intensity: [r, g, b, intensity],
    shadow_index:    0,
    light_type:      LightType::Point as u32,
    inner_angle:     0.0,
    _pad:            0,
}

// Spot light
GpuLight {
    position_range:  [x, y, z, range],
    direction_outer: [dx, dy, dz, outer_angle.cos()],
    color_intensity: [r, g, b, intensity],
    shadow_index:    0,
    light_type:      LightType::Spot as u32,
    inner_angle:     inner_angle.cos(),
    _pad:            0,
}

// Directional light
GpuLight {
    position_range:  [0.0, 0.0, 0.0, f32::MAX],
    direction_outer: [dx, dy, dz, 0.0],
    color_intensity: [r, g, b, intensity],
    shadow_index:    0,
    light_type:      LightType::Directional as u32,
    inner_angle:     0.0,
    _pad:            0,
}

// Metallic-roughness PBR (workflow = 0)
GpuMaterial {
    base_color:         [r, g, b, a],        // linear RGBA
    emissive:           [r, g, b, strength],
    roughness_metallic: [roughness, metallic, ior, specular_tint],
    tex_base_color:     GpuMaterial::NO_TEXTURE,
    tex_normal:         GpuMaterial::NO_TEXTURE,
    tex_roughness:      GpuMaterial::NO_TEXTURE,
    tex_emissive:       GpuMaterial::NO_TEXTURE,
    tex_occlusion:      GpuMaterial::NO_TEXTURE,
    workflow: 0,
    flags:    0,   // bit0=double-sided  bit1=alpha-blend  bit2=alpha-test
    _pad:     0,
}

renderer.hide_group(GroupId::EDITOR);
renderer.show_group(GroupId::EDITOR);
renderer.is_group_hidden(GroupId::EDITOR);

renderer.scene_mut().set_object_groups(obj_id, GroupMask::NONE.with(GroupId::STATIC));
renderer.scene_mut().add_object_to_group(obj_id, GroupId::STATIC);
renderer.scene_mut().remove_object_from_group(obj_id, GroupId::STATIC);

// GPU-side mass transform — O(N objects in the group)
renderer.scene_mut().move_group(GroupId::DYNAMIC, Mat4::from_translation(delta));

// Bitmask composition
let mask = GroupMask::NONE
    .with(GroupId::STATIC)
    .with(GroupId::SHADOW_CASTERS);
mask.contains(GroupId::STATIC);
let combined = mask_a | mask_b;

renderer.set_shadow_quality(ShadowQuality::Ultra);

use helio::{SceneActor, VirtualObjectDescriptor};

let virt_id = renderer
    .scene_mut()
    .insert_actor(SceneActor::virtual_mesh(virtual_mesh_upload))
    .as_virtual_mesh()
    .unwrap();

let vobj_id = renderer
    .scene_mut()
    .insert_actor(SceneActor::virtual_object(VirtualObjectDescriptor {
        virtual_mesh: virt_id,
        material_id:  0,
        transform:    Mat4::IDENTITY,
        bounds:       [0.0, 0.0, 0.0, 2.0],
        flags:        0,
        groups:       GroupMask::NONE,
    }))
    .as_virtual_object()
    .unwrap();

use helio_asset_compat::{
    load_scene_file, load_scene_file_with_config,
    load_scene_bytes_with_config,
    upload_scene, upload_sectioned_scene,
    load_and_upload_scene, LoadConfig,
};

// Load from disk — format detected from extension (FBX, glTF, OBJ, USDC).
let scene = load_scene_file("assets/prop.fbx")?;

// Load from embedded bytes.
let scene = load_scene_bytes_with_config(
    include_bytes!("prop.fbx"),
    "fbx",
    None,                               // optional base dir for texture resolution
    LoadConfig::default()
        .with_uv_flip(false)
        .with_import_scale(glam::Vec3::splat(1.0 / 100.0)),
)?;

// Upload all meshes + materials in one pass → UploadedScene { mesh_ids, material_ids }
let uploaded = upload_scene(&mut renderer, &scene)?;

// Convenience: load + upload together.
let uploaded = load_and_upload_scene("assets/prop.fbx", LoadConfig::default(), &mut renderer)?;

// Sectioned (multi-material) upload — requires merge_meshes = true.
let scene = load_scene_file_with_config(
    "assets/prop.fbx",
    LoadConfig::default().with_merge_meshes(true),
)?;
let (multi_mesh_id, section_mat_ids) = upload_sectioned_scene(&mut renderer, &scene)?;

pub struct BillboardInstance {
    pub world_pos:   [f32; 4],  // xyz=world position
    pub scale_flags: [f32; 4],  // xy=width/height (metres), z>0.5=screen-space mode
    pub color:       [f32; 4],  // linear RGBA tint
}