sharing\natives/

common.rs

/*
 * Authors: Jorge.A Duran & Mario Gónzalez
 * Company: pispas Technologies SL
 * Date: April 23, 2023
 * Description: commons definition for singleton.
 */
use thiserror::Error;


#[derive(Error, Debug)]
pub enum NativeError {
    #[error("singleton was owned from another pid")]
    SingletonLocked,
    #[error("Unable to get singleton handle")]
    SingletonUnavailable
}

pub type NativeResult<T> = crate::PisPasResult<T>;

pub trait Lock {
    fn lock(&self) -> NativeResult<()>;

    fn unlock(&self)-> NativeResult<()> ;
}
use std::process::{Command, Stdio};

pub fn show_message_box_non_blocking(message: &str) {
    let title = "UNPISPAS SERVICIO IMPRESION";

    #[cfg(target_os = "windows")]
    show_message_box_windows(message, title);

    #[cfg(target_os = "macos")]
    show_message_box_macos(message, title);

    #[cfg(target_os = "linux")]
    show_message_box_linux(message, title);

    #[cfg(not(any(target_os = "windows", target_os = "macos", target_os = "linux")))]
    {
        tracing::warn!("Message box not supported on this platform: {}", message);
        println!("{}: {}", title, message);
    }
}

#[cfg(target_os = "windows")]
fn show_message_box_windows(message: &str, title: &str) {
    let command = format!(
        "[reflection.assembly]::LoadWithPartialName('System.Windows.Forms')|out-null;[windows.forms.messagebox]::Show('{}', '{}')",
        message, title
    );

    let result = Command::new("powershell")
        .arg("-WindowStyle")
        .arg("Hidden")
        .arg("-Command")
        .arg(command)
        .stdout(Stdio::null())
        .stderr(Stdio::piped())
        .spawn();

    if let Err(e) = result {
        tracing::error!("Error al ejecutar el comando PowerShell: {}", e);
    }
}

#[cfg(target_os = "macos")]
fn show_message_box_macos(message: &str, title: &str) {
    // Opción 1: osascript (AppleScript) - más nativo
    let script = format!(
        "display dialog \"{}\" with title \"{}\" buttons {{\"OK\"}} default button \"OK\"",
        message.replace("\"", "\\\""),
        title.replace("\"", "\\\"")
    );

    let result = Command::new("osascript")
        .arg("-e")
        .arg(script)
        .stdout(Stdio::null())
        .stderr(Stdio::piped())
        .spawn();

    if let Err(e) = result {
        tracing::error!("Error al ejecutar osascript: {}", e);

        // Fallback: terminal-notifier si está instalado
        fallback_macos_notification(message, title);
    }
}

#[cfg(target_os = "macos")]
fn fallback_macos_notification(message: &str, title: &str) {
    // Alternativa usando terminal-notifier (si está instalado)
    let result = Command::new("terminal-notifier")
        .arg("-message")
        .arg(message)
        .arg("-title")
        .arg(title)
        .arg("-sound")
        .arg("default")
        .stdout(Stdio::null())
        .stderr(Stdio::piped())
        .spawn();

    if let Err(e) = result {
        tracing::error!("Error con terminal-notifier: {}", e);
        // Como último recurso, usar say para notificación por voz
        let _ = Command::new("say")
            .arg(format!("{}: {}", title, message))
            .spawn();
    }
}

#[cfg(target_os = "linux")]
fn show_message_box_linux(message: &str, title: &str) {
    // Intentar diferentes opciones en orden de preferencia

    // Opción 1: zenity (GNOME)
    if try_zenity(message, title) {
        return;
    }

    // Opción 2: kdialog (KDE)
    if try_kdialog(message, title) {
        return;
    }

    // Opción 3: notify-send (notificaciones del sistema)
    if try_notify_send(message, title) {
        return;
    }

    // Opción 4: xmessage (X11 básico)
    if try_xmessage(message, title) {
        return;
    }

    // Fallback: log y print
    tracing::warn!("No se pudo mostrar message box en Linux: {}", message);
    println!("{}: {}", title, message);
}

#[cfg(target_os = "linux")]
fn try_zenity(message: &str, title: &str) -> bool {
    Command::new("zenity")
        .arg("--info")
        .arg("--title")
        .arg(title)
        .arg("--text")
        .arg(message)
        .arg("--no-wrap")
        .stdout(Stdio::null())
        .stderr(Stdio::piped())
        .spawn()
        .is_ok()
}

#[cfg(target_os = "linux")]
fn try_kdialog(message: &str, title: &str) -> bool {
    Command::new("kdialog")
        .arg("--msgbox")
        .arg(message)
        .arg("--title")
        .arg(title)
        .stdout(Stdio::null())
        .stderr(Stdio::piped())
        .spawn()
        .is_ok()
}

#[cfg(target_os = "linux")]
fn try_notify_send(message: &str, title: &str) -> bool {
    Command::new("notify-send")
        .arg(title)
        .arg(message)
        .arg("--urgency=normal")
        .arg("--expire-time=5000") // 5 segundos
        .stdout(Stdio::null())
        .stderr(Stdio::piped())
        .spawn()
        .is_ok()
}

#[cfg(target_os = "linux")]
fn try_xmessage(message: &str, title: &str) -> bool {
    let full_message = format!("{}\n\n{}", title, message);
    Command::new("xmessage")
        .arg("-center")
        .arg(full_message)
        .stdout(Stdio::null())
        .stderr(Stdio::piped())
        .spawn()
        .is_ok()
}

// Función adicional para message boxes síncronos (con respuesta)
pub fn show_message_box_blocking(message: &str) -> bool {
    let title = "UNPISPAS SERVICIO IMPRESION";

    #[cfg(target_os = "windows")]
    return show_message_box_blocking_windows(message, title);

    #[cfg(target_os = "macos")]
    return show_message_box_blocking_macos(message, title);

    #[cfg(target_os = "linux")]
    return show_message_box_blocking_linux(message, title);

    #[cfg(not(any(target_os = "windows", target_os = "macos", target_os = "linux")))]
    {
        println!("{}: {}", title, message);
        false
    }
}

#[cfg(target_os = "windows")]
fn show_message_box_blocking_windows(message: &str, title: &str) -> bool {
    let command = format!(
        "[reflection.assembly]::LoadWithPartialName('System.Windows.Forms')|out-null;[windows.forms.messagebox]::Show('{}', '{}', 'YesNo')",
        message, title
    );

    let result = Command::new("powershell")
        .arg("-WindowStyle")
        .arg("Hidden")
        .arg("-Command")
        .arg(command)
        .output();

    match result {
        Ok(output) => {
            let stdout = String::from_utf8_lossy(&output.stdout);
            stdout.trim() == "Yes"
        }
        Err(e) => {
            tracing::error!("Error al ejecutar PowerShell: {}", e);
            false
        }
    }
}

#[cfg(target_os = "macos")]
fn show_message_box_blocking_macos(message: &str, title: &str) -> bool {
    let script = format!(
        "display dialog \"{}\" with title \"{}\" buttons {{\"No\", \"Yes\"}} default button \"Yes\"",
        message.replace("\"", "\\\""),
        title.replace("\"", "\\\"")
    );

    let result = Command::new("osascript")
        .arg("-e")
        .arg(script)
        .output();

    match result {
        Ok(output) => {
            let stdout = String::from_utf8_lossy(&output.stdout);
            stdout.contains("Yes")
        }
        Err(e) => {
            tracing::error!("Error al ejecutar osascript: {}", e);
            false
        }
    }
}

#[cfg(target_os = "linux")]
fn show_message_box_blocking_linux(message: &str, title: &str) -> bool {
    // Intentar zenity primero para Yes/No dialog
    if let Ok(output) = Command::new("zenity")
        .arg("--question")
        .arg("--title")
        .arg(title)
        .arg("--text")
        .arg(message)
        .output()
    {
        return output.status.success();
    }

    // Fallback a kdialog
    if let Ok(output) = Command::new("kdialog")
        .arg("--yesno")
        .arg(message)
        .arg("--title")
        .arg(title)
        .output()
    {
        return output.status.success();
    }

    // Si nada funciona, usar la versión no-blocking
    show_message_box_linux(message, title);
    false
}