GitCorner

Code

ossartcraftphotocraft🌐
856f865cf98d
//! Process-level tests of the `photocraft-cli` binary.

use std::io::{BufRead, BufReader, Write};
use std::path::{Path, PathBuf};
use std::process::{Command, Stdio};

use serde_json::{Value, json};

/// The binary, without the variables `mcp` and `serve` fall back to: a test that wants one sets it.
fn bin() -> Command {
    let mut cmd = crate::command();
    for var in ENV_VARS {
        cmd.env_remove(var);
    }
    cmd
}

const ENV_VARS: [&str; 4] = ["PHOTOCRAFT_CONTROL_PORT", "PHOTOCRAFT_CONTROL_TOKEN", "PHOTOCRAFT_CONTROL_TOKEN_FILE", "PHOTOCRAFT_GPU"];

fn tmp(name: &str) -> PathBuf {
    let d = std::env::temp_dir().join(format!("pc-cli-{}-{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, seed: u8) {
    let data: Vec<u8> = (0..w * h * 4).map(|i| (i as u8).wrapping_mul(seed).wrapping_add(seed)).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();
}

/// What a successful run printed.
struct Printed {
    stdout: String,
    stderr: String,
}

fn ok(cmd: &mut Command) -> Printed {
    let o = cmd.output().unwrap();
    let (stdout, stderr) = (String::from_utf8_lossy(&o.stdout).into_owned(), String::from_utf8_lossy(&o.stderr).into_owned());
    assert!(o.status.success(), "exit {:?}\nstdout: {stdout}\nstderr: {stderr}", o.status);
    Printed { stdout, stderr }
}

#[test]
fn usage_and_unknown_command() {
    let o = bin().output().unwrap();
    assert_eq!(o.status.code(), Some(2));
    assert!(String::from_utf8_lossy(&o.stderr).contains("convert"));
    let o = bin().arg("frobnicate").output().unwrap();
    assert_eq!(o.status.code(), Some(2));
    // `help` names a subcommand or nothing: anything else is a usage error too.
    let o = bin().args(["help", "frobnicate"]).output().unwrap();
    assert_eq!(o.status.code(), Some(2));
    assert!(!o.stderr.is_empty());
    let out = ok(bin().arg("--help")).stdout;
    assert!(out.contains("convert"));
    let out = ok(bin().arg("--version")).stdout;
    assert!(out.starts_with("photocraft-cli "));
}

/// #423: `<subcommand> --help` and `-h` print usage and return at once (no inputs read, no files
/// written, no server started), whatever else is on the line.
#[test]
fn every_subcommand_answers_help() {
    let d = tmp("help");
    for sub in ["convert", "info", "run", "batch", "droplet", "commands", "mcp", "serve"] {
        for help in ["--help", "-h"] {
            let o = bin().current_dir(&d).arg(sub).arg(help).arg("--out").arg("x.png").stdin(Stdio::null()).output().unwrap();
            let out = String::from_utf8_lossy(&o.stdout);
            assert_eq!(o.status.code(), Some(0), "{sub} {help}: {}", String::from_utf8_lossy(&o.stderr));
            assert!(out.contains(&format!("photocraft-cli {sub}")), "{sub} {help}: {out}");
        }
    }
    // Help where a flag's value should be is still help, not a missing value or a file named `-h`.
    // So is help after another mistake.
    for args in [
        &["run", "x.png", "--out", "--help"][..],
        &["commands", "--filter", "-h"],
        &["mcp", "--bridge", "-h"],
        &["serve", "--port", "--help"],
        &["mcp", "stray.psd", "--help"],
        &["serve", "--port", "abc", "--port", "1", "-h"],
    ] {
        let o = bin().current_dir(&d).args(args).stdin(Stdio::null()).output().unwrap();
        assert_eq!(o.status.code(), Some(0), "{args:?}: {}", String::from_utf8_lossy(&o.stderr));
        assert!(String::from_utf8_lossy(&o.stdout).contains(&format!("photocraft-cli {}", args[0])), "{args:?}");
    }
    assert_eq!(std::fs::read_dir(&d).unwrap().count(), 0, "help wrote nothing");
}

/// #423: a flag the subcommand doesn't take is a usage error naming it, before any work.
#[test]
fn unknown_flags_are_usage_errors() {
    let d = tmp("flags");
    let input = d.join("in");
    std::fs::create_dir_all(&input).unwrap();
    write_png(&input.join("a.png"), 8, 4, 3);
    let actions = d.join("actions.json");
    std::fs::write(&actions, r#"[{"command":"image.adjustments.invert"}]"#).unwrap();
    let out_dir = d.join("out");
    let fails = |cmd: &mut Command, flag: &str| {
        let o = cmd.output().unwrap();
        let err = String::from_utf8_lossy(&o.stderr);
        assert_eq!(o.status.code(), Some(2), "{err}");
        assert!(err.contains(flag), "{err}");
    };
    for typo in [&["--fromat", "jpg"][..], &["--fromat=jpg"][..]] {
        fails(bin().args(["batch", "--actions"]).arg(&actions).arg("--in").arg(&input).arg("--out").arg(&out_dir).args(typo), "--fromat");
        assert!(!out_dir.exists(), "nothing written");
    }
    let x = d.join("x.png");
    fails(bin().arg("run").arg(input.join("a.png")).args(["--cmd", "image.adjustments.invert", "--param", "{}", "--out"]).arg(&x), "--param");
    assert!(!x.exists());
    // A flag one subcommand takes is still unknown to another; a bare flag takes no value.
    fails(bin().args(["info", "--json"]).arg(input.join("a.png")), "--json");
    let o = bin().args(["commands", "--json=yes"]).output().unwrap();
    assert_eq!(o.status.code(), Some(2));
    assert!(String::from_utf8_lossy(&o.stderr).contains("--json"));
    // A flag can't be a value: a missing value is reported, not filled with the next flag.
    let o = bin()
        .args(["batch", "--actions"])
        .arg(&actions)
        .arg("--in")
        .arg(&input)
        .arg("--out")
        .arg(&out_dir)
        .args(["--format", "--quality", "80"])
        .output()
        .unwrap();
    assert_eq!(o.status.code(), Some(2));
    assert!(String::from_utf8_lossy(&o.stderr).contains("a value is required for '--format"));
    assert!(!out_dir.exists(), "nothing written");
    // `--flag=value` still passes a value that starts with `--`.
    ok(bin().args(["commands", "--filter=--json"]));
    // Every flag still works in both forms.
    let out = ok(bin().args(["commands", "--json", "--filter=gaussian"])).stdout;
    assert!(out.contains("filter.blur.gaussianBlur"), "{out}");
    // The Elliptical Marquee is a `select.rect` option, found by its keywords (#5060).
    for needle in ["ellipse", "marquee"] {
        let out = ok(bin().args(["commands", "--filter", needle])).stdout;
        assert!(out.contains("select.rect"), "{needle}: {out}");
    }
    ok(bin().args(["batch", "--actions"]).arg(&actions).arg(format!("--in={}", input.display())).arg("--out").arg(&out_dir).args([
        "--format=jpg",
        "--quality",
        "80",
    ]));
    assert!(out_dir.join("a.jpg").exists());
    let out = ok(bin().arg("info").arg(input.join("a.png")).arg("--compact")).stdout;
    assert!(!out.trim().contains('\n'), "compact JSON is one line");
}

fn server_usage_error(args: &[&str], expected: &str) {
    let o = bin().args(args).env_remove("PHOTOCRAFT_CONTROL_TOKEN").env_remove("PHOTOCRAFT_CONTROL_TOKEN_FILE").stdin(Stdio::null()).output().unwrap();
    let err = String::from_utf8_lossy(&o.stderr);
    assert_eq!(o.status.code(), Some(2), "{args:?}: {err}");
    assert!(o.stdout.is_empty(), "usage errors must leave protocol stdout empty: {args:?}");
    assert!(err.contains(expected), "{args:?}: expected {expected:?} in {err}");
}

#[test]
fn server_modes_reject_ignored_or_conflicting_options() {
    for sub in ["mcp", "serve"] {
        server_usage_error(&[sub, "stray.psd"], "unexpected argument 'stray.psd'");
        for flag in ["--control-token", "--control-token-file"] {
            server_usage_error(&[sub, flag, "unused"], if sub == "mcp" { "requires --bridge" } else { "requires --port" });
        }
        server_usage_error(&[sub, "--automation-write-root", ".", "--automation-write-root", "."], "cannot be used multiple times");
        for flag in ["--automation-read-root", "--automation-write-root"] {
            server_usage_error(&[sub, &format!("{flag}=")], "root needs a non-empty directory");
            server_usage_error(&[sub, flag, "--automation-write-root", "."], &format!("a value is required for '{flag} "));
        }
        let transport = if sub == "mcp" { "--bridge" } else { "--port" };
        for flag in [transport, "--control-token", "--control-token-file"] {
            // Valid values, so the repeat is what is refused (a transport value is parsed first).
            server_usage_error(&[sub, flag, "7878", &format!("{flag}=7879")], "cannot be used multiple times");
            server_usage_error(&[sub, flag, ""], &format!("for '{flag} "));
        }
        server_usage_error(&[sub, transport, "7878", "--control-token", "unused", "--control-token-file", "unused"], "cannot be used with");
    }
    for flag in ["--automation-read-root", "--automation-write-root"] {
        server_usage_error(&["mcp", "--bridge", "127.0.0.1:7878", flag, "."], "configure automation roots on the desktop app");
    }
}

/// Each launch line would, before validation, have started a TCP server and written the token file.
#[test]
fn server_validation_does_not_consume_stdio_or_create_files() {
    let d = tmp("server-validation");
    let token = d.join("must-not-be-created.token");
    let other = d.join("other.token");
    let token_flag = format!("--control-token-file={}", token.display());
    let other_flag = format!("--control-token-file={}", other.display());
    for tail in [&["stray"][..], &["--automation-write-root", ".", "--automation-write-root", "."], &["--port", "0"], &[&other_flag]] {
        let mut child = bin()
            .current_dir(&d)
            .args(["serve", "--port", "0", &token_flag])
            .args(tail)
            .env_remove("PHOTOCRAFT_CONTROL_TOKEN")
            .env_remove("PHOTOCRAFT_CONTROL_TOKEN_FILE")
            .stdin(Stdio::piped())
            .stdout(Stdio::piped())
            .stderr(Stdio::piped())
            .spawn()
            .unwrap();
        // Keep stdin open: invalid launch arguments must fail before starting a server.
        let input = child.stdin.take().unwrap();
        let deadline = std::time::Instant::now() + std::time::Duration::from_secs(5);
        while child.try_wait().unwrap().is_none() && std::time::Instant::now() < deadline {
            std::thread::sleep(std::time::Duration::from_millis(10));
        }
        if child.try_wait().unwrap().is_none() {
            child.kill().unwrap();
            child.wait().unwrap();
            panic!("{tail:?}: invalid configuration started a server");
        }
        drop(input);
        let o = child.wait_with_output().unwrap();
        assert_eq!(o.status.code(), Some(2), "{tail:?}: {}", String::from_utf8_lossy(&o.stderr));
        assert!(o.stdout.is_empty(), "{tail:?}");
        assert!(!token.exists() && !other.exists(), "{tail:?}: validation must happen before creating credentials");
    }
    std::fs::remove_dir_all(d).unwrap();
}

#[test]
fn convert_png_pcraft_png_is_lossless() {
    let d = tmp("convert");
    let (a, b, c) = (d.join("a.png"), d.join("b.pcraft"), d.join("c.png"));
    write_png(&a, 37, 23, 7);
    ok(bin().args(["convert"]).arg(&a).arg(&b));
    assert!(photocraft_format::is_pcraft(&std::fs::read(&b).unwrap()));
    ok(bin().args(["convert"]).arg(&b).arg(&c));
    let x = photocraft_codecs::decode(&std::fs::read(&a).unwrap()).unwrap();
    let y = photocraft_codecs::decode(&std::fs::read(&c).unwrap()).unwrap();
    assert_eq!(x.to_rgba8(), y.to_rgba8());
    // Format override and lossy warning path.
    ok(bin().args(["convert"]).arg(&a).arg(d.join("out.bin")).args(["--format", "jpg", "--quality", "60"]));
    assert!(photocraft_codecs::detect(&std::fs::read(d.join("out.bin")).unwrap()) == Some(photocraft_codecs::Format::Jpeg));
    std::fs::remove_dir_all(d).unwrap();
}

#[test]
fn convert_errors() {
    let d = tmp("converr");
    let o = bin().args(["convert", "/missing/in.png"]).arg(d.join("x.png")).output().unwrap();
    assert_eq!(o.status.code(), Some(1));
    let o = bin().args(["convert", "only-one"]).output().unwrap();
    assert_eq!(o.status.code(), Some(2));
    std::fs::remove_dir_all(d).unwrap();
}

#[test]
fn info_prints_layer_tree_json() {
    let d = tmp("info");
    let a = d.join("a.png");
    write_png(&a, 10, 6, 3);
    let out = ok(bin().arg("info").arg(&a)).stdout;
    let v: Value = serde_json::from_str(&out).unwrap();
    assert_eq!(v["width"], 10);
    assert_eq!(v["height"], 6);
    // An RGBA PNG opens as a normal "Layer 0", not the locked Background (as in Photoshop).
    assert_eq!(v["layers"][0]["name"], "Layer 0");
    assert!(v.get("history").is_none());
    let out = ok(bin().arg("info").arg(&a).arg("--compact")).stdout;
    assert_eq!(out.trim().lines().count(), 1);
    std::fs::remove_dir_all(d).unwrap();
}

/// #518, #523: a truncated JPEG and an animated GIF open, but `info` lists why the image is
/// incomplete and `convert` prints it on stderr (and still succeeds); complete files stay quiet.
#[test]
fn info_and_convert_report_decode_warnings() {
    let d = tmp("decode-warnings");
    let noise: Vec<u8> = (0..64 * 48 * 3).map(|i: u32| (i.wrapping_mul(7919) % 251) as u8).collect();
    let img = photocraft_codecs::Image::from_u8(64, 48, photocraft_codecs::ChannelLayout::Rgb, noise).unwrap();
    let jpeg = photocraft_codecs::encode(&img, photocraft_codecs::Format::Jpeg, &Default::default()).unwrap();
    // Three 1x1 frames.
    let mut gif = b"GIF89a\x01\0\x01\0\x80\0\0\0\0\0\xFF\xFF\xFF".to_vec();
    for _ in 0..3 {
        gif.extend_from_slice(b"\x2C\0\0\0\0\x01\0\x01\0\0\x02\x02\x44\x01\0");
    }
    gif.push(0x3B);
    // A GIF opens in Indexed Color (#7886), so `convert` to PNG also notes the palette PNG it
    // writes, after the decode warning.
    let cases = [
        ("whole.jpg", &jpeg[..], None, None),
        ("half.jpg", &jpeg[..jpeg.len() / 2], Some("JPEG data ends early (the file is truncated or damaged); part of the image is missing"), None),
        ("anim.gif", &gif[..], Some("only the first of 3 frames was imported"), Some("written as an 8-bit palette PNG (2 colours)")),
    ];
    for (name, bytes, warning, export) in cases {
        let file = d.join(name);
        std::fs::write(&file, bytes).unwrap();
        let out = ok(bin().arg("info").arg(&file).arg("--compact")).stdout;
        let v: Value = serde_json::from_str(&out).unwrap();
        assert_eq!(v["warnings"], json!(warning.into_iter().collect::<Vec<_>>()), "{name}");
        let err = ok(bin().arg("convert").arg(&file).arg(d.join(format!("{name}.png")))).stderr;
        let expected: Vec<String> = warning.into_iter().chain(export).map(|w| format!("warning: {w}")).collect();
        assert_eq!(
            err.trim(),
            expected.join(
                "
"
            ),
            "{name}"
        );
    }
    std::fs::remove_dir_all(d).unwrap();
}

#[test]
fn run_commands_and_save() {
    let d = tmp("run");
    let out_pc = d.join("r.pcraft");
    let out = ok(bin()
        .args(["run", "--new", r#"{"width":40,"height":30,"name":"Run"}"#])
        .args(["--cmd", "layer.new.layer", "--params", r#"{"name":"Ink"}"#])
        .args(["--cmd", "paint.stroke", "--params", r##"{"points":[[2,2,1],[30,20,1]],"size":5,"color":"#00ff00"}"##])
        .args(["--cmd", "document.inspect"])
        .arg("--out")
        .arg(&out_pc))
    .stdout;
    let lines: Vec<Value> = out.lines().map(|l| serde_json::from_str(l).unwrap()).collect();
    assert_eq!(lines.len(), 3);
    assert_eq!(lines[2]["command"], "document.inspect");
    assert_eq!(lines[2]["result"]["name"], "Run");
    let info = ok(bin().arg("info").arg(&out_pc)).stdout;
    let v: Value = serde_json::from_str(&info).unwrap();
    // Saving a native document gives the reopened bundle its output filename.
    assert_eq!(v["name"], "r.pcraft");
    let names: Vec<&str> = v["layers"].as_array().unwrap().iter().filter_map(|l| l["name"].as_str()).collect();
    assert_eq!(names, ["Ink", "Background"]);
    // Continue from the saved file and export PNG.
    let png = d.join("r.png");
    ok(bin().arg("run").arg(&out_pc).args(["--cmd", "layer.new.layer"]).arg("--out").arg(&png));
    assert_eq!(photocraft_codecs::decode(&std::fs::read(&png).unwrap()).unwrap().dimensions(), (40, 30));
    std::fs::remove_dir_all(d).unwrap();
}

#[test]
fn run_stops_after_failed_action_without_exporting() {
    let d = tmp("run-failed-action");
    let out = d.join("result.png");
    let result = bin()
        .args(["run", "--new", r#"{"width":8,"height":8}"#])
        .args(["--cmd", "layer.new.layer"])
        .args(["--cmd", "actions.record", "--params", r#"{"name":"Delete"}"#])
        .args(["--cmd", "layer.delete", "--cmd", "actions.stop"])
        // The recorded deletion succeeded with two layers; replay cannot delete the last one.
        .args(["--cmd", "actions.play", "--params", r#"{"action":"Delete"}"#])
        .args(["--cmd", "document.inspect", "--out"])
        .arg(&out)
        .output()
        .unwrap();
    let error = String::from_utf8_lossy(&result.stderr);
    assert_eq!(result.status.code(), Some(1), "stdout: {}\nstderr: {error}", String::from_utf8_lossy(&result.stdout));
    assert!(error.contains("actions.play") && error.contains("Delete") && error.contains("step 1"), "{error}");
    let rows: Vec<Value> = String::from_utf8_lossy(&result.stdout).lines().map(|line| serde_json::from_str(line).unwrap()).collect();
    assert!(rows.iter().all(|row| row["command"] != "document.inspect"), "later commands must not run");
    assert!(!out.exists(), "a failed action must not export a partial result");
    std::fs::remove_dir_all(d).unwrap();
}

/// A direct Batch keeps its partial result without preventing later commands or export.
#[test]
fn run_continues_after_batch_file_errors_and_keeps_partial_results() {
    let d = tmp("run-partial-batch");
    let good = d.join("good.png");
    let bad = d.join("bad.png");
    let batch_out = d.join("batch");
    let caller_out = d.join("caller.pcraft");
    write_png(&good, 6, 4, 3);
    std::fs::write(&bad, b"not a PNG").unwrap();
    let params = json!({"input":[good,bad],"output":batch_out,"format":"pcraft","steps":[
        ["layer.renameLayer",{"name":"Batch output"}]
    ]})
    .to_string();
    let stdout = ok(bin()
        .args(["run", "--new", r#"{"width":8,"height":8}"#])
        .args(["--cmd", "file.automate.batch", "--params", &params])
        .args(["--cmd", "layer.new.layer", "--params", r#"{"name":"After batch"}"#])
        .args(["--cmd", "document.inspect", "--out"])
        .arg(&caller_out))
    .stdout;
    let rows: Vec<Value> = stdout.lines().map(|line| serde_json::from_str(line).unwrap()).collect();
    assert_eq!(rows.len(), 3);
    assert_eq!(rows[0]["command"], "file.automate.batch");
    let result = &rows[0]["result"];
    let files = result["files"].as_array().unwrap();
    assert_eq!(files.len(), 1);
    assert_eq!(Path::new(files[0].as_str().unwrap()).canonicalize().unwrap(), batch_out.join("good.pcraft").canonicalize().unwrap());
    assert_eq!(result["errors"].as_array().unwrap().len(), 1);
    assert_eq!(result["errors"][0]["file"], json!(bad));
    assert!(result["errors"][0]["error"].as_str().is_some_and(|message| !message.is_empty()));
    assert!(batch_out.join("good.pcraft").is_file());
    assert!(!batch_out.join("bad.pcraft").exists());
    assert_eq!(rows[2]["command"], "document.inspect");
    assert!(rows[2]["result"]["layers"].as_array().unwrap().iter().any(|layer| layer["name"] == "After batch"));
    assert!(caller_out.is_file());
    let saved: Value = serde_json::from_str(&ok(bin().arg("info").arg(&caller_out)).stdout).unwrap();
    assert!(saved["layers"].as_array().unwrap().iter().any(|layer| layer["name"] == "After batch"));
    std::fs::remove_dir_all(d).unwrap();
}

/// A direct Batch whose error log can't be written stops the command list before export, also
/// when a file failed as well (per-file errors alone would let it go on).
#[test]
fn run_stops_when_a_direct_batch_cannot_write_its_error_log() {
    let d = tmp("run-batch-log-fails");
    let bad = d.join("bad.png");
    let out = d.join("result.png");
    std::fs::write(&bad, b"not a PNG").unwrap();
    // The folder itself as the log path: the log write fails.
    let params = json!({"input":[bad],"output":d.join("batch"),"format":"png","steps":[],"errorLog":d}).to_string();
    let result = bin()
        .args(["run", "--new", r#"{"width":8,"height":8}"#])
        .args(["--cmd", "file.automate.batch", "--params", &params])
        .args(["--cmd", "document.inspect", "--out"])
        .arg(&out)
        .output()
        .unwrap();
    let error = String::from_utf8_lossy(&result.stderr);
    assert_eq!(result.status.code(), Some(1), "stdout: {}\nstderr: {error}", String::from_utf8_lossy(&result.stdout));
    assert!(error.contains("error log"), "{error}");
    let rows: Vec<Value> = String::from_utf8_lossy(&result.stdout).lines().map(|line| serde_json::from_str(line).unwrap()).collect();
    assert!(rows.iter().all(|row| row["command"] != "document.inspect"), "later commands must not run");
    assert!(!out.exists(), "a stopped command list must not export");
    std::fs::remove_dir_all(d).unwrap();
}

#[test]
fn run_continues_after_successful_action_and_exports() {
    let d = tmp("run-successful-action");
    let out = d.join("result.png");
    let stdout = ok(bin()
        .args(["run", "--new", r#"{"width":8,"height":8}"#])
        .args(["--cmd", "actions.record", "--params", r#"{"name":"Add"}"#])
        .args(["--cmd", "layer.new.layer", "--cmd", "actions.stop"])
        .args(["--cmd", "actions.play", "--params", r#"{"action":"Add"}"#])
        .args(["--cmd", "document.inspect", "--out"])
        .arg(&out))
    .stdout;
    let rows: Vec<Value> = stdout.lines().map(|line| serde_json::from_str(line).unwrap()).collect();
    let playback = rows.iter().find(|row| row["command"] == "actions.play").unwrap();
    assert_eq!(playback["result"]["ran"], 1);
    assert!(playback["result"].get("failed").is_none());
    assert!(rows.iter().any(|row| row["command"] == "document.inspect"));
    assert!(out.is_file());
    std::fs::remove_dir_all(d).unwrap();
}

#[test]
fn run_errors() {
    let o = bin().args(["run", "--new", "{}", "--cmd", "no.such"]).output().unwrap();
    assert_eq!(o.status.code(), Some(1));
    assert!(String::from_utf8_lossy(&o.stderr).contains("unknown command"));
    // Neither a --cmd nor --out, and JSON that doesn't parse, are usage errors naming the flag.
    let o = bin().args(["run", "--new", "{}", "--params", "{}"]).output().unwrap();
    assert_eq!(o.status.code(), Some(2));
    assert!(String::from_utf8_lossy(&o.stderr).contains("--cmd"));
    let o = bin().args(["run", "--new", "{", "--cmd", "x"]).output().unwrap();
    assert_eq!(o.status.code(), Some(2));
    assert!(String::from_utf8_lossy(&o.stderr).contains("--new"));
    // Params must be a JSON object, for `--new` and for each `--params`.
    let o = bin().args(["run", "--new", "[3]", "--cmd", "layer.new.layer"]).output().unwrap();
    assert_eq!(o.status.code(), Some(1));
    let e = String::from_utf8_lossy(&o.stderr);
    assert!(e.contains("--new") && e.contains("must be a JSON object"), "{e}");
    let o = bin().args(["run", "--new", "{}", "--cmd", "layer.new.layer", "--params", "\"x\""]).output().unwrap();
    assert_eq!(o.status.code(), Some(1));
    let e = String::from_utf8_lossy(&o.stderr);
    assert!(e.contains("layer.new.layer") && e.contains("must be a JSON object"), "{e}");
}

#[test]
fn run_rejects_invalid_filter_parameters_without_exporting() {
    let d = tmp("invalid-filter-params");
    let out = d.join("result.png");
    for (params, key) in [(r#"{"radius":"big"}"#, "radius"), (r#"{"radus":3}"#, "radus"), (r#"{"radius":5000}"#, "radius"), (r#"{"radius":-4}"#, "radius")] {
        let result = bin()
            .args(["run", "--new", r#"{"width":8,"height":8}"#, "--cmd", "filter.blur.gaussianBlur", "--params", params, "--out"])
            .arg(&out)
            .output()
            .unwrap();
        assert_eq!(result.status.code(), Some(1));
        let error = String::from_utf8_lossy(&result.stderr);
        assert!(error.contains("filter.blur.gaussianBlur") && error.contains(key), "{error}");
        assert!(!out.exists());
    }
    std::fs::remove_dir_all(d).unwrap();
}

#[test]
fn batch_applies_actions_to_directory() {
    let d = tmp("batch");
    let (inp, outp) = (d.join("in"), d.join("out"));
    std::fs::create_dir_all(&inp).unwrap();
    write_png(&inp.join("one.png"), 12, 8, 1);
    write_png(&inp.join("two.png"), 9, 9, 2);
    std::fs::write(inp.join("notes.txt"), "ignored").unwrap();
    let actions = d.join("actions.json");
    let log = d.join("errors.txt");
    std::fs::write(&actions, json!([{"command": "layer.new.layer", "params": {"name": "Batch"}}]).to_string()).unwrap();
    let out = ok(bin()
        .args(["batch", "--actions"])
        .arg(&actions)
        .arg("--in")
        .arg(&inp)
        .arg("--out")
        .arg(&outp)
        .args(["--format", "pcraft", "--error-log"])
        .arg(&log))
    .stdout;
    assert!(out.contains("2 succeeded, 0 failed"), "{out}");
    let clean_log = std::fs::read(&log).unwrap();
    assert!(clean_log.starts_with(&[0xff, 0xfe]));
    let (pairs, remainder) = clean_log[2..].as_chunks::<2>();
    assert!(remainder.is_empty());
    let body = String::from_utf16(&pairs.iter().map(|pair| u16::from_le_bytes(*pair)).collect::<Vec<_>>()).unwrap();
    assert_eq!(body, "Batch Start\r\n\r\nBatch End\r\n");
    for n in ["one", "two"] {
        let info = ok(bin().arg("info").arg(outp.join(format!("{n}.pcraft")))).stdout;
        let v: Value = serde_json::from_str(&info).unwrap();
        assert_eq!(v["layers"][0]["name"], "Batch");
    }
    // A failing action reports and exits 1.
    std::fs::write(&actions, r#"{"actions":[{"id":"no.such.command"}]}"#).unwrap();
    let o = bin().args(["batch", "--actions"]).arg(&actions).arg("--in").arg(&inp).arg("--out").arg(&outp).output().unwrap();
    assert_eq!(o.status.code(), Some(1));
    assert!(String::from_utf8_lossy(&o.stderr).contains("FAIL"));
    std::fs::remove_dir_all(d).unwrap();
}

#[test]
fn batch_recursive_naming_stop_and_error_log() {
    let root = tmp("batch-recursive-options");
    let input = root.join("in");
    std::fs::create_dir_all(input.join("sub")).unwrap();
    for file in ["a.png", "sub/a.png", "sub/c.png"] {
        write_png(&input.join(file), 8, 6, 3);
    }
    std::fs::write(input.join("sub/b.png"), b"not a png").unwrap();
    let actions = root.join("actions.json");
    std::fs::write(&actions, r#"[["image.imageRotation.90cw", {}]]"#).unwrap();
    let output = root.join("out");
    let log = root.join("errors.txt");
    let run = |out: &Path, extra: &[&str]| {
        bin().args(["batch", "--actions"]).arg(&actions).arg("--in").arg(&input).arg("--out").arg(out).args(extra).output().unwrap()
    };
    let result = run(&output, &["--recursive", "--naming", "{name}-{serial:2}.{ext}", "--start-serial", "5", "--error-log", &log.to_string_lossy()]);
    let stdout = String::from_utf8_lossy(&result.stdout);
    assert!(!result.status.success(), "{stdout}");
    assert!(stdout.contains("3 succeeded, 1 failed"), "{stdout}");
    for file in ["a-05.png", "a-06.png", "c-08.png"] {
        assert!(output.join(file).is_file(), "{file}: {stdout}");
    }
    let bytes = std::fs::read(log).unwrap();
    assert!(bytes.starts_with(&[0xff, 0xfe]));
    let (pairs, remainder) = bytes[2..].as_chunks::<2>();
    assert!(remainder.is_empty());
    let errors = String::from_utf16(&pairs.iter().map(|pair| u16::from_le_bytes(*pair)).collect::<Vec<_>>()).unwrap();
    assert!(errors.contains("Batch Start\r\n") && errors.contains("b.png") && errors.ends_with("Batch End\r\n"), "{errors}");

    let stopped = root.join("stopped");
    let result = run(&stopped, &["--recursive", "--stop-on-error"]);
    let stdout = String::from_utf8_lossy(&result.stdout);
    let stderr = String::from_utf8_lossy(&result.stderr);
    assert!(!result.status.success(), "{stdout}");
    assert!(stdout.contains("2 succeeded, 1 failed, 1 skipped"), "{stdout}");
    assert!(stderr.contains("--stop-on-error"), "{stderr}");
    assert!(!stopped.join("c.png").exists());

    let collision = root.join("collision");
    let alias = collision.join("../collision/a.png");
    let result = run(&collision, &["--recursive", "--error-log", &alias.to_string_lossy()]);
    assert!(!result.status.success());
    assert!(String::from_utf8_lossy(&result.stderr).contains("--error-log"));
    assert!(!collision.join("a.png").exists());
}

/// `{serial}` numbers a recursive batch in the engine's order (a folder's files before its
/// subfolders), `--format` encodes the bytes whatever extension `--naming` writes, and an
/// `--error-log` that can't be written still leaves the summary printed.
#[test]
fn batch_naming_keeps_the_tree_order_and_the_selected_encoder() {
    let root = tmp("batch-naming-order");
    let input = root.join("in");
    std::fs::create_dir_all(input.join("sub")).unwrap();
    write_png(&input.join("z.png"), 8, 6, 3);
    write_png(&input.join("sub/a.png"), 5, 4, 3);
    let actions = root.join("actions.json");
    std::fs::write(&actions, "[]").unwrap();
    let run = |out: &Path, extra: &[&str]| {
        bin().args(["batch", "--actions"]).arg(&actions).arg("--in").arg(&input).arg("--out").arg(out).args(extra).output().unwrap()
    };
    let png_width = |path: &Path| {
        let bytes = std::fs::read(path).unwrap();
        u32::from_be_bytes(bytes[16..20].try_into().unwrap())
    };
    let ordered = root.join("ordered");
    let result = run(&ordered, &["--recursive", "--naming", "{serial:2}.{ext}"]);
    assert!(result.status.success(), "{}", String::from_utf8_lossy(&result.stderr));
    assert_eq!(png_width(&ordered.join("01.png")), 8, "the root file comes first");
    assert_eq!(png_width(&ordered.join("02.png")), 5);

    let jpeg = root.join("jpeg");
    let result = run(&jpeg, &["--format", "jpg", "--naming", "{name}_{serial}"]);
    assert!(result.status.success(), "{}", String::from_utf8_lossy(&result.stderr));
    assert!(std::fs::read(jpeg.join("z_001")).unwrap().starts_with(&[0xff, 0xd8]), "JPEG bytes without an extension");
    let png = root.join("png");
    let result = run(&png, &["--format", "png", "--naming", "{name}.jpg"]);
    assert!(result.status.success(), "{}", String::from_utf8_lossy(&result.stderr));
    assert!(std::fs::read(png.join("z.jpg")).unwrap().starts_with(b"\x89PNG"), "PNG bytes under a .jpg name");

    let log = root.join("log-is-a-folder");
    std::fs::create_dir_all(&log).unwrap();
    let result = run(&root.join("logged"), &["--error-log", &log.to_string_lossy()]);
    let stdout = String::from_utf8_lossy(&result.stdout);
    assert!(!result.status.success(), "{stdout}");
    assert!(stdout.contains("1 succeeded, 0 failed"), "{stdout}");
    std::fs::remove_dir_all(root).unwrap();
}

/// Without --format, a file PhotoCraft only opens is saved as PSD, with or without --naming:
/// the encoder gets the format the planned name uses, not the input's import-only extension.
#[test]
fn batch_saves_import_only_inputs_as_psd() {
    let root = tmp("batch-import-only");
    let input = root.join("in");
    std::fs::create_dir_all(&input).unwrap();
    std::fs::write(
        input.join("logo.xpm"),
        "/* XPM */
static char *logo[] = {
\"2 2 1 1\",
\"a c #FF0000\",
\"aa\",
\"aa\"
};
",
    )
    .unwrap();
    let actions = root.join("actions.json");
    std::fs::write(&actions, "[]").unwrap();
    for (name, extra) in [("plain", &[][..]), ("named", &["--naming", "{name}.{ext}"][..])] {
        let out = root.join(name);
        let result = bin().args(["batch", "--actions"]).arg(&actions).arg("--in").arg(&input).arg("--out").arg(&out).args(extra).output().unwrap();
        assert!(result.status.success(), "{name}: {}{}", String::from_utf8_lossy(&result.stdout), String::from_utf8_lossy(&result.stderr));
        assert!(std::fs::read(out.join("logo.psd")).unwrap().starts_with(b"8BPS"), "{name}: PSD bytes");
        assert!(!out.join("logo.xpm").exists(), "{name}");
    }
    std::fs::remove_dir_all(root).unwrap();
}

#[test]
fn batch_skips_recorded_view_and_save_steps() {
    let d = tmp("batch-shell-steps");
    let input = d.join("in");
    std::fs::create_dir_all(&input).unwrap();
    let source = input.join("a.png");
    write_png(&source, 12, 8, 3);
    let original = std::fs::read(&source).unwrap();
    let recorded_save = d.join("recorded-save.psd");
    let mut cases = Vec::new();
    for (name, id) in [("zoom-in", "view.zoomIn"), ("zoom-out", "view.zoomOut"), ("fit", "view.fitOnScreen"), ("actual-pixels", "view.actualPixels")] {
        cases.push((name, json!([[id, {}], ["image.imageRotation.90cw", {}]]).to_string()));
    }
    cases.push(("save", json!([["file.save", {}], ["image.imageRotation.90cw", {}]]).to_string()));
    cases.push(("save-as", json!([["file.saveAs", {"path": recorded_save.to_string_lossy()}], ["image.imageRotation.90cw", {}]]).to_string()));

    for (name, actions) in cases {
        let o = batch_with(&d, &input, name, &actions, &[]);
        let (stdout, stderr) = (String::from_utf8_lossy(&o.stdout), String::from_utf8_lossy(&o.stderr));
        assert!(o.status.success(), "{name}: {stdout}\n{stderr}");
        assert!(stdout.contains("1 succeeded, 0 failed"), "{name}: {stdout}");
        let output = d.join(name).join("a.png");
        let info = ok(bin().arg("info").arg(&output)).stdout;
        let info: Value = serde_json::from_str(&info).unwrap();
        assert_eq!((info["width"].as_u64(), info["height"].as_u64()), (Some(8), Some(12)), "{name}: {info}");
        assert_eq!(std::fs::read(&source).unwrap(), original, "{name} changed its input");
        assert!(!recorded_save.exists(), "{name} wrote the recorded Save As path");
    }
    std::fs::remove_dir_all(d).unwrap();
}

#[test]
fn parse_actions_formats() {
    let a = photocraft_cli::parse_actions(r#"[{"command":"a","params":{"x":1}},{"id":"b"}]"#).unwrap();
    assert_eq!(a, vec![("a".to_string(), json!({"x":1})), ("b".to_string(), json!({}))]);
    assert!(photocraft_cli::parse_actions(r#"{"actions":[{"command":"c"}]}"#).unwrap().len() == 1);
    assert!(photocraft_cli::parse_actions(r#"[{"params":{}}]"#).is_err());
    assert!(photocraft_cli::parse_actions("7").is_err());
    // #489: the step shapes a recorded action and a droplet store, bare or wrapped.
    let want = vec![("a".to_string(), json!({"x":1})), ("b".to_string(), json!({}))];
    for text in [
        r#"[["a",{"x":1}],["b"]]"#,
        r#"[["a",{"x":1}],"b"]"#,
        r#"{"steps":[["a",{"x":1}],["b",{}]]}"#,
        r#"{"photocraftDroplet":1,"action":{"steps":[["a",{"x":1}],{"command":"b"}]}}"#,
        r#"{"actions":[["a",{"x":1}],["b",{}]]}"#,
    ] {
        assert_eq!(photocraft_cli::parse_actions(text).unwrap(), want, "{text}");
    }
    for text in ["[42]", "[[]]", "[[7,{}]]", r#"{"name":"x"}"#] {
        assert!(photocraft_cli::parse_actions(text).is_err(), "{text}");
    }
}

/// Runs `batch` on `input` with `actions` (saved as `<name>.json`), writing to the folder `<d>/<name>`.
fn batch_with(d: &Path, input: &Path, name: &str, actions: &str, extra: &[&str]) -> std::process::Output {
    let file = d.join(format!("{name}.json"));
    std::fs::write(&file, actions).unwrap();
    bin().args(["batch", "--actions"]).arg(&file).arg("--in").arg(input).arg("--out").arg(d.join(name)).args(extra).output().unwrap()
}

/// #489: `batch --actions` takes `[id, params]` steps and a droplet's steps, with the same results
/// as the object form; a malformed step fails before anything is written.
#[test]
fn batch_accepts_recorded_action_steps() {
    let d = tmp("batch-steps");
    let input = d.join("in");
    std::fs::create_dir_all(&input).unwrap();
    write_png(&input.join("a.png"), 8, 4, 3);
    write_png(&input.join("b.png"), 6, 5, 9);
    let shapes = [
        ("objects", r#"[{"command":"image.adjustments.invert"}]"#),
        ("pairs", r#"[["image.adjustments.invert",{}]]"#),
        ("ids", r#"["image.adjustments.invert"]"#),
        ("droplet", r#"{"photocraftDroplet":1,"action":{"steps":[["image.adjustments.invert",{}]]}}"#),
    ];
    for (name, actions) in shapes {
        let o = batch_with(&d, &input, name, actions, &[]);
        assert!(o.status.success(), "{name}: {}", String::from_utf8_lossy(&o.stderr));
        assert!(String::from_utf8_lossy(&o.stdout).contains("2 succeeded, 0 failed"), "{name}");
        for f in ["a.png", "b.png"] {
            assert_eq!(std::fs::read(d.join(name).join(f)).unwrap(), std::fs::read(d.join("objects").join(f)).unwrap(), "{name}/{f}");
        }
    }
    let o = batch_with(&d, &input, "bad", "[42]", &[]);
    assert_eq!(o.status.code(), Some(1));
    assert!(!d.join("bad").exists(), "nothing written");
}

/// #490: a leading dot on `--format` doesn't double the dot in output names.
#[test]
fn batch_format_with_leading_dot() {
    let d = tmp("batch-dot");
    let input = d.join("in");
    std::fs::create_dir_all(&input).unwrap();
    write_png(&input.join("a.png"), 8, 4, 3);
    write_png(&input.join("b.png"), 6, 5, 9);
    let invert = r#"[{"command":"image.adjustments.invert"}]"#;
    for (name, format) in [("dot", ".jpg"), ("plain", "jpg")] {
        let o = batch_with(&d, &input, name, invert, &["--format", format]);
        assert!(o.status.success(), "{format}: {}", String::from_utf8_lossy(&o.stderr));
        let mut names: Vec<String> = std::fs::read_dir(d.join(name)).unwrap().map(|e| e.unwrap().file_name().to_string_lossy().into_owned()).collect();
        names.sort();
        assert_eq!(names, ["a.jpg", "b.jpg"], "{format}");
        assert_eq!(photocraft_codecs::detect(&std::fs::read(d.join(name).join("a.jpg")).unwrap()), Some(photocraft_codecs::Format::Jpeg));
    }
}

/// #491: `--quality` outside 1-100 is a usage error for every subcommand, whatever the number's
/// size, and nothing is written.
#[test]
fn quality_outside_1_to_100_is_refused() {
    let d = tmp("quality");
    let input = d.join("in");
    std::fs::create_dir_all(&input).unwrap();
    let a = input.join("a.png");
    write_png(&a, 8, 4, 3);
    let invert = r#"[{"command":"image.adjustments.invert"}]"#;
    for q in ["0", "101", "255", "256", "1000", "-1", "abc", "50.5", ""] {
        let out = d.join("q.jpg");
        let (mut convert, mut run) = (bin(), bin());
        convert.arg("convert").arg(&a).arg(&out).args(["--quality", q]);
        run.arg("run").arg(&a).args(["--cmd", "image.adjustments.invert", "--out"]).arg(&out).args(["--quality", q]);
        for cmd in [&mut convert, &mut run] {
            let o = cmd.output().unwrap();
            assert_eq!(o.status.code(), Some(2), "--quality {q}");
            assert!(String::from_utf8_lossy(&o.stderr).contains("--quality"), "--quality {q}");
            assert!(!out.exists(), "--quality {q} wrote a file");
        }
        let o = batch_with(&d, &input, "qb", invert, &["--format", "jpg", "--quality", q]);
        assert_eq!(o.status.code(), Some(2), "batch --quality {q}");
        assert!(!d.join("qb").exists(), "batch --quality {q} wrote a folder");
    }
    // The documented range still encodes, lower quality making a smaller file.
    let sizes: Vec<usize> = ["1", "50", "100"]
        .iter()
        .map(|q| {
            let out = d.join(format!("q{q}.jpg"));
            ok(bin().arg("convert").arg(&a).arg(&out).args(["--quality", q]));
            std::fs::read(out).unwrap().len()
        })
        .collect();
    assert!(sizes[0] <= sizes[1] && sizes[1] <= sizes[2], "{sizes:?}");
}

/// DPX converts both ways, `info` reports its size, mode and depth, and `--dpx-bits` picks the
/// bits per sample (byte 803 of the header); anything but 8, 10, 12 or 16 is a usage error (#1049).
#[test]
fn dpx_converts_both_ways_with_the_bits_asked_for() {
    let d = tmp("dpx");
    let a = d.join("a.png");
    write_png(&a, 8, 4, 3);
    for (bits, want) in [(None, 8), (Some("10"), 10), (Some("12"), 12), (Some("16"), 16)] {
        let out = d.join("a.dpx");
        let mut convert = bin();
        convert.arg("convert").arg(&a).arg(&out);
        if let Some(b) = bits {
            convert.args(["--dpx-bits", b]);
        }
        ok(&mut convert);
        let bytes = std::fs::read(&out).unwrap();
        assert_eq!((&bytes[..4], bytes[803]), (&b"SDPX"[..], want), "--dpx-bits {bits:?}");
    }
    let info = ok(bin().arg("info").arg(d.join("a.dpx")).arg("--compact")).stdout;
    let v: Value = serde_json::from_str(&info).unwrap();
    assert_eq!((v["width"].as_u64(), v["height"].as_u64()), (Some(8), Some(4)), "{v}");
    assert!(info.contains("16") && info.to_lowercase().contains("rgb"), "{info}");
    let back = d.join("back.png");
    ok(bin().arg("convert").arg(d.join("a.dpx")).arg(&back));
    assert!(back.exists());
    for bad in ["24", "0", "abc"] {
        let out = d.join("bad.dpx");
        let o = bin().arg("convert").arg(&a).arg(&out).args(["--dpx-bits", bad]).output().unwrap();
        let err = String::from_utf8_lossy(&o.stderr);
        assert_eq!(o.status.code(), Some(2), "--dpx-bits {bad}");
        assert!(err.contains("--dpx-bits") && err.contains("expected 8, 10, 12 or 16"), "--dpx-bits {bad}: {err}");
        assert!(!out.exists(), "--dpx-bits {bad} wrote a file");
    }
}

/// DDS converts both ways; `--dds-compression` picks the FourCC (bytes 84–87; none writes
/// uncompressed pixels) and `--dds-mipmaps` the mip count (bytes 28–31). A compression that
/// isn't none, bc1, bc2 or bc3 is a usage error and nothing is written (#1327).
#[test]
fn dds_converts_both_ways_with_the_compression_asked_for() {
    let d = tmp("dds");
    let a = d.join("a.png");
    write_png(&a, 8, 4, 3);
    for (args, fourcc, mips) in [
        (&[][..], [0; 4], 1),
        (&["--dds-compression", "bc1"][..], *b"DXT1", 1),
        (&["--dds-compression", "DXT3", "--dds-mipmaps"][..], *b"DXT3", 4),
        (&["--dds-compression", "bc3"][..], *b"DXT5", 1),
        (&["--dds-mipmaps"][..], [0; 4], 4),
    ] {
        let out = d.join("a.dds");
        ok(bin().arg("convert").arg(&a).arg(&out).args(args));
        let bytes = std::fs::read(&out).unwrap();
        let mip_count = u32::from_le_bytes(bytes[28..32].try_into().unwrap());
        assert_eq!((&bytes[..4], &bytes[84..88], mip_count), (&b"DDS "[..], &fourcc[..], mips), "{args:?}");
        let back = d.join("back.png");
        ok(bin().arg("convert").arg(&out).arg(&back));
        assert!(back.exists(), "{args:?}");
    }
    for bad in ["bc7", "dxt2", ""] {
        let out = d.join("bad.dds");
        let o = bin().arg("convert").arg(&a).arg(&out).args(["--dds-compression", bad]).output().unwrap();
        assert_eq!(o.status.code(), Some(2), "--dds-compression {bad}");
        assert!(String::from_utf8_lossy(&o.stderr).contains("--dds-compression"), "--dds-compression {bad}");
        assert!(!out.exists(), "--dds-compression {bad} wrote a file");
    }
}

/// #8064: `--no-maximize-compatibility` writes a layered PSD/PSB with Photoshop's placeholder
/// instead of the merged image, flagged in resource 1057; without it, the real image.
#[test]
fn no_maximize_compatibility_writes_the_psd_placeholder() {
    let d = tmp("maximize-compat");
    let a = d.join("a.png");
    write_png(&a, 32, 16, 3);
    for (args, ext, real) in
        [(&[][..], "psd", true), (&["--no-maximize-compatibility"][..], "psd", false), (&["--no-maximize-compatibility"][..], "psb", false)]
    {
        let out = d.join(format!("a.{ext}"));
        ok(bin().arg("run").arg(&a).args(["--cmd", "layer.new.layer"]).arg("--out").arg(&out).args(args));
        let psd = craft_psd::PsdFile::from_bytes(&std::fs::read(&out).unwrap()).unwrap();
        assert_eq!(psd.has_real_merged_data(), Some(real), "{args:?} {ext}");
    }
    std::fs::remove_dir_all(d).unwrap();
}

/// `--tga-bits` picks a TGA's bits per pixel (byte 16 of its header); anything but 24 or 32 is a
/// usage error and nothing is written.
#[test]
fn tga_bits_choose_the_targa_depth() {
    let d = tmp("tga-bits");
    let a = d.join("a.png");
    write_png(&a, 8, 4, 3);
    for (bits, want) in [(None, 32), (Some("24"), 24), (Some("32"), 32)] {
        let out = d.join("a.tga");
        let mut convert = bin();
        convert.arg("convert").arg(&a).arg(&out);
        if let Some(b) = bits {
            convert.args(["--tga-bits", b]);
        }
        ok(&mut convert);
        assert_eq!(std::fs::read(&out).unwrap()[16], want, "--tga-bits {bits:?}");
    }
    for bad in ["16", "0", "abc", ""] {
        let out = d.join("bad.tga");
        let o = bin().arg("convert").arg(&a).arg(&out).args(["--tga-bits", bad]).output().unwrap();
        let err = String::from_utf8_lossy(&o.stderr);
        assert_eq!(o.status.code(), Some(2), "--tga-bits {bad}");
        assert!(err.contains("--tga-bits") && err.contains("expected 24 or 32"), "--tga-bits {bad}: {err}");
        assert!(!out.exists(), "--tga-bits {bad} wrote a file");
    }
}

/// #7437: `run <file> --out` to that same file, however `--out` is spelt, is refused before the
/// file is read or any command runs, unless `--in-place` asks for it (as `batch` does, #492).
#[test]
fn run_refuses_to_write_over_its_input() {
    let d = tmp("run-in-place");
    write_png(&d.join("in.png"), 8, 4, 7);
    let before = std::fs::read(d.join("in.png")).unwrap();
    let run = |out: &Path, extra: &[&str]| {
        bin().current_dir(&d).args(["run", "in.png", "--cmd", "image.adjustments.invert", "--out"]).arg(out).args(extra).output().unwrap()
    };
    let mut outs = vec![PathBuf::from("in.png"), PathBuf::from("./in.png"), d.join("in.png"), d.join(".").join("in.png")];
    std::fs::hard_link(d.join("in.png"), d.join("hard.png")).unwrap();
    outs.push(PathBuf::from("hard.png"));
    #[cfg(unix)]
    {
        std::os::unix::fs::symlink(d.join("in.png"), d.join("soft.png")).unwrap();
        outs.push(PathBuf::from("soft.png"));
    }
    for out in &outs {
        for extra in [&[][..], &["--format", "png"][..]] {
            let o = run(out, extra);
            let (stdout, err) = (String::from_utf8_lossy(&o.stdout), String::from_utf8_lossy(&o.stderr));
            assert_eq!(o.status.code(), Some(1), "--out {} {extra:?}: {err}", out.display());
            assert!(err.contains("is the input file") && err.contains("--in-place"), "{err}");
            assert!(stdout.is_empty(), "--out {} {extra:?} ran commands: {stdout}", out.display());
            assert_eq!(std::fs::read(d.join("in.png")).unwrap(), before, "--out {} {extra:?} changed the original", out.display());
        }
    }
    // Another file is written as before, leaving the original alone.
    ok(bin().current_dir(&d).args(["run", "in.png", "--cmd", "image.adjustments.invert", "--out", "out.png"]));
    assert!(d.join("out.png").is_file());
    assert_eq!(std::fs::read(d.join("in.png")).unwrap(), before);
    // `--in-place` opts in: the inverted result replaces the original, which still opens.
    ok(bin().current_dir(&d).args(["run", "in.png", "--cmd", "image.adjustments.invert", "--out", "in.png", "--in-place"]));
    assert_ne!(std::fs::read(d.join("in.png")).unwrap(), before, "--in-place left the original unchanged");
    let out = ok(bin().current_dir(&d).args(["info", "in.png", "--compact"])).stdout;
    let info: Value = serde_json::from_str(&out).unwrap();
    assert_eq!((info["width"].as_u64(), info["height"].as_u64()), (Some(8), Some(4)), "{info}");
}

/// `--jpeg-format` picks the JPEG's scans: progressive writes a progressive frame (SOF2). One it
/// doesn't name is a usage error and nothing is written.
#[test]
fn jpeg_format_chooses_the_scans() {
    let d = tmp("jpeg-format");
    let a = d.join("a.png");
    write_png(&a, 16, 8, 3);
    let marker = |b: &[u8], m: u8| b.windows(2).any(|w| w == [0xFF, m]);
    for (format, progressive) in [(None, false), (Some("baseline"), false), (Some("optimized"), false), (Some("progressive"), true)] {
        let out = d.join("a.jpg");
        let mut convert = bin();
        convert.arg("convert").arg(&a).arg(&out);
        if let Some(f) = format {
            convert.args(["--jpeg-format", f]);
        }
        ok(&mut convert);
        assert_eq!(marker(&std::fs::read(&out).unwrap(), 0xC2), progressive, "--jpeg-format {format:?}");
    }
    for bad in ["Progressive", "1", ""] {
        let out = d.join("bad.jpg");
        let o = bin().arg("convert").arg(&a).arg(&out).args(["--jpeg-format", bad]).output().unwrap();
        let err = String::from_utf8_lossy(&o.stderr);
        assert_eq!(o.status.code(), Some(2), "--jpeg-format {bad}");
        assert!(err.contains("--jpeg-format") && err.contains("expected baseline, optimized or progressive"), "--jpeg-format {bad}: {err}");
        assert!(!out.exists(), "--jpeg-format {bad} wrote a file");
    }
}

/// #9466: `--metadata none` leaves the document's XMP packet and free-form text out of a flat
/// export from `convert`, `run --out` and `batch`, as Export As's Metadata: None does, and changes
/// nothing else (pixels, ICC profile, resolution). The default, and `all`, keep them as before (the
/// text where the format holds it, as PNG does), and a PSD or `.pcraft` keeps the XMP either way.
/// A value it doesn't name is a usage error and nothing is written.
#[test]
fn metadata_none_leaves_out_the_document_xmp() {
    const XMP: &str = "<x:xmpmeta xmlns:x=\"adobe:ns:meta/\"><rdf:RDF xmlns:rdf=\"http://www.w3.org/1999/02/22-rdf-syntax-ns#\">\
<rdf:Description rdf:about=\"\" xmlns:photoshop=\"http://ns.adobe.com/photoshop/1.0/\">\
<photoshop:DocumentAncestors><rdf:Bag><rdf:li>xmp.did:11111111-2222-3333-4444-555555555555</rdf:li></rdf:Bag></photoshop:DocumentAncestors>\
</rdf:Description></rdf:RDF></x:xmpmeta>";
    let d = tmp("metadata");
    let input = d.join("in");
    std::fs::create_dir_all(&input).unwrap();
    let a = input.join("a.png");
    let data: Vec<u8> = (0..8 * 6 * 4).map(|i| (i as u8).wrapping_mul(7).wrapping_add(3)).collect();
    let mut img = photocraft_codecs::Image::from_u8(8, 6, photocraft_codecs::ChannelLayout::Rgba, data).unwrap();
    img.meta.xmp = Some(XMP.into());
    img.meta.dpi = Some((300.0, 300.0));
    img.meta.text = vec![("Comment".into(), "free-form-note".into())];
    // Display P3 rather than sRGB, so no export can pass for keeping it by writing its default.
    let p3 = craft_cms::Builtin::DisplayP3.profile().to_bytes().to_vec();
    img.icc = Some(p3.clone());
    std::fs::write(&a, photocraft_codecs::encode(&img, photocraft_codecs::Format::Png, &Default::default()).unwrap()).unwrap();
    let ancestors = |p: &Path| String::from_utf8_lossy(&std::fs::read(p).unwrap()).contains("DocumentAncestors");
    let decoded = |p: &Path| photocraft_codecs::decode(&std::fs::read(p).unwrap()).unwrap();
    let note = |p: &Path| decoded(p).meta.text.iter().any(|(_, v)| v == "free-form-note");
    assert!(ancestors(&a) && note(&a), "the input carries the packet and the text");
    let invert = r#"[{"command":"image.adjustments.invert"}]"#;
    for ext in ["png", "webp", "jpg", "tif"] {
        let mut converted_files = Vec::new();
        for flag in [None, Some("all"), Some("none")] {
            let extra: Vec<&str> = flag.map(|f| vec!["--metadata", f]).unwrap_or_default();
            let name = format!("{ext}-{}", flag.unwrap_or("default"));
            let converted = d.join(format!("convert-{name}.{ext}"));
            ok(bin().arg("convert").arg(&a).arg(&converted).args(&extra));
            let ran = d.join(format!("run-{name}.{ext}"));
            ok(bin().arg("run").arg(&a).arg("--out").arg(&ran).args(&extra));
            let o = batch_with(&d, &input, &format!("batch-{name}"), invert, &[&["--format", ext][..], &extra[..]].concat());
            assert!(o.status.success(), "batch {name}: {}", String::from_utf8_lossy(&o.stderr));
            let batched = d.join(format!("batch-{name}")).join(format!("a.{ext}"));
            for out in [&converted, &ran, &batched] {
                assert_eq!(ancestors(out), flag != Some("none"), "{name}: {}", out.display());
                // PNG holds free-form text; JPEG, WebP and TIFF (but for its named tags) don't.
                assert_eq!(note(out), ext == "png" && flag != Some("none"), "{name} text: {}", out.display());
            }
            converted_files.push(converted);
        }
        // Only the XMP and text go: the pixels, profile and resolution are the default export's.
        let (default, none) = (decoded(&converted_files[0]), decoded(&converted_files[2]));
        assert_eq!(none.data(), default.data(), "{ext}: pixels");
        assert_eq!(default.icc.as_deref(), Some(&p3[..]), "{ext}: the default export keeps the input's Display P3 profile");
        assert_eq!(none.icc, default.icc, "{ext}: ICC profile");
        assert_eq!(none.meta.dpi, default.meta.dpi, "{ext}: resolution");
        assert!(none.meta.dpi.is_some_and(|(x, y)| (x - 300.0).abs() < 0.5 && (y - 300.0).abs() < 0.5), "{ext}: {:?}", none.meta.dpi);
    }
    // A layered save keeps the document's XMP whatever the option.
    for ext in ["psd", "pcraft"] {
        let out = d.join(format!("layered.{ext}"));
        ok(bin().arg("convert").arg(&a).arg(&out).args(["--metadata", "none"]));
        let back = d.join(format!("layered-{ext}.png"));
        ok(bin().arg("convert").arg(&out).arg(&back));
        assert!(ancestors(&back), "{ext} kept the packet");
    }
    for bad in ["None", "exif", "0", ""] {
        let out = d.join("bad.png");
        let (mut convert, mut run) = (bin(), bin());
        convert.arg("convert").arg(&a).arg(&out).args(["--metadata", bad]);
        run.arg("run").arg(&a).arg("--out").arg(&out).args(["--metadata", bad]);
        for cmd in [&mut convert, &mut run] {
            let o = cmd.output().unwrap();
            let err = String::from_utf8_lossy(&o.stderr);
            assert_eq!(o.status.code(), Some(2), "--metadata {bad}: {err}");
            assert!(err.contains("--metadata") && err.contains("expected none or all"), "--metadata {bad}: {err}");
            assert!(!out.exists(), "--metadata {bad} wrote a file");
        }
        let o = batch_with(&d, &input, "bad-batch", invert, &["--metadata", bad]);
        assert_eq!(o.status.code(), Some(2), "batch --metadata {bad}");
        assert!(!d.join("bad-batch").exists(), "batch --metadata {bad} wrote a folder");
    }
}

/// #492: an `--out` folder that is the `--in` folder, however it is spelt, is refused before
/// anything is written, unless `--in-place` asks for it.
#[test]
fn batch_refuses_to_write_over_its_inputs() {
    let d = tmp("batch-in-place");
    let input = d.join("in");
    std::fs::create_dir_all(&input).unwrap();
    write_png(&input.join("a.png"), 8, 4, 3);
    let img = photocraft_codecs::Image::from_u8(8, 4, photocraft_codecs::ChannelLayout::Rgb, vec![90; 96]).unwrap();
    std::fs::write(input.join("a.tif"), photocraft_codecs::encode(&img, photocraft_codecs::Format::Tiff, &Default::default()).unwrap()).unwrap();
    let actions = d.join("actions.json");
    std::fs::write(&actions, r#"[{"command":"image.adjustments.invert"}]"#).unwrap();
    let snapshot = || {
        let mut files: Vec<(PathBuf, Vec<u8>)> =
            std::fs::read_dir(&input).unwrap().map(|e| e.unwrap().path()).map(|p| (p.clone(), std::fs::read(p).unwrap())).collect();
        files.sort();
        files
    };
    let before = snapshot();
    let batch = |out: &Path, extra: &[&str]| {
        bin().current_dir(&d).args(["batch", "--actions"]).arg(&actions).args(["--in", "in", "--out"]).arg(out).args(extra).output().unwrap()
    };
    #[cfg(unix)]
    std::os::unix::fs::symlink(&input, d.join("link")).unwrap();
    let link = cfg!(unix).then(|| PathBuf::from("link"));
    for out in [PathBuf::from("in"), PathBuf::from("./in/"), input.clone(), input.join(".")].iter().chain(&link) {
        for extra in [&[][..], &["--format", "tif"][..]] {
            let o = batch(out, extra);
            let err = String::from_utf8_lossy(&o.stderr);
            assert_eq!(o.status.code(), Some(1), "--out {} {extra:?}: {err}", out.display());
            assert!(err.contains("is the --in folder") && err.contains("--in-place"), "{err}");
            assert_eq!(snapshot(), before, "--out {} {extra:?} changed the originals", out.display());
        }
    }
    // A separate folder runs as before, leaving the originals alone.
    let out = ok(bin().current_dir(&d).args(["batch", "--actions"]).arg(&actions).args(["--in", "in", "--out", "out"])).stdout;
    assert!(out.contains("2 succeeded, 0 failed"), "{out}");
    assert_eq!(snapshot(), before);
    // `--in-place` opts in: each result replaces its original.
    let o = batch(Path::new("in"), &["--in-place"]);
    assert!(o.status.success(), "{}", String::from_utf8_lossy(&o.stderr));
    let after = snapshot();
    assert_eq!(after.len(), 2);
    assert!(after.iter().zip(&before).all(|(a, b)| a.0 == b.0 && a.1 != b.1), "both inputs replaced");
}

#[test]
fn batch_naming_rejects_unread_input_alias_through_a_missing_directory() {
    let d = tmp("batch-missing-directory-alias");
    let input = d.join("in");
    std::fs::create_dir_all(&input).unwrap();
    write_png(&input.join("a.png"), 8, 4, 3);
    write_png(&input.join("b.png"), 8, 4, 7);
    let original = std::fs::read(input.join("b.png")).unwrap();
    let actions = d.join("actions.json");
    std::fs::write(&actions, r#"[{"command":"image.adjustments.invert"}]"#).unwrap();
    let output = bin()
        .arg("batch")
        .arg("--actions")
        .arg(&actions)
        .arg("--in")
        .arg(&input)
        .arg("--out")
        .arg(input.join("missing/.."))
        .args(["--in-place", "--naming", "b.{ext}"])
        .output()
        .unwrap();
    assert!(!output.status.success(), "{}", String::from_utf8_lossy(&output.stdout));
    assert!(String::from_utf8_lossy(&output.stderr).contains("replace an input"));
    assert_eq!(std::fs::read(input.join("b.png")).unwrap(), original);
    assert!(!input.join("missing").exists());
}

/// #7437: `convert` to its own input file, however the output is spelt, is refused before
/// anything is read or written, unless `--in-place` asks for it (as `batch` does, #492).
#[test]
fn convert_refuses_to_write_over_its_input() {
    let d = tmp("convert-in-place");
    write_png(&d.join("in.png"), 8, 4, 5);
    let before = std::fs::read(d.join("in.png")).unwrap();
    let convert = |out: &Path, extra: &[&str]| bin().current_dir(&d).args(["convert", "in.png"]).arg(out).args(extra).output().unwrap();
    let mut outs = vec![PathBuf::from("in.png"), PathBuf::from("./in.png"), d.join("in.png"), d.join(".").join("in.png")];
    std::fs::hard_link(d.join("in.png"), d.join("hard.png")).unwrap();
    outs.push(PathBuf::from("hard.png"));
    #[cfg(unix)]
    {
        std::os::unix::fs::symlink(d.join("in.png"), d.join("soft.png")).unwrap();
        outs.push(PathBuf::from("soft.png"));
    }
    for out in &outs {
        for extra in [&[][..], &["--format", "png"][..], &["--quality", "80"][..]] {
            let o = convert(out, extra);
            let err = String::from_utf8_lossy(&o.stderr);
            assert_eq!(o.status.code(), Some(1), "{} {extra:?}: {err}", out.display());
            assert!(err.contains("is the input file") && err.contains("--in-place"), "{err}");
            assert_eq!(std::fs::read(d.join("in.png")).unwrap(), before, "{} {extra:?} changed the original", out.display());
        }
    }
    // Another file converts as before, leaving the original alone.
    ok(bin().current_dir(&d).args(["convert", "in.png", "out.jpg"]));
    assert!(d.join("out.jpg").is_file());
    assert_eq!(std::fs::read(d.join("in.png")).unwrap(), before);
    // `--in-place` opts in: the result replaces the original, which still opens.
    ok(bin().current_dir(&d).args(["convert", "in.png", "in.png", "--in-place"]));
    let Printed { stdout: out, .. } = ok(bin().current_dir(&d).args(["info", "in.png", "--compact"]));
    let info: Value = serde_json::from_str(&out).unwrap();
    assert_eq!((info["width"].as_u64(), info["height"].as_u64()), (Some(8), Some(4)), "{info}");
}

#[test]
fn commands_listing() {
    let out = ok(bin().arg("commands")).stdout;
    assert!(out.contains("file.new"));
    let out = ok(bin().args(["commands", "--json", "--filter", "layer.new"])).stdout;
    let v: Value = serde_json::from_str(&out).unwrap();
    assert!(
        v.as_array()
            .unwrap()
            .iter()
            .all(|c| { c["id"].as_str().unwrap().contains("layer.new") || c["label"].as_str().unwrap().to_lowercase().contains("layer.new") })
    );
}

#[test]
fn in_process_run_matches_binary() {
    let mut out = Vec::new();
    let mut err = Vec::new();
    let code = photocraft_cli::run(["commands", "--filter", "file.new"], &mut out, &mut err);
    assert_eq!(code, 0);
    assert!(String::from_utf8(out).unwrap().contains("file.new"));
}

#[test]
fn mcp_stdio_handshake_and_tool_call() {
    let mut child = bin().arg("mcp").stdin(Stdio::piped()).stdout(Stdio::piped()).stderr(Stdio::null()).spawn().unwrap();
    let mut stdin = child.stdin.take().unwrap();
    let mut stdout = BufReader::new(child.stdout.take().unwrap());
    let mut send = |v: Value| mcp_send(&mut stdin, v);
    let mut recv = |id: u64| mcp_recv(&mut stdout, id);
    send(json!({"jsonrpc":"2.0","id":1,"method":"initialize","params":{
        "protocolVersion":"2025-06-18","capabilities":{},"clientInfo":{"name":"test","version":"0"}}}));
    let init = recv(1);
    assert_eq!(init["result"]["serverInfo"]["name"], "photocraft", "{init}");
    send(json!({"jsonrpc":"2.0","method":"notifications/initialized"}));
    send(json!({"jsonrpc":"2.0","id":2,"method":"tools/list","params":{}}));
    let tools = recv(2);
    let names: Vec<&str> = tools["result"]["tools"].as_array().unwrap().iter().filter_map(|t| t["name"].as_str()).collect();
    assert!(names.contains(&"command_run") && names.contains(&"doc_render_preview"), "{names:?}");
    send(json!({"jsonrpc":"2.0","id":3,"method":"tools/call","params":{"name":"doc_new","arguments":{"width":8,"height":8}}}));
    let r = recv(3);
    assert_ne!(r["result"]["isError"], true, "{r}");
    send(json!({"jsonrpc":"2.0","id":4,"method":"tools/call","params":{"name":"doc_render_preview","arguments":{}}}));
    let r = recv(4);
    assert_eq!(r["result"]["content"][0]["type"], "image", "{r}");
    let _ = child.kill();
    let _ = child.wait();
}

/// Send one JSON-RPC line to an `mcp` child.
fn mcp_send(stdin: &mut impl Write, v: Value) {
    writeln!(stdin, "{v}").unwrap();
    stdin.flush().unwrap();
}

/// Read an `mcp` child's lines up to the reply to `id`.
fn mcp_recv(stdout: &mut impl BufRead, id: u64) -> Value {
    loop {
        let mut line = String::new();
        assert!(stdout.read_line(&mut line).unwrap() > 0, "server closed");
        let v: Value = serde_json::from_str(&line).unwrap();
        if v["id"] == id {
            return v;
        }
    }
}

/// `mcp --bridge` takes a port or anything with a `:`; anything else is a usage error. A bare port
/// means 127.0.0.1, and the bridge connects at the first call, so with no app there the call fails
/// naming that address.
#[test]
fn mcp_bridge_takes_a_port_or_an_address() {
    let o = bin().args(["mcp", "--bridge", "nope"]).stdin(Stdio::null()).output().unwrap();
    let err = String::from_utf8_lossy(&o.stderr);
    assert_eq!(o.status.code(), Some(2), "{err}");
    assert!(err.contains("invalid value 'nope' for '--bridge"), "{err}");
    assert!(err.contains("expected a port, 0-65535 (--bridge also takes 127.0.0.1:<PORT>)"), "{err}");

    // Nothing listens on port 1 in a test run. The token only has to be well-formed.
    let token = "a".repeat(64);
    let mut child = bin()
        .args(["mcp", "--bridge", "1", "--control-token", token.as_str()])
        .stdin(Stdio::piped())
        .stdout(Stdio::piped())
        .stderr(Stdio::null())
        .spawn()
        .unwrap();
    let mut stdin = child.stdin.take().unwrap();
    let mut stdout = BufReader::new(child.stdout.take().unwrap());
    mcp_send(
        &mut stdin,
        json!({"jsonrpc":"2.0","id":1,"method":"initialize","params":{
        "protocolVersion":"2025-06-18","capabilities":{},"clientInfo":{"name":"test","version":"0"}}}),
    );
    mcp_recv(&mut stdout, 1);
    mcp_send(&mut stdin, json!({"jsonrpc":"2.0","method":"notifications/initialized"}));
    mcp_send(&mut stdin, json!({"jsonrpc":"2.0","id":2,"method":"tools/call","params":{"name":"session_list","arguments":{}}}));
    let r = mcp_recv(&mut stdout, 2);
    assert_eq!(r["result"]["isError"], true, "{r}");
    assert!(r["result"]["content"][0]["text"].as_str().unwrap_or_default().contains("127.0.0.1:1"), "{r}");
    let _ = child.kill();
    let _ = child.wait();
}

/// Photoshop Batch processes every input in order, replacing earlier flat results with the same name.
#[test]
fn batch_later_input_replaces_a_same_named_output() {
    let d = tmp("batch-collide");
    let input = d.join("in");
    std::fs::create_dir_all(&input).unwrap();
    write_png(&input.join("a.png"), 8, 4, 3);
    // Same stem in other formats; `A.tif` differs only in case.
    let img = photocraft_codecs::Image::from_u8(8, 4, photocraft_codecs::ChannelLayout::Rgb, vec![90; 96]).unwrap();
    for (name, format) in [("a.bmp", photocraft_codecs::Format::Bmp), ("A.tif", photocraft_codecs::Format::Tiff)] {
        std::fs::write(input.join(name), photocraft_codecs::encode(&img, format, &Default::default()).unwrap()).unwrap();
    }
    let actions = d.join("actions.json");
    std::fs::write(&actions, r#"[{"command":"image.adjustments.invert"}]"#).unwrap();
    let out_dir = d.join("out");
    let o = bin().args(["batch", "--actions"]).arg(&actions).arg("--in").arg(&input).arg("--out").arg(&out_dir).args(["--format", "png"]).output().unwrap();
    let (out, err) = (String::from_utf8_lossy(&o.stdout), String::from_utf8_lossy(&o.stderr));
    assert!(o.status.success(), "{out}{err}");
    assert!(out.contains("3 succeeded, 0 failed"), "{out}");
    assert!(out_dir.join("a.png").is_file());
    assert!(std::fs::read_dir(&out_dir).unwrap().count() <= 2);
    // Keeping each file's format, every input gets its own output.
    let out_dir = d.join("same");
    let out = ok(bin().args(["batch", "--actions"]).arg(&actions).arg("--in").arg(&input).arg("--out").arg(&out_dir)).stdout;
    assert!(out.contains("3 succeeded, 0 failed"), "{out}");
}

#[test]
fn droplet_runs_an_action_on_files() {
    let d = tmp("droplet");
    write_png(&d.join("a.png"), 8, 4, 3);
    write_png(&d.join("b.png"), 6, 2, 5);
    let droplet = d.join("rot.pcdroplet");
    std::fs::write(
        &droplet,
        json!({"photocraftDroplet": 1, "name": "rot", "action": {"steps": [["image.imageRotation.90cw", {}]]}, "options": {"format": "png"}}).to_string(),
    )
    .unwrap();
    let out_dir = d.join("out");
    let out = ok(bin().arg("droplet").arg(&droplet).arg(d.join("a.png")).arg(d.join("b.png")).arg("--out").arg(&out_dir)).stdout;
    assert_eq!(out.lines().filter(|l| l.starts_with("ok")).count(), 2, "{out}");
    let img = photocraft_codecs::decode(&std::fs::read(out_dir.join("a.png")).unwrap()).unwrap();
    assert_eq!(img.dimensions(), (4, 8));
    let o = bin().arg("droplet").arg(d.join("a.png")).arg(d.join("b.png")).output().unwrap();
    assert!(!o.status.success(), "not a droplet");
}

#[test]
fn tiff_output_is_flat_unless_tiff_layers_is_given() {
    let d = tmp("tiff-layers");
    let layer_count = |path: &std::path::Path| -> usize {
        let info = ok(bin().arg("info").arg(path)).stdout;
        let v: Value = serde_json::from_str(&info).unwrap();
        v["layers"].as_array().unwrap().len()
    };
    for (name, flag, layers) in [("flat.tif", None, 1), ("layered.tif", Some("--tiff-layers"), 2)] {
        let out = d.join(name);
        let mut cmd = bin();
        cmd.args(["run", "--new", r#"{"width":16,"height":16}"#]).args(["--cmd", "layer.new.layer", "--params", r#"{"name":"Ink"}"#]);
        if let Some(flag) = flag {
            cmd.arg(flag);
        }
        ok(cmd.arg("--out").arg(&out));
        assert_eq!(layer_count(&out), layers, "{name}");
    }
    // convert honours the same flag.
    let src = d.join("layered.tif");
    let flat = d.join("converted.tif");
    ok(bin().arg("convert").arg(&src).arg(&flat));
    assert_eq!(layer_count(&flat), 1);
    let kept = d.join("kept.tif");
    ok(bin().arg("convert").arg(&src).arg(&kept).arg("--tiff-layers"));
    assert_eq!(layer_count(&kept), 2);
    std::fs::remove_dir_all(d).unwrap();
}

#[test]
fn pcraft_output_has_no_full_composite_unless_asked() {
    let d = tmp("pcraft-full-composite");
    let full = |path: &std::path::Path| photocraft_format::read_full_composite(&std::fs::read(path).unwrap()).unwrap().is_some();
    for (name, flag, expect) in [("plain.pcraft", None, false), ("full.pcraft", Some("--pcraft-full-composite"), true)] {
        let out = d.join(name);
        let mut cmd = bin();
        cmd.args(["run", "--new", r#"{"width":16,"height":16}"#]);
        if let Some(flag) = flag {
            cmd.arg(flag);
        }
        ok(cmd.arg("--out").arg(&out));
        assert_eq!(full(&out), expect, "{name}");
    }
    let converted = d.join("converted.pcraft");
    ok(bin().arg("convert").arg(d.join("plain.pcraft")).arg(&converted).arg("--pcraft-full-composite"));
    assert!(full(&converted));
    std::fs::remove_dir_all(d).unwrap();
}

/// Issue #1108: a non-Unicode argument (a Latin-1 file name on Linux) used to panic in
/// `std::env::args()` before anything was printed. clap reads the arguments as they are: a path
/// takes one, and text (`--filter`) refuses it with a usage error.
#[cfg(unix)]
#[test]
fn a_non_unicode_path_is_taken_and_non_unicode_text_is_a_usage_error() {
    use std::ffi::OsStr;
    use std::os::unix::ffi::OsStrExt;
    let d = tmp("non-unicode");
    let name = OsStr::from_bytes(b"caf\xe9.png");
    // No such file yet: the handler runs and fails on it (exit 1), no usage error.
    for args in [vec![OsStr::new("info"), name], vec![OsStr::new("convert"), name, OsStr::new("out.png")]] {
        let o = bin().current_dir(&d).args(&args).output().unwrap();
        let err = String::from_utf8_lossy(&o.stderr);
        assert_eq!(o.status.code(), Some(1), "{args:?}: {err}");
        assert!(!err.contains("panicked"), "{err}");
    }
    // Linux file systems take the name (macOS ones refuse it). `convert` reads it; `info` opens
    // through the automation layer, which still needs UTF-8 paths, and says so (exit 1).
    if cfg!(target_os = "linux") {
        write_png(&d.join(name), 8, 4, 3);
        ok(bin().current_dir(&d).arg("convert").arg(name).arg("out.png"));
        assert!(d.join("out.png").is_file());
        let o = bin().current_dir(&d).arg("info").arg(name).output().unwrap();
        let err = String::from_utf8_lossy(&o.stderr);
        assert_eq!(o.status.code(), Some(1), "{err}");
        assert!(err.contains("UTF-8"), "{err}");
    }
    let o = bin().args([OsStr::new("commands"), OsStr::new("--filter"), name]).output().unwrap();
    let err = String::from_utf8_lossy(&o.stderr);
    assert_eq!((o.status.code(), o.stdout.is_empty()), (Some(2), true), "{err}");
    assert!(err.contains("UTF-8") && !err.contains("panicked"), "{err}");
    std::fs::remove_dir_all(d).unwrap();
}

/// `batch --actions set.atn`: a Photoshop Actions file plays like an Actions set, and its steps
/// PhotoCraft can't play are warned about up front.
#[test]
fn batch_plays_a_photoshop_actions_file() {
    use photocraft_engine::actions_cmds::{Action, ActionStep};
    let d = tmp("atn");
    let input = d.join("in");
    std::fs::create_dir_all(&input).unwrap();
    write_png(&input.join("a.png"), 8, 4, 3);
    let invert = Action::new("Negative", vec![ActionStep::new("image.adjustments.invert", json!({})), ActionStep::new("select.all", json!({}))]);
    let odd =
        Action::new("Odd", vec![ActionStep::new(photocraft_engine::atn_cmds::PHOTOSHOP_STEP, json!({"event": "syntheticFill", "name": "Generative Fill"}))]);
    let (bytes, skipped) = photocraft_engine::atn_cmds::export("Set", &[&invert, &odd], &[], false).unwrap();
    assert!(skipped.is_empty());
    let atn = d.join("Set.atn");
    std::fs::write(&atn, bytes).unwrap();
    let out_dir = d.join("out");
    // Two actions: the set needs --action.
    let o = bin().args(["batch", "--actions"]).arg(&atn).arg("--in").arg(&input).arg("--out").arg(&out_dir).output().unwrap();
    assert!(!o.status.success());
    assert!(String::from_utf8_lossy(&o.stderr).contains("--action"), "{}", String::from_utf8_lossy(&o.stderr));
    let err = ok(bin().args(["batch", "--actions"]).arg(&atn).args(["--action", "Negative", "--in"]).arg(&input).arg("--out").arg(&out_dir)).stderr;
    assert!(out_dir.join("a.png").exists());
    assert!(!err.contains("warning"), "{err}");
    // The unsupported step is warned about, and fails the file as Photoshop would stop on it.
    let o = bin().args(["batch", "--actions"]).arg(&atn).args(["--action", "Odd", "--in"]).arg(&input).arg("--out").arg(d.join("out2")).output().unwrap();
    let err = String::from_utf8_lossy(&o.stderr);
    assert!(err.contains("Generative Fill"), "{err}");
    assert!(!o.status.success());
}

/// A version 12 Actions file (Photoshop 5, often saved on classic Mac OS without an extension) is
/// recognised by its version word like version 16, not read as a JSON actions list.
#[test]
fn extensionless_version_12_actions_file_is_read_as_atn() {
    let d = tmp("atn-v12");
    let path = d.join("Legacy Actions");
    std::fs::write(&path, include_bytes!("../../../../crates/engine/tests/fixtures/atn/v12-commands.atn")).unwrap();
    let (steps, set, warnings) = photocraft_cli::load_actions_file(&path, None).unwrap();
    assert_eq!(set.len(), 1);
    assert_eq!(steps, vec![("actions.play".to_string(), json!({"action": set[0].name}))]);
    assert!(warnings.is_empty(), "{warnings:?}");
    std::fs::remove_dir_all(d).unwrap();
}

/// What `photocraft_cli::run` returned and wrote, in-process.
struct Invoke {
    code: i32,
    stdout: String,
    stderr: String,
}

fn invoke(args: &[&str]) -> Invoke {
    let (mut stdout, mut stderr) = (Vec::new(), Vec::new());
    let code = photocraft_cli::run(args, &mut stdout, &mut stderr);
    Invoke { code, stdout: String::from_utf8(stdout).unwrap(), stderr: String::from_utf8(stderr).unwrap() }
}

const SUBCOMMANDS: [&str; 8] = ["convert", "info", "run", "batch", "droplet", "commands", "mcp", "serve"];

/// Pins top-level dispatch: help and the version go to stdout (exit 0), no arguments is a usage
/// error on stderr. There is no `version` subcommand.
#[test]
fn top_level_help_version_and_no_arguments() {
    let Invoke { code, stdout: out, stderr: err } = invoke(&[]);
    assert_eq!((code, out.is_empty(), err.is_empty()), (2, true, false));
    for help in ["--help", "-h", "help"] {
        let Invoke { code, stdout: out, stderr: err } = invoke(&[help]);
        assert_eq!((code, out.is_empty(), err.is_empty()), (0, false, true), "{help}");
    }
    for version in ["--version", "-V"] {
        let Invoke { code, stdout: out, stderr: err } = invoke(&[version]);
        assert_eq!((code, err.as_str()), (0, ""), "{version}");
        assert!(out.starts_with("photocraft-cli ") && out.ends_with('\n') && out.lines().count() == 1, "{version}: {out}");
    }
    let Invoke { code, stdout: out, stderr: err } = invoke(&["version"]);
    assert_eq!((code, out.is_empty()), (2, true));
    assert!(err.contains("version"), "{err}");
    let Invoke { code, stdout: out, stderr: err } = invoke(&["frobnicate"]);
    assert_eq!((code, out.is_empty()), (2, true));
    assert!(err.contains("frobnicate"), "{err}");
}

/// `<sub> --help` / `-h` prints help on stdout and returns without running the subcommand
/// (`mcp` and `serve` would otherwise block on stdin).
#[test]
fn every_subcommand_help_returns_on_stdout() {
    for sub in SUBCOMMANDS {
        for help in ["--help", "-h"] {
            let Invoke { code, stdout: out, stderr: err } = invoke(&[sub, help]);
            assert_eq!((code, out.is_empty(), err.is_empty()), (0, false, true), "{sub} {help}: {err}");
            // `commands` would also exit 0 with output if it ran; its list names `file.new`, help doesn't.
            assert!(!out.contains("file.new"), "{sub} {help} ran instead of printing help: {out}");
        }
    }
}

/// Every subcommand refuses an unknown flag (bare or `=value`) with exit 2, naming it on stderr.
#[test]
fn every_subcommand_rejects_an_unknown_flag() {
    for sub in SUBCOMMANDS {
        for flag in [&["--fromat"][..], &["--fromat=jpg"][..], &["--fromat", "jpg"][..]] {
            let args: Vec<&str> = [sub].into_iter().chain(flag.iter().copied()).collect();
            let Invoke { code, stdout: out, stderr: err } = invoke(&args);
            assert_eq!((code, out.is_empty()), (2, true), "{args:?}: {err}");
            assert!(err.contains("--fromat"), "{args:?}: {err}");
        }
    }
}

/// `--flag=value`, a bare flag given a value, a value flag without one, repeated flags, and values
/// that start with `-`.
#[test]
fn flag_value_forms_and_repeats() {
    let ids = |out: &str| out.lines().filter_map(|l| l.split_whitespace().next()).map(str::to_owned).collect::<Vec<_>>();
    let Invoke { code, stdout: eq, stderr: err } = invoke(&["commands", "--filter=file.new"]);
    assert_eq!(code, 0, "{err}");
    let spaced = invoke(&["commands", "--filter", "file.new"]).stdout;
    assert_eq!(eq, spaced);
    assert!(ids(&eq).contains(&"file.new".to_string()), "{eq}");
    // A repeated flag is a usage error naming it, more likely a mistake than a choice.
    for repeat in [&["commands", "--filter", "zzz-no-match", "--filter", "file.new"][..], &["commands", "--json", "--json"][..]] {
        let Invoke { code, stdout: out, stderr: err } = invoke(repeat);
        assert_eq!((code, out.is_empty()), (2, true), "{repeat:?}");
        assert!(err.contains(repeat[1]) && err.contains("cannot be used multiple times"), "{repeat:?}: {err}");
    }
    let Invoke { code, stderr: err, .. } = invoke(&["convert", "a.png", "b.jpg", "--quality", "80", "--quality", "60"]);
    assert_eq!(code, 2);
    assert!(err.contains("--quality"), "{err}");
    // A value starting with `-` needs `=`; without it the token is a flag, never the value. A
    // negative number is still a value.
    let Invoke { code, stdout: out, stderr: err } = invoke(&["commands", "--filter=-zzz-no-match"]);
    assert_eq!((code, out.as_str()), (0, ""), "{err}");
    for value in ["-zzz-no-match", "--json"] {
        let Invoke { code, stdout: out, .. } = invoke(&["commands", "--filter", value]);
        assert_eq!((code, out.is_empty()), (2, true), "--filter {value}");
    }
    let Invoke { code, stderr: err, .. } = invoke(&["commands", "--filter", "-1"]);
    assert_eq!(code, 0, "{err}");
    // A bare flag takes no value; a value flag needs one.
    let Invoke { code, stdout: out, stderr: err } = invoke(&["commands", "--json=1"]);
    assert_eq!((code, out.is_empty()), (2, true));
    assert!(err.contains("--json"), "{err}");
    let Invoke { code, stdout: out, stderr: err } = invoke(&["commands", "--filter"]);
    assert_eq!((code, out.is_empty()), (2, true));
    assert!(err.contains("--filter"), "{err}");
}

/// Each `--params` applies to the `--cmd` before it; a `--cmd` without one gets `{}`; a
/// `--params` ahead of every `--cmd` fails naming `--params`.
#[test]
fn run_pairs_params_with_the_preceding_cmd() {
    let Invoke { code, stdout: out, stderr: err } = invoke(&[
        "run",
        "--new",
        r#"{"width":8,"height":8}"#,
        "--cmd",
        "layer.new.layer",
        "--params",
        r#"{"name":"First"}"#,
        "--cmd",
        "layer.new.layer",
        "--cmd",
        "layer.new.layer",
        "--params",
        r#"{"name":"Third"}"#,
        "--cmd",
        "document.inspect",
    ]);
    assert_eq!(code, 0, "{err}");
    let rows: Vec<Value> = out.lines().map(|l| serde_json::from_str(l).unwrap()).collect();
    assert_eq!(rows.len(), 4, "{out}");
    let names: Vec<&str> = rows[3]["result"]["layers"].as_array().unwrap().iter().filter_map(|l| l["name"].as_str()).collect();
    let count = |n: &str| names.iter().filter(|x| **x == n).count();
    assert_eq!((count("First"), count("Third")), (1, 1), "each --params applies to its own --cmd only: {names:?}");
    // Three new layers plus the background; the middle one (no --params) has a default name.
    assert_eq!(names.len(), 4, "{names:?}");
    // Layers list top first: Third, the unnamed middle one, First, Background. Pairing --params
    // with --cmd by position (params[i] -> cmd[i]) would name the middle one Third instead.
    assert_eq!((names[0], names[2]), ("Third", "First"), "{names:?}");
    let Invoke { code, stderr: err, .. } = invoke(&["run", "--new", "{}", "--params", "{}", "--cmd", "layer.new.layer"]);
    assert_ne!(code, 0);
    assert!(err.contains("--params"), "{err}");
}

/// #7789: `convert` opens a developed raw at Raw Defaults › Resolution (default 300 ppi), as
/// `run`, `info` and the app do; it wrote 72.
#[test]
fn convert_opens_a_raw_at_the_raw_defaults_resolution() {
    use photocraft_raw::testgen::{DngSpec, mosaic, scene};
    let d = tmp("convert-raw");
    let (w, h) = (24, 16);
    let (raw, psd) = (d.join("IMG_0001.dng"), d.join("IMG_0001.psd"));
    std::fs::write(&raw, DngSpec::cfa(w, h, mosaic(&scene(w, h), w, [0, 1, 1, 2], 0, 65535)).build()).unwrap();
    ok(bin().args(["convert"]).arg(&raw).arg(&psd));
    let doc = photocraft_io::import("IMG_0001.psd", &std::fs::read(&psd).unwrap()).unwrap().document;
    assert_eq!(doc.resolution_dpi, 300.0);
    std::fs::remove_dir_all(d).unwrap();
}

/// `--out=-image.png` writes `-image.png`; `--out -image.png` is a usage error and writes nothing.
#[test]
fn a_value_starting_with_a_dash_is_written_with_equals() {
    let d = tmp("dash-value");
    let o = bin().current_dir(&d).args(["run", "--new", r#"{"width":4,"height":4}"#, "--out", "-image.png"]).output().unwrap();
    assert_eq!(o.status.code(), Some(2), "{}", String::from_utf8_lossy(&o.stderr));
    assert_eq!(std::fs::read_dir(&d).unwrap().count(), 0);
    ok(bin().current_dir(&d).args(["run", "--new", r#"{"width":4,"height":4}"#, "--out=-image.png"]));
    assert!(d.join("-image.png").is_file());
    std::fs::remove_dir_all(d).unwrap();
}

/// `run` takes exactly one of `<FILE>` or `--new`, and `mcp`/`serve` one of `--control-token` or
/// `--control-token-file`: anything else is a usage error naming the flags, before any work.
#[test]
fn either_or_flags_are_usage_errors() {
    let Invoke { code, stderr: err, .. } = invoke(&["run", "a.png", "--new", "{}", "--cmd", "layer.new.layer"]);
    assert_eq!(code, 2);
    assert!(err.contains("--new") && err.contains("cannot be used with"), "{err}");
    let Invoke { code, stderr: err, .. } = invoke(&["run", "--cmd", "layer.new.layer"]);
    assert_eq!(code, 2);
    assert!(err.contains("--new"), "{err}");
    let Invoke { code, stderr: err, .. } = invoke(&["run", "--new", "{}", "--cmd", "layer.new.layer", "--params", "{"]);
    assert_eq!(code, 2);
    assert!(err.contains("--params"), "{err}");
    let token = "a".repeat(64);
    for mode in [["mcp", "--bridge", "1"], ["serve", "--port", "0"]] {
        let o = bin().args(mode).args(["--control-token", token.as_str(), "--control-token-file", "token"]).stdin(Stdio::null()).output().unwrap();
        let err = String::from_utf8_lossy(&o.stderr);
        assert_eq!(o.status.code(), Some(2), "{mode:?}: {err}");
        assert!(err.contains("--control-token-file") && err.contains("cannot be used with"), "{mode:?}: {err}");
    }
    for port in ["70000", "x"] {
        let o = bin().args(["serve", "--port", port]).stdin(Stdio::null()).output().unwrap();
        let err = String::from_utf8_lossy(&o.stderr);
        assert_eq!(o.status.code(), Some(2), "--port {port}: {err}");
        assert!(err.contains("--port"), "--port {port}: {err}");
    }
}

/// How a run of the binary ended.
struct Exited {
    code: Option<i32>,
    stderr: String,
}

/// The binary run with `args` and one variable set, stdin at its end.
fn with_var(args: &[&str], var: &str, value: &str) -> Exited {
    let o = bin().args(args).env(var, value).stdin(Stdio::null()).output().unwrap();
    Exited { code: o.status.code(), stderr: String::from_utf8_lossy(&o.stderr).into_owned() }
}

/// A port nothing listens on, for a `serve` to take.
fn free_port() -> u16 {
    std::net::TcpListener::bind((std::net::Ipv4Addr::LOCALHOST, 0)).unwrap().local_addr().unwrap().port()
}

/// `serve` on TCP never exits: read its stderr until it says it is serving (or its stderr closes),
/// then kill it.
fn serve_tcp_stderr(cmd: &mut Command) -> String {
    use std::io::Read as _;
    let mut child = cmd.stdin(Stdio::null()).stderr(Stdio::piped()).spawn().unwrap();
    // Read on a thread, so a `serve` that stays silent with stderr open fails the test after the
    // deadline instead of hanging it.
    let mut stderr = child.stderr.take().unwrap();
    let (tx, rx) = std::sync::mpsc::channel();
    std::thread::spawn(move || {
        let mut buf = [0u8; 4096];
        while let Ok(n) = stderr.read(&mut buf) {
            if n == 0 || tx.send(buf[..n].to_vec()).is_err() {
                break;
            }
        }
    });
    let deadline = std::time::Instant::now() + std::time::Duration::from_secs(30);
    let mut err = String::new();
    while !err.contains("photocraft-cli serving on") {
        match rx.recv_timeout(deadline.saturating_duration_since(std::time::Instant::now())) {
            Ok(chunk) => err.push_str(&String::from_utf8_lossy(&chunk)),
            Err(_) => break,
        }
    }
    let _ = child.kill();
    let _ = child.wait();
    err
}

/// #2491: `PHOTOCRAFT_CONTROL_PORT` turns `serve` from stdio into a TCP listener and `mcp` from a
/// headless engine into a bridge, and both say so on stderr. A flag wins, an empty value counts as
/// unset, and a bad value is a usage error naming the variable.
#[test]
fn control_port_env_switches_modes_with_a_notice_and_flags_win() {
    let port = free_port();
    let err = serve_tcp_stderr(bin().arg("serve").env("PHOTOCRAFT_CONTROL_PORT", port.to_string()));
    assert!(err.contains(&format!("PHOTOCRAFT_CONTROL_PORT={port} is set; serving on TCP instead of stdio")), "{err}");
    assert!(err.contains("unset it to serve stdio") && err.contains("photocraft-cli serving on"), "{err}");

    // No token is given, so the bridge fails after the notice.
    let err = with_var(&["mcp"], "PHOTOCRAFT_CONTROL_PORT", &port.to_string()).stderr;
    assert!(err.contains(&format!("PHOTOCRAFT_CONTROL_PORT is set; bridging to the app on 127.0.0.1:{port}")), "{err}");
    assert!(err.contains("unset it to run headless"), "{err}");

    // The flag wins, so the variable's bad value is never parsed.
    let err = serve_tcp_stderr(bin().args(["serve", "--port"]).arg(port.to_string()).env("PHOTOCRAFT_CONTROL_PORT", "not-a-port"));
    assert!(err.contains("photocraft-cli serving on") && !err.contains("PHOTOCRAFT_CONTROL_PORT"), "{err}");

    // Empty or blank counts as unset: `serve` reads stdio (at its end, so it exits at once) and
    // `mcp` stays headless.
    // A root on the command line is the headless engine's: the variable can't switch to a bridge
    // that would drop it.
    for root in ["--automation-read-root", "--automation-write-root"] {
        let Exited { code, stderr: err } = with_var(&["mcp", root, "."], "PHOTOCRAFT_CONTROL_PORT", &port.to_string());
        assert_eq!(code, Some(2), "{root}: {err}");
        assert!(err.contains(root) && err.contains("cannot be used with 'PHOTOCRAFT_CONTROL_PORT'") && !err.contains("bridging"), "{root}: {err}");
    }

    for empty in ["", "  "] {
        let Exited { code, stderr: err } = with_var(&["serve"], "PHOTOCRAFT_CONTROL_PORT", empty);
        assert!(code == Some(0) && !err.contains("PHOTOCRAFT_CONTROL_PORT"), "{empty:?}: {err}");
        let err = with_var(&["mcp"], "PHOTOCRAFT_CONTROL_PORT", empty).stderr;
        assert!(!err.contains("bridging"), "{empty:?}: {err}");
    }

    for (sub, bad) in [
        ("serve", "not-a-port"),
        ("serve", "70000"),
        ("mcp", "nope"),
        ("mcp", "70000"),
        // `--bridge` takes host:port, the variable only a port.
        ("mcp", "127.0.0.1:7878"),
        ("mcp", ":7878"),
        ("mcp", "bad:port"),
    ] {
        let Exited { code, stderr: err } = with_var(&[sub], "PHOTOCRAFT_CONTROL_PORT", bad);
        assert_eq!(code, Some(2), "{sub} {bad}: {err}");
        assert!(err.contains(&format!("invalid value '{bad}' for 'PHOTOCRAFT_CONTROL_PORT'")), "{sub} {bad}: {err}");
    }
}

/// `--control-token` and `--control-token-file` fall back to `PHOTOCRAFT_CONTROL_TOKEN` and
/// `PHOTOCRAFT_CONTROL_TOKEN_FILE`. One from the environment and the other as a flag is the
/// either/or usage error, naming the variable, when a token is used: a stale exported pair doesn't
/// stop headless `mcp` or stdio `serve`. Help names the token's variable, never its value.
#[test]
fn control_token_env_vars_are_the_flags_fallbacks() {
    let token = "a".repeat(64);
    for mode in [["mcp", "--bridge", "1"], ["serve", "--port", "0"]] {
        let Exited { code, stderr: err } = with_var(&[&mode[..], &["--control-token", token.as_str()][..]].concat(), "PHOTOCRAFT_CONTROL_TOKEN_FILE", "token");
        assert_eq!(code, Some(2), "{mode:?}: {err}");
        assert!(err.contains("PHOTOCRAFT_CONTROL_TOKEN_FILE") && err.contains("cannot be used with"), "{mode:?}: {err}");
        let Exited { code, stderr: err } = with_var(&[&mode[..], &["--control-token-file", "token"][..]].concat(), "PHOTOCRAFT_CONTROL_TOKEN", &token);
        assert_eq!(code, Some(2), "{mode:?}: {err}");
        assert!(err.contains("PHOTOCRAFT_CONTROL_TOKEN") && err.contains("cannot be used with") && !err.contains(&token), "{mode:?}: {err}");
    }
    for sub in ["mcp", "serve"] {
        let o = bin().arg(sub).env("PHOTOCRAFT_CONTROL_TOKEN", &token).env("PHOTOCRAFT_CONTROL_TOKEN_FILE", "token").stdin(Stdio::null()).output().unwrap();
        let err = String::from_utf8_lossy(&o.stderr);
        assert!(!err.contains("cannot be used with"), "{sub}: {err}");
        // stdio `serve` exits 0 at the end of its input; how headless `mcp` ends there isn't
        // pinned, so it only must not be the usage error.
        if sub == "serve" {
            assert_eq!(o.status.code(), Some(0), "{sub}: {err}");
        } else {
            assert_ne!(o.status.code(), Some(2), "{sub}: {err}");
        }
        let o = bin().args([sub, "--help"]).env("PHOTOCRAFT_CONTROL_TOKEN", &token).output().unwrap();
        let out = String::from_utf8_lossy(&o.stdout);
        assert!(out.contains("[env: PHOTOCRAFT_CONTROL_TOKEN]") && !out.contains(&token), "{sub}: {out}");
    }
    // The server takes the variable's token, so it neither generates nor prints one; an empty
    // variable counts as unset.
    let err = serve_tcp_stderr(bin().args(["serve", "--port"]).arg(free_port().to_string()).env("PHOTOCRAFT_CONTROL_TOKEN", &token));
    assert!(err.contains("photocraft-cli serving on") && !err.contains("control token"), "{err}");
    let err = serve_tcp_stderr(bin().args(["serve", "--port"]).arg(free_port().to_string()).env("PHOTOCRAFT_CONTROL_TOKEN", ""));
    assert!(err.contains("photocraft-cli serving on") && err.contains("photocraft-cli control token: "), "{err}");
}

/// #8802: Deselect with nothing selected is skipped in a `run`, as action playback does (#6744),
/// so a script that deselects after Reveal Selection still finishes and saves.
#[test]
fn run_skips_deselect_with_nothing_selected() {
    let folder = tmp("deselect-run");
    let native = folder.join("out.pcraft").to_string_lossy().to_string();
    let Invoke { code, stdout, stderr } = invoke(&[
        "run",
        "--new",
        r#"{"width":16,"height":16}"#,
        "--cmd",
        "select.rect",
        "--params",
        r#"{"x":0,"y":0,"width":8,"height":16}"#,
        "--cmd",
        "layer.new.layer",
        "--cmd",
        "layer.layerMask.revealSelection",
        "--cmd",
        "select.deselect",
        "--cmd",
        "layer.new.layer",
        "--params",
        r#"{"name":"after"}"#,
        "--out",
        &native,
    ]);
    assert_eq!(code, 0, "{stderr}");
    let results: Vec<Value> = stdout.lines().map(|l| serde_json::from_str(l).unwrap()).collect();
    assert_eq!(results.len(), 5, "every command reports a result: {stdout}");
    assert_eq!(results[3], json!({"command": "select.deselect", "result": null}));
    let Invoke { code, stdout, stderr } = invoke(&["info", &native, "--compact"]);
    assert_eq!(code, 0, "{stderr}");
    let info: Value = serde_json::from_str(&stdout).unwrap();
    assert_eq!(info["layers"][0]["name"], "after", "the steps after Deselect ran: {info}");

    // Deselect with a selection still deselects: Inverse afterwards finds nothing to invert.
    let Invoke { code, stderr, .. } = invoke(&[
        "run",
        "--new",
        r#"{"width":16,"height":16}"#,
        "--cmd",
        "select.all",
        "--cmd",
        "select.deselect",
        "--cmd",
        "select.inverse",
        "--out",
        &native,
    ]);
    assert_eq!(code, 1, "{stderr}");
    assert!(stderr.contains("select.inverse") && stderr.contains("no selection"), "{stderr}");
    let _ = std::fs::remove_dir_all(&folder);
}

/// #8802: a batched action that starts with Deselect plays on files with nothing selected, as the
/// same action does in the Actions panel (#6744).
#[test]
fn batch_skips_deselect_with_nothing_selected() {
    let dir = tmp("deselect-batch");
    let path = |name: &str| dir.join(name).to_string_lossy().to_string();
    std::fs::create_dir_all(dir.join("in")).unwrap();
    let Invoke { code, stderr, .. } = invoke(&["run", "--new", r#"{"width":8,"height":6}"#, "--out", &path("in/a.png")]);
    assert_eq!(code, 0, "{stderr}");
    std::fs::write(dir.join("steps.json"), json!([["select.deselect", {}], ["image.imageRotation.90cw", {}]]).to_string()).unwrap();
    let Invoke { code, stdout, stderr } = invoke(&["batch", "--actions", &path("steps.json"), "--in", &path("in"), "--out", &path("out")]);
    assert_eq!(code, 0, "{stdout}{stderr}");
    assert!(stdout.contains("1 succeeded, 0 failed"), "{stdout}");
    let Invoke { code, stdout, stderr } = invoke(&["info", &path("out/a.png"), "--compact"]);
    assert_eq!(code, 0, "{stderr}");
    let info: Value = serde_json::from_str(&stdout).unwrap();
    assert_eq!((info["width"].as_u64(), info["height"].as_u64()), (Some(6), Some(8)), "the step after Deselect ran: {info}");
    let _ = std::fs::remove_dir_all(&dir);
}

#[test]
fn every_configured_read_root_must_be_a_valid_directory() {
    let d = tmp("invalid-read-roots");
    let good = d.join("good");
    std::fs::create_dir_all(&good).unwrap();
    let file = d.join("file");
    std::fs::write(&file, b"not a directory").unwrap();
    for sub in ["mcp", "serve"] {
        for invalid in [d.join("missing"), file.clone()] {
            for roots in [[&good, &invalid], [&invalid, &good]] {
                let o = bin()
                    .arg(sub)
                    .arg("--automation-read-root")
                    .arg(roots[0])
                    .arg(format!("--automation-read-root={}", roots[1].display()))
                    .stdin(Stdio::null())
                    .output()
                    .unwrap();
                assert_eq!(o.status.code(), Some(1), "{sub}: {}", String::from_utf8_lossy(&o.stderr));
                assert!(String::from_utf8_lossy(&o.stderr).contains("automation read root"));
                assert!(o.stdout.is_empty(), "invalid roots must fail before the server starts");
            }
        }
    }
}

#[test]
fn serve_reads_roots_in_order_and_supports_absolute_paths_in_each_root() {
    let d = tmp("serve-read-roots");
    let first = d.join("first");
    let second = d.join("second");
    std::fs::create_dir_all(&first).unwrap();
    std::fs::create_dir_all(&second).unwrap();
    write_png(&first.join("shared.png"), 3, 2, 3);
    write_png(&second.join("shared.png"), 7, 4, 5);
    write_png(&second.join("fallback.png"), 6, 5, 7);
    let mut child = bin()
        .args(["serve", "--automation-read-root"])
        .arg(&first)
        .arg(format!("--automation-read-root={}", second.display()))
        .arg("--automation-read-root")
        .arg(&first)
        .stdin(Stdio::piped())
        .stdout(Stdio::piped())
        .stderr(Stdio::piped())
        .spawn()
        .unwrap();
    let mut stdin = child.stdin.take().unwrap();
    for (id, path) in [(1, "shared.png".into()), (2, "fallback.png".into()), (3, second.join("shared.png").to_string_lossy().into_owned())] {
        writeln!(stdin, "{}", json!({"id": id, "method": "doc.open", "params": {"path": path}})).unwrap();
    }
    drop(stdin);
    let output = child.wait_with_output().unwrap();
    assert!(output.status.success(), "{}", String::from_utf8_lossy(&output.stderr));
    let replies: Vec<Value> = String::from_utf8(output.stdout).unwrap().lines().map(|line| serde_json::from_str(line).unwrap()).collect();
    assert_eq!(replies.len(), 3);
    for (reply, (width, height)) in replies.iter().zip([(3, 2), (6, 5), (7, 4)]) {
        assert_eq!(reply["ok"], true, "{reply}");
        assert_eq!(reply["result"]["width"], width, "{reply}");
        assert_eq!(reply["result"]["height"], height, "{reply}");
    }
}

#[test]
fn mcp_reads_roots_in_order_with_fallback() {
    let d = tmp("mcp-read-roots");
    let first = d.join("first");
    let second = d.join("second");
    std::fs::create_dir_all(&first).unwrap();
    std::fs::create_dir_all(&second).unwrap();
    write_png(&first.join("shared.png"), 3, 2, 3);
    write_png(&second.join("shared.png"), 7, 4, 5);
    write_png(&second.join("fallback.png"), 6, 5, 7);
    let mut child = bin()
        .arg("mcp")
        .arg(format!("--automation-read-root={}", first.display()))
        .arg("--automation-read-root")
        .arg(&second)
        .stdin(Stdio::piped())
        .stdout(Stdio::piped())
        .stderr(Stdio::null())
        .spawn()
        .unwrap();
    let mut stdin = child.stdin.take().unwrap();
    let mut stdout = BufReader::new(child.stdout.take().unwrap());
    let mut send = |value: Value| {
        writeln!(stdin, "{value}").unwrap();
        stdin.flush().unwrap();
    };
    let mut recv = |id: u64| -> Value {
        loop {
            let mut line = String::new();
            assert!(stdout.read_line(&mut line).unwrap() > 0, "server closed");
            let value: Value = serde_json::from_str(&line).unwrap();
            if value["id"] == id {
                return value;
            }
        }
    };
    send(json!({"jsonrpc":"2.0","id":1,"method":"initialize","params":{
        "protocolVersion":"2025-06-18","capabilities":{},"clientInfo":{"name":"test","version":"0"}}}));
    assert_eq!(recv(1)["result"]["serverInfo"]["name"], "photocraft");
    send(json!({"jsonrpc":"2.0","method":"notifications/initialized"}));
    for (id, path, width) in [(2, "shared.png", 3), (3, "fallback.png", 6)] {
        send(json!({"jsonrpc":"2.0","id":id,"method":"tools/call","params":{"name":"doc_open","arguments":{"path":path}}}));
        let reply = recv(id);
        assert_ne!(reply["result"]["isError"], true, "{reply}");
        let opened: Value = serde_json::from_str(reply["result"]["content"][0]["text"].as_str().unwrap()).unwrap();
        assert_eq!(opened["width"], width, "{reply}");
    }
    let _ = child.kill();
    let _ = child.wait();
}

/// TIFF Options from the command line (#8827): `--tiff-compression`, `--tiff-transparency on|off`
/// and `--tiff-pyramid`; a bad value is a usage error that writes nothing.
#[test]
fn tiff_options_choose_compression_transparency_and_pyramid() {
    let d = tmp("tiff-options");
    let a = d.join("a.png");
    write_png(&a, 200, 100, 3);
    // (flags, compression tag, alpha, directories)
    for (flags, compression, alpha, dirs) in [
        (&[][..], 1, true, 1),
        (&["--tiff-compression", "lzw"][..], 5, true, 1),
        (&["--tiff-transparency", "off", "--tiff-compression", "zip"][..], 8, false, 1),
        (&["--tiff-transparency", "on", "--tiff-pyramid"][..], 1, true, 3),
    ] {
        let out = d.join("a.tif");
        ok(bin().arg("convert").arg(&a).arg(&out).args(flags));
        let bytes = std::fs::read(&out).unwrap();
        let info = photocraft_codecs::tiff_info(&bytes).unwrap();
        assert_eq!(info.pages.len(), dirs, "{flags:?}");
        assert!(info.pages.iter().all(|p| p.compression == compression), "{flags:?}: {:?}", info.pages);
        assert_eq!(photocraft_codecs::decode(&bytes).unwrap().layout().has_alpha(), alpha, "{flags:?}");
    }
    for (flag, bad, expected) in [("--tiff-transparency", "maybe", "expected on or off"), ("--tiff-compression", "jpeg", "expected none, lzw or zip")] {
        let out = d.join("bad.tif");
        let o = bin().arg("convert").arg(&a).arg(&out).args([flag, bad]).output().unwrap();
        let err = String::from_utf8_lossy(&o.stderr);
        assert_eq!(o.status.code(), Some(2), "{flag} {bad}");
        assert!(err.contains(flag) && err.contains(expected), "{flag} {bad}: {err}");
        assert!(!out.exists(), "{flag} {bad} wrote a file");
    }
}

#[test]
fn info_detail_adds_text_runs_and_antialiasing() {
    fn type_layer(doc: &Value) -> Option<&Value> {
        let mut stack: Vec<&Value> = doc["layers"].as_array()?.iter().collect();
        while let Some(l) = stack.pop() {
            if l["kind"] == "Type" {
                return Some(l);
            }
            stack.extend(l["children"].as_array().into_iter().flatten());
        }
        None
    }
    let dir = tmp("info-detail");
    let file = dir.join("t.psd");
    ok(bin()
        .args(["run", "--new", r#"{"width":64,"height":64}"#, "--cmd", "type.create", "--params", r#"{"text":"Hi","x":4,"y":30,"name":"T"}"#, "--out"])
        .arg(&file));
    let plain: Value = serde_json::from_str(&ok(bin().arg("info").arg(&file).arg("--compact")).stdout).unwrap();
    let text = &type_layer(&plain).expect("type layer")["text"];
    assert!(text.get("runs").is_none() && text.get("antialias").is_none(), "{text}");
    let detail: Value = serde_json::from_str(&ok(bin().arg("info").arg(&file).args(["--compact", "--detail"])).stdout).unwrap();
    let text = &type_layer(&detail).expect("type layer")["text"];
    assert!(text.get("antialias").is_some(), "{text}");
    assert!(text["runs"].as_array().is_some_and(|r| !r.is_empty()), "{text}");
    let _ = std::fs::remove_dir_all(&dir);
}

/// Flags that don't go together are usage errors before anything starts. Adding PhotoCraft to an
/// MCP client is the ArtCraft Launcher's job, so there is no `mcp install`, and plain `mcp` does
/// what `--live` did, so there is no `--live` either.
#[test]
fn mcp_rejects_mismatched_flags() {
    for (args, needle) in [
        (&["mcp", "install"][..], "install"),
        (&["mcp", "--live"], "--live"),
        (&["mcp", "--client", "json"], "--client"),
        (&["mcp", "--headless", "--bridge", "127.0.0.1:1"], "--bridge"),
        (&["mcp", "--headless", "--control-token-file", "t"], "--control-token-file"),
        (&["mcp", "--headless", "--when-closed", "launch"], "--when-closed"),
        (&["mcp", "--when-closed", "sometimes"], "sometimes"),
        (&["mcp", "--bridge", "127.0.0.1:1", "--when-closed", "error"], "--when-closed"),
    ] {
        let o = bin().args(args).stdin(Stdio::null()).output().unwrap();
        let err = String::from_utf8_lossy(&o.stderr);
        assert_eq!(o.status.code(), Some(2), "{args:?}: {err}");
        assert!(err.contains(needle), "{args:?}: {err}");
    }
}

/// One MCP exchange with `photocraft-cli mcp <args>`: initialize, then each tool call; returns the
/// tool results.
fn mcp_session(args: &[&str], env: &[(&str, &std::ffi::OsStr)], calls: &[(&str, Value)]) -> Vec<Value> {
    let mut cmd = bin();
    cmd.args(args).stdin(Stdio::piped()).stdout(Stdio::piped()).stderr(Stdio::null());
    for (k, v) in env {
        cmd.env(k, v);
    }
    let mut child = cmd.spawn().unwrap();
    let mut stdin = child.stdin.take().unwrap();
    let mut stdout = BufReader::new(child.stdout.take().unwrap());
    let mut send = |v: Value| {
        writeln!(stdin, "{v}").unwrap();
        stdin.flush().unwrap();
    };
    let mut recv = |id: u64| -> Value {
        loop {
            let mut line = String::new();
            assert!(stdout.read_line(&mut line).unwrap() > 0, "server closed");
            let v: Value = serde_json::from_str(&line).unwrap();
            if v["id"] == id {
                return v;
            }
        }
    };
    send(json!({"jsonrpc":"2.0","id":1,"method":"initialize","params":{
        "protocolVersion":"2025-06-18","capabilities":{},"clientInfo":{"name":"test","version":"0"}}}));
    recv(1);
    send(json!({"jsonrpc":"2.0","method":"notifications/initialized"}));
    let mut out = Vec::new();
    for (i, (name, arguments)) in calls.iter().enumerate() {
        let id = 2 + i as u64;
        send(json!({"jsonrpc":"2.0","id":id,"method":"tools/call","params":{"name":name,"arguments":arguments}}));
        out.push(recv(id)["result"].clone());
    }
    drop(stdin);
    let _ = child.kill();
    let _ = child.wait();
    out
}

/// Plain `mcp` without the person's consent works headless, as it always did: commands run, UI
/// tools say they need the open app. `--headless` too, and it doesn't read a PHOTOCRAFT_CONTROL_PORT
/// exported for another tool (here not even a port).
#[test]
fn mcp_without_consent_works_headless() {
    let dir = tmp("mcp-plain");
    let empty = tmp("mcp-plain-launcher");
    // `crate::command()` keeps the machine's launcher and flags out already; this test names its
    // own settings and an empty launcher folder as well, to say what it relies on.
    let env = [("PHOTOCRAFT_CONFIG_DIR", dir.as_os_str()), ("CRAFT_MCP_DIR", empty.as_os_str())];
    let calls = [("command_list", json!({})), ("ui_inspect", json!({}))];
    let r = mcp_session(&["mcp", "--when-closed", "error"], &env, &calls);
    assert_ne!(r[0]["isError"], true, "headless commands run: {}", r[0]);
    assert_eq!(r[1]["isError"], true, "{}", r[1]);
    assert!(r[1]["content"][0]["text"].as_str().unwrap().contains("bridge"), "{}", r[1]);
    let mut env = env.to_vec();
    env.push(("PHOTOCRAFT_CONTROL_PORT", std::ffi::OsStr::new("not-a-port")));
    let r = mcp_session(&["mcp", "--headless"], &env, &calls[..1]);
    assert_ne!(r[0]["isError"], true, "{}", r[0]);
    // Without the `AI-MCP` flag a Control Port saved before the agents switch (which the app
    // reads as "agents may connect") still leaves plain `mcp` headless: it neither looks for
    // the app nor applies When PhotoCraft Is Closed ("error" would fail this call).
    std::fs::write(dir.join("preferences.json"), r#"{"integrations": {"controlPort": 7878}}"#).unwrap();
    let r = mcp_session(&["mcp", "--when-closed", "error"], &env[..2], &calls[..1]);
    assert_ne!(r[0]["isError"], true, "without the flag plain mcp stays headless: {}", r[0]);
    let _ = std::fs::remove_dir_all(&dir);
    let _ = std::fs::remove_dir_all(&empty);
}