pispas_modules/

command_viewer.rs

use actix_web::middleware::Logger;
use actix_web::{web, App, HttpResponse, HttpServer, Responder};
use easy_trace::prelude::{debug, error, info};
use futures_util::SinkExt;
use futures_util::StreamExt;
use serde::{Deserialize, Serialize};
use sharing::utils::ConfigEnv;
use std::collections::HashMap;
use std::sync::atomic::{AtomicU64, Ordering};
use std::sync::Arc;
use std::time::{SystemTime, UNIX_EPOCH};
use tokio::net::TcpListener;
use tokio::sync::Mutex;
use tokio_tungstenite::{accept_async, connect_async, tungstenite::protocol::Message};

use crate::service::{Service, WebSocketWrite};
use async_trait::async_trait;
use easy_trace::instruments::tracing;
use serde_json::Value;
use std::any::Any;

/// The version of the CommandViewerService module.
pub const COMMAND_VIEWER_VERSION: &str = "1.0.0";

/// A minimal service that only returns its version and performs no other operations.
#[derive(Clone)]
pub struct CommandViewerService;

impl CommandViewerService {
    /// Creates a new instance of `CommandViewerService`.
    pub fn new() -> Self {
        info!(
            "CommandViewerService initialized (version: {})",
            COMMAND_VIEWER_VERSION
        );
        CommandViewerService
    }
}

#[async_trait]
impl Service for CommandViewerService {
    /// This method does nothing meaningful. It only logs the action received and returns a placeholder result.
    async fn run(&self, _action: Value, _write: WebSocketWrite) -> (i32, String) {
        info!("CommandViewerService: run method called, but no action is performed.");
        (0, "No action performed".to_string())
    }

    /// Allows dynamic casting to `Any` for type-safe downcasting.
    fn as_any(&self) -> &dyn Any {
        self
    }

    /// Stops the service. Since this service does nothing, the method just logs a message.
    fn stop_service(&self) {
        info!("CommandViewerService: stop_service called, but nothing to stop.");
    }

    /// Returns the version of the CommandViewerService module.
    fn get_version(&self) -> String {
        COMMAND_VIEWER_VERSION.to_string()
    }
}
fn current_timestamp() -> u64 {
    //fix panic
    match SystemTime::now().duration_since(UNIX_EPOCH) {
        Ok(n) => n.as_secs(),
        Err(_) => {
            return 0
        }
    }    
}

const MAX_COMMANDS_PER_PRINTER: usize = 45;
// Estructura para una comanda
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct Command {
    pub id: String,
    pub order_no: String,
    pub html: String,
    pub archived: bool,
    pub printer: String,
    pub timestamp: Option<u64>,
}

// Archivo de persistencia
const PERSISTENCE_FILE: &str = "commands.json";
pub struct KitchenState {
    pub commands: Mutex<HashMap<String, Vec<Command>>>, // GUID -> Comandas
    pub connections: Mutex<HashMap<u64, tokio::sync::mpsc::UnboundedSender<Message>>>, // Connection ID -> Sender
    pub subscriptions: Mutex<HashMap<String, Vec<u64>>>, // GUID -> Connection IDs
    pub config_env: ConfigEnv,
}

pub type SharedKitchenState = Arc<KitchenState>;

/// Agregar una nueva comanda a la impresora correspondiente
async fn add_command(command: Command, state: SharedKitchenState) -> Result<(), String> {
    let printer = command.printer.clone();

    // Si la impresora es "CommandViewer", saltamos la verificación de suscriptores
    if printer != "CommandViewer" {
        let subscriptions = state.subscriptions.lock().await;
        if let Some(connection_ids) = subscriptions.get(&printer) {
            if connection_ids.is_empty() {
                info!(
                    "Dont save command because there are no subscribers for printer: {}",
                    printer
                );
                return Err(format!(
                    "There are no subscribers for printer: {}",
                    printer
                ));
            }
        } else {
            let commands = state.commands.lock().await;
            if !commands.contains_key(&printer) {
                info!(
                    "Dont save command because there are no subscribers for printer: {}",
                    printer
                );
                return Err(format!(
                    "There are no subscribers for printer: {}",
                    printer
                ));
            }
        }
        drop(subscriptions);
    }
    let mut commands = state.commands.lock().await;

    let printer_commands = commands
        .entry(command.printer.clone())
        .or_insert_with(Vec::new);

    printer_commands.push(command);
    printer_commands.sort_by_key(|c| c.timestamp.unwrap_or(0));
    tracing::warn!("comandas para esa impresra: {}", printer_commands.len());

    // Limitar a un máximo de 200 comandas
    if printer_commands.len() > MAX_COMMANDS_PER_PRINTER {
        let drain_amount = printer_commands.len() / 3; // delete 25% of the oldest commands
        tracing::warn!("Draining {}", drain_amount);
        printer_commands.drain(0..drain_amount); // FIFO

        //send lenArchivedCommand to all clients
        let response = serde_json::json!({
            "status": "lenArchivedCommand",
            "printer": printer.clone(),
            "len": printer_commands.len(),
        });
        broadcast_to_clients(Message::Text(response.to_string()), &printer, state.clone()).await;
        tracing::warn!("SEND ALL CLIENTS {}", printer_commands.len());
    }

    save_commands_to_disk(&*commands).await;

    Ok(())
}

/// Load persistent commands from disk
async fn load_commands_from_disk() -> HashMap<String, Vec<Command>> {
    if let Ok(data) = std::fs::read_to_string(PERSISTENCE_FILE) {
        if let Ok(mut commands) = serde_json::from_str::<HashMap<String, Vec<Command>>>(&data) {
            for printer_commands in commands.values_mut() {
                for command in printer_commands.iter_mut() {
                    // Asigna un timestamp si no existe
                    if command.timestamp.is_none() || command.timestamp == Some(0) {
                        command.timestamp = Some(current_timestamp());
                    }
                }
            }
            return commands;
        }
    }
    HashMap::new()
}

/// Save commands to disk
async fn save_commands_to_disk(commands: &HashMap<String, Vec<Command>>) {
    if let Ok(json) = serde_json::to_string_pretty(commands) {
        if let Err(e) = std::fs::write(PERSISTENCE_FILE, json) {
            error!("Error saving commands to disk: {}", e);
        }
    }
}

/// GET /commands
async fn list_commands(state: web::Data<SharedKitchenState>) -> impl Responder {
    let commands = state.commands.lock().await;
    HttpResponse::Ok().json(&*commands)
}

/// incude all static files in the binary
const INDEX_HTML: &str = include_str!("../src/static/index.html");
const APP_JS: &str = include_str!("../src/static/app.js");
const STYLE_CSS: &str = include_str!("../src/static/style.css");
pub const FAVICON_ICO: &[u8] = include_bytes!("../src/static/favicon.ico");

/// Configuration and start of the Actix HTTP server
async fn start_http_server(addr: &str, state: SharedKitchenState) -> std::io::Result<()> {
    HttpServer::new(move || {
        App::new()
            .app_data(web::Data::new(state.clone())) // Compartir el estado
            .wrap(Logger::default()) // Logging
            // Servir el contenido embebido para HTML, JS, y CSS
            .route(
                "/",
                web::get().to(|| async {
                    HttpResponse::Ok()
                        .content_type("text/html")
                        .body(INDEX_HTML)
                }),
            )
            .route(
                "/app.js",
                web::get().to(|| async {
                    HttpResponse::Ok()
                        .content_type("application/javascript")
                        .body(APP_JS)
                }),
            )
            .route(
                "/style.css",
                web::get()
                    .to(|| async { HttpResponse::Ok().content_type("text/css").body(STYLE_CSS) }),
            )
            .route(
                "/favicon.ico", // Ruta para favicon.ico
                web::get().to(|| async {
                    HttpResponse::Ok()
                        .content_type("image/x-icon")
                        .body(FAVICON_ICO)
                }),
            )
            .route("/commands", web::get().to(list_commands)) // Listar todas las comandas
    })
    .bind(addr)? // Dirección para el servidor
    .run() // Ejecutar el servidor
    .await
}

static CONNECTION_ID_COUNTER: AtomicU64 = AtomicU64::new(1);

/// process a WebSocket connection
async fn process_websocket_connection(
    ws_stream: tokio_tungstenite::WebSocketStream<tokio::net::TcpStream>,
    state: SharedKitchenState,
) {
    let (mut write, mut read) = ws_stream.split();
    let (tx, rx) = tokio::sync::mpsc::unbounded_channel();
    let connection_id = CONNECTION_ID_COUNTER.fetch_add(1, Ordering::SeqCst);

    {
        let mut connections = state.connections.lock().await;
        connections.insert(connection_id, tx.clone());
    }

    let send_task = tokio::spawn(async move {
        let mut rx = tokio_stream::wrappers::UnboundedReceiverStream::new(rx);
        while let Some(msg) = rx.next().await {
            if let Err(e) = write.send(msg).await {
                error!("Error sending message to client: {}", e);
                break;
            }
        }
    });

    while let Some(Ok(msg)) = read.next().await {
        if let Message::Text(txt) = msg {
            match serde_json::from_str::<serde_json::Value>(&txt) {
                Ok(json) => {
                    debug!("Mensaje WebSocket recibido: {:?}", json);
                    if let Some(action) = json.get("action").and_then(|v| v.as_str()) {
                        match action {
                            "getCommands" => {
                                let commands = state.commands.lock().await.clone();
                                let response = serde_json::json!({
                                    "status": "success",
                                    "commands": commands
                                });
                                let _ = tx.send(Message::Text(response.to_string()));
                            }
                            "sendPdfPrint" => {
                                info!("sendPdfPrint action received: {:?}", json);

                                let guid = json.get("guid").and_then(|v| v.as_str());
                                if let Some(printers) =
                                    json.get("printers").and_then(|v| v.as_array())
                                {
                                    info!("Printers to send to: {:?}", printers);

                                    for printer in printers {
                                        if let Some(printer_name) = printer.as_str() {
                                            info!("Processing printer: {}", printer_name);

                                            if let Some(html) =
                                                json.get("html").and_then(|v| v.as_str())
                                            {
                                                info!(
                                                    "HTML content found for printer {}",
                                                    printer_name
                                                );

                                                // Serializar el campo ACTION como una cadena JSON
                                                let action_object = serde_json::json!({
                                                    printer_name: {
                                                        "print": html.to_string(),
                                                        "copies": 1,
                                                        "open": false,
                                                    }
                                                });

                                                let action_serialized = action_object.to_string();

                                                // Construir el mensaje completo
                                                let message = serde_json::json!({
                                                    "UUIDV4": guid,
                                                    "TARGET": "PRINT",
                                                    "ACTION": action_serialized  // Serializado como cadena
                                                });

                                                debug!(
                                                    "Message to send to printsvc: {:?}",
                                                    message
                                                );

                                                match send_to_printsvc(&state.config_env, message)
                                                    .await
                                                {
                                                    Ok(response) => {
                                                        info!(
                                                            "Successfully sent to printsvc: {:?}",
                                                            response
                                                        );
                                                        let _ = tx.send(Message::Text(
                                                            response.to_string(),
                                                        ));
                                                    }
                                                    Err(e) => {
                                                        error!("Error sending to printsvc for printer {}: {}", printer_name, e);
                                                        let error_response = serde_json::json!({
                                                            "status": "error",
                                                            "message": format!("Failed to send to printer {}: {}", printer_name, e),
                                                        });
                                                        let _ = tx.send(Message::Text(
                                                            error_response.to_string(),
                                                        ));
                                                    }
                                                }
                                            } else {
                                                error!(
                                                    "Missing HTML content for printer {}",
                                                    printer_name
                                                );
                                            }
                                        } else {
                                            error!(
                                                "Invalid printer name in printers array: {:?}",
                                                printer
                                            );
                                        }
                                    }
                                } else {
                                    error!("Missing or invalid printers array in sendPdfPrint message: {:?}", json);
                                }
                            }

                            "subscribe" => {
                                // Agregar traza para el mensaje recibido
                                info!("Procesando mensaje de suscripción: {:?}", json);

                                if let Some(printers) =
                                    json.get("printers").and_then(|v| v.as_array())
                                {
                                    // Trazar las impresoras enviadas en el mensaje
                                    info!(
                                        "Lista de impresoras recibida para suscripción: {:?}",
                                        printers
                                    );

                                    if let Some(guid) = json.get("guid").and_then(|v| v.as_str()) {
                                        let mut subscriptions = state.subscriptions.lock().await;

                                        // Trazar estado actual de suscripciones antes de procesar
                                        info!(
                                            "Suscripciones actuales antes de agregar: {:?}",
                                            *subscriptions
                                        );

                                        // Iterar sobre cada impresora y procesar la suscripción
                                        for printer in printers {
                                            if let Some(printer_name) = printer.as_str() {
                                                info!(
                                                    "Agregando conexión {} a la impresora: {}",
                                                    connection_id, printer_name
                                                );

                                                // Agregar conexión a la lista de suscriptores de la impresora
                                                subscriptions
                                                    .entry(printer_name.to_string())
                                                    .or_insert_with(Vec::new)
                                                    .push(connection_id);

                                                // Confirmar que se ha agregado
                                                info!(
                        "Conexión {} suscrita correctamente a la impresora: {}",
                        connection_id, printer_name
                    );
                                            } else {
                                                // Si algún valor en la lista no es válido
                                                error!(
                        "Impresora inválida detectada en el array: {:?}",
                        printer
                    );
                                            }
                                        }

                                        // Trazar estado de las suscripciones después de agregar
                                        info!(
                                            "Suscripciones actuales después de agregar: {:?}",
                                            *subscriptions
                                        );

                                        // Enviar respuesta de éxito al cliente
                                        let response = serde_json::json!({
                                            "status": "success",
                                            "message": format!(
                                                "Subscribed to printers: {:?} with GUID: {}",
                                                printers, guid
                                            ),
                                        });

                                        let _ = tx.send(Message::Text(response.to_string()));
                                    } else {
                                        // Log para un GUID faltante
                                        error!(
                                            "Campo 'guid' faltante en el mensaje de suscripción."
                                        );
                                        let error_response = serde_json::json!({
                                            "status": "error",
                                            "message": "Missing 'guid' field in subscription",
                                        });

                                        let _ = tx.send(Message::Text(error_response.to_string()));
                                    }
                                } else {
                                    // Log para impresoras faltantes o inválidas
                                    error!(
                                        "Campo 'printers' faltante o inválido en el mensaje: {:?}",
                                        json
                                    );
                                    let error_response = serde_json::json!({
                                        "status": "error",
                                        "message": "Missing or invalid 'printers' field in subscription",
                                    });

                                    let _ = tx.send(Message::Text(error_response.to_string()));
                                }
                            }
                            "getPrinters" => {
                                let message = serde_json::json!({
                                    "UUIDV4": uuid::Uuid::new_v4().to_string(),
                                    "TARGET": "PRINT",
                                    "ACTION": "getPrinters",
                                });

                                match send_to_printsvc(&state.config_env, message).await {
                                    Ok(response) => {
                                        let _ = tx.send(Message::Text(response.to_string()));
                                    }
                                    Err(e) => {
                                        let error_response = serde_json::json!({
                                            "status": "error",
                                            "message": format!("Failed to get printers: {}", e),
                                        });
                                        let _ = tx.send(Message::Text(error_response.to_string()));
                                    }
                                }
                            }
                            "updateCommandArchive" => {
                                if let Some(id) = json.get("id").and_then(|v| v.as_str()) {
                                    if let Some(archived) =
                                        json.get("archived").and_then(|v| v.as_bool())
                                    {
                                        let updated_html =
                                            json.get("html").and_then(|v| v.as_str());
                                        let mut commands = state.commands.lock().await;

                                        // Buscar y actualizar la comanda en todas las listas
                                        for (guid, command_list) in commands.iter_mut() {
                                            if let Some(command) =
                                                command_list.iter_mut().find(|cmd| cmd.id == id)
                                            {
                                                command.archived = archived;

                                                // Actualiza el HTML si se proporciona
                                                if let Some(html) = updated_html {
                                                    command.html = html.to_string();
                                                }

                                                let affected_guid = Some(guid.clone());
                                                if let Some(guid) = affected_guid {
                                                    // Notificar a los suscriptores del GUID
                                                    let response = serde_json::json!({
                                                        "status": "updateCommand",
                                                        "id": id,
                                                        "archived": archived,
                                                        "html": command.html, // Enviar HTML actualizado
                                                        "timestamp": command.timestamp,
                                                    });

                                                    broadcast_to_clients_excluding(
                                                        Message::Text(response.to_string()),
                                                        &guid, // GUID del cliente que actualizó
                                                        &connection_id, // Excluye este connection_id
                                                        state.clone(),
                                                    )
                                                    .await;
                                                } else {
                                                    // Si no se encontró la comanda
                                                    let error_response = serde_json::json!({
                                                        "status": "error",
                                                        "message": "Command not found",
                                                    });
                                                    let _ = tx.send(Message::Text(
                                                        error_response.to_string(),
                                                    ));
                                                }
                                                break;
                                            }
                                        }

                                        // Guardar cambios en disco después de liberar el préstamo mutable
                                        let commands_to_save = commands.clone(); // Clonar antes de liberar el MutexGuard
                                        drop(commands);
                                        save_commands_to_disk(&commands_to_save).await;
                                        info!("Comanda actualizada: {}", id);
                                    }
                                }
                            }
                            "lenArchivedCommand" => {
                                //recorrer las impresoras y mandar el len de cada una de ellas
                                let mut commands = state.commands.lock().await;
                                for (printer, command_list) in commands.iter_mut() {
                                    let mut archived = 0;
                                    for command in command_list.iter() {
                                        if command.archived {
                                            archived += 1;
                                        }
                                    }
                                    let response = serde_json::json!({
                                        "status": "lenArchivedCommand",
                                        "printer": printer,
                                        "len": archived,
                                    });
                                    broadcast_to_clients(
                                        Message::Text(response.to_string()),
                                        &printer,
                                        state.clone(),
                                    )
                                    .await;
                                }
                            }
                            "deleteCommand" => {
                                if let Some(command_id) = json.get("id").and_then(|v| v.as_str()) {
                                    let mut commands = state.commands.lock().await;

                                    // Buscar la comanda en todas las listas de suscriptores
                                    let mut found_printer: Option<String> = None;
                                    for (_guid, command_list) in commands.iter_mut() {
                                        if let Some(pos) =
                                            command_list.iter().position(|c| c.id == command_id)
                                        {
                                            // Obtener la impresora asociada a la comanda
                                            found_printer = Some(command_list[pos].printer.clone());
                                            command_list.remove(pos);
                                            break;
                                        }
                                    }

                                    if let Some(printer) = found_printer {
                                        save_commands_to_disk(&commands).await;

                                        // Confirmación al cliente que solicitó la acción
                                        let response = serde_json::json!({
                                            "status": "success",
                                            "message": "commandDeleted",
                                            "id": command_id,
                                        });

                                        // Notificar a los clientes suscritos a la impresora correspondiente
                                        broadcast_to_clients(
                                            Message::Text(response.to_string()),
                                            &printer,
                                            state.clone(),
                                        )
                                        .await;
                                    } else {
                                        // Manejar caso de comanda no encontrada
                                        let response = serde_json::json!({
                                            "status": "error",
                                            "message": "Command not found"
                                        });

                                        let _ = tx.send(Message::Text(response.to_string()));
                                    }
                                } else {
                                    error!("ID de comanda no encontrado en el mensaje: {}", txt);
                                }
                            }
                            "addCommand" => {
                                if let Some(command) = json
                                    .get("data")
                                    .and_then(|v| serde_json::from_value::<Command>(v.clone()).ok())
                                {
                                    // Validar el contenido de la comanda (HTML)
                                    if let Some(title_start) = command.html.find("<title>") {
                                        if let Some(title_end) = command.html.find("</title>") {
                                            let new_id =
                                                &command.html[(title_start + 7)..title_end];

                                            // Verificar que sea una comanda válida
                                            // if command.html.contains("Factura simplificada") {
                                            //     info!("No es una comanda válida. Ignorada.");
                                            //     return;
                                            // }

                                            info!(
                                                "Nueva comanda recibida con ID del título: {:?}",
                                                new_id
                                            );

                                            // Crear la comanda actualizada con el nuevo ID
                                            let updated_command = Command {
                                                id: command.id.clone(),
                                                order_no: new_id.to_string(),
                                                html: command.html.clone(),
                                                archived: false,
                                                printer: command.printer.clone(),
                                                timestamp: Some(current_timestamp()),
                                            };

                                            // Agregar la comanda utilizando el método con FIFO
                                            if let Err(e) =
                                                add_command(updated_command.clone(), state.clone())
                                                    .await
                                            {
                                                error!("Error al agregar la comanda: {}", e);
                                            }

                                            // Notificar a los clientes suscritos
                                            let broadcast_message = Message::Text(
                                                serde_json::json!({
                                                    "status": "newCommand",
                                                    "id": updated_command.id,
                                                    "html": updated_command.html,
                                                    "timestamp": updated_command.timestamp,
                                                })
                                                .to_string(),
                                            );

                                            let subscriptions = state.subscriptions.lock().await;
                                            info!("Suscripciones actuales: {:?}", subscriptions);

                                            if let Some(connection_ids) =
                                                subscriptions.get(&updated_command.printer)
                                            {
                                                info!(
                                                    "Conexiones suscritas a {}: {:?}",
                                                    updated_command.printer, connection_ids
                                                );
                                                for connection_id in connection_ids {
                                                    info!(
                                                        "Intentando enviar a conexión: {}",
                                                        connection_id
                                                    );
                                                    if let Some(tx) = state
                                                        .connections
                                                        .lock()
                                                        .await
                                                        .get(connection_id)
                                                    {
                                                        if tx
                                                            .send(broadcast_message.clone())
                                                            .is_err()
                                                        {
                                                            error!("Error enviando mensaje a la conexión: {}", connection_id);
                                                        } else {
                                                            info!(
                                                                "Mensaje enviado a conexión: {}",
                                                                connection_id
                                                            );
                                                        }
                                                    }
                                                }
                                            } else {
                                                error!(
        "No hay conexiones suscritas a la impresora: {}",
        updated_command.printer
    );
                                            }
                                        } else {
                                            error!("Error: No se encontró el cierre del tag <title> en el HTML.");
                                        }
                                    } else {
                                        error!("Error: No se encontró el tag <title> en el HTML.");
                                    }
                                } else {
                                    error!("Error: Formato de comando inválido o datos faltantes.");
                                }
                            }

                            _ => error!("Acción desconocida: {}", action),
                        }
                    }
                }
                Err(e) => error!("Error procesando el mensaje WebSocket: {}", e),
            }
        }
    }

    {
        let mut connections = state.connections.lock().await;
        connections.remove(&connection_id);
        info!("Connection {} removed", connection_id);
    }
    {
        let mut subscriptions = state.subscriptions.lock().await;

        for (_printer, connection_ids) in subscriptions.iter_mut() {
            connection_ids.retain(|&id| id != connection_id);
        }

        subscriptions.retain(|_, v| !v.is_empty());

        info!(
            "Connection {} unsubscribed from all printers",
            connection_id
        );
    }

    let _ = send_task.await;
}

async fn send_to_printsvc(
    config: &ConfigEnv,
    message: serde_json::Value,
) -> Result<serde_json::Value, String> {
    // When TLS is on the embedded cert is issued for `local.unpispas.es`,
    // not for the IP we bind to (`config.local_host` is usually 127.0.0.1).
    // Use the cert hostname so verification passes — DNS still resolves to 127.0.0.1.
    let (proto, host) = if config.local_ussl {
        ("wss", "local.unpispas.es")
    } else {
        ("ws", config.local_host.as_str())
    };
    let url = format!("{}://{}:{}", proto, host, config.local_port);
    info!("Connecting to printsvc at {}", url);
    match connect_async(url).await {
        Ok((mut ws_stream, _)) => {
            // Enviar el mensaje
            let msg_text = serde_json::to_string(&message)
                .map_err(|e| format!("Error serializing message to JSON: {}", e))?;

            ws_stream
                .send(Message::Text(msg_text))
                .await
                .map_err(|e| e.to_string())?;

            // Esperar la respuesta
            if let Some(Ok(Message::Text(response_text))) = ws_stream.next().await {
                serde_json::from_str(&response_text).map_err(|e| e.to_string())
            } else {
                Err("No response from printsvc".to_string())
            }
        }
        Err(e) => Err(format!("Failed to connect to printsvc: {}", e)),
    }
}

/// Configuración y arranque del servidor WebSocket
async fn start_websocket_server(addr: &str, state: SharedKitchenState) -> tokio::io::Result<()> {
    let listener = TcpListener::bind(addr).await?;
    info!("WebSocket server running on {}", addr);

    while let Ok((stream, _)) = listener.accept().await {
        let state = Arc::clone(&state);
        tokio::spawn(async move {
            if let Ok(ws_stream) = accept_async(stream).await {
                process_websocket_connection(ws_stream, state).await;
            }
        });
    }

    Ok(())
}

/// Arranque combinado de HTTP y WebSocket
pub async fn start_kitchen_server() -> std::io::Result<()> {
    let state = Arc::new(KitchenState {
        commands: Mutex::new(load_commands_from_disk().await),
        connections: Mutex::new(HashMap::new()),
        subscriptions: Mutex::new(HashMap::new()),
        config_env: ConfigEnv::load(),
    });

    // Levantar ambos servidores en paralelo
    tokio::try_join!(
        start_http_server("0.0.0.0:80", state.clone()),
        start_websocket_server("0.0.0.0:9001", state),
    )?;

    Ok(())
}
async fn broadcast_to_clients_excluding(
    message: Message,
    printer: &str,
    exclude_connection_id: &u64, // Nuevo parámetro para excluir un cliente
    state: SharedKitchenState,
) {
    let connections = state.connections.lock().await;
    let subscriptions = state.subscriptions.lock().await;

    if let Some(connection_ids) = subscriptions.get(printer) {
        for connection_id in connection_ids {
            if *connection_id != *exclude_connection_id {
                if let Some(tx) = connections.get(connection_id) {
                    if tx.send(message.clone()).is_err() {
                        error!("Failed to send message to connection {}", connection_id);
                    } else {
                        info!("Message sent to connection {}", connection_id);
                    }
                }
            }
        }
    } else {
        info!("No hay suscriptores asociados a la impresora: {}", printer);
    }
}

async fn broadcast_to_clients(message: Message, printer: &str, state: SharedKitchenState) {
    let connections = state.connections.lock().await;
    let subscriptions = state.subscriptions.lock().await;

    if let Some(connection_ids) = subscriptions.get(printer) {
        for connection_id in connection_ids {
            if let Some(tx) = connections.get(connection_id) {
                if tx.send(message.clone()).is_err() {
                    error!("Failed to send message to connection {}", connection_id);
                } else {
                    info!("Message sent to connection {}", connection_id);
                }
            }
        }
    } else {
        info!("No hay suscriptores asociados a la impresora: {}", printer);
    }
}