#![deny(clippy::all, clippy::pedantic)]
#![allow(clippy::needless_pass_by_value)]

use ecs::component::{Component, Sequence as ComponentSequence};
use ecs::extension::Extension;
use ecs::phase::PRE_UPDATE as PRE_UPDATE_PHASE;
use ecs::sole::Sole;
use ecs::system::{Into, System};
use ecs::uid::Uid;
use ecs::{SoleAlreadyExistsError, World};

use crate::delta_time::{update as update_delta_time, DeltaTime, LastUpdate};

mod opengl;
mod util;

pub mod camera;
pub mod data_types;
pub mod delta_time;
pub mod draw_flags;
pub mod file_format;
pub mod input;
pub mod lighting;
pub mod material;
pub mod math;
pub mod mesh;
pub mod projection;
pub mod renderer;
pub mod texture;
pub mod transform;
pub mod vertex;
pub mod window;

pub extern crate ecs;

pub(crate) use crate::data_types::matrix;
pub use crate::data_types::{color, vector};

#[derive(Debug)]
pub struct Engine
{
    world: World,
}

impl Engine
{
    /// Returns a new `Engine`.
    #[must_use]
    pub fn new() -> Self
    {
        let mut world = World::new();

        world.add_sole(DeltaTime::default()).ok();

        world.register_system(
            *PRE_UPDATE_PHASE,
            update_delta_time
                .into_system()
                .initialize((LastUpdate::default(),)),
        );

        Self { world }
    }

    pub fn spawn<Comps>(&mut self, components: Comps) -> Uid
    where
        Comps: ComponentSequence,
    {
        self.world.create_entity(components)
    }

    pub fn register_system<'this, SystemImpl>(
        &'this mut self,
        phase_euid: Uid,
        system: impl System<'this, SystemImpl>,
    )
    {
        self.world.register_system(phase_euid, system);
    }

    pub fn register_observer_system<'this, SystemImpl, Event>(
        &'this mut self,
        system: impl System<'this, SystemImpl>,
        event: Event,
    ) where
        Event: Component,
    {
        self.world.register_observer_system(system, event);
    }

    /// Adds a globally shared singleton value.
    ///
    /// # Errors
    /// Returns `Err` if this [`Sole`] has already been added.
    pub fn add_sole(&mut self, sole: impl Sole) -> Result<(), SoleAlreadyExistsError>
    {
        self.world.add_sole(sole)
    }

    pub fn add_extension(&mut self, extension: impl Extension)
    {
        self.world.add_extension(extension);
    }

    /// Runs the event loop.
    pub fn start(&self)
    {
        self.world.start_loop();
    }
}

impl Default for Engine
{
    fn default() -> Self
    {
        Self::new()
    }
}