// in a normal program, it can be hard to know whether this will put our thread to sleep or not...
socket.read();
// but in async, it's explicit that it will make our task wait!
socket.read().await;

while task.do_some_work() == NotReady {}

let task = async {
    socket.read().await;
    socket.read().await;
}

let task = {
    let mut read_operation = socket.read();
    while read_operation() == NotReady {}
    let mut read_operation_two = socket.read();
    while read_operation() == NotReady {}
}

socket.on_has_data(|| {
    read();
});

fn do_some_work() {
    // if our data is ready, we can just read it and return immediately!
    if socket.has_data() {
        return Ready(socket.read())
    } else {
        // else, we register ourselves with the socket: it will tell the executor to call us again when it actually has some data.
        socket.on_has_data(|| executor.wake_me_up());
        return NotReady // we aren't ready, so we return for now!
    }
}

fn executor() {
    if do_some_work() == Ready(data) { return data }; // we call it once, just in case it has data already, or so that it can register itself for waking later.
    while let Some(wake_request) = wake_requests.receive() { // we can use a channel or something like it for receiving wake requests
        do_some_work();
    }
}

pub struct Sleep {
    registered: bool
}

impl Future for Sleep {
    type Output = ();

    // instead of our Ready/NotReady pseudocode, here we use the standard library's Poll<T> type, which has two variants: Ready(val) or Pending.
    fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
        if !self.registered { // this is our first time being called!
            let waker = context.waker().clone();
            std::thread::spawn(move || {
                std::thread::sleep(Duration::from_secs(5));
                waker.wake(); // ask the executor to call the Sleep future again
            });

            self.registered = true; // make sure we know we've already asked to be woken up in five seconds
            return Poll::Pending // we aren't done yet!
        } else { // this isn't our first time being called, so we must have been woken up by our waker!
            return Poll::Ready(())
        }
    }
}

// lets just use some ints to identify our tasks!
pub struct TaskId(u32);

// for reasons that i will not get into here, futures have some very specific memory placement requirements which make it easier to just put our tasks on the heap. here we're using the `futures`' crate BoxFuture type alias. 
pub type Task = BoxFuture<'static, ()>;

// we're just going to use an mpsc channel for our wake-up requests, so our `Waker` is just a channel sender + the id we'd like to wake up
pub struct TaskWaker {
    id: TaskId,
    sender: std::sync::mpsc::SyncSender<TaskId>
}

// we need to implement the Wake trait to make Wakers: it just defines exactly how we go about waking up a task in our setup
impl Wake for TaskWaker {
    fn wake(self: Arc<Self>) {
        self.sender.send(self.id);
    }
}


// this is what will do the heavy lifting
pub struct Executor {
    tasks: BTreeMap<TaskId, BoxFuture<'static, ()>>>,
    wake_requests: std::sync::mpsc::Receiver<TaskId>,
    wake_sender: std::sync::mpsc::SyncSender<TaskId>
}

impl Executor {
    pub fn new() -> Executor { ... }

    fn waker_for_task(&self, id: TaskId) -> Waker {
        Arc::new(TaskWaker {
            id: task_id,
            sender: self.wake_sender.clone();
        }).into()
    }

    // poll a task, letting it do some work as it wishes
    fn poll_task(&mut self, id: TaskId) {
        let waker = self.waker_for_task(task_id);
        let mut context = Context::from_waker(&waker); // a Context is a fancy little wrapper for our waker type
        if let Poll::Ready(()) = self.tasks[task_id].poll(context) {
            self.tasks.remove(task_id); // task is done! we can remove it
        }
    }

    // place a task on our executor
    pub fn spawn(&mut self, id: TaskId, future: BoxFuture<'static, ()>) {
        self.tasks.insert(id, future);
        self.poll_task(id); // we give it an initial poll so it can set up its waker registration
    }

    pub fn run(mut self) {
        // every time we get a wake request, we poll the task it tells us to again
        for task_id in self.wake_requests.iter() {
            self.poll_task(task_id);
        }
    }
}


let mut executor = Executor::new();
executor.spawn(Sleep { registered: false });
executor.run();