use tokio::sync::Semaphore; // 1.33.0
use std::{future::Future, sync::Arc};

#[derive(Clone)]
pub struct Countdown(Arc<Semaphore>);

impl Drop for Countdown {
    fn drop(&mut self) {
        self.0.add_permits(1);
    }
}

impl Countdown {
    pub fn new(n: u32) -> (Self, impl Future + Send) {
        let sem = Arc::new(Semaphore::new(0));
        let latch = Self(sem.clone());
        
        let wait = async move {
            let _ = sem.acquire_many(n).await;
        };
        
        (latch, wait)
    }
}

#[tokio::main]
async fn main() {
    let (latch, wait) = Countdown::new(5);
    for i in 1..=5 {
        let latch = latch.clone();
        tokio::spawn(async move {
            // move the latch into the task.
            let _latch = latch;
            
            // do stuff...
            println!("countdown task {i} running...");
            tokio::task::yield_now().await;
            
            // when the task completes, the latch is dropped.
            println!("countdown task {i} done!");
        });
    }
    
    println!("waiting for tasks to complete...");
    wait.await;
    println!("tasks completed!");
}