use reactor::prelude::*;

struct MiJuego { rotacion: f32 }

impl ReactorApp for MiJuego {
    // ═══════════════════════════════════════════════════════════════
    // CONFIG — Una sola función para configurar TODO
    // ═══════════════════════════════════════════════════════════════
    fn config(&self) -> ReactorConfig {
        ReactorConfig::new("Mi Juego")
            .with_size(1920, 1080)
            .with_vsync(true)
            .with_msaa(4)
            .with_renderer(RendererMode::Forward)
    }

    // ═══════════════════════════════════════════════════════════════
    // INIT — Setup inicial (cámara, luces, objetos)
    // ═══════════════════════════════════════════════════════════════
    fn init(&mut self, ctx: &mut ReactorContext) {
        ctx.camera.position = Vec3::new(0.0, 2.0, 4.0);
        ctx.lighting.add_light(Light::directional(Vec3::NEG_Y, Vec3::ONE, 1.0));
        // Agregar objetos a la escena...
    }

    // ═══════════════════════════════════════════════════════════════
    // UPDATE — Lógica de juego cada frame
    // ═══════════════════════════════════════════════════════════════
    fn update(&mut self, ctx: &mut ReactorContext) {
        self.rotacion += ctx.time.delta();
        ctx.scene.objects[0].transform = Mat4::from_rotation_y(self.rotacion);
    }
    
    // render() es AUTOMÁTICO — no necesitas override
}

// ═══════════════════════════════════════════════════════════════════
// MAIN — UNA SOLA LÍNEA
// ═══════════════════════════════════════════════════════════════════
fn main() {
    reactor::run(MiJuego { rotacion: 0.0 });
}

use reactor::prelude::*;

let mut lighting = LightingSystem::with_sun();

// Agregar luz puntual
lighting.add_light(Light::point(
    Vec3::new(0.0, 5.0, 0.0),  // posición
    Vec3::new(1.0, 0.8, 0.6),  // color
    2.0,                        // intensidad
    20.0,                       // rango
));

// Agregar spotlight
lighting.add_light(Light::spot(
    Vec3::new(0.0, 10.0, 0.0), // posición
    Vec3::NEG_Y,               // dirección
    Vec3::ONE,                 // color
    5.0,                       // intensidad
    30.0,                      // rango
    45.0,                      // ángulo
));

// Efecto de fuego predefinido
let mut fire = ParticleSystem::fire();
fire.position = Vec3::new(0.0, 0.0, 0.0);

// Explosión
let mut explosion = ParticleSystem::explosion();
explosion.play();

// Sistema personalizado
let config = ParticleSystemConfig {
    emission_rate: 100.0,
    lifetime: RandomRange::new(1.0, 2.0),
    start_color: Vec4::new(0.0, 0.5, 1.0, 1.0),
    ..Default::default()
};
let custom = ParticleSystem::new(config);

// Tween simple
let mut tween = Tween::new(0.0, 100.0, 2.0)
    .with_easing(EasingFunction::EaseOutElastic);

// En el loop
let value = tween.update(delta_time);
if tween.is_finished() { /* ... */ }

// Sistema de animación completo
let mut player = AnimationPlayer::new();
player.add_clip(walk_animation);
player.play("walk");
let sample = player.update(delta_time);
sample.apply_to_transform(&mut transform);

// Crear mundo físico
let mut physics = PhysicsWorld::new();
physics.gravity = Vec3::new(0.0, -9.81, 0.0);

// Cuerpo rígido
let mut body = RigidBody::default();
body.add_force(Vec3::new(100.0, 0.0, 0.0));

// Raycasting
let ray = Ray::from_screen(mouse_x, mouse_y, width, height, inv_vp);
if let Some(t) = ray.intersects_aabb(&aabb) {
    let hit_point = ray.point_at(t);
}

// Frustum Culling
let mut culling = CullingSystem::new();
culling.update_frustum(view_projection);
for object in &scene.objects {
    if culling.is_visible_aabb(&object.bounds) {
        // Renderizar
    }
}
println!("Culled: {:.1}%", culling.cull_percentage());

// Preset cinematográfico
let post = PostProcessPipeline::with_preset(PostProcessPreset::Cinematic);

// Configuración manual
let mut settings = PostProcessSettings::default();
settings.enable_effect(PostProcessEffect::Bloom);
settings.enable_effect(PostProcessEffect::Vignette);
settings.bloom_intensity = 0.5;
settings.vignette_intensity = 0.3;

let mut debug = DebugRenderer::new();

// Dibujar líneas
debug.line(start, end, Vec4::new(1.0, 0.0, 0.0, 1.0));

// Dibujar AABB
debug.aabb(&DebugAABB { min, max }, Vec4::ONE);

// Dibujar ejes
debug.axes(origin, 1.0);

// Dibujar grid
debug.grid(Vec3::ZERO, 10.0, 10, Vec4::new(0.5, 0.5, 0.5, 1.0));

// Dibujar frustum de cámara
debug.frustum(inv_view_proj, Vec4::new(1.0, 1.0, 0.0, 1.0));

// Generar meshes procedurales
let (vertices, indices) = Primitives::cube();
let (vertices, indices) = Primitives::sphere(32, 16);
let (vertices, indices) = Primitives::plane(10);
let (vertices, indices) = Primitives::cylinder(32, 2.0, 0.5);
let (vertices, indices) = Primitives::cone(32, 2.0, 0.5);
let (vertices, indices) = Primitives::torus(32, 16, 1.0, 0.3);

let camera = Camera::perspective(45.0, aspect, 0.1, 1000.0)
    .look_at(eye, target, Vec3::Y);
let vp = camera.view_projection_matrix();

// Controles FPS
camera.rotate_yaw(mouse_delta.x * sensitivity);
camera.rotate_pitch(mouse_delta.y * sensitivity);
camera.move_forward(speed * delta);

use reactor::{IntelligentShadingRate, ISRConfig};

// Crear sistema ISR
let mut isr = IntelligentShadingRate::new(1920, 1080);

// Configurar presets
isr.config = IntelligentShadingRate::preset_performance(); // Máximo ahorro
isr.config = IntelligentShadingRate::preset_quality();     // Máxima calidad
isr.config = IntelligentShadingRate::preset_vr();          // VR con foveated

// Calcular importancia de un punto
let importance = isr.calculate_importance(
    world_pos, normal, prev_pos, camera_pos, sdf_distance
);

// Obtener tamaño de pixel adaptativo
let pixel_size = isr.get_adaptive_pixel_size(screen_x, screen_y);

// Estadísticas
let stats = isr.stats();
println!("GPU Savings: {:.1}%", stats.savings_percent * 100.0);

use reactor::{sd_sphere, sd_box, op_smooth_union, calc_normal};

// Primitivas SDF
let sphere = sd_sphere(point, 1.0);
let cube = sd_box(point, Vec3::splat(0.5));

// Operaciones CSG
let merged = op_smooth_union(sphere, cube, 0.3);

// Calcular normal
let normal = calc_normal(point, |p| scene_sdf(p));

use reactor::{RayMarcher, SDFScene, SDFPrimitive};

// Crear escena SDF
let mut scene = SDFScene::new();
scene.add(SDFPrimitive::sphere(Vec3::ZERO, 1.0).with_color(Vec4::new(1.0, 0.0, 0.0, 1.0)));
scene.add(SDFPrimitive::cube(Vec3::new(2.0, 0.0, 0.0), Vec3::splat(0.5)));

// Ray marcher
let ray_marcher = RayMarcher::new();
let hit = ray_marcher.march(&scene, ray_origin, ray_direction);

if hit.hit {
    let color = ray_marcher.shade(&scene, &hit);
}

use reactor::{SDFAntiAliasing, AAComparison};

let aa = SDFAntiAliasing::new();

// Calcular alpha de AA desde SDF
let alpha = aa.compute_aa(sdf_value, screen_derivative);

// Comparar métodos
AAComparison::print_comparison();
// ╔═══════════════════════════════════════════════════════════════════╗
// ║ Method            ║ Quality ║ Perf Cost║ Memory ║ Ghost   ║ Blur  ║
// ╠═══════════════════╬═════════╬══════════╬════════╬═════════╬═══════╣
// ║ SDF-AA (ADead)    ║  98.0%  ║    5.0%  ║   0MB  ║ No      ║ No    ║
// ║ MSAA 4x           ║  85.0%  ║   40.0%  ║  32MB  ║ No      ║ No    ║
// ║ FXAA              ║  70.0%  ║   10.0%  ║   0MB  ║ No      ║ Yes   ║
// ║ TAA               ║  88.0%  ║   15.0%  ║  16MB  ║ Yes     ║ Yes   ║
// ║ DLSS 2.0          ║  85.0%  ║   20.0%  ║  64MB  ║ Yes     ║ Yes   ║
// ╚═══════════════════╩═════════╩══════════╩════════╩═════════╩═══════╝

use reactor::{HybridRenderer, RenderMode, LODLevel};

let mut renderer = HybridRenderer::new(1920, 1080);

// Agregar objetos SDF
renderer.add_sphere("Sun", Vec3::new(0.0, 5.0, 0.0), 1.0, Vec4::new(1.0, 0.9, 0.0, 1.0));
renderer.add_cube("Building", Vec3::new(5.0, 0.0, 0.0), Vec3::new(1.0, 3.0, 1.0), Vec4::ONE);

// Actualizar (calcula LOD automáticamente)
renderer.update(camera_pos, delta_time);

// Benchmark vs DLSS
let benchmark = ADeadBenchmark::run("City Scene", &mut renderer, 16.6);
benchmark.compare_with_dlss();