use async_nats;
use std::sync::Arc;
use tokio::sync::Mutex;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Create token refresh callback
    let token_callback = Arc::new(Mutex::new(|| async {
        // Fetch fresh token from OpenFrame Auth API
        let client = reqwest::Client::new();
        let response = client
            .post("https://openframe-auth.svc.cluster.local/api/oauth/token")
            .json(&serde_json::json!({
                "grant_type": "refresh_token",
                "refresh_token": std::env::var("REFRESH_TOKEN")?
            }))
            .send()
            .await?;
        
        let token_data: serde_json::Value = response.json().await?;
        Ok(token_data["access_token"].as_str().unwrap().to_string())
    }));

    // Connect with token callback
    let client = async_nats::ConnectOptions::new()
        .jwt_token_callback(token_callback)
        .connect("nats://nats-server.svc.cluster.local:4222")
        .await?;

    // Use the client normally
    let sub = client.subscribe("openframe.events").await?;
    
    while let Some(msg) = sub.next().await {
        println!("Received: {:?}", msg);
    }

    Ok(())
}

use async_nats::{ConnectOptions, ServerAddr};
use std::time::Duration;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let openframe_token_refresh = || async {
        // Your OpenFrame token refresh logic
        fetch_fresh_token().await
    };

    let client = ConnectOptions::new()
        // OpenFrame token refresh callback
        .jwt_token_callback(Box::new(openframe_token_refresh))
        // Connection options
        .name("openframe-service")
        .max_reconnects(Some(10))
        .reconnect_delay_callback(|attempts| {
            std::cmp::min(Duration::from_secs(2_u64.pow(attempts as u32)), Duration::from_secs(60))
        })
        // TLS configuration
        .require_tls(true)
        .tls_client_config(tls_config)
        // Connect
        .connect("nats://nats-cluster.openframe.svc.cluster.local:4222")
        .await?;

    // Publish to OpenFrame event stream
    client.publish("openframe.device.created", "device-123".into()).await?;
    
    // Subscribe to OpenFrame events
    let mut subscription = client.subscribe("openframe.alerts.*").await?;
    
    while let Some(message) = subscription.next().await {
        println!("Alert received: {}", String::from_utf8_lossy(&message.payload));
    }

    Ok(())
}

async fn fetch_fresh_token() -> Result<String, Box<dyn std::error::Error>> {
    // Implementation to fetch token from OpenFrame Auth API
    let client = reqwest::Client::new();
    let response = client
        .post("https://openframe-auth.svc.cluster.local/api/oauth/token")
        .header("Content-Type", "application/json")
        .json(&serde_json::json!({
            "grant_type": "client_credentials",
            "client_id": std::env::var("CLIENT_ID")?,
            "client_secret": std::env::var("CLIENT_SECRET")?
        }))
        .send()
        .await?;
    
    let data: serde_json::Value = response.json().await?;
    Ok(data["access_token"].as_str().unwrap().to_string())
}

use async_nats::jetstream;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Connect with OpenFrame token refresh
    let client = async_nats::ConnectOptions::new()
        .jwt_token_callback(Box::new(|| async {
            fetch_openframe_token().await
        }))
        .connect("nats://nats.openframe.svc.cluster.local:4222")
        .await?;

    // Create JetStream context
    let jetstream = jetstream::new(client);

    // Create or get stream
    let stream = jetstream
        .get_or_create_stream(jetstream::stream::Config {
            name: "OPENFRAME_EVENTS".to_string(),
            subjects: vec!["openframe.>".to_string()],
            ..Default::default()
        })
        .await?;

    // Publish events
    jetstream
        .publish("openframe.device.updated", "data".into())
        .await?;

    // Create consumer
    let consumer = stream
        .get_or_create_consumer("event-processor", jetstream::consumer::pull::Config {
            durable_name: Some("event-processor".to_string()),
            ..Default::default()
        })
        .await?;

    // Process messages
    let mut messages = consumer.messages().await?;
    while let Some(message) = messages.next().await {
        let msg = message?;
        println!("Processing: {:?}", msg);
        msg.ack().await?;
    }

    Ok(())
}

async fn fetch_openframe_token() -> Result<String, Box<dyn std::error::Error>> {
    // Fetch token from OpenFrame Auth
    // ... implementation
    Ok("fresh_jwt_token".to_string())
}