use xaeroflux::{XaeroFlux, Event, generate_event_id};

#[tokio::main]
async fn main() -> anyhow::Result<()> {
    let mut xf = XaeroFlux::new(
        "my-app-key".to_string(),
        "events.db".to_string()
    ).await?;

    // Send an event
    let now = chrono::Utc::now().timestamp() as u64;
    xf.event_tx.send(Event {
        id: generate_event_id("hello world", &xf.node_id, now),
        payload: "hello world".to_string(),
        source: xf.node_id.clone(),
        ts: now,
    })?;

    // Receive synced events from other peers
    while let Some(event) = xf.event_rx.recv().await {
        println!("Received: {} from {}", event.payload, event.source);
    }

    Ok(())
}

pub struct Event {
    pub id: String,      // Unique ID (blake3 hash)
    pub payload: String, // Your data (any string)
    pub source: String,  // Node ID that created event
    pub ts: u64,        // Unix timestamp
}

// These sync together (same discovery key)
let peer1 = XaeroFlux::new("project-alpha".to_string(), "db1.db".to_string()).await?;
let peer2 = XaeroFlux::new("project-alpha".to_string(), "db2.db".to_string()).await?;

// This syncs separately (different discovery key)
let peer3 = XaeroFlux::new("project-beta".to_string(), "db3.db".to_string()).await?;

use xaeroflux::{XaeroFlux, Event, generate_event_id};
use serde::{Serialize, Deserialize};

#[derive(Serialize, Deserialize)]
struct ChatMessage {
    user: String,
    message: String,
}

#[tokio::main]
async fn main() -> anyhow::Result<()> {
    let mut xf = XaeroFlux::new("my-chat".to_string(), "chat.db".to_string()).await?;
    let node_id = xf.node_id.clone();

    // Send chat messages
    let tx = xf.event_tx.clone();
    tokio::spawn(async move {
        let stdin = tokio::io::stdin();
        let mut lines = tokio::io::BufReader::new(stdin).lines();
        
        while let Ok(Some(line)) = lines.next_line().await {
            let msg = ChatMessage {
                user: node_id[..8].to_string(),
                message: line,
            };
            let payload = serde_json::to_string(&msg).unwrap();
            let now = chrono::Utc::now().timestamp() as u64;
            
            tx.send(Event {
                id: generate_event_id(&payload, &node_id, now),
                payload,
                source: node_id.clone(),
                ts: now,
            }).unwrap();
        }
    });

    // Receive and display messages
    while let Some(event) = xf.event_rx.recv().await {
        let msg: ChatMessage = serde_json::from_str(&event.payload)?;
        println!("[{}] {}", msg.user, msg.message);
    }

    Ok(())
}