yosh 0.2.4

use std::os::fd::AsRawFd;
use std::path::PathBuf;
use std::process::Command;
use std::sync::atomic::{AtomicU64, Ordering};
use std::time::{Duration, Instant};

use expectrl::{Eof, Expect, Regex, Session, session::OsSession};

const TIMEOUT: Duration = Duration::from_secs(15);
const RAW_MODE_WAIT_TIMEOUT: Duration = Duration::from_secs(5);

// ── TempDir (inline, avoids pulling in mock_terminal via mod helpers) ─────

static TEMP_DIR_COUNTER: AtomicU64 = AtomicU64::new(0);

struct TempDir {
    path: PathBuf,
}

impl TempDir {
    fn new() -> Self {
        let mut path = std::env::temp_dir();
        let id = std::time::SystemTime::now()
            .duration_since(std::time::UNIX_EPOCH)
            .unwrap()
            .as_nanos();
        let seq = TEMP_DIR_COUNTER.fetch_add(1, Ordering::Relaxed);
        path.push(format!("yosh-pty-test-{}-{}", id, seq));
        std::fs::create_dir_all(&path).unwrap();
        TempDir { path }
    }

    fn path(&self) -> &PathBuf {
        &self.path
    }
}

impl Drop for TempDir {
    fn drop(&mut self) {
        let _ = std::fs::remove_dir_all(&self.path);
    }
}

// ── Helpers ─────────────────────────────────────────────────────────────

/// Returns (session, tmpdir). The tmpdir must be kept alive for the
/// duration of the test so that yosh's HOME directory is not deleted.
fn spawn_yosh() -> (OsSession, TempDir) {
    let bin = env!("CARGO_BIN_EXE_yosh");
    let tmpdir = TempDir::new();

    let mut cmd = Command::new(bin);
    cmd.env("TERM", "dumb");
    cmd.env("HOME", tmpdir.path());

    let mut session = Session::spawn(cmd).expect("failed to spawn yosh");
    session.set_expect_timeout(Some(TIMEOUT));
    (session, tmpdir)
}

fn wait_for_prompt(session: &mut OsSession) {
    session.expect("$ ").expect("prompt not found");
    wait_for_raw_mode(session);
}

fn wait_for_ps2(session: &mut OsSession) {
    session.expect("> ").expect("PS2 prompt not found");
    wait_for_raw_mode(session);
}

/// Block until yosh has called `enable_raw_mode()` on the PTY slave.
///
/// The previous implementation used a fixed 50ms sleep, which is a classic
/// flaky-test pattern — under load the child can take longer than that to
/// transition from canonical to raw mode, and input sent in the race window
/// gets processed by the cooked line discipline (ICRNL translation, ECHO,
/// ICANON buffering) instead of yosh's LineEditor.
///
/// Both ends of a PTY share one termios struct, so `tcgetattr` on the master
/// fd (which expectrl exposes via `AsRawFd`) observes the slave-side settings.
/// Poll for `ICANON` cleared — raw mode disables it — and return as soon as
/// the transition is visible.
fn wait_for_raw_mode(session: &OsSession) {
    let fd = session.as_raw_fd();
    let deadline = Instant::now() + RAW_MODE_WAIT_TIMEOUT;
    loop {
        let mut termios: libc::termios = unsafe { std::mem::zeroed() };
        let rc = unsafe { libc::tcgetattr(fd, &mut termios) };
        if rc == 0 && (termios.c_lflag & (libc::ICANON as libc::tcflag_t)) == 0 {
            return;
        }
        if Instant::now() >= deadline {
            let errno = if rc != 0 {
                std::io::Error::last_os_error().to_string()
            } else {
                "ok".to_string()
            };
            panic!(
                "wait_for_raw_mode timed out: tcgetattr rc={} ({}), c_lflag=0x{:x}",
                rc, errno, termios.c_lflag,
            );
        }
        std::thread::sleep(Duration::from_millis(2));
    }
}

/// Wait for command output (a line following a newline, not the input echo).
/// Uses a regex that matches the pattern preceded by a newline. The \r before
/// \n is optional because crossterm raw mode suppresses PTY ONLCR output
/// processing when active — so output may arrive as either \r\n or just \n.
fn expect_output(session: &mut OsSession, text: &str, msg: &str) {
    // \r? makes the carriage return optional to handle both ONLCR and raw mode
    let pattern = format!("\r?\n{}", text);
    session
        .expect(Regex(&pattern))
        .unwrap_or_else(|e| panic!("{}: {}", msg, e));
}

/// Send Ctrl+D and wait for the shell to exit cleanly.
fn exit_shell(session: &mut OsSession) {
    session.send("\x04").unwrap();
    // Wait for EOF to ensure the yosh process has fully exited before the
    // next test starts — avoids PTY resource contention between tests.
    let _ = session.expect(Eof);
}

/// RAII guard that restores the expectrl session's timeout on drop.
///
/// Use when temporarily shrinking the timeout for fast-failing expects
/// (e.g. buffer drains). Restores the original timeout even if a panic
/// aborts the test, preventing a leaked short timeout from cascading
/// into later assertions.
struct TimeoutGuard<'a> {
    session: &'a mut OsSession,
    saved: Duration,
}

impl<'a> TimeoutGuard<'a> {
    /// Install `temporary` as the session's expect timeout, restoring
    /// `prior` on drop. expectrl 0.8 has no getter for the current
    /// timeout, so the caller must pass it explicitly — this prevents
    /// a future test from silently restoring the wrong value if it has
    /// already changed the timeout away from `TIMEOUT`.
    fn new(session: &'a mut OsSession, temporary: Duration, prior: Duration) -> Self {
        session.set_expect_timeout(Some(temporary));
        Self {
            session,
            saved: prior,
        }
    }
}

impl<'a> Drop for TimeoutGuard<'a> {
    fn drop(&mut self) {
        self.session.set_expect_timeout(Some(self.saved));
    }
}

/// Consume whatever is currently in expectrl's internal buffer so the
/// next `expect` sees only fresh bytes.
///
/// The line editor repaints each typed character with syntax-highlight
/// ANSI escape sequences; by the time a user-visible command has been
/// echoed, expectrl's buffer holds ~2KB of stale `$ ` + color codes.
/// Without draining, subsequent `expect` calls can match those stale
/// prompts and race past the real post-command output.
///
/// The regex lower-bound `0,` is intentional: we want "up to 8KB or
/// whatever is there," not "at least one character." Changing it to
/// `1,` reintroduces a hang when the buffer is already empty.
///
/// `PTY_DRAIN_MAX_BYTES` is the regex's *upper bound* on a single
/// expect call — the actual drain depth is bounded by the 300 ms
/// timeout window in `drain_pty_buffer`, not by this constant.
const PTY_DRAIN_MAX_BYTES: usize = 8192;
fn drain_pty_buffer(session: &mut OsSession) {
    let guard = TimeoutGuard::new(session, Duration::from_millis(300), TIMEOUT);
    // Two back-to-back reads: the first consumes what's currently
    // buffered; the second catches bytes that arrived during the first
    // read's brief timeout window.
    let _ = guard
        .session
        .expect(Regex(&format!(r".{{0,{}}}", PTY_DRAIN_MAX_BYTES)));
    let _ = guard
        .session
        .expect(Regex(&format!(r".{{0,{}}}", PTY_DRAIN_MAX_BYTES)));
}

/// Send Ctrl-Z and wait for the foreground job's "Stopped" notification.
///
/// Drains prior line-editor echo before sending so the later `expect`
/// does not race on stale prompt bytes.
fn suspend_fg_job(session: &mut OsSession) {
    drain_pty_buffer(session);
    session.send("\x1a").unwrap();
    session
        .expect("Stopped")
        .expect("job did not stop after Ctrl-Z");
}

// ── Tests ───────────────────────────────────────────────────────────────

#[test]
fn test_pty_echo_command() {
    let (mut s, _tmpdir) = spawn_yosh();
    wait_for_prompt(&mut s);

    s.send("echo hello\r").unwrap();
    expect_output(&mut s, "hello", "echo output not found");
    wait_for_prompt(&mut s);

    exit_shell(&mut s);
}

#[test]
fn test_pty_ctrl_d_exits() {
    let (mut s, _tmpdir) = spawn_yosh();
    wait_for_prompt(&mut s);

    s.send("\x04").unwrap();
    s.expect(Eof).expect("shell did not exit on Ctrl+D");
}

#[test]
fn test_pty_ctrl_c_interrupts_input() {
    let (mut s, _tmpdir) = spawn_yosh();
    wait_for_prompt(&mut s);

    // Type something, then Ctrl+C
    s.send("partial input").unwrap();
    s.send("\x03").unwrap();

    // Should get a new prompt
    wait_for_prompt(&mut s);

    // Can still run commands
    s.send("echo ok\r").unwrap();
    expect_output(&mut s, "ok", "command after Ctrl+C failed");
    wait_for_prompt(&mut s);

    exit_shell(&mut s);
}

#[test]
fn test_pty_history_up_re_executes() {
    let (mut s, _tmpdir) = spawn_yosh();
    wait_for_prompt(&mut s);

    s.send("echo first_cmd\r").unwrap();
    expect_output(&mut s, "first_cmd", "first command output not found");
    wait_for_prompt(&mut s);

    // Press Up then Enter to re-execute
    s.send("\x1b[A").unwrap(); // Up arrow (ANSI escape)
    s.send("\r").unwrap();
    expect_output(&mut s, "first_cmd", "history re-execution failed");
    wait_for_prompt(&mut s);

    exit_shell(&mut s);
}

#[test]
fn test_pty_backspace_editing() {
    let (mut s, _tmpdir) = spawn_yosh();
    wait_for_prompt(&mut s);

    // Type "echoo", backspace, " works"
    s.send("echoo").unwrap();
    s.send("\x7f").unwrap(); // Backspace
    s.send(" works\r").unwrap();
    expect_output(&mut s, "works", "line editing with backspace failed");
    wait_for_prompt(&mut s);

    exit_shell(&mut s);
}

#[test]
fn test_pty_ps2_continuation() {
    let (mut s, _tmpdir) = spawn_yosh();
    wait_for_prompt(&mut s);

    // Incomplete command: if true; then
    s.send("if true; then\r").unwrap();
    wait_for_ps2(&mut s);

    // Body — still incomplete (needs fi)
    s.send("echo continued\r").unwrap();
    wait_for_ps2(&mut s);

    s.send("fi\r").unwrap();
    expect_output(&mut s, "continued", "if-then-fi output not found");
    wait_for_prompt(&mut s);

    exit_shell(&mut s);
}

#[test]
fn test_pty_ctrl_r_history_search() {
    let (mut s, _tmpdir) = spawn_yosh();
    wait_for_prompt(&mut s);

    // Build up history
    s.send("echo alpha\r").unwrap();
    expect_output(&mut s, "alpha", "first echo alpha failed");
    wait_for_prompt(&mut s);

    s.send("echo beta\r").unwrap();
    expect_output(&mut s, "beta", "echo beta failed");
    wait_for_prompt(&mut s);

    // Ctrl+R to search - wait for search UI, type query, then select and execute
    s.send("\x12").unwrap(); // Ctrl+R
    // Wait for the search UI query line to appear
    s.expect("2/2 > ").expect("Ctrl+R search UI did not appear");
    // FuzzySearchUI::run() draws UI then enables raw mode — wait for transition
    wait_for_raw_mode(&s);

    // Type "echo alpha" to uniquely select it
    s.send("echo alpha").unwrap();
    // Wait for filter to narrow down to unique match
    s.expect("1/1 > ")
        .expect("search query did not filter to unique match");

    s.send("\r").unwrap(); // Select from search
    // After selection, FuzzySearchUI exits and LineEditor re-enables raw mode
    wait_for_raw_mode(&s);
    s.send("\r").unwrap(); // Execute
    expect_output(&mut s, "alpha", "Ctrl+R history search failed");
    wait_for_prompt(&mut s);

    exit_shell(&mut s);
}

#[test]
fn test_pty_autosuggest_accept_with_right_arrow() {
    let (mut s, _tmpdir) = spawn_yosh();
    wait_for_prompt(&mut s);

    // Execute a command to populate history
    s.send("echo autosuggest_test_value\r").unwrap();
    expect_output(&mut s, "autosuggest_test_value", "initial echo failed");
    wait_for_prompt(&mut s);

    // Type prefix "echo auto" — suggestion should appear
    s.send("echo auto").unwrap();
    // Brief pause for suggestion to render
    std::thread::sleep(Duration::from_millis(50));

    // Press Right arrow to accept the suggestion
    s.send("\x1b[C").unwrap(); // Right arrow (ANSI escape)
    // Brief pause for acceptance
    std::thread::sleep(Duration::from_millis(50));

    // Press Enter to execute
    s.send("\r").unwrap();
    expect_output(
        &mut s,
        "autosuggest_test_value",
        "autosuggest acceptance failed",
    );
    wait_for_prompt(&mut s);

    exit_shell(&mut s);
}

#[test]
fn test_pty_tab_completion() {
    let (mut s, tmpdir) = spawn_yosh();
    wait_for_prompt(&mut s);

    // Create a uniquely named file in the temp HOME directory
    let test_file = tmpdir.path().join("yosh_tab_test_unique.txt");
    std::fs::write(&test_file, "hello").unwrap();

    // cd to HOME (which is tmpdir)
    s.send("cd\r").unwrap();
    wait_for_prompt(&mut s);

    // Type "echo yosh_tab" then Tab to complete the filename
    s.send("echo yosh_tab").unwrap();
    std::thread::sleep(Duration::from_millis(50));
    s.send("\t").unwrap(); // Tab
    std::thread::sleep(Duration::from_millis(100));

    // Press Enter to execute — echo will print the completed filename
    s.send("\r").unwrap();
    expect_output(
        &mut s,
        "yosh_tab_test_unique.txt",
        "Tab completion failed to complete and execute",
    );
    wait_for_prompt(&mut s);

    exit_shell(&mut s);
}

#[test]
fn test_pty_command_completion() {
    let (mut s, _tmpdir) = spawn_yosh();
    wait_for_prompt(&mut s);

    // "ech" + Tab should complete to "echo" (builtin)
    s.send("ech").unwrap();
    std::thread::sleep(Duration::from_millis(50));
    s.send("\t").unwrap();
    std::thread::sleep(Duration::from_millis(100));

    // Add " hello" and press Enter to execute "echo hello"
    s.send(" hello\r").unwrap();
    expect_output(&mut s, "hello", "Command completion for 'echo' failed");
    wait_for_prompt(&mut s);

    exit_shell(&mut s);
}

#[test]
fn test_pty_command_completion_after_pipe() {
    let (mut s, _tmpdir) = spawn_yosh();
    wait_for_prompt(&mut s);

    // "echo hello | ca" + Tab inserts the common prefix of ca* commands.
    // Then send "t" to ensure we have "cat", then Enter.
    s.send("echo hello | ca").unwrap();
    std::thread::sleep(Duration::from_millis(50));
    s.send("\t").unwrap();
    std::thread::sleep(Duration::from_millis(100));
    // Send "t\r" in case Tab only completed up to the common prefix "ca"
    s.send("t\r").unwrap();
    expect_output(&mut s, "hello", "Command completion after pipe failed");
    wait_for_prompt(&mut s);

    exit_shell(&mut s);
}

#[test]
fn test_pty_path_completion_in_argument_position() {
    let (mut s, tmpdir) = spawn_yosh();
    wait_for_prompt(&mut s);

    // Create a uniquely named file
    let test_file = tmpdir.path().join("yosh_argcomp_unique.txt");
    std::fs::write(&test_file, "content").unwrap();

    // cd to HOME
    s.send("cd\r").unwrap();
    wait_for_prompt(&mut s);

    // "cat yosh_argcomp" + Tab should path-complete to "yosh_argcomp_unique.txt"
    s.send("cat yosh_argcomp").unwrap();
    std::thread::sleep(Duration::from_millis(50));
    s.send("\t").unwrap();
    std::thread::sleep(Duration::from_millis(100));

    // Press Enter — should print the file content
    s.send("\r").unwrap();
    expect_output(
        &mut s,
        "content",
        "Path completion in argument position failed",
    );
    wait_for_prompt(&mut s);

    exit_shell(&mut s);
}

#[test]
fn test_pty_syntax_highlight_keyword() {
    let (mut s, _tmpdir) = spawn_yosh();
    wait_for_prompt(&mut s);

    // Type "if" — should be highlighted as Keyword (Bold + Magenta)
    s.send("if").unwrap();
    std::thread::sleep(Duration::from_millis(100));

    // Cancel with Ctrl+C
    s.send("\x03").unwrap(); // Ctrl+C to cancel
    wait_for_prompt(&mut s);

    exit_shell(&mut s);
}

#[test]
fn test_pty_syntax_highlight_valid_command() {
    let (mut s, _tmpdir) = spawn_yosh();
    wait_for_prompt(&mut s);

    // Type "echo hi" — echo should be highlighted as CommandValid (Bold + Green)
    s.send("echo hi\r").unwrap();
    expect_output(&mut s, "hi", "echo with highlighting failed");
    wait_for_prompt(&mut s);

    exit_shell(&mut s);
}

#[test]
fn test_pty_syntax_highlight_pipe() {
    let (mut s, _tmpdir) = spawn_yosh();
    wait_for_prompt(&mut s);

    // Execute a pipe command with highlighting active
    s.send("echo pipe_ok | cat\r").unwrap();
    expect_output(&mut s, "pipe_ok", "pipe with highlighting failed");
    wait_for_prompt(&mut s);

    exit_shell(&mut s);
}

#[test]
fn ansi_colored_prompt() {
    let (mut session, _tmpdir) = spawn_yosh();
    wait_for_prompt(&mut session);

    // Set PS1 to an ANSI-colored prompt using command substitution with printf
    session
        .send("PS1=$(printf '\\033[32m$ \\033[0m')\r")
        .unwrap();
    wait_for_raw_mode(&session);

    // The prompt should render and accept input
    session.expect("$").expect("colored prompt not found");
    wait_for_raw_mode(&session);

    session.send("echo hello\r").unwrap();
    expect_output(&mut session, "hello", "echo after colored prompt");

    exit_shell(&mut session);
}

#[test]
fn multi_line_prompt() {
    let (mut session, _tmpdir) = spawn_yosh();
    wait_for_prompt(&mut session);

    // Set a two-line PS1: info line + prompt char
    // Use printf to get the newline in the prompt
    session.send("PS1=$(printf 'info line\\n> ')\r").unwrap();
    wait_for_raw_mode(&session);

    session
        .expect(">")
        .expect("multi-line prompt char not found");
    wait_for_raw_mode(&session);

    session.send("echo works\r").unwrap();
    expect_output(&mut session, "works", "echo after multi-line prompt");

    exit_shell(&mut session);
}

#[test]
fn test_pty_sighup_saves_history() {
    let (mut s, tmpdir) = spawn_yosh();
    wait_for_prompt(&mut s);

    // Execute a command so it gets added to history
    s.send("echo sighup_test_marker\r").unwrap();
    expect_output(&mut s, "sighup_test_marker", "echo output");
    wait_for_prompt(&mut s);

    // Send SIGHUP to the yosh process
    // get_process() returns &UnixProcess which Derefs to PtyProcess; pid() returns nix::unistd::Pid
    let pid = s.get_process().pid();
    unsafe {
        libc::kill(pid.as_raw(), libc::SIGHUP);
    }

    // Wait for yosh to exit
    let _ = s.expect(Eof);

    // Verify history file was written
    let histfile = tmpdir.path().join(".yosh_history");
    let contents =
        std::fs::read_to_string(&histfile).expect("history file should exist after SIGHUP");
    assert!(
        contents.contains("echo sighup_test_marker"),
        "history file should contain the command, got: {:?}",
        contents
    );
}

#[test]
fn test_pty_set_plus_m_disables_job_control() {
    let (mut s, _tmpdir) = spawn_yosh();
    wait_for_prompt(&mut s);

    // Interactive shell starts with monitor=on; disable it
    s.send("set +m\r").unwrap();
    wait_for_prompt(&mut s);

    // fg should fail with "no job control"
    s.send("fg\r").unwrap();
    s.expect("no job control")
        .expect("fg should report 'no job control' after set +m");
    wait_for_prompt(&mut s);

    exit_shell(&mut s);
}

#[test]
fn test_pty_set_minus_m_reenables_job_control() {
    let (mut s, _tmpdir) = spawn_yosh();
    wait_for_prompt(&mut s);

    // Disable then re-enable monitor mode
    s.send("set +m\r").unwrap();
    wait_for_prompt(&mut s);
    s.send("set -m\r").unwrap();
    wait_for_prompt(&mut s);

    // Start a foreground job
    s.send("sleep 100\r").unwrap();
    // Brief pause to let sleep start
    std::thread::sleep(Duration::from_millis(200));

    // Ctrl+Z to suspend
    s.send("\x1a").unwrap();

    // Shell should regain control and show prompt
    wait_for_prompt(&mut s);

    // jobs should show the stopped job
    s.send("jobs\r").unwrap();
    s.expect("Stopped")
        .expect("jobs should show Stopped after Ctrl+Z suspend");
    wait_for_prompt(&mut s);

    // Cleanup: kill the stopped job
    s.send("kill %1\r").unwrap();
    wait_for_prompt(&mut s);

    exit_shell(&mut s);
}

#[test]
fn test_pty_shell_termios_restored_after_stopped_job() {
    // Regression test for: a foreground job that modifies termios (here,
    // via `stty raw`) must not leave the shell stuck in raw mode after
    // Ctrl-Z. After suspension, the shell must be back in cooked/icanon.
    let (mut s, _tmpdir) = spawn_yosh();
    wait_for_prompt(&mut s);

    // Run `stty raw` then `sleep` in the same sequential job list. stty
    // modifies the terminal; sleep inherits raw mode. Sync on the PTY
    // actually being in raw mode (ICANON cleared) before sending Ctrl-Z
    // — this is more deterministic than a fixed sleep and matches what
    // the existing wait_for_raw_mode helper does for the line-editor
    // startup case.
    s.send("stty raw; sleep 30\r").unwrap();
    wait_for_raw_mode(&s);

    suspend_fg_job(&mut s);

    // After the stop notification, yosh should reach the next prompt in
    // cooked mode. Assert by running `stty -a` and looking for "icanon"
    // in its output — this only works if the terminal is truly in
    // canonical mode.
    wait_for_prompt(&mut s);
    s.send("stty -a\r").unwrap();
    // stty -a output includes flag names; "icanon" (without leading "-")
    // indicates canonical mode is ON. "-icanon" would indicate raw mode.
    s.expect(Regex(r"[^\-]icanon"))
        .expect("terminal was not restored to canonical mode after Ctrl-Z");

    wait_for_prompt(&mut s);
    exit_shell(&mut s);
}

#[test]
fn test_pty_termios_preserved_across_suspend_fg() {
    // Regression test for: `stty -echo; cat` followed by Ctrl-Z then `fg`
    // must resume with echo still OFF, because job.saved_tmodes captured
    // "-echo" at suspend and restored it on fg.
    let (mut s, _tmpdir) = spawn_yosh();
    wait_for_prompt(&mut s);

    // Disable echo, then start cat (a foreground reader). The cat inherits
    // the -echo setting.
    s.send("stty -echo; cat\r").unwrap();

    // Let cat start reading, then suspend. suspend_fg_job drains the line
    // editor echo, sends Ctrl-Z, and waits for the "Stopped" notification.
    suspend_fg_job(&mut s);
    wait_for_prompt(&mut s);

    // Resume cat in the foreground.
    s.send("fg\r").unwrap();
    // DEVIATION from the task spec: the spec sent `\x04` (Ctrl-D) to EOF
    // cat, then ran `stty -a`. On macOS/BSD, `cat`'s read() returns EINTR
    // when SIGCONT is delivered (cat inherits SIG_DFL for SIGCONT, and
    // BSD does not auto-restart read() without SA_RESTART). /bin/cat does
    // not retry on EINTR, so it exits with "Interrupted system call"
    // immediately after fg. On Linux, read() on terminals auto-restarts
    // for SIG_DFL signals, so cat would keep running there. This is
    // platform behavior, not a yosh bug — yosh correctly leaves SIGCONT
    // as the kernel default for children, and SA_RESTART is a child-side
    // decision. Sending `\x04` after cat already died caused the shell
    // itself to receive Ctrl-D and exit, which produced a spurious EOF
    // on the later `stty -a` expect.
    //
    // Fix: wait for the post-cat prompt (cat self-terminates after fg)
    // and then check stty -a, skipping the explicit Ctrl-D.
    wait_for_prompt(&mut s);
    drain_pty_buffer(&mut s);

    // `cat` has exited: we hit the Task 6 restore path, which puts us back
    // in shell_tmodes (echo ON). That confirms the restore ran — but to
    // prove the DURING-fg state had echo OFF we would need a mid-resume
    // snapshot.
    //
    // This test is therefore an END-STATE test: after the full cycle,
    // echo is ON (shell_tmodes restored). Combined with Task 10's bg→fg
    // variant, we have coverage of both transitions.
    s.send("stty -a\r").unwrap();
    s.expect(Regex(r"[^\-]echo"))
        .expect("terminal echo should be restored after fg cycle completes");

    wait_for_prompt(&mut s);

    // Reset echo explicitly in case the test leaves the PTY in a weird state.
    s.send("stty echo\r").unwrap();
    wait_for_prompt(&mut s);

    exit_shell(&mut s);
}

#[test]
fn test_pty_bg_then_fg_preserves_shell_termios_restoration() {
    // Variant of test_pty_termios_preserved_across_suspend_fg that exercises
    // the Ctrl-Z -> bg -> fg path. The `bg` builtin does not touch termios,
    // so all termios transitions happen in fg. End-state check: after the
    // full cycle, echo is restored (shell_tmodes applied by Task 6).
    let (mut s, _tmpdir) = spawn_yosh();
    wait_for_prompt(&mut s);

    s.send("stty -echo; cat\r").unwrap();

    // Suspend cat. suspend_fg_job handles drain + Ctrl-Z + "Stopped" sync.
    suspend_fg_job(&mut s);
    wait_for_prompt(&mut s);

    s.send("bg\r").unwrap();
    wait_for_prompt(&mut s);

    s.send("fg\r").unwrap();
    // On macOS/BSD, cat resumed by fg exits immediately with EINTR (same
    // mechanism as test_pty_termios_preserved_across_suspend_fg). Sending
    // \x04 after cat is already dead hits the shell and causes spurious
    // exit, producing Eof on the later `stty -a` expect. Instead, rely on
    // cat self-terminating and wait for the next prompt.
    wait_for_prompt(&mut s);
    drain_pty_buffer(&mut s);

    s.send("stty -a\r").unwrap();
    s.expect(Regex(r"[^\-]echo"))
        .expect("terminal echo should be restored after bg-then-fg cycle");

    wait_for_prompt(&mut s);
    s.send("stty echo\r").unwrap();
    wait_for_prompt(&mut s);

    exit_shell(&mut s);
}