lune/src/lib/globals/task.rs

use std::{
    sync::{Arc, Mutex},
    time::Duration,
};

use mlua::{Function, Lua, Result, Table, Thread, Value, Variadic};
use tokio::time;

use crate::utils::table_builder::ReadonlyTableBuilder;

const DEFAULT_SLEEP_DURATION: f32 = 1.0 / 60.0;

pub struct WaitingThread<'a> {
    is_delayed_for: Option<f32>,
    is_deferred: Option<bool>,
    thread: Thread<'a>,
    args: Variadic<Value<'a>>,
}

pub fn new<'a>(lua: &'a Lua, threads: &Arc<Mutex<Vec<WaitingThread<'a>>>>) -> Result<Table<'a>> {
    // TODO: Figure out how to insert into threads vec
    ReadonlyTableBuilder::new(lua)?
        .with_async_function(
            "defer",
            |lua, (func, args): (Function, Variadic<Value>)| async move {
                let thread = lua.create_thread(func)?;
                thread.into_async(args).await?;
                Ok(())
            },
        )?
        .with_async_function(
            "delay",
            |lua, (func, duration, args): (Function, Option<f32>, Variadic<Value>)| async move {
                let secs = duration.unwrap_or(DEFAULT_SLEEP_DURATION);
                time::sleep(Duration::from_secs_f32(secs)).await;
                let thread = lua.create_thread(func)?;
                thread.into_async(args).await?;
                Ok(())
            },
        )?
        .with_async_function(
            "spawn",
            |lua, (func, args): (Function, Variadic<Value>)| async move {
                let thread = lua.create_thread(func)?;
                thread.into_async(args).await?;
                Ok(())
            },
        )?
        .with_async_function("wait", |_, duration: Option<f32>| async move {
            let secs = duration.unwrap_or(DEFAULT_SLEEP_DURATION);
            time::sleep(Duration::from_secs_f32(secs)).await;
            Ok(secs)
        })?
        .build()
}