chore: remove Cycle struct and begin scheduler design

src/scheduler.rs

@@ -0,0 +1,79 @@
+use crate::Cycle;
+use std::collections::BinaryHeap;
+
+#[derive(Debug)]
+pub(crate) struct Scheduler {
+    timestamp: Cycle,
+    queue: BinaryHeap<Event>,
+}
+
+impl Scheduler {
+    pub(crate) fn init() -> Self {
+        let mut scheduler = Self {
+            timestamp: Default::default(),
+            queue: Default::default(),
+        };
+
+        scheduler.push(Event {
+            kind: EventKind::TimestampOverflow,
+            timestamp: Cycle::MAX,
+            cb: |_delay| panic!("Reached Cycle::MAX"),
+        });
+
+        scheduler
+    }
+
+    pub(crate) fn push(&mut self, event: Event) {
+        self.queue.push(event);
+    }
+
+    pub(crate) fn step(&mut self, cycles: Cycle) {
+        self.timestamp += cycles;
+
+        loop {
+            let should_pop = match self.queue.peek() {
+                Some(event) => self.timestamp >= event.timestamp,
+                None => false,
+            };
+
+            if !should_pop {
+                break;
+            }
+
+            let event = self.queue.pop().expect("Pop Event from Scheduler Queue");
+
+            (event.cb)(self.timestamp - event.timestamp);
+        }
+    }
+}
+
+#[derive(Debug)]
+pub(crate) struct Event {
+    kind: EventKind,
+    cb: fn(Cycle),
+    pub(crate) timestamp: Cycle,
+}
+
+impl Eq for Event {}
+impl PartialEq for Event {
+    fn eq(&self, other: &Self) -> bool {
+        self.kind == other.kind && self.timestamp == other.timestamp
+    }
+}
+
+impl PartialOrd for Event {
+    fn partial_cmp(&self, other: &Self) -> Option<std::cmp::Ordering> {
+        Some(self.cmp(other))
+    }
+}
+
+impl Ord for Event {
+    fn cmp(&self, other: &Self) -> std::cmp::Ordering {
+        self.timestamp.cmp(&other.timestamp)
+    }
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub(crate) enum EventKind {
+    TimestampOverflow,
+}