#![deny(missing_docs)]
/*!
See [README.md]
**/

use layer_system::LayerManager;
pub use layer_system::{Change, Layer};

/// A trait for types, that can handle specific event types.
pub trait Handler {
    /// The handled event type.
    type Event;
    /// The method to handle the event.
    fn handle(&mut self, event: Self::Event);
}

/// A system trait, which process their events by passing them to handlers.
/// Systems generate events and pass them to a handler.
pub trait System<H: Handler> {
    /// Process all systems one after another.
    fn process(&mut self, handler: &mut H);
}

impl<E> Handler for Vec<E> {
    type Event = E;
    fn handle(&mut self, event: E) {
        self.push(event);
    }
}

/// Starts the engine.
pub fn run<S: System<Vec<E>>, E>(mut state: S, layers: Vec<Box<dyn Layer<S, E>>>) {
    let mut layers = LayerManager::new(layers);

    while layers.is_active() {
        let mut queue = Vec::new();
        state.process(&mut queue);
        for event in queue {
            layers.update(&mut state, event)
        }
    }
}