use std::sync::Arc;
use winit::event_loop::EventLoop;
use winit::window::WindowBuilder;
use wsg_lib::core::Context;
use wsg_lib::core::Frame;
use wsg_lib::core::Renderer;
use wsg_lib::pipeline::PipelineCache;
use wsg_lib::resources::Material;
use wsg_lib::resources::Mesh;
use wsg_lib::resources::Vertex;
use wsg_lib::utils;

fn main() {
    println!(
        "Répertoire courant : {:?}",
        std::env::current_dir().unwrap()
    );
    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 device = Arc::new(context.device.clone());
    let mut cache = PipelineCache::new(device);
    cache
        .register_shader("basic", utils::BASIC_SHADER_PATH)
        .unwrap();

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

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

    // Mesh : On utilise le device du renderer
    let vertices = [
        // Position (x,y,z) | Normale (x,y,z) | UV (u,v) | Couleur (r,g,b,a)
        Vertex {
            position: [-0.5, 0.5, 0.0],
            normal: [0.0, 0.0, 1.0],
            uv: [0.0, 0.0],
            color: [1.0, 0.0, 0.0, 1.0],
        }, // Haut-Gauche (Rouge)
        Vertex {
            position: [0.5, 0.5, 0.0],
            normal: [0.0, 0.0, 1.0],
            uv: [1.0, 0.0],
            color: [0.0, 1.0, 0.0, 1.0],
        }, // Haut-Droite (Vert)
        Vertex {
            position: [0.5, -0.5, 0.0],
            normal: [0.0, 0.0, 1.0],
            uv: [1.0, 1.0],
            color: [0.0, 0.0, 1.0, 1.0],
        }, // Bas-Droite (Bleu)
        Vertex {
            position: [-0.5, -0.5, 0.0],
            normal: [0.0, 0.0, 1.0],
            uv: [0.0, 1.0],
            color: [1.0, 1.0, 0.0, 1.0],
        }, // Bas-Gauche (Jaune)
    ];
    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);
                    }
                }
                winit::event::Event::WindowEvent {
                    event: winit::event::WindowEvent::CloseRequested,
                    ..
                } => {
                    elwt.exit(); // C'est ici que tu demandes à la boucle de s'arrêter
                }
                _ => (),
            }
        })
        .unwrap();
}