aurora-modules 0.1.0

use aurora_core::{AuroraResult, Pipeline, Value};
use std::process::Command;

fn check_tool(name: &str) -> AuroraResult<()> {
    let status = Command::new("which")
        .arg(name)
        .output()
        .ok()
        .map(|o| o.status.success())
        .unwrap_or(false);
    if !status {
        return Err(aurora_core::AuroraError::CommandNotFound(
            format!("{} is not installed (install with: apt install {})", name, name)
        ));
    }
    Ok(())
}

pub fn qr_encode(text: &str, output: Option<&str>) -> AuroraResult<Pipeline> {
    check_tool("qrencode")?;

    let mut cmd = Command::new("qrencode");
    if let Some(out) = output {
        cmd.args(["-o", out, text]);
    } else {
        cmd.arg(text);
    }

    let result = cmd.output()
        .map_err(|e| aurora_core::AuroraError::ModuleError(
            format!("qrencode failed: {}", e)
        ))?;

    if !result.status.success() {
        let stderr = String::from_utf8_lossy(&result.stderr);
        return Err(aurora_core::AuroraError::ModuleError(
            format!("qrencode failed: {}", stderr)
        ));
    }

    Ok(Pipeline::table(
        vec!["action".into(), "text".into(), "output".into(), "status".into()],
        vec![vec![
            Value::String("encode".into()),
            Value::String(text.into()),
            Value::String(output.unwrap_or("stdout").into()),
            Value::String("ok".into()),
        ]],
    ))
}

pub fn qr_decode(input: &str) -> AuroraResult<Pipeline> {
    check_tool("zbarimg")?;

    let output = Command::new("zbarimg")
        .arg(input)
        .output()
        .map_err(|e| aurora_core::AuroraError::ModuleError(
            format!("zbarimg failed: {}", e)
        ))?;

    let stdout = String::from_utf8_lossy(&output.stdout);
    let stderr = String::from_utf8_lossy(&output.stderr);

    if !output.status.success() && stdout.is_empty() {
        return Err(aurora_core::AuroraError::ModuleError(
            format!("zbarimg failed: {}", stderr)
        ));
    }

    Ok(Pipeline::table(
        vec!["decoded".into()],
        vec![vec![Value::String(stdout.trim().into())]],
    ))
}