use rs_poke::{Poke, PokeOptions};

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let client = Poke::new(PokeOptions::default())?;

    let response = client.send_message("Hello, world!").await?;
    println!("{}", response.message);

    let webhook = client.create_webhook(&rs_poke::CreateWebhook {
        condition: "event.type == 'trigger'",
        action: "POST",
    }).await?;
    println!("trigger: {}", webhook.trigger_id);

    Ok(())
}

use rs_poke::{Poke, TunnelOptions, TunnelRunner};

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let poke = Poke::new(rs_poke::PokeOptions::default())?;
    let mut runner = TunnelRunner::new(poke, TunnelOptions {
        url: "http://127.0.0.1:52333/mcp".into(),
        name: "my-tunnel".into(),
        cleanup_on_stop: true,
        sync_interval: std::time::Duration::from_secs(300),
        startup_timeout: std::time::Duration::from_secs(30),
        ..TunnelOptions::default()
    });

    let info = runner.start().await?;
    println!("Tunnel connected: {}", info.tunnel_url);

    let mut events = runner.subscribe();
    while let Ok(event) = events.recv().await {
        match event {
            rs_poke::TunnelEvent::Connected(info) => {
                println!("Connected: {}", info.tunnel_url);
            }
            rs_poke::TunnelEvent::Disconnected => break,
            _ => {}
        }
    }

    runner.stop().await?;
    Ok(())
}

use rs_poke::{login, logout, is_logged_in, CredentialsStore, LoginOptions};

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let store = CredentialsStore::default_store()?;
    let result = login(
        LoginOptions::new(store).on_code(|info| {
            println!("Open {} and enter {}", info.login_url, info.user_code);
        }),
    )
    .await?;

    if is_logged_in() {
        println!("Authenticated as {}", result.token);
    }

    logout().await?;
    Ok(())
}