[dependencies]
strait = "0.1"
tokio = { version = "1", features = ["full"] }

use strait::Client;

let client = Client::from_file(None).await?;

// Custom directory
let client = Client::from_file(Some(
    strait::ConfigFileOptions::builder()
        .dir("/path/to/project")
        .build()
)).await?;

// Explicit path
let client = Client::from_file(Some(
    strait::ConfigFileOptions::builder()
        .path("/path/to/config.json")
        .build()
)).await?;

// Reads STRAIT_BASE_URL, STRAIT_API_KEY, STRAIT_AUTH_TYPE, STRAIT_TIMEOUT_MS
let client = Client::from_env()?;

let client = Client::builder()
    .base_url("https://api.strait.dev")
    .api_key("sk_live_...")
    .timeout_ms(5000)
    .build()?;

use strait::Client;
use strait::operations::Jobs;

let client = Client::from_file(None).await?;
let jobs = Jobs::new(&client);

// List jobs
let list = jobs.list(Some(
    &[("project_id", "proj_1")]
)).await?;

// Create a job
let created = jobs.create(serde_json::json!({
    "name": "Sync Inventory",
    "slug": "sync-inventory",
    "project_id": "proj_1",
    "endpoint_url": "https://worker.example.com/run",
})).await?;

// Trigger a job
let run = jobs.trigger("job_abc", serde_json::json!({
    "payload": { "sku": "ABC-123" },
})).await?;

use strait::authoring::{self, JobOptions, RunContext};
use serde::{Deserialize, Serialize};

#[derive(Debug, Serialize, Deserialize)]
struct Payload {
    sku: String,
}

let job = authoring::define_job(JobOptions {
    name: "Sync Inventory",
    slug: "sync-inventory",
    endpoint_url: "https://worker.dev/jobs/sync",
    project_id: "proj_1",
    run: |payload: Payload, ctx: RunContext| async move {
        sync_inventory(&payload.sku).await
    },
})?;

job.register(&client, None).await?;
job.trigger(&client, Payload { sku: "ABC-123".into() }).await?;

use strait::authoring::{self, WorkflowOptions, Step};

let wf = authoring::define_workflow(WorkflowOptions {
    name: "Order Pipeline",
    slug: "order-pipeline",
    project_id: "proj_1",
    steps: vec![
        Step::job("validate", "job_validate"),
        Step::job("charge", "job_charge").depends_on(&["validate"]),
        Step::approval("review").depends_on(&["charge"]),
    ],
})?;
// DAG is validated at definition time

use strait::composition;

// Retry with backoff
let result = composition::with_retry(
    || async { call_api().await },
    composition::RetryOptions { attempts: 5, delay_ms: 100 },
).await?;

// Paginate
let mut stream = composition::paginate(|cursor| async move {
    list_fn(cursor).await
});
while let Some(item) = stream.next().await {
    // process item
}

// Wait for run
let run = composition::wait_for_run(
    |id| async move { get_run(id).await },
    |run| get_status(run),
    "run_123",
    None,
).await?;

use strait::fsm;

fsm::can_transition_run(fsm::RunState::Executing, fsm::RunEvent::Complete);  // true
fsm::is_terminal_run_status(fsm::RunState::Completed);                        // true

let client = Client::builder()
    .base_url("https://api.strait.dev")
    .api_key("sk_live_...")
    .middleware(strait::Middleware {
        on_request: Some(Box::new(|ctx| {
            println!("{} {}", ctx.method, ctx.url);
        })),
        on_response: Some(Box::new(|ctx| {
            println!("{} {}ms", ctx.status, ctx.duration_ms);
        })),
        on_error: Some(Box::new(|ctx| {
            eprintln!("error: {}", ctx.error);
        })),
    })
    .build()?;

let http_client = reqwest::Client::builder()
    .pool_max_idle_per_host(10)
    .connect_timeout(std::time::Duration::from_secs(5))
    .build()?;

let client = Client::builder()
    .base_url("https://api.strait.dev")
    .api_key("sk_live_...")
    .http_client(http_client)
    .build()?;

use strait::error::StraitError;

match jobs.get("nonexistent").await {
    Ok(result) => println!("Found: {:?}", result),
    Err(StraitError::NotFound(e)) => println!("Not found: {}", e.message),
    Err(StraitError::RateLimited(e)) => println!("Rate limited: {}", e.message),
    Err(StraitError::Unauthorized(e)) => println!("Auth error: {}", e.message),
    Err(e) => println!("Error: {}", e),
}