//! `brahman-demo-broker` — broker standalone para demos.
//!
//! ente-zero (PID 1) es el broker "real" pero pesa toneladas
//! (kernel surface, child subreaper, bus, brain, audit, etc). Este
//! binario sólo arma `brahman_handshake::Server::bind` con un broker
//! configurado, escucha en el socket default, y corre forever.
//!
//! Suficiente para que el script de bootstrap (y los 4 explorers)
//! tengan algo a qué conectarse sin necesitar el bootstrap PID 1
//! completo.
//!
//! Variables de entorno respetadas:
//! - `BRAHMAN_INIT_SOCKET` — path del Unix socket. Default: el
//!   resuelto por `brahman_handshake::transport::default_socket_path`.
//! - `BRAHMAN_BROKER_CONTEXT` — context bias del broker (igual que
//!   ente-zero); afecta priority_contexts si las Cards lo declaran.
//! - `RUST_LOG` — filtro de tracing (default `info`).

use std::sync::Arc;

use brahman_broker::{Broker, BrokerConfig, MatchStrategy};
use brahman_handshake::server::{Server, ServerConfig};
use brahman_handshake::transport;
use tokio::sync::Mutex;

#[tokio::main(flavor = "current_thread")]
async fn main() -> std::io::Result<()> {
    tracing_subscriber::fmt()
        .with_env_filter(
            tracing_subscriber::EnvFilter::try_from_default_env()
                .unwrap_or_else(|_| tracing_subscriber::EnvFilter::new("info")),
        )
        .init();

    let context = std::env::var("BRAHMAN_BROKER_CONTEXT").ok();
    let broker = Arc::new(Mutex::new(Broker::new(BrokerConfig {
        strategy: MatchStrategy::default(),
        current_context: context.clone(),
    })));

    let socket = transport::default_socket_path();
    tracing::info!(
        socket = %socket.display(),
        context = ?context,
        "brahman-demo-broker arranca"
    );

    let server = Server::bind(
        &socket,
        ServerConfig {
            init_attached: false,
            broker: Some(broker),
            net: None,
            policy: None,
        },
    )?;

    // Loop accept-forever. Cada conexión va a su propia tokio task —
    // sesiones independientes, ninguna bloquea a las otras.
    loop {
        let session = server.accept_one().await?;
        tokio::spawn(async move {
            if let Err(e) = session.handle().await {
                tracing::warn!(?e, "session terminó con error");
            }
        });
    }
}