use std::time::{Duration, Instant};

use gemini_engine::{
    elements::{
        containers::CanShade,
        view::{ScaleFitView, Wrapping},
    },
    elements3d::{DisplayMode, Mesh3D, Transform3D, Viewport},
    gameloop::{sleep_fps, MainLoopRoot},
};

mod debug_manager;
pub use debug_manager::DebugManager;

#[allow(dead_code)]
pub struct Root {
    canvas: ScaleFitView,
    viewport: Viewport,
    models: Vec<Mesh3D>,
    display_mode: DisplayMode,
    shader: Box<dyn CanShade>,
    // Debug
    debug_manager: DebugManager,
}

impl Root {
    pub fn new(
        canvas: ScaleFitView,
        fov: f64,
        initial_viewport_transform: Transform3D,
        models: Vec<Mesh3D>,
        display_mode: DisplayMode,
        shader: impl CanShade + 'static,
        debug_manager: DebugManager,
    ) -> Self {
        let viewport_center = canvas.intended_size() / 2;

        let models = models
            .into_iter()
            .map(|m| {
                let mut m = m;
                m.transform *= -initial_viewport_transform;
                m
            })
            .collect();

        Self {
            canvas,
            viewport: Viewport::new(Transform3D::default(), fov, viewport_center),
            models,
            display_mode,
            shader: Box::new(shader),
            debug_manager,
        }
    }
}

impl MainLoopRoot for Root {
    type InputDataType = u8;

    fn frame(&mut self, _input_data: Option<Self::InputDataType>) {
        for model in &mut self.models {
            model.transform.rotation.y += 0.05;
        }
    }

    fn render_frame(&mut self) {
        // Auto-resize
        self.viewport.origin = self.canvas.intended_size() / 2;
        self.canvas.update();

        let now = Instant::now();

        self.canvas.view.blit(
            &self
                .viewport
                .render(
                    self.models.iter().collect(),
                    self.display_mode.clone(),
                )
                .shade_with(&mut self.shader),
            Wrapping::Ignore,
        );

        self.debug_manager.log_blitting_since(now);

        let now = Instant::now();
        let _ = self.canvas.view.display_render();
        self.debug_manager.log_rendering_since(now);

        self.debug_manager.frame();
    }

    fn sleep_and_get_input_data(
        &self,
        fps: f32,
        elapsed: Duration,
    ) -> (bool, Option<Self::InputDataType>) {
        // Hijack the sleep function to print elapsed times before falling back to default sleep function
        self.debug_manager.print_benchmark(fps, elapsed);

        (sleep_fps(fps, Some(elapsed)), None)
    }
}