use std::sync::Arc;
use winit::event_loop::EventLoop;
use winit::window::WindowBuilder;
use wsg_lib::conf;
use wsg_lib::context::Context;
use wsg_lib::frame::Frame; // Import nécessaire
use wsg_lib::material::Material;
use wsg_lib::mesh::Mesh;
use wsg_lib::pipeline_cache::PipelineCache;
use wsg_lib::renderer::Renderer;
use wsg_lib::vertex::Vertex;

fn main() {
    let event_loop = EventLoop::new().unwrap();
    let window = Arc::new(WindowBuilder::new().build(&event_loop).unwrap());

    // 1. Initialisation
    let context = pollster::block_on(Context::new(window.clone())).expect("Échec init GPU");

    // Configuration de la surface et récupération du format
    let format = context
        .configure(&context.adapter, 800, 600)
        .expect("Échec configuration");

    // 2. Initialisation du Renderer (Il récupère tout ce dont il a besoin)
    let mut cache = PipelineCache::new();
    cache.register_shader("basic", conf::BASIC_SHADER).unwrap();

    let renderer = Renderer::new(&context, format);

    // 3. Material : On utilise renderer.device() et renderer.format()
    let material = Material::new(renderer.device(), renderer.format(), "basic", &mut cache);

    // Mesh : On utilise le device du renderer
    let vertices = [ /* ... tes sommets ... */ ];
    let indices: [u16; 6] = [0, 1, 2, 0, 2, 3];
    let mesh = Mesh::new(renderer.device(), &vertices, Some(&indices));

    // Render loop
    event_loop
        .run(|event, elwt| {
            match event {
                winit::event::Event::AboutToWait => {
                    window.request_redraw();
                }
                winit::event::Event::WindowEvent {
                    event: winit::event::WindowEvent::RedrawRequested,
                    ..
                } => {
                    if let Some(frame) = Frame::try_new(&context.surface) {
                        // 1. Rendu (plus d'arguments device/queue inutiles)
                        renderer.render(frame.view(), &mesh, &material);

                        // 2. Présentation
                        renderer.present(frame);
                    }
                }
                _ => (),
            }
        })
        .unwrap();
}