photocraft/apps/photocraft-cli/tests/it/gpu.rs

//! Tests for photocraft-cli GPU rendering flags, precedence, and fallback behavior.

use std::path::{Path, PathBuf};
use std::process::Command;

use serde_json::Value;

fn bin() -> Command {
    let mut cmd = Command::new(crate::binary());
    cmd.env_remove("PHOTOCRAFT_CONTROL_PORT");
    cmd.env_remove("PHOTOCRAFT_CONTROL_TOKEN");
    cmd.env_remove("PHOTOCRAFT_CONTROL_TOKEN_FILE");
    cmd.env_remove("PHOTOCRAFT_GPU");
    cmd
}

fn tmp(name: &str) -> PathBuf {
    let d = std::env::temp_dir().join(format!("pc-cli-gpu-{}-{name}", std::process::id()));
    let _ = std::fs::remove_dir_all(&d);
    std::fs::create_dir_all(&d).unwrap();
    d
}

fn write_png(path: &Path, w: u32, h: u32) {
    let data: Vec<u8> = (0..w * h * 4).map(|i| (i as u8).wrapping_mul(7)).collect();
    let img = photocraft_codecs::Image::from_u8(w, h, photocraft_codecs::ChannelLayout::Rgba, data).unwrap();
    std::fs::write(path, photocraft_codecs::encode(&img, photocraft_codecs::Format::Png, &Default::default()).unwrap()).unwrap();
}

#[test]
fn gpu_and_no_gpu_conflict() {
    let d = tmp("conflict");
    let in_png = d.join("in.png");
    let out_png = d.join("out.png");
    write_png(&in_png, 16, 16);

    let o = bin().args(["convert", "--gpu", "--no-gpu", in_png.to_str().unwrap(), out_png.to_str().unwrap()]).output().unwrap();
    assert_eq!(o.status.code(), Some(2));
    let stderr = String::from_utf8_lossy(&o.stderr);
    assert!(stderr.contains("cannot be used with") || stderr.contains("conflicts with"), "{stderr}");
    let _ = std::fs::remove_dir_all(&d);
}

#[test]
fn gpu_env_var_validation() {
    let d = tmp("env_val");
    let in_png = d.join("in.png");
    let out_png = d.join("out.png");
    write_png(&in_png, 16, 16);

    // Invalid non-empty value rejected with usage error naming the variable
    for bad in ["2", "true", "yes", "false", "on", "off"] {
        let o = bin().env("PHOTOCRAFT_GPU", bad).args(["convert", in_png.to_str().unwrap(), out_png.to_str().unwrap()]).output().unwrap();
        assert_eq!(o.status.code(), Some(2), "expected exit 2 for PHOTOCRAFT_GPU={bad}");
        let stderr = String::from_utf8_lossy(&o.stderr);
        assert!(stderr.contains("PHOTOCRAFT_GPU"), "expected stderr to name variable: {stderr}");
        assert!(stderr.contains("expected '1' or '0'"), "expected usage note: {stderr}");
    }

    // Empty or blank value is accepted as unset (CPU default)
    for empty in ["", "   "] {
        let out_sub = d.join(format!("out_{}.png", empty.trim()));
        let o = bin().env("PHOTOCRAFT_GPU", empty).args(["convert", in_png.to_str().unwrap(), out_sub.to_str().unwrap()]).output().unwrap();
        assert!(o.status.success(), "expected success for PHOTOCRAFT_GPU={empty:?}");
        assert!(out_sub.is_file());
    }

    let _ = std::fs::remove_dir_all(&d);
}

#[cfg(unix)]
#[test]
fn gpu_env_var_rejects_a_non_utf8_value() {
    use std::ffi::OsString;
    use std::os::unix::ffi::OsStringExt;

    let d = tmp("env_non_utf8");
    let in_png = d.join("in.png");
    let out_png = d.join("out.png");
    write_png(&in_png, 16, 16);

    let bad = OsString::from_vec(vec![0xff, 0xfe]);
    let o = bin().env("PHOTOCRAFT_GPU", bad).args(["convert", in_png.to_str().unwrap(), out_png.to_str().unwrap()]).output().unwrap();
    assert_eq!(o.status.code(), Some(2), "a non-UTF-8 PHOTOCRAFT_GPU must be a usage error");
    let stderr = String::from_utf8_lossy(&o.stderr);
    assert!(stderr.contains("PHOTOCRAFT_GPU"), "the usage error must name the variable: {stderr}");
    let _ = std::fs::remove_dir_all(&d);
}

#[test]
fn explicit_flags_override_environment() {
    let d = tmp("override");
    let in_png = d.join("in.png");
    let in_layers = d.join("in.pcraft");
    let out1 = d.join("out1.png");
    let out2 = d.join("out2.png");
    write_png(&in_png, 16, 16);
    // A single-layer PNG takes the native export path and never calls the renderer; a
    // multi-layer document composites, so it observes whether `--gpu` reached the backend.
    let o = bin().args(["run", "--new", r#"{"width":16,"height":16}"#, "--cmd", "layer.new.layer", "--out", in_layers.to_str().unwrap()]).output().unwrap();
    assert!(o.status.success(), "stderr: {}", String::from_utf8_lossy(&o.stderr));

    // --no-gpu overrides PHOTOCRAFT_GPU=1
    let o = bin().env("PHOTOCRAFT_GPU", "1").args(["convert", "--no-gpu", in_png.to_str().unwrap(), out1.to_str().unwrap()]).output().unwrap();
    assert!(o.status.success(), "stderr: {}", String::from_utf8_lossy(&o.stderr));
    assert!(out1.is_file());

    // --gpu overrides PHOTOCRAFT_GPU=0
    let o = bin().env("PHOTOCRAFT_GPU", "0").args(["convert", "--gpu", in_layers.to_str().unwrap(), out2.to_str().unwrap()]).output().unwrap();
    assert!(o.status.success(), "stderr: {}", String::from_utf8_lossy(&o.stderr));
    assert!(out2.is_file());
    let stderr = String::from_utf8_lossy(&o.stderr);
    // The renderer reports either its adapter, an unavailable adapter, or (in a build without
    // GPU support) that GPU rendering was requested; the CPU default emits none of these.
    let markers = ["GPU adapter:", "no GPU adapter available", "could not build GPU compositor", "falling back to CPU"];
    assert!(markers.iter().any(|marker| stderr.contains(marker)), "explicit --gpu must reach the renderer when the environment disables it: {stderr}");

    // Explicit flag overrides even bad environment value
    let out3 = d.join("out3.png");
    let o = bin().env("PHOTOCRAFT_GPU", "invalid").args(["convert", "--no-gpu", in_png.to_str().unwrap(), out3.to_str().unwrap()]).output().unwrap();
    assert!(o.status.success(), "stderr: {}", String::from_utf8_lossy(&o.stderr));
    assert!(out3.is_file());

    let _ = std::fs::remove_dir_all(&d);
}

#[test]
fn mcp_bridge_rejects_explicit_gpu_flags_and_ignores_env() {
    // Explicit --gpu with --bridge rejected
    let o = bin().args(["mcp", "--bridge", "127.0.0.1:50000", "--gpu"]).output().unwrap();
    assert_eq!(o.status.code(), Some(2));
    let stderr = String::from_utf8_lossy(&o.stderr);
    assert!(stderr.contains("configure rendering on the desktop app"), "{stderr}");

    // Explicit --no-gpu with --bridge rejected
    let o = bin().args(["mcp", "--bridge", "127.0.0.1:50000", "--no-gpu"]).output().unwrap();
    assert_eq!(o.status.code(), Some(2));
    let stderr = String::from_utf8_lossy(&o.stderr);
    assert!(stderr.contains("configure rendering on the desktop app"), "{stderr}");

    // An invalid PHOTOCRAFT_GPU value is ignored in bridge mode: the desktop process controls
    // rendering, so the bridge must not validate the variable or reject the request for it.
    let o = bin().env("PHOTOCRAFT_GPU", "invalid").args(["mcp", "--bridge", "127.0.0.1:50000"]).stdin(std::process::Stdio::null()).output().unwrap();
    let stderr = String::from_utf8_lossy(&o.stderr);
    assert!(!stderr.contains("PHOTOCRAFT_GPU"), "bridge mode must ignore the GPU environment: {stderr}");
}

#[test]
fn convert_and_run_honor_gpu_flag_and_preserve_stdout_protocol() {
    let d = tmp("protocol");
    let out_png = d.join("out.png");

    // run --gpu output on stdout is clean JSON
    let o =
        bin().args(["run", "--gpu", "--new", r#"{"width":32,"height":32}"#, "--cmd", "layer.new.layer", "--out", out_png.to_str().unwrap()]).output().unwrap();
    assert!(o.status.success(), "stderr: {}", String::from_utf8_lossy(&o.stderr));
    assert!(out_png.is_file());
    let stdout = String::from_utf8_lossy(&o.stdout);
    for line in stdout.lines() {
        let v: Value = serde_json::from_str(line).expect("each stdout line must be valid JSON");
        assert!(v.get("command").is_some());
    }

    let _ = std::fs::remove_dir_all(&d);
}

#[test]
fn batch_recovers_renderer_after_failed_item_and_preserves_gpu_policy() {
    let d = tmp("batch_regress");
    let in_dir = d.join("in");
    let out_dir = d.join("out");
    std::fs::create_dir_all(&in_dir).unwrap();
    std::fs::create_dir_all(&out_dir).unwrap();

    // First item is corrupt and fails to open
    let corrupt_png = in_dir.join("01_corrupt.png");
    std::fs::write(&corrupt_png, b"invalid png bytes").unwrap();

    // Second item is valid
    let valid_png = in_dir.join("02_valid.png");
    write_png(&valid_png, 32, 32);

    let actions = d.join("actions.json");
    std::fs::write(&actions, serde_json::json!([{"command": "layer.new.layer", "params": {"name": "Batch"}}]).to_string()).unwrap();
    let o = bin()
        .args(["batch", "--gpu", "--actions"])
        .arg(&actions)
        .args(["--in", in_dir.to_str().unwrap(), "--out", out_dir.to_str().unwrap()])
        .output()
        .unwrap();

    // Exit code 1 because 1 file failed
    assert_eq!(o.status.code(), Some(1));
    let stdout = String::from_utf8_lossy(&o.stdout);
    let stderr = String::from_utf8_lossy(&o.stderr);

    assert!(stdout.contains("1 succeeded, 1 failed"), "stdout: {stdout}");
    assert!(stderr.contains("FAIL"), "stderr must report failing item: {stderr}");
    let markers = ["GPU adapter:", "no GPU adapter available", "could not build GPU compositor", "falling back to CPU"];
    assert!(markers.iter().any(|marker| stderr.contains(marker)), "--gpu must reach the batch renderer: {stderr}");
    assert!(out_dir.join("02_valid.png").is_file(), "second item must have been saved successfully");

    let _ = std::fs::remove_dir_all(&d);
}

#[test]
fn diagnostics_preserve_clean_stdout_and_emit_to_stderr() {
    let d = tmp("diag_clean");
    let in_png = d.join("in.png");
    let out_png = d.join("out.png");
    write_png(&in_png, 32, 32);

    let o = bin().args(["convert", "--gpu", in_png.to_str().unwrap(), out_png.to_str().unwrap()]).output().unwrap();

    assert!(o.status.success(), "stderr: {}", String::from_utf8_lossy(&o.stderr));
    assert!(out_png.is_file());
    // Convert emits no stdout; diagnostics must go to stderr
    assert!(o.stdout.is_empty(), "convert stdout must remain completely empty, got: {:?}", String::from_utf8_lossy(&o.stdout));
    let stderr = String::from_utf8_lossy(&o.stderr);
    assert!(stderr.contains("falling back to CPU"), "single-layer convert must report its CPU fallback on stderr: {stderr}");

    let _ = std::fs::remove_dir_all(&d);
}

#[test]
fn serve_gpu_preserves_clean_protocol_stdout_and_drains_diagnostics_to_stderr() {
    use std::io::{BufRead, BufReader, Write};
    use std::process::Stdio;

    let mut child = bin().args(["serve", "--gpu"]).stdin(Stdio::piped()).stdout(Stdio::piped()).stderr(Stdio::piped()).spawn().unwrap();

    let mut stdin = child.stdin.take().unwrap();
    let mut stdout = BufReader::new(child.stdout.take().unwrap());

    // 1. Initial valid command
    writeln!(stdin, "{}", serde_json::json!({"id": 1, "method": "doc.new", "params": {"width": 16, "height": 16}})).unwrap();
    stdin.flush().unwrap();

    let mut line1 = String::new();
    assert!(stdout.read_line(&mut line1).unwrap() > 0, "server must respond");
    let v1: Value = serde_json::from_str(&line1).expect("line 1 on stdout must be valid JSON");
    assert_eq!(v1["id"], 1);
    assert_eq!(v1["ok"], true, "{v1}");

    // 2. A second layer so the render below composites instead of taking the native path.
    writeln!(stdin, "{}", serde_json::json!({"id": 2, "method": "engine.execute", "params": {"command": "layer.new.layer", "params": {"name": "Top"}}}))
        .unwrap();
    stdin.flush().unwrap();

    let mut line2 = String::new();
    assert!(stdout.read_line(&mut line2).unwrap() > 0, "server must respond to the layer command");
    let v2: Value = serde_json::from_str(&line2).expect("line 2 on stdout must be valid JSON");
    assert_eq!(v2["id"], 2);
    assert_eq!(v2["ok"], true, "{v2}");

    // 3. Failure recovery: invalid request receives error reply without crashing server
    writeln!(stdin, "{}", serde_json::json!({"id": 3, "method": "invalid.nonexistent.method", "params": {}})).unwrap();
    stdin.flush().unwrap();

    let mut line3 = String::new();
    assert!(stdout.read_line(&mut line3).unwrap() > 0, "server must respond to invalid request");
    let v3: Value = serde_json::from_str(&line3).expect("line 3 on stdout must be valid JSON");
    assert_eq!(v3["id"], 3);
    assert_eq!(v3["ok"], false, "{v3}");

    // 4. Subsequent valid command still succeeds (proves session & renderer recovery)
    writeln!(stdin, "{}", serde_json::json!({"id": 4, "method": "doc.inspect"})).unwrap();
    stdin.flush().unwrap();

    let mut line4 = String::new();
    assert!(stdout.read_line(&mut line4).unwrap() > 0, "server must respond to the inspect request");
    let v4: Value = serde_json::from_str(&line4).expect("line 4 on stdout must be valid JSON");
    assert_eq!(v4["id"], 4);
    assert_eq!(v4["ok"], true, "{v4}");

    // 5. Render the composite: one JSON line on stdout, diagnostics only on stderr.
    writeln!(stdin, "{}", serde_json::json!({"id": 5, "method": "doc.render", "params": {"maxSide": 16}})).unwrap();
    stdin.flush().unwrap();

    let mut line5 = String::new();
    assert!(stdout.read_line(&mut line5).unwrap() > 0, "server must answer the render request");
    let v5: Value = serde_json::from_str(&line5).expect("line 5 on stdout must be valid JSON");
    assert_eq!(v5["id"], 5);
    assert_eq!(v5["ok"], true, "{v5}");
    assert!(v5["result"]["base64"].as_str().is_some_and(|b| !b.is_empty()), "render must return PNG bytes: {v5}");

    // Close stdin and verify graceful exit
    drop(stdin);
    let output = child.wait_with_output().unwrap();
    assert!(output.status.success());

    // Every render that reaches the renderer reports its adapter or why it fell back, whichever
    // build and adapter this test runs on.
    // `doc.render` returns the diagnostics of its own render in the reply's `warnings`; any left
    // in the queue go to stderr. Either way they stay off the protocol lines' framing.
    let stderr = String::from_utf8_lossy(&output.stderr);
    let reported = format!("{stderr}\n{}", v5["result"]["warnings"]);
    let markers = ["GPU adapter:", "no GPU adapter available", "could not build GPU compositor", "falling back to CPU", "GPU acceleration requested"];
    assert!(markers.iter().any(|m| reported.contains(m)), "render must report its GPU backend or fallback in its reply or on stderr: {reported}");
}

#[test]
fn cpu_default_does_not_emit_gpu_warnings() {
    let d = tmp("cpu_default");
    let in_png = d.join("in.png");
    let out_png = d.join("out.png");
    write_png(&in_png, 16, 16);

    let o = bin().args(["convert", in_png.to_str().unwrap(), out_png.to_str().unwrap()]).output().unwrap();
    assert!(o.status.success(), "stderr: {}", String::from_utf8_lossy(&o.stderr));
    assert!(out_png.is_file());

    let stderr = String::from_utf8_lossy(&o.stderr);
    assert!(!stderr.contains("GPU"), "default CPU convert should not emit GPU warnings, got: {stderr}");

    let _ = std::fs::remove_dir_all(&d);
}

#[test]
fn run_gpu_quick_export_reports_that_it_runs_on_the_cpu() {
    let d = tmp("quick_export");
    let out_png = d.join("quick.png");
    let params = format!(r#"{{"path":{}}}"#, serde_json::to_string(&out_png.to_string_lossy()).unwrap());
    let args = ["run", "--new", r#"{"width":16,"height":16,"background":"white"}"#, "--cmd", "file.export.quickExport", "--params", params.as_str()];
    let o = bin().args(args).arg("--gpu").output().unwrap();
    assert!(o.status.success(), "stderr: {}", String::from_utf8_lossy(&o.stderr));
    assert!(out_png.is_file());
    let stderr = String::from_utf8_lossy(&o.stderr);
    assert_eq!(stderr.matches("quickExport runs on the CPU compositor").count(), 1, "one CPU note expected: {stderr}");

    let o = bin().args(args).output().unwrap();
    assert!(o.status.success());
    assert!(!String::from_utf8_lossy(&o.stderr).contains("runs on the CPU compositor"), "no note without --gpu");
    let _ = std::fs::remove_dir_all(&d);
}