//! Main entry point for the Project Catalyst client.
//!
//! This crate handles window creation, input processing, and drives the
//! renderer to display the game world.

use anyhow::{Context, Result};
use raw_window_handle::{HasDisplayHandle, HasWindowHandle};
use tracing::info;
use winit::application::ApplicationHandler;
use winit::event::WindowEvent;
use winit::event_loop::{ActiveEventLoop, ControlFlow, EventLoop};
use winit::window::{Window, WindowId};

#[derive(Default)]
struct App {
    window: Option<Window>,
    renderer: Option<renderer::Renderer>,
}

impl ApplicationHandler for App {
    fn resumed(&mut self, event_loop: &ActiveEventLoop) {
        let attributes = Window::default_attributes().with_title("Project Catalyst");

        self.window = Some(event_loop.create_window(attributes).unwrap());

        let display_handle = event_loop
            .display_handle()
            .expect("Failed to get display handle")
            .as_raw();

        // Get the window handle for surface creation
        let window_handle = self
            .window
            .as_ref()
            .unwrap()
            .window_handle()
            .expect("Failed to get window handle")
            .as_raw();

        let required_extensions = ash_window::enumerate_required_extensions(display_handle)
            .expect("Failed to enumerate required extensions");

        let size = self.window.as_ref().unwrap().inner_size();
        let renderer = renderer::Renderer::new(
            display_handle,
            window_handle,
            size.width,
            size.height,
            required_extensions,
        )
        .expect("Failed to initialize Vulkan renderer");

        self.renderer = Some(renderer);
    }

    fn window_event(&mut self, event_loop: &ActiveEventLoop, _id: WindowId, event: WindowEvent) {
        match event {
            WindowEvent::CloseRequested => {
                event_loop.exit();
            }
            WindowEvent::RedrawRequested => {
                if let Some(renderer) = self.renderer.as_mut() {
                    renderer.draw_frame().expect("Failed to draw frame");
                }

                if let Some(window) = self.window.as_ref() {
                    window.request_redraw();
                }
            }
            _ => (),
        }
    }
}

fn main() -> Result<()> {
    tracing_subscriber::fmt()
        .with_env_filter(tracing_subscriber::EnvFilter::from_default_env())
        .init();
    info!("Starting Project Catalyst client");

    let event_loop = EventLoop::new().context("Failed to create event loop")?;

    event_loop.set_control_flow(ControlFlow::Poll);

    let mut app = App::default();
    event_loop
        .run_app(&mut app)
        .context("Failed to run event loop")?;
    Ok(())
}