use amethyst::core::{
    ecs::prelude::*,
    shrev::{Event, EventChannel},
};

pub trait SimpleEventHandler<'a> {
    type EventType: Event;
    type HandlerSystemData: SystemData<'a>;

    fn active(&self) -> bool {
        true
    }

    fn handle_event(&mut self, event: Self::EventType, data: &mut Self::HandlerSystemData);
}

pub struct EventHandlerSystem<'a, T>
where
    T: SimpleEventHandler<'a>,
{
    event_reader: Option<ReaderId<T::EventType>>,
    handler: T,
}

impl<'a, T> Default for EventHandlerSystem<'a, T>
where
    T: Default + SimpleEventHandler<'a>,
{
    fn default() -> Self {
        Self {
            event_reader: None,
            handler: T::default(),
        }
    }
}

impl<'a, T> System<'a> for EventHandlerSystem<'a, T>
where
    T: SimpleEventHandler<'a>,
{
    type SystemData = (Read<'a, EventChannel<T::EventType>>, T::HandlerSystemData);

    fn setup(&mut self, res: &mut Resources) {
        Self::SystemData::setup(res);

        self.event_reader = Some(
            res.fetch_mut::<EventChannel<T::EventType>>()
                .register_reader(),
        );
    }

    fn run(&mut self, data: Self::SystemData) {
        let (events, inner_data) = data;

        // Make sure we at least consume the input events so we don't act on stale ones.
        let events_iter = events.read(
            &mut self
                .event_reader
                .as_mut()
                .expect("EventHandlerSystem was not setup before running"),
        );

        if !self.handler.active() {
            return;
        }

        for event in events_iter {
            self.handler.handle_event(*event, &mut inner_data);
        }
    }
}