use std::time::Duration;

fn main() {

    // Run a task with no initial budget. The first time the task asks to spend

    // any budget, it will be paused.

    let mut progress = Runtime::run_with_budget(some_task_to_limit, 0);

        progress = match progress {

            Progress::NoBudget(incomplete_task) => {

                // Resume the task, allowing for 5 more budget to be spent.

                println!("+5 budget");

                incomplete_task.continue_with_additional_budget(5)

            Progress::Complete(result) => {

                // The task has completed. `result.output` contains the output

                // of the task itself. We can also inspect the balance of the

                // budget:

                println!(

                    "Task completed with balance: {:?}, output: {:?}",

                    result.balance, result.output

                );

                break;

            }

        };

    }

}

async fn some_task_to_limit(runtime: Runtime<usize>) -> bool {

    do_some_operation(1, &runtime).await;

    do_some_operation(5, &runtime).await;

    do_some_operation(1, &runtime).await;

    do_some_operation(25, &runtime).await;

    true

}

async fn do_some_operation(times: u8, runtime: &Runtime<usize>) {

    println!("> Asking to spend {times} from the budget");

    runtime.spend(usize::from(times)).await;

    std::thread::sleep(Duration::from_millis(u64::from(times) * 100));

}

#[test]

fn runs() {

    main()

}