use std::{

    cmp::{Eq, Ord, Ordering, PartialEq, PartialOrd},

    collections::BinaryHeap,

};

use hwphysics::common::{GearId, Millis};

pub type EventId = u16;

struct TimeEvent {

    time: Millis,

    gear_id: GearId,

    event_id: EventId,

}

impl PartialOrd for TimeEvent {

    #[inline]

    fn partial_cmp(&self, other: &Self) -> Option<Ordering> {

        self.time.partial_cmp(&other.time)

    }

}

impl PartialEq for TimeEvent {

    #[inline]

    fn eq(&self, other: &Self) -> bool {

        self.time.eq(&other.time)

    }

}

impl Ord for TimeEvent {

    #[inline]

    fn cmp(&self, other: &Self) -> Ordering {

        self.time.cmp(&other.time)

    }

}

impl Eq for TimeEvent {}

pub struct OccurredEvents {

    events: Vec<(GearId, EventId)>,

}

impl OccurredEvents {

    fn new() -> Self {

        Self { events: vec![] }

    }

    fn clear(&mut self) {

        self.events.clear()

    }

}

pub struct TimeProcessor {

    current_event_id: EventId,

    current_time: Millis,

    events: BinaryHeap<TimeEvent>,

    timeouts: OccurredEvents,

}

impl TimeProcessor {

    pub fn new() -> Self {

        Self {

            current_event_id: 0,

            current_time: Millis::new(0),

            events: BinaryHeap::with_capacity(1024),

            timeouts: OccurredEvents::new(),

        }

    }

    pub fn register(&mut self, gear_id: GearId, timeout: Millis) -> EventId {

        let event_id = self.current_event_id;

        self.current_event_id = self.current_event_id.wrapping_add(1);

        let event = TimeEvent {

            time: self.current_time + timeout,

            gear_id,

            event_id,

        };

        self.events.push(event);

        event_id

    }

    fn retain_events<P>(&mut self, predicate: P)

    where

        P: Fn(&TimeEvent) -> bool,

    {

        let events = self.events.drain().filter(predicate).collect::<Vec<_>>();

        self.events.extend(events);

    }

    pub fn cancel(&mut self, event_id: EventId) {

        //self.events.retain(|event| event.event_id != event_id)

        self.retain_events(|event| event.event_id != event_id)

    }

    pub fn cancel_all(&mut self, gear_id: GearId) {

        //self.events.retain(|event| event.gear_id != gear_id)

        self.retain_events(|event| event.gear_id != gear_id)

    }

    pub fn process(&mut self, time_step: Millis) -> &OccurredEvents {

        self.timeouts.clear();

        self.current_time = self.current_time + time_step;

        while self

            .events

            .peek()

            .filter(|e| e.time <= self.current_time)

            .is_some()

        {

            let event = self.events.pop().unwrap();

            self.timeouts.events.push((event.gear_id, event.event_id))

        }

        &self.timeouts

    }

}