use hero_supervisor::{SupervisorBuilder, ScriptType};
use hero_job::JobBuilder as CoreJobBuilder;

#[tokio::main]
async fn main() -> anyhow::Result<()> {
    // 1) Build a Supervisor
    let supervisor = SupervisorBuilder::new()
        .redis_url("redis://127.0.0.1/")
        .build()
        .await?;

    // 2) Build a Job (using core job builder to set caller_id, context_id)
    let job = CoreJobBuilder::new()
        .caller_id("02abc...caller")        // required
        .context_id("02def...context")      // required
        .script_type(ScriptType::OSIS)      // select the OSIS actor (matches configured osis_actor_1)
        .script("40 + 3")                   // simple Rhai script
        .timeout(std::time::Duration::from_secs(10))
        .build()?;                          // returns hero_job::Job

    let job_id = job.id.clone();

    // 3a) Store the job in Redis
    supervisor.create_job(&job).await?;

    // 3b) Start the job (pushes ID to the actor’s Redis queue)
    supervisor.start_job(&job_id).await?;

    // 3c) Wait until finished, then fetch output
    use tokio::time::sleep;

    let deadline = std::time::Instant::now() + std::time::Duration::from_secs(10);
    loop {
        let status = supervisor.get_job_status(&job_id).await?;
        if status == hero_supervisor::JobStatus::Finished {
            break;
        }
        if std::time::Instant::now() >= deadline {
            println!("Job {} timed out waiting for completion (status: {:?})", job_id, status);
            break;
        }
        sleep(std::time::Duration::from_millis(250)).await;
    }

    if let Some(output) = supervisor.get_job_output(&job_id).await? {
        println!("Job {} output: {}", job_id, output);
    } else {
        println!("Job {} completed with no output field set", job_id);
    }

    Ok(())
}