pispas_modules/

printsrvc.rs

// ===== IMPORTS CORE (Todas las plataformas) =====
use crate::{
    pdf_manager::PDFManager,
    send_message,
    service::{Service, WebSocketWrite},
};

use async_trait::async_trait;
use base64::{engine::general_purpose, Engine};
use easy_trace::prelude::{debug, error, info};
use futures_util::SinkExt;
use lazy_static::lazy_static;
use md5;
use regex::{Regex, RegexBuilder};
use serde::{Deserialize, Serialize};
use serde_json::{json, Value};
use std::{
    collections::HashMap,
    fs::File,
    io::Write,
    path::Path,
    process::{Command, Stdio},
    sync::Arc,
};
use printers::common::base::job::PrinterJobOptions;
use tokio::sync::Mutex;
use tokio::task;
use tokio::time::timeout;
use tokio::time::{sleep, Duration};
use std::time::Instant;

// ===== IMPORTS ESPECÍFICOS DE WINDOWS =====
#[cfg(target_os = "windows")]
use {
    std::{
        os::windows::{
            process::CommandExt,
        },
    },
};



use printers::common::base::printer::Printer;
use sharing::paths::WKHTMLTOPDF_PATH;
use sharing::utils::ConfigEnv;

type BoxError = Box<dyn std::error::Error + Send + Sync>;

lazy_static! {
    /// Global PDF Manager to handle cached PDF files.
    static ref PDF_MANAGER: Mutex<PDFManager> = Mutex::new(PDFManager::new());
}

/// Version of the PrintService module.
pub const PRINT_VERSION: &str = "1.0.0";
/// Predefined buffer for opening cash drawers.
pub const BUFFER_OPEN_DRAWER: &[u8] = b"\x1B\x70\x00\x64\xC8";

/// Time window during which duplicate `(printer, content-md5)` print
/// requests are suppressed. The backend sometimes sends the same HTML
/// twice for the same printer when a client retries — the second one is
/// dropped silently so we don't print twice.
///
/// `copies` is respected — if the same request asks for 2 copies we still
/// print 2. Dedup only affects the *second identical request*.
const PRINT_DEDUP_WINDOW: Duration = Duration::from_millis(2_500);

lazy_static! {
    /// Strip clock timestamps (`HH:MM` or `HH:MM:SS`) from the HTML before
    /// hashing for dedup so two prints of the "same ticket" seconds apart
    /// are considered identical.
    static ref DEDUP_TIME_RE: Regex = Regex::new(r"\d{1,2}:\d{2}(?::\d{2})?").unwrap();

    /// Strip the order-stage label so `Nueva comanda` and `Cambios en
    /// comanda` with the same products collapse to the same key. The
    /// backend emits both for what is logically one kitchen event.
    static ref DEDUP_STAGE_RE: Regex = Regex::new(r"(?i)(Nueva|Cambios? en) comanda").unwrap();
}

/// Produces a signature intended to be equal across cosmetic variations
/// of the same logical print (stage header + clock time removed).
///
/// Used **only** for the dedup check. The full-content md5 still drives
/// file naming so PDF cache hits remain correct.
fn dedup_signature(html: &str) -> String {
    let s1 = DEDUP_TIME_RE.replace_all(html, "");
    let s2 = DEDUP_STAGE_RE.replace_all(&s1, "");
    format!("{:x}", md5::compute(s2.as_bytes()))
}

/// Struct to manage the printing service, including printer handling and job processing.
pub struct PrintService {
    printers: Arc<Mutex<Vec<Printer>>>, // List of available printers.
    list_printers: Arc<Mutex<Vec<String>>>, // List of printer names.
    config: ConfigEnv,                     // Configuration for the service.
    command_viewer: bool, // Flag to indicate if CommandViewer is enabled.
    /// Per-(printer, content-md5) last-print timestamp, used for dedup.
    recent_prints: Arc<Mutex<HashMap<(String, String), Instant>>>,
}

impl Clone for PrintService {
    fn clone(&self) -> Self {
        PrintService {
            printers: Arc::clone(&self.printers),
            list_printers: Arc::clone(&self.list_printers),
            config: self.config.clone(),
            command_viewer: self.command_viewer,
            recent_prints: Arc::clone(&self.recent_prints),
        }
    }
}

/// Enum defining the various actions supported by the PrintService.
#[derive(Deserialize, Serialize, Debug, Clone)]
#[serde(rename_all = "PascalCase")]
pub enum PrintAction {
    Print {
        content: String,
        printer_name: Option<String>,
        copies: Option<u32>,
        open: bool,
    },
    OpenDrawer {
        printer_name: String,
    },
    Check,
    ListPrinters,
    Unknown,
}

impl PrintService {
    /// Creates a new instance of the PrintService.
    pub async fn new(mut config: ConfigEnv) -> Self {
        let devices = PrintService::list_printers().await;
        println!("PrintService initialized with {} printers", devices.len());

        // Log printer details (solo para debug)
        let simplified_devices: Vec<String> = devices
            .iter()
            .map(|p| format!("name: {}, driver_name: {}", p.name, p.driver_name))
            .collect();
        debug!("PrintService initialized with printers: {:?}", simplified_devices);

        // 1) Partimos de las impresoras detectadas en el sistema
        let mut names: std::collections::HashSet<String> = devices.iter().map(|p| p.name.clone()).collect();

        // 2) Añadimos CommandViewer si está habilitado
        info!("modules configured: {:?}", config.modules);
        let command_viewer = config.modules.iter().any(|m| m == "commandViewer");
        if command_viewer {
            names.insert("CommandViewer".to_string());
        }
        info!("CommandViewer enabled: {}", command_viewer);

        // 3) Unimos con las que ya hubiera en config.list_printers
        if let Some(cfg_list) = &config.list_printers {
            for p in cfg_list {
                names.insert(p.clone());
            }
        } else {
            info!("No printers configured in config, using detected ones");
        }

        // 4) Convertimos a Vec ordenado (opcional, para determinismo)
        let mut merged: Vec<String> = names.into_iter().collect();
        merged.sort();

        // 5) Escribimos la unión de vuelta al config (¡aquí está la clave!)
        config.list_printers = Some(merged.clone());

        info!("PRINTERS NAMES (merged): {:?}", merged);

        config.save(); // descomenta si tu tipo lo soporta aquí

        PrintService {
            printers: Arc::new(Mutex::new(devices)),
            list_printers: Arc::new(Mutex::new(merged)),
            config,
            command_viewer,
            recent_prints: Arc::new(Mutex::new(HashMap::new())),
        }
    }

    async fn add_printer_string(&mut self, printer_name: &str) {
        info!("LIST_PRINTERS BEFORE: {:?}", self.config.list_printers);
        let mut printers = self.list_printers.lock().await;
        if !printers.contains(&printer_name.to_string()) {
            printers.push(printer_name.to_string());
        }
        self.config.list_printers
            .get_or_insert_with(Vec::new)
            .push(printer_name.to_string());
        info!("list_printers updated: {:?}", self.config.list_printers);
        self.config.save();
    }

    async fn get_print_list(&self) -> Vec<String> {
        let printers = self.list_printers.lock().await;
        printers.clone()
    }


    /// Extracts CSS properties like margins and page dimensions from the HTML content.
    ///
    /// # Arguments
    /// - `html`: HTML content as a string.
    fn extract_css_from_html(&self, html: &str) -> HashMap<String, String> {
        let mut extracted_css = HashMap::new();

        extracted_css.insert("margin-top".to_string(), "0mm".to_string());
        extracted_css.insert("margin-right".to_string(), "0mm".to_string());
        extracted_css.insert("margin-bottom".to_string(), "0mm".to_string());
        extracted_css.insert("margin-left".to_string(), "0mm".to_string());
        extracted_css.insert("page-width".to_string(), "72mm".to_string());
        extracted_css.insert("page-height".to_string(), "297mm".to_string());

        let page_re = RegexBuilder::new(r"@page\s*\{\s*([^}]*)\s*\}")
            .dot_matches_new_line(true)
            .build();

        match page_re {
            Ok(page_re) => {
                // Search for the @page block
                if let Some(page_match) = page_re.captures(html) {
                    let page_css = page_match.get(1).map_or("", |m| m.as_str());

                    // Regex to capture page size (size)
                    if let Ok(size_re) = Regex::new(r"size:\s*([\d.]+mm)\s+([\d.]+mm)(?:\s+\w+)?;")
                    {
                        if let Some(size_match) = size_re.captures(page_css) {
                            let page_width = size_match.get(1).map_or("", |m| m.as_str());
                            let page_height = size_match.get(2).map_or("", |m| m.as_str());
                            extracted_css.insert("page-width".to_string(), page_width.to_string());
                            extracted_css
                                .insert("page-height".to_string(), page_height.to_string());
                        }
                    }

                    // Regex to capture margins
                    if let Ok(margin_re) =
                        Regex::new(r"margin-(top|right|bottom|left):\s*([\d.]+[a-z]+);")
                    {
                        for margin_match in margin_re.captures_iter(page_css) {
                            let margin_name = margin_match.get(1).map_or("", |m| m.as_str());
                            let margin_value = margin_match.get(2).map_or("", |m| m.as_str());
                            extracted_css.insert(
                                format!("margin-{}", margin_name),
                                margin_value.to_string(),
                            );
                        }
                    }
                }
            }
            Err(e) => {
                error!("Error to create regex: {}", e);
            }
        }

        extracted_css
    }

    /// Processes a given print action and executes the respective logic.
    async fn run_action(&mut self, action: PrintAction) -> (i32, String) {
        match action {
            PrintAction::Print {
                content,
                printer_name,
                copies,
                open,
            } => {
                info!("Printing content");

                // Llamamos a `save_and_print_pdf` para manejar la impresión
                let print_result = self
                    .save_and_print_pdf(&content, printer_name.as_deref(), copies.unwrap_or(1))
                    .await;

                match print_result {
                    Ok(_) => {
                        info!("Print job completed successfully.");

                        if open {
                            if let Some(printer_name) = printer_name {
                                info!("Opening drawer for printer: {}", printer_name);
                                let (status, message) = self.open_drawer(&printer_name).await;
                                if status != 0 {
                                    error!("Failed to open drawer: {}", message);
                                } else {
                                    info!("Drawer opened successfully");
                                }
                            } else {
                                error!("Printer name is not provided for opening drawer");
                            }
                        }

                        (0, "print ok".to_string())
                    }
                    Err(e) => {
                        error!("Failed to print: {}", e);
                        (1, "print failed".to_string())
                    }
                }
            }
            PrintAction::OpenDrawer { printer_name } => {
                info!("Opening drawer for printer: {}", printer_name);
                self.open_drawer(&printer_name).await
            }
            PrintAction::Check => {
                info!("Performing check action");
                (0, "check ok".to_string())
            }
            PrintAction::ListPrinters => {
                let printers = self.printers.lock();
                let printer_names = printers
                    .await
                    .iter()
                    .map(|p| p.name.clone())
                    .collect::<Vec<String>>();
                (0, serde_json::to_string(&printer_names).unwrap())
            }
            PrintAction::Unknown => {
                error!("Unknown action");
                (1, "unknown action".to_string())
            }
        }
    }

    async fn send_html_to_kitchen(
        &self,
        decoded_html: String,
        _id: &str,
        print_name: &str,
    ) -> Result<(), BoxError> {
        use serde_json::json;
        use tokio_tungstenite::{connect_async, tungstenite::Message};

        let url = "ws://127.0.0.1:9001"; // WebSocket del módulo de cocina
        let (mut socket, _) = connect_async(url).await?;
        //nuevo uuid v4
        let uuid = uuid::Uuid::new_v4();
        // Crear un mensaje JSON para agregar la comanda
        let command_message = json!({
            "action": "addCommand",
            "data": {
                "id": format!("{}", uuid), // Generar un ID único
                "html": decoded_html,
                "order_no": "",
                "archived": false,
                "printer": print_name,
            }
        });

        // Enviar el mensaje
        socket
            .send(Message::Text(command_message.to_string()))
            .await?;
        // debug!("HTML sent to kitchen: {:?}", decoded_html);
        info!("HTML sent to kitchen");
        Ok(())
    }

    /// Saves the given HTML content as a PDF and sends it to the specified printer.
    ///
    /// # Arguments
    /// - `content`: The base64-encoded HTML content to be printed.
    /// - `printer_name`: The name of the printer to which the job should be sent.
    /// - `copies`: Number of copies to print.
    ///
    /// # Returns
    /// - `Ok(())` if the job was successfully processed.
    /// - `Err` with an appropriate error message otherwise.

    #[cfg(not(target_os = "windows"))]
    /// Prints a PDF file using the printers crate (cross-platform)
    async fn print_pdf(
        &self,
        file_path: &Path,
        printer_name: Option<&str>,
        copies: u32,
    ) -> Result<(), BoxError> {
        info!("Printing with printers crate: {:?} printer {:?} copies {}",
          file_path, printer_name, copies);

        // Verificar que el archivo existe
        if !file_path.exists() {
            error!("PDF file not found: {:?}", file_path);
            return Err("PDF file not found".into());
        }

        let printer_name = printer_name.unwrap_or("Default");

        // Skip printing if it's CommandViewer
        if printer_name == "CommandViewer" {
            info!("Skipping print for CommandViewer");
            return Ok(());
        }

        // Obtener la impresora usando la librería printers
        let printer = if printer_name == "Default" {
            printers::get_default_printer()
        } else {
            printers::get_printer_by_name(printer_name)
        };

        let printer = match printer {
            Some(p) => p,
            None => {
                // Actualizar lista de impresoras y reintentar
                let new_printers = PrintService::list_printers().await;
                let mut printers_cache = self.printers.lock().await;
                *printers_cache = new_printers;

                return Err(format!("Printer '{}' not found", printer_name).into());
            }
        };

        // Imprimir el PDF el número de copias especificado
        for copy in 1..=copies {
            let job_name = format!("Print Job {} (copy {}/{})",
                                   file_path.file_name().unwrap_or_default().to_string_lossy(),
                                   copy, copies);

            let options = PrinterJobOptions {
                name: Some(&job_name),
                raw_properties: &[],
            };

            match printer.print_file(file_path.to_str().unwrap(), options) {
                Ok(_) => {
                    info!("Print job {} sent successfully", job_name);
                }
                Err(e) => {
                    error!("Failed to print copy {}: {:?}", copy, e);
                    return Err(format!("Failed to print: {:?}", e).into());
                }
            }
        }

        info!("All {} copies printed successfully", copies);
        Ok(())
    }

    /// Envía datos raw a la impresora usando printer.print() directamente
    pub async fn send_to_printer(&self, printer_name: &str, data: &[u8]) -> Result<(), BoxError> {
        info!("Sending raw data to printer: {} ({} bytes)", printer_name, data.len());

        // Buscar la impresora (asumimos que ya existe porque se validó antes)
        let printers = self.printers.lock().await;
        let printer = printers.iter()
            .find(|p| p.name == printer_name)
            .ok_or_else(|| format!("Printer '{}' not found", printer_name))?
            .clone();

        drop(printers); // Liberar el lock inmediatamente

        info!("Found printer: {} (driver: {})", printer.name, printer.driver_name);

        // Enviar datos raw usando print() directamente
        let result = tokio::task::spawn_blocking({
            let data = data.to_vec();
            move || {
                let options = PrinterJobOptions {
                    name: Some("Open Drawer Command"),  
                    raw_properties: &[],             
                };

                printer.print(&data, options)
            }
        }).await;

        match result {
            Ok(Ok(job)) => {
                info!("Raw data sent successfully. Job: {:?}", job);
                Ok(())
            }
            Ok(Err(e)) => {
                error!("Failed to print raw data: {:?}", e);
                Err(format!("Print failed: {:?}", e).into())
            }
            Err(e) => {
                error!("Task spawn failed: {}", e);
                Err(format!("Task spawn failed: {}", e).into())
            }
        }
    }

    /// Función específica para abrir cajón (wrapper más semántico)
    pub async fn open_drawer(&self, printer_name: &str) -> (i32, String) {
        info!("Opening drawer for printer: {}", printer_name);

        match self.send_to_printer(printer_name, BUFFER_OPEN_DRAWER).await {
            Ok(_) => {
                info!("Drawer opened successfully");
                (0, "drawer opened".to_string())
            }
            Err(e) => {
                error!("Failed to open drawer: {}", e);
                (1, "drawer failed".to_string())
            }
        }
    }


    async fn save_and_print_pdf(
        &mut self,
        content: &str,
        printer_name: Option<&str>,
        copies: u32,
    ) -> Result<(), BoxError> {
        // Ensure the jobs directory exists
        let job_dir = sharing::paths::jobs_dir();
        if !job_dir.exists() {
            match std::fs::create_dir_all(&job_dir) {
                Ok(_) => {
                    info!("Created jobs directory");
                }
                Err(e) => {
                    error!("Failed to create jobs directory: {}", e);
                    return Err(e.into());
                }
            }
        }

        // Decode the base64 content
        let decoded_html = match general_purpose::STANDARD.decode(content) {
            Ok(decoded) => decoded,
            Err(e) => {
                error!("Failed to decode content: {}", e);
                return Err(e.into());
            }
        };

        // Convert the Vec<u8> to a String (assuming the content is valid UTF-8)
        let decoded_html_str = String::from_utf8(decoded_html.clone())
            .map_err(|e| format!("Failed to convert decoded content to string: {}", e))?;

        // Extract CSS properties
        let css_properties = self.extract_css_from_html(&decoded_html_str);

        // Clonar las propiedades CSS necesarias
        let page_width = css_properties
            .get("page-width")
            .unwrap_or(&"72mm".to_string())
            .clone();
        let page_height = css_properties
            .get("page-height")
            .unwrap_or(&"297mm".to_string())
            .clone();
        let margin_top = css_properties
            .get("margin-top")
            .unwrap_or(&"0mm".to_string())
            .clone();
        let margin_right = css_properties
            .get("margin-right")
            .unwrap_or(&"0mm".to_string())
            .clone();
        let margin_bottom = css_properties
            .get("margin-bottom")
            .unwrap_or(&"0mm".to_string())
            .clone();
        let margin_left = css_properties
            .get("margin-left")
            .unwrap_or(&"0mm".to_string())
            .clone();

        let file_md5 = format!("{:x}", md5::compute(decoded_html_str.as_bytes()));
        let name = printer_name.unwrap_or("POS-80C");

        // Dedup: if a logically-equivalent ticket was printed to the same
        // printer in the last PRINT_DEDUP_WINDOW, drop this one.
        //
        // Key is (printer, normalized-signature), where the signature
        // ignores the stage header (Nueva / Cambios en comanda) and the
        // clock time so the backend's "new + change" pair for the same
        // order collapses to a single print. See `dedup_signature`.
        //
        // We still return Ok so the caller sees SUCCESS and does not retry.
        {
            let sig = dedup_signature(&decoded_html_str);
            let key = (name.to_string(), sig.clone());
            let mut recent = self.recent_prints.lock().await;
            let now = Instant::now();

            recent.retain(|_, ts| now.duration_since(*ts) <= PRINT_DEDUP_WINDOW);

            if let Some(prev) = recent.get(&key) {
                let age = now.duration_since(*prev);
                info!(
                    "Skipping duplicate print: printer={} sig={} md5={} age={:?}",
                    name, sig, file_md5, age
                );
                return Ok(());
            }

            recent.insert(key, now);
        }

        if self.command_viewer{
            if let Err(e) = self
                .send_html_to_kitchen(decoded_html_str.clone(), &file_md5.clone(), name)
                .await
            {
                error!("Failed to send HTML to kitchen: {}", e);
            }
        }

        // Build the file path using the hash
        let pdf_filename = format!("{}_{}.pdf", self.config.service_name, file_md5);
        let pdf_path = job_dir.join(pdf_filename);
        info!("PDF path: {:?}", pdf_path);

        //if pdf_filename exists, call print)
        if !pdf_path.exists() {
            // Guardamos el HTML como archivo temporal
            let html_filename = format!("{}_{}.html", self.config.service_name, file_md5);
            let html_path = job_dir.join(html_filename);
            let mut file = match File::create(&html_path) {
                Ok(f) => f,
                Err(e) => {
                    error!("Failed to create HTML file: {}", e);
                    return Err(e.into());
                }
            };
            match file.write_all(&decoded_html.clone()) {
                Ok(_) => {
                    info!("HTML content saved to file: {:?}", html_path);
                }
                Err(e) => {
                    error!("Failed to write HTML content to file: {}", e);
                    return Err(e.into());
                }
            }


            // Verificar si wkhtmltopdf está disponible
            if !Path::new(sharing::paths::WKHTMLTOPDF_PATH.as_str()).exists() {
                info!("WKHTMLTOPDF_PATH: {:?}", sharing::paths::WKHTMLTOPDF_PATH);
                return Err("wkhtmltopdf executable not found".into());
            }
            let wkhtmltopdf_path = WKHTMLTOPDF_PATH.as_str().to_string();
            // Clone pdf_path to pass to the async task
            let pdf_path_clone = pdf_path.clone();
            let html_path_clone = html_path.clone();

            info!("Converting HTML to PDF");
            let result = timeout(
                Duration::from_secs(10),
                task::spawn_blocking(move || {
                    let mut command = Command::new(&wkhtmltopdf_path);
                    command
                        .arg("--page-width")
                        .arg(page_width)
                        .arg("--page-height")
                        .arg(page_height)
                        .arg("--margin-top")
                        .arg(margin_top)
                        .arg("--margin-right")
                        .arg(margin_right)
                        .arg("--margin-bottom")
                        .arg(margin_bottom)
                        .arg("--margin-left")
                        .arg(margin_left)
                        .arg("--print-media-type")
                        .arg("--no-pdf-compression")           // Evita compresión que puede causar problemas
                        .arg("--image-quality")
                        .arg("100")
                        .arg(&html_path_clone)
                        .arg(&pdf_path_clone)
                        .stdout(Stdio::null())
                        .stderr(Stdio::null());

                    // ✅ Solo aplicar creation_flags en Windows
                    #[cfg(target_os = "windows")]
                    command.creation_flags(winapi::um::winbase::CREATE_NO_WINDOW);

                    let status = command
                        .spawn()
                        .map_err(|e| format!("Failed to execute wkhtmltopdf: {}", e))?
                        .wait()
                        .map_err(|e| format!("Failed to wait for wkhtmltopdf: {}", e))?;

                    if status.success() {
                        Ok(())
                    } else {
                        Err(format!("wkhtmltopdf failed with exit code: {:?}", status))
                    }
                }),
            )
                .await??;
            match result {
                Ok(_) => {
                    info!("HTML successfully converted to PDF.");
                }
                Err(e) => {
                    error!("Failed to convert HTML to PDF: {}", e);
                    return Err(e.into());
                }
            }


            //delete html file
            match std::fs::remove_file(&html_path) {
                Ok(_) => {
                    info!("HTML file deleted: {:?}", html_path);
                }
                Err(e) => {
                    error!("Failed to delete HTML file: {}", e);
                    return Err(e.into());
                }
            }
        }

        info!("PDF file generated: {:?}", pdf_path);
            //return if printer is CommandViewer
            if name.contains("CommandViewer") {
                //if printer_name not in list add list_printers
                if !self.list_printers.lock().await.contains(&name.to_string()) {
                    info!("Adding CommandViewer to printer list");
                    self.add_printer_string(name).await;
                }
                PDF_MANAGER.lock().await.add_pdf_file(pdf_path);
                return Ok(());
            }
        //if not windows call print_pdf_ else print_with_sumatra
        #[cfg(target_os = "windows")]
        {
            match self.print_with_sumatra(pdf_path.as_path(), printer_name, copies).await {
                Ok(_) => {
                    info!("Print job sent successfully");
                }
                Err(e) => {
                    error!("Failed to send print job: {}", e);
                    PDF_MANAGER.lock().await.add_pdf_file(pdf_path);
                    return Err(e.into());
                }
            }
        }
        #[cfg(not(target_os = "windows"))]
        {
            match self.print_pdf(pdf_path.as_path(), printer_name, copies).await {
                Ok(_) => {
                    info!("Print job sent successfully");
                }
                Err(e) => {
                    error!("Failed to send print job: {}", e);
                    crate::printsrvc::PDF_MANAGER.lock().await.add_pdf_file(pdf_path);
                    return Err(e.into());
                }
            }
        }

        PDF_MANAGER.lock().await.add_pdf_file(pdf_path);
    Ok(())
    }


    #[cfg(target_os = "windows")]
    /// Prints the given PDF file using the SumatraPDF application.
    ///
    /// # Arguments
    /// - `file_path`: Path to the PDF file to print.
    /// - `printer_name`: The target printer's name.
    /// - `copies`: Number of copies to print.
    ///
    /// # Returns
    /// - `Ok(())` if the print job was successfully sent.
    /// - `Err` with an appropriate error message if the job failed.
    async fn print_with_sumatra(
        &self,
        file_path: &Path,
        printer_name: Option<&str>,
        copies: u32,
    ) -> Result<(), BoxError> {
        info!(
            "Printing with SumatraPDF file {:?} printer {:?} copies {}",
            file_path, printer_name, copies
        );
        if !Path::new(sharing::paths::SUMATRA_PATH.as_str()).exists() {
            return Err("SumatraPDF executable not found".into());
        }
        let name = printer_name.unwrap_or("Default Printer");

        // Verifica si la impresora está disponible
        let printer_exists = {
            let printers = self.printers.lock().await; // Bloquea el mutex aquí
            printers.iter().any(|p| p.name == name) || name == "CommandViewer"
        };

        // Check if the printer is available
        if !printer_exists {
            let new_printers = PrintService::list_printers().await;
            let mut printers = self.printers.lock().await; // Bloquea nuevamente para actualizar
            if !new_printers.iter().any(|p| p.name == name) {
                return Err("Printer not found".into());
            }
            *printers = new_printers;
        }

        for _ in 0..copies {
            let file_path = file_path.to_path_buf(); // Clona el Path en un PathBuf
            let name = name.to_string(); // Clona el nombre para el hilo

            let result = timeout(
                Duration::from_secs(5),
                task::spawn_blocking(move || {
                    Command::new(sharing::paths::SUMATRA_PATH.as_str())
                        .arg("-print-to")
                        .arg(name)
                        .arg("-print-settings")
                        .arg("noscale") // Separar correctamente la opción y su valor
                        .arg(file_path)
                        .stdout(Stdio::null())
                        .stderr(Stdio::null())
                        .status()
                        .expect("Failed to execute print command")
                }),
            )
                .await;

            match result {
                Ok(Ok(status)) => {
                    if !status.success() {
                        error!("º command failed: {:?}", status);
                        return Err("Print command failed".into());
                    }
                }
                Ok(Err(e)) => {
                    error!("Task spawn failed: {:?}", e);
                    return Err("Task spawn failed".into());
                }
                Err(_) => {
                    error!("Print command timed out");
                    return Err("Print command timed out".into());
                }
            }
        }

        info!("Print job sent successfully");
        Ok(())
    }

    /// Finds a printer by name from the cached list of printers.
    ///
    /// # Arguments
    /// - `printer_name`: Name of the printer to locate.
    ///
    /// # Returns
    /// - `Option<Printer>` containing the printer details if found.
    /// - `None` if the printer does not exist in the cached list.
    pub async fn _find_printer(&self, printer_name: &str) -> Option<Printer> {
        self.printers
            .lock()
            .await
            .iter()
            .find(|p| p.name == printer_name)
            .cloned()
    }



    /// Retrieves the list of available printers.
    ///
    /// # Returns
    /// - A vector of `Printer` objects representing the available printers.
    async fn list_printers() -> Vec<Printer> {
        #[cfg(target_os = "linux")]
        {
            printers::get_printers()
        }

        #[cfg(target_os = "windows")]
        {
            printers::get_printers()
        }

        #[cfg(target_os = "macos")]
        {
            printers::get_printers()
        }

        #[cfg(target_os = "ios")]
        {
            // Implementación para obtener impresoras en iOS
            Vec::new()
        }
    }

    /// Processes the given JSON action object and executes the respective operations.
    ///
    /// # Arguments
    /// - `action`: A JSON `Value` containing the action details.
    ///
    /// # Returns
    /// - `(0, String)` if the actions were processed successfully.
    /// - `(1, String)` if an error occurred during processing.
    async fn process_action(&mut self, action: Value, write: WebSocketWrite) -> (i32, String) {
        let action_type = match action.get("ACTION").and_then(Value::as_str) {
            Some(action_str) => action_str,
            None => {
                error!("Missing or invalid ACTION field");
                return (1, "Missing ACTION field".to_string());
            }
        };

        if action_type == "getPrinters" {
            info!("Processing getPrinters action");
            let printers = self.get_print_list().await;

            let uuid = match action.get("UUIDV4") {
                Some(Value::String(uuid)) => uuid,
                _ => {
                    error!("Missing or invalid MESSAGE_UUID field");
                    return (1, "Missing MESSAGE_UUID field".to_string());
                }
            };
            let response = json!({
            "SERVICE_NAME": "PRINT",
            "SERVICE_VERS": PRINT_VERSION,
            "MESSAGE_TYPE": "RESPONSE",
            "MESSAGE_EXEC": "SUCCESS",
            "MESSAGE_UUID": uuid,
            "MESSAGE_DATA": printers,
        }).to_string();

            send_message(&write, response).await;
            return (0, "Printers list sent".to_string());
        }

        let action_map = match action.get("ACTION") {
            Some(Value::String(action_str)) => {
                match serde_json::from_str::<serde_json::Map<String, Value>>(action_str) {
                    Ok(map) => map,
                    Err(e) => {
                        error!("Failed to parse ACTION as JSON object: {}", e);
                        return (1, format!("Invalid ACTION format: {}", e));
                    }
                }
            }
            _ => {
                error!("Missing or invalid ACTION field");
                return (1, "Missing ACTION field".to_string());
            }
        };

        for (device_name, device_actions) in action_map {
            info!("Processing actions for device: {}", device_name);

            if device_actions.is_null() {
                return (0, "Device is reachable".to_string());
            }

            // ✅ MANEJO CORRECTO SEGÚN EL TIPO DE DEVICE_ACTIONS
            match &device_actions {
                Value::Object(actions) => {
                    debug!("Device actions is object: {:?}", actions);

                    // Check if the "print" field exists and is not null
                    if let Some(Value::String(print_content)) = actions.get("print") {
                        info!("Found print content, length: {}", print_content.len());

                        if let Some(print_action) = self.parse_print_action(&device_name, &actions) {
                            let result = self.run_action(print_action).await;
                            if result.0 != 0 {
                                return result;
                            }
                        }
                    } else {
                        // Process as drawer open if not a valid print
                        if let Some(open_action) = self.parse_open_action(&device_name, &actions) {
                            info!("open_action {:?}", open_action);
                            let result = self.run_action(open_action).await;
                            if result.0 != 0 {
                                return result;
                            }
                        }
                    }
                }
                Value::String(content) => {
                    // 🔥 SI ES UN STRING, ASUMIR QUE ES CONTENIDO BASE64 DIRECTO
                    info!("Device actions is string (assuming base64), length: {}", content.len());

                    let print_action = PrintAction::Print {
                        content: content.clone(),
                        printer_name: Some(device_name.clone()),
                        copies: Some(1),
                        open: false,
                    };

                    let result = self.run_action(print_action).await;
                    if result.0 != 0 {
                        return result;
                    }
                }
                _ => {
                    let error_msg = format!("Actions for '{}' must be a JSON object or string, got: {:?}",
                                            device_name, device_actions);
                    error!("{}", error_msg);
                    return (1, error_msg);
                }
            }
        }

        (0, "All actions processed successfully".to_string())
    }

    /// Parses a print action from a JSON object.
    ///
    /// # Arguments
    /// - `device`: Name of the printer.
    /// - `actions`: JSON object containing the action details.
    ///
    /// # Returns
    /// - `Option<PrintAction>` if the action could be parsed successfully.
    /// - `None` if the action is invalid or unsupported.
    fn parse_print_action(
        &self,
        device: &str,
        actions: &serde_json::Map<String, Value>,
    ) -> Option<PrintAction> {
        if let Some(print_content) = actions.get("print") {
            let content = match print_content {
                Value::String(s) => {
                    info!("Print content for device {}: {} chars", device, s.len());
                    s.clone()
                }
                _ => {
                    error!("Print content for device {} is not a string: {:?}", device, print_content);
                    return None;
                }
            };

            let copies = actions
                .get("copies")
                .and_then(Value::as_u64)
                .map(|c| c as u32)
                .unwrap_or(1);

            let open = actions
                .get("open")
                .and_then(Value::as_bool)
                .unwrap_or(false);

            info!("Parsed print action - device: {}, copies: {}, open: {}", device, copies, open);

            Some(PrintAction::Print {
                content,
                printer_name: Some(device.to_string()),
                copies: Some(copies),
                open,
            })
        } else {
            debug!("No 'print' field found in actions for device: {}", device);
            None
        }
    }

    /// Parses an open drawer action from a JSON object.
    ///
    /// # Arguments
    /// - `device`: Name of the printer.
    /// - `actions`: JSON object containing the action details.
    ///
    /// # Returns
    /// - `Option<PrintAction>` if the action could be parsed successfully.
    /// - `None` if the action is invalid or unsupported.
    fn parse_open_action(
        &self,
        device: &str,
        actions: &serde_json::Map<String, Value>,
    ) -> Option<PrintAction> {
        if let Some(open_drawer) = actions.get("open") {
            if open_drawer.as_bool().unwrap_or(false) {
                return Some(PrintAction::OpenDrawer {
                    printer_name: device.to_string(),
                });
            }
        }
        None
    }
}

#[async_trait]
impl Service for PrintService {
    /// Executes a print service action based on the provided JSON input.
    ///
    /// # Arguments
    ///
    /// * `action` - A JSON value containing the action details.
    /// * `_write` - A `WebSocketWrite` (unused in this implementation).
    ///
    /// # Returns
    ///
    /// A tuple containing:
    /// * `i32` - Status code (0 for success, 1 for failure).
    /// * `String` - A descriptive message about the action result. If the action takes longer than 2 seconds, returns an asynchronous processing message.
    async fn run(&self, action: Value, _write: WebSocketWrite) -> (i32, String) {
        let deserialized_action = if action.is_string() {
            match serde_json::from_str::<Value>(action.as_str().unwrap_or("")) {
                Ok(val) => val,
                Err(err) => {
                    error!("Failed to parse string JSON: {}", err);
                    return (1, format!("Invalid action format: {}", err));
                }
            }
        } else {
            action
        };

        let result: Arc<Mutex<Option<(i32, String)>>> = Arc::new(Mutex::new(None)); // Explicit type annotation
        let result_clone = Arc::clone(&result);
        let mut self_clone = self.clone();

        // Spawn the background task
        tokio::spawn(async move {
            let process_result = self_clone.process_action(deserialized_action, _write).await;
            let mut lock = result_clone.lock().await;
            *lock = Some(process_result);
        });

        // Active wait for up to 2 seconds
        let start = tokio::time::Instant::now();
        while start.elapsed() < Duration::from_secs(2) {
            {
                let lock = result.lock().await;
                if let Some((code, msg)) = &*lock {
                    return (*code, msg.clone()); // If result is ready, return it
                }
            }
            sleep(Duration::from_millis(100)).await; // Small delay to avoid busy waiting
        }

        // If no result within 2 seconds, return async message but continue processing
        (0, "Action is being processed asynchronously".to_string())
    }

    /// Converts the service instance into a `dyn Any` reference.
    ///
    /// # Returns
    ///
    /// A reference to `dyn Any` for dynamic type checks.
    fn as_any(&self) -> &dyn std::any::Any {
        self
    }

    /// Stops the print service, performing any necessary cleanup tasks.
    fn stop_service(&self) {
        info!("Stopping PrintService...");
    }

    /// Retrieves the current version of the PrintService.
    ///
    /// # Returns
    ///
    /// A `String` containing the version of the service.
    fn get_version(&self) -> String {
        PRINT_VERSION.to_string()
    }
}