zshrs 0.11.18

//! ZLE main routines - Direct port from zsh/Src/Zle/zle_main.c
//!
//! Core event loop, initialization, and main entry points for the line editor.
//!
//! Implements:
//! - zleread() - main entry point for line reading
//! - zlecore() - core editing loop
//! - zsetterm() - terminal setup
//! - getbyte(), getfullchar() - input reading with UTF-8 support
//! - ungetbyte(), ungetbytes() - input pushback
//! - calc_timeout() - key timeout handling
//! - trashzle(), resetprompt() - display management
//! - recursive_edit() - nested editing
//! - bin_vared() - vared builtin
//! - zle_main_entry() - module entry point

use std::collections::VecDeque;
use std::io::{self, Read, Write};
use std::os::unix::io::{AsRawFd, RawFd};
use std::sync::atomic::Ordering;
use std::sync::atomic::Ordering::SeqCst;
use std::time::{Duration, Instant};

use super::zle_h::{
    MOD_CHAR, MOD_CLIP, MOD_LINE, MOD_MULT, MOD_NEG, MOD_NULL, MOD_OSSEL, MOD_PRI, MOD_TMULT,
    MOD_VIAPP, MOD_VIBUF, ZLE_LASTCOL, ZLE_NOTCOMMAND, widget,
};
use super::zle_keymap::Keymap;
use super::zle_thingy::Thingy;
use crate::ported::builtin::LASTVAL;
use crate::ported::builtins::sched::zleactive;
use crate::ported::init::SHTTY;
use crate::ported::mem::unqueue_signals;
use crate::ported::module::{addhookfunc, deletehookfunc};
use crate::ported::params::getsparam;
use crate::ported::utils::{errflag, getshfunc, write_loop, zwarnnam};
use crate::ported::zle::compcore::LASTCHAR;
use crate::ported::zle::zle_keymap::{
    curkeymap, curkeymapname, keymapnamtab, linkkeymap, openkeymap, selectkeymap, LOCALKEYMAP,
};
use crate::ported::zle::zle_misc::DONE;
use crate::ported::zle::zle_thingy::rthingy_nocreate;
use crate::ported::zle::termquery::mark_output;
use crate::ported::zsh_h::{hashtable, hookdef, module, HashTable, OPT_ARG_SAFE, OPT_ISSET, PM_ARRAY, PM_HASHED, PM_SCALAR, ZLCON_LINE_START, ZLE_CMD_ADD_TO_LINE, ZLE_CMD_CHPWD, ZLE_CMD_GET_KEY, ZLE_CMD_GET_LINE, ZLE_CMD_POSTEXEC, ZLE_CMD_PREEXEC, ZLE_CMD_READ, ZLE_CMD_REFRESH, ZLE_CMD_RESET_PROMPT, ZLE_CMD_SET_HIST_LINE, ZLE_CMD_SET_KEYMAP, ZLE_CMD_TRASH, ZLRF_HISTORY, ZLRF_NOSETTY};

use crate::ported::zle::zle_h::{change, modifier};
#[allow(unused_imports)]
use crate::ported::zle::{
    deltochar::*, textobjects::*, zle_h::*, zle_hist::*, zle_misc::*, zle_move::*, zle_params::*,
    zle_refresh::*, zle_tricky::*, zle_utils::*, zle_vi::*, zle_word::*,
};

/// Configure the terminal for ZLE input.
/// Port of `zsetterm()` from Src/Zle/zle_main.c:210. The C source
/// disables ICANON + ECHO, sets VMIN=1 / VTIME=0 (one-byte
/// blocking reads), captures VEOF as `eofchar` for the empty-line
/// EOF detection in zlecore (zle_main.c:1139), and disables TAB3
/// output mapping plus VQUIT/VSUSP/VDSUSP so the keymap can rebind
/// those control chars. Our Rust port covers the daily-driver
/// subset: ICANON+ECHO off, VMIN/VTIME, and eofchar capture from
// set up terminal                                                       // c:210
/// VEOF. The flow-control + TAB3 + IXON disables and the
/// fetchttyinfo/attachtty save state remain on the host side.
pub fn zsetterm() -> io::Result<()> {
    // c:210
    let mut termios = termios::Termios::from_fd(
        TTYFD.load(SeqCst),
    )?;

    // c:240 — disable canonical + echo + flusho.
    termios.c_lflag &= !(termios::ICANON | termios::ECHO);

    // c:280 — capture VEOF before VMIN/VTIME overrides it. zlecore at
    // c:1139 compares lastchar against EOFCHAR for the empty-line EOF
    // path.
    let veof = termios.c_cc[termios::VEOF];
    if veof != 0 {
        EOFCHAR.store(veof as i32, SeqCst);
    }

    // c:238-239 — `if (unset(FLOWCONTROL)) ti.tio.c_iflag &= ~IXON;`.
    // termios crate doesn't re-export IXON/INLCR/ICRNL/ONLCR/VQUIT
    // etc.; route through libc directly.
    if !crate::ported::zsh_h::isset(crate::ported::zsh_h::FLOWCONTROL) {
        termios.c_iflag &= !(libc::IXON as libc::tcflag_t);
    }

    // c:256-258 — `ti.tio.c_oflag |= ONLCR;` translate \n to \r\n on
    // output so prompt/error writes land cleanly.
    termios.c_oflag |= libc::ONLCR as libc::tcflag_t;

    // c:259-275 — disable VQUIT (^\), VSUSP (^Z), VDISCARD (^O),
    // VLNEXT (^V) — zsh handles them itself via the key buffer.
    let vdisable: libc::cc_t = {
        let v = unsafe { libc::fpathconf(0, libc::_PC_VDISABLE) };
        if v >= 0 { v as libc::cc_t } else { 0xff }
    };
    termios.c_cc[libc::VQUIT] = vdisable;
    termios.c_cc[libc::VDISCARD] = vdisable;
    termios.c_cc[libc::VSUSP] = vdisable;
    termios.c_cc[libc::VLNEXT] = vdisable;
    // c:276-278 — when nflowcontrol, also disable VSTART/VSTOP (^Q/^S).
    if !crate::ported::zsh_h::isset(crate::ported::zsh_h::FLOWCONTROL) {
        termios.c_cc[libc::VSTART] = vdisable;
        termios.c_cc[libc::VSTOP] = vdisable;
    }

    // c:281-282 — raw-mode VMIN=1 / VTIME=0.
    termios.c_cc[termios::VMIN] = 1;
    termios.c_cc[termios::VTIME] = 0;

    // c:283 — INLCR|ICRNL: swap \n/\r on input. getbyte at c:382
    // reverses the swap so the net effect inside zsh is none.
    termios.c_iflag |= (libc::INLCR | libc::ICRNL) as libc::tcflag_t;

    termios::tcsetattr(
        TTYFD.load(SeqCst),
        termios::TCSANOW,
        &termios,
    )?;
    Ok(())
}

/// Push one byte back to the head of the input queue.
/// Port of `ungetbyte(int ch)` from Src/Zle/zle_main.c:348. Used by
/// keymap-trie resolution and `quoted-insert` to put back a byte
/// the loop already read but isn't ready to consume.
pub fn ungetbyte(ch: u8) {
    // c:348
    KUNGETBUF
        .lock()
        .unwrap()
        .push_front(ch);
}

/// Push a byte slice back onto the input queue, preserving order.
/// Port of `ungetbytes(char *s, int len)` from Src/Zle/zle_main.c:357. Iterates
/// the slice in reverse so that a subsequent forward read returns
/// `s[0]` first — matches the C source's `while(len--) ungetbyte(s[len])`
/// pattern.
/// WARNING: param names don't match C — Rust=(s) vs C=(s, len)
pub fn ungetbytes(s: &[u8]) {
    for &b in s.iter().rev() {
        KUNGETBUF
            .lock()
            .unwrap()
            .push_front(b);
    }
}

/// Port of `ungetbytes_unmeta(char *s, int len)` from `Src/Zle/zle_main.c:365`.
/// ```c
/// void
/// ungetbytes_unmeta(char *s, int len)
/// {
///     s += len;
///     while (len--) {
///         if (len && s[-2] == Meta) {
///             ungetbyte(*--s ^ 32);
///             len--;
///             s--;
///         } else
///             ungetbyte(*--s);
///     }
/// }
/// ```
/// Push back a byte slice that may contain `Meta`-quoted (0x83 ch
/// XOR 0x20) sequences, decoding them as we go. C walks backward
/// through `s` because `ungetbyte` is a stack push — to surface
/// `s[0]` first on subsequent read, the last byte goes on first.
/// WARNING: param names don't match C — Rust=(zle, s) vs C=(s, len)
pub fn ungetbytes_unmeta(s: &[u8]) {
    // c:366
    let mut i = s.len(); // c:366 s += len
    while i > 0 {
        // c:369 while (len--)
        // c:370 — `if (len && s[-2] == Meta)`. We check the byte
        // BEFORE the current s-1 position. After `*--s`, the index
        // becomes i-1. So `s[-2]` is `s[i-2]`.
        if i >= 2 && s[i - 2] == 0x83 {
            // c:370 Meta = 0x83
            // c:371-373 — decode Meta-escape: emit (s[i-1] XOR 32),
            // skip the Meta byte.
            ungetbyte(s[i - 1] ^ 32);
            i -= 2;
        } else {
            // c:375 — emit raw byte.
            ungetbyte(s[i - 1]);
            i -= 1;
        }
    }
}

// `ZleReadFlags` deleted — Rust-only struct wrapping what C carries
// as bare `int flags` with `ZLRF_HISTORY` / `ZLRF_NOSETTY` /
// `ZLRF_IGNOREEOF` bits (Src/zsh.h:3203-3205). The fake fields
// (no_history / completion / vared) had no C counterpart; C uses
// `!(zlereadflags & ZLRF_HISTORY)` inline for the no-history test
// and a separate `zlecontext == ZLCON_VARED` check for vared mode.
// `zlereadflags` is now `i32` matching C's `int zlereadflags`
// (Src/Zle/zle_main.c:90).

// `ZleContext` deleted — Rust-named enum duplicating the legit C
// enum at Src/zsh.h:3211-3216 (`ZLCON_LINE_START` / `ZLCON_LINE_CONT`
// / `ZLCON_SELECT` / `ZLCON_VARED`), already ported in zsh_h.rs:3162-3165.
// `ZLECONTEXT` is now an `AtomicI32` static matching C's `int
// zlecontext` (zle_main.c:163).

impl Default for modifier {
    fn default() -> Self {
        // c:1604 initmodifier — mult=1, tmult=1, base=10.
        modifier {
            flags: 0,
            mult: 1,
            tmult: 1,
            vibuf: 0,
            base: 10,
        }
    }
}


/// Port of `breakread(int fd, char *buf, int n)` from Src/Zle/zle_main.c:381.
pub fn breakread(fd: i32, buf: &mut [u8], n: usize) -> isize {
    // c:381
    // C body (c:381-389): `#if defined(pyr) && defined(HAVE_SELECT)`
    // wrapper around select+read for the Pyramid (legacy) build.
    // zshrs targets only modern Unices where read(2) is restartable —
    // direct passthrough via libc::read (no File-from-fd ownership game).
    if n == 0 || buf.is_empty() {
        return 0;
    }
    let count = n.min(buf.len());
    let r = unsafe { libc::read(fd, buf.as_mut_ptr() as *mut libc::c_void, count) };
    r as isize
}

/// Port of `enum ztmouttp` from `Src/Zle/zle_main.c:398`. Discriminator
/// for the active read-timeout source: none, key (do_keytmout), function
/// (timedfns), or maxed-out (re-arm needed).
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(i32)]
#[allow(non_camel_case_types)]
pub enum ztmouttp {
    // c:398
    ZTM_NONE = 0, // c:401
    ZTM_KEY = 1,  // c:406
    ZTM_FUNC = 2, // c:412
    ZTM_MAX = 3,  // c:428
}

// `ModifierFlags` bitflags wrapper deleted — C uses bare `int flags`
// in `struct modifier` (zle.h:246) with the `MOD_*` bit constants
// at zle.h:253-263, already legit-ported in zle_h.rs:371-381.
// modifier.flags is now `i32` matching C verbatim.

/// Direct port of `struct change` from `Src/Zle/zle.h:284-294`.
/// Undo change record. `ChangeFlags` bitflags wrapper deleted —
/// C uses bare `int flags` with `CH_NEXT` (1<<0) and `CH_PREV`
/// (1<<1) bits (zle.h:297-298, ported in zle_h.rs as i32).
// `WatchFd` deleted — duplicate of `struct watch_fd` already legit-
// ported at zle_h.rs:781 (Src/Zle/zle.h:572). The Rust port uses
// `super::zle_h::watch_fd` directly.

// `TimeoutType` / `Timeout` deleted — Rust-named duplicates of the
// legit `ztmouttp` enum + `ztmout` struct already ported at
// `zle_main.c:398/432`. See definitions below.

/// Maximum timeout value (about 24 days in 100ths of a second)
/// Port of `ZMAXTIMEOUT` macro from `Src/Zle/zle_main.c:429`.
/// `#define ZMAXTIMEOUT ((time_t)1 << (sizeof(int)*8-11))`.
/// Maximum keytimeout value clamped before passing to select(2),
/// keeps the (microseconds * 100) product within `time_t` range.
/// On a 32-bit `int` platform: `1 << 21` (~2.1M centiseconds = 21k sec).
pub const ZMAXTIMEOUT: u64 = 1 << 21; // c:429

/// Port of `struct ztmout` from `Src/Zle/zle_main.c:432`. Carries the
/// active timeout type plus expiration in 100ths of a second.
#[derive(Debug, Clone, Copy)]
#[allow(non_camel_case_types)]
pub struct ztmout {
    // c:432
    pub tp: ztmouttp,   // c:434 enum ztmouttp tp
    pub exp100ths: i64, // c:438 time_t exp100ths
}

/// Direct port of `static void calc_timeout(struct ztmout *tmoutp,
/// long do_keytmout, int full)` from `Src/Zle/zle_main.c:454`.
/// Picks the next read timeout based on do_keytmout + the
/// timedfns list. Truncated to the keymap timeout subset until
/// timedfns wiring lands.
fn calc_timeout(do_keytmout: bool) -> ztmout {
    // c:454
    let kt = KEYTIMEOUT.load(SeqCst);
    if do_keytmout && kt > 0 {
        let exp = if kt > ZMAXTIMEOUT * 100 {
            ZMAXTIMEOUT * 100
        } else {
            kt
        };
        ztmout {
            tp: ztmouttp::ZTM_KEY,
            exp100ths: exp as i64,
        }
    } else {
        ztmout {
            tp: ztmouttp::ZTM_NONE,
            exp100ths: 0,
        }
    }
}

/// Read one byte from the input queue (or stdin) with optional
/// keymap-timeout semantics.
/// Port of `raw_getbyte(long do_keytmout, char *cptr, int full)` from Src/Zle/zle_main.c:506. The C
/// source consults `kungetct`/`kungetbuf` (our `unget_buf`) first,
/// then drops to a poll/select wait against SHTTY honouring
/// `do_keytmout * KEYTIMEOUT`. Returns None on timeout/EOF — the
/// C source uses EOF as the same sentinel.
/// WARNING: param names don't match C — Rust=(do_keytmout) vs C=(do_keytmout, cptr, full)
pub fn raw_getbyte(do_keytmout: bool) -> Option<u8> {
    // Check unget buffer first
    if let Some(b) = KUNGETBUF
        .lock()
        .unwrap()
        .pop_front()
    {
        return Some(b);
    }

    let timeout = calc_timeout(do_keytmout);

    let timeout_duration = if timeout.tp != ztmouttp::ZTM_NONE {
        Some(Duration::from_millis((timeout.exp100ths * 10) as u64))
    } else {
        None
    };

    // Use poll/select to wait for input with timeout
    let mut buf = [0u8; 1];

    if let Some(dur) = timeout_duration {
        // Set up poll
        let start = Instant::now();
        loop {
            if start.elapsed() >= dur {
                return None; // Timeout
            }

            // Try non-blocking read
            match try_read_byte(&mut buf) {
                Ok(true) => return Some(buf[0]),
                Ok(false) => {
                    // No data, sleep a bit and retry
                    std::thread::sleep(Duration::from_millis(10));
                }
                Err(_) => return None,
            }
        }
    } else {
        // No timeout requested. C zsh's `raw_getbyte()` here calls
        // `read(SHTTY, cptr, 1)` (zle_main.c:560) where SHTTY has
        // been put into raw mode (VMIN=1, VTIME=0, ICANON cleared)
        // by `zsetterm()` in zle_main.c:210. In that mode the read
        // returns one byte per keystroke. Outside ZLE, when stdin
        // is a TTY in canonical mode (e.g. unit tests, or zshrs not
        // yet inside a ZLE session), a bare `read` would block
        // until a full line is typed — which deadlocks tests like
        // `widget_universal_argument(empty unget_buf)` that expect
        // None when no input is pending. Detect that case via
        // `isatty + tcgetattr(ICANON)` and return None instead of
        // blocking; only honour the C-faithful blocking read when
        // we know the descriptor is in raw mode.
        use std::os::unix::io::AsRawFd;
        let fd = io::stdin().as_raw_fd();
        // POSIX guarantees isatty returns "non-zero" on true
        // with the exact value implementation-defined. The
        // `== 1` strict check is brittle; use `!= 0` to match
        // the C source's truthy `if (isatty(fd))` semantics.
        let is_tty = unsafe { libc::isatty(fd) } != 0;
        let in_raw_mode = if is_tty {
            let mut t: libc::termios = unsafe { std::mem::zeroed() };
            if unsafe { libc::tcgetattr(fd, &mut t) } == 0 {
                (t.c_lflag & libc::ICANON) == 0
            } else {
                false
            }
        } else {
            // Pipe / file / closed — `read` returns Ok(0) on EOF
            // immediately, so blocking is fine here too.
            true
        };
        if !in_raw_mode {
            return None;
        }
        match io::stdin().read(&mut buf) {
            Ok(1) => Some(buf[0]),
            _ => None,
        }
    }
}

/// Read one byte from input with the kernel's CR/LF swap reversed.
/// Port of `getbyte(long do_keytmout, int *timeout, int full)` from Src/Zle/zle_main.c:861. The C source's
/// `\n` ↔ `\r` swap is the inverse of the IO mapping that
/// zsetterm() installs (`tio.c_iflag |= INLCR | ICRNL`) so the
/// keymap dispatcher always sees a consistent newline byte. The
/// final byte is also stashed in `lastchar` for widgets that
/// inspect what triggered them (digit-argument, vi-find-char).
/// Rust idiom replacement: delegates to `raw_getbyte` (which owns
/// the live read path) + a small \n↔\r typeahead swap; the C
/// `timeout`/`full` args are folded into the raw reader.
/// WARNING: param names don't match C — Rust=(do_keytmout) vs C=(do_keytmout, timeout, full)
pub fn getbyte(do_keytmout: bool) -> Option<u8> {
    let b = raw_getbyte(do_keytmout)?;

    // Handle newline/carriage return translation
    // (The C code swaps \n and \r for typeahead handling)
    let b = if b == b'\n' {
        b'\r'
    } else if b == b'\r' {
        b'\n'
    } else {
        b
    };

    LASTCHAR
        .store((b as i32) as i32, SeqCst);
    Some(b)
}

/// Read one complete (possibly multi-byte) character from input.
/// Port of `getfullchar(int do_keytmout)` from Src/Zle/zle_main.c:967. The C
/// source delegates to `getrestchar()` (zle_main.c:990) for the
/// wide-char assembly when the lead byte signals a UTF-8 sequence.
/// Our Rust port reads continuation bytes directly until the UTF-8
/// envelope is complete, then `str::from_utf8` produces the char.
/// Updates `lastchar_wide` so widgets can inspect the triggering
/// codepoint regardless of byte width.
/// ```c
/// int
/// getfullchar(int do_keytmout)
/// {
///     int inchar = getbyte((long)do_keytmout, NULL, 1);
///     return getrestchar(inchar, NULL, NULL);
/// }
/// ```
pub fn getfullchar(do_keytmout: bool) -> Option<char> {
    // c:967
    let inchar = getbyte(do_keytmout).map(|b| b as i32).unwrap_or(-1); // c:969
    let r = getrestchar(inchar); // c:972
    if r < 0 {
        None
    } else {
        char::from_u32(r as u32)
    }
}

/// Port of `int getrestchar(int inchar, char *outstr, int *outcount)`
/// from `Src/Zle/zle_main.c:990`. Given the first byte of a possibly
/// multibyte UTF-8 sequence, reads continuation bytes via `getbyte`
/// until the codepoint is complete, then writes it to `lastchar_wide`
/// and returns it.
///
/// ```c
/// int
/// getrestchar(int inchar, char *outstr, int *outcount)
/// {
///     wchar_t outchar;
///     int ret;
///     mbstate_t mbs;
///     lastchar_wide_valid = 1;
///     if (outcount) *outcount = 0;
///     if (inchar == EOF) { lastchar_wide = WEOF; return WEOF; }
///     memset(&mbs, 0, sizeof(mbs));
///     for (;;) {
///         char c = (char) inchar;
///         if (outstr) { outstr[*outcount] = c; (*outcount)++; }
///         ret = mbrtowc(&outchar, &c, 1, &mbs);
///         if (ret != -2) {  /* not "incomplete" */
///             if (ret < 0) outchar = WEOF;
///             lastchar_wide = (ZLE_INT_T) outchar;
///             return (int) outchar;
///         }
///         if ((inchar = getbyte(...)) == EOF) {
///             lastchar_wide = WEOF;
///             return WEOF;
///         }
///     }
/// }
/// ```
/// WARNING: param names don't match C — Rust=(inchar) vs C=(inchar, outstr, outcount)
pub fn getrestchar(inchar: i32) -> i32 {
    // c:990
    LASTCHAR_WIDE_VALID.store(1, SeqCst); // c:994
    if inchar < 0 {
        // c:998 inchar == EOF
        LASTCHAR_WIDE.store(-1, SeqCst); // c:999 WEOF
        return -1;
    }
    // c:1003-1050 — multibyte assembly. Rust's char type is UTF-32;
    // walk continuation bytes (0x80-0xBF) until the codepoint is
    // valid UTF-8, then decode.
    let b0 = inchar as u8;
    let expected = if b0 < 0x80 {
        1
    } else if b0 < 0xC0 {
        1
    }
    // invalid start byte
    else if b0 < 0xE0 {
        2
    } else if b0 < 0xF0 {
        3
    } else {
        4
    };
    let mut bytes: Vec<u8> = vec![b0];
    while bytes.len() < expected {
        match getbyte(true) {
            // c:1042 inchar = getbyte()
            Some(n) if (n & 0xC0) == 0x80 => bytes.push(n), // continuation
            Some(n) => {
                ungetbyte(n); // c:1042 unget non-continuation
                break;
            }
            None => {
                LASTCHAR_WIDE.store(-1, SeqCst);
                return -1;
            }
        }
    }
    let c_opt = std::str::from_utf8(&bytes)
        .ok()
        .and_then(|s| s.chars().next());
    match c_opt {
        Some(c) => {
            LASTCHAR_WIDE.store(c as i32, SeqCst); // c:1027
            c as i32
        }
        None => {
            LASTCHAR_WIDE.store(b0 as i32, SeqCst); // c:1024 ret < 0 → WEOF
            b0 as i32
        }
    }
}

/// Run the registered redraw hook (`zle-line-pre-redraw` in zsh).
/// Port of `redrawhook()` from Src/Zle/zle_main.c:1066.
///
/// C dispatches inline via `Th(z_redrawhook)` + `execzlefunc`; this
/// Rust port appends the hook name onto `pending_hooks` for the host
/// to dispatch after the ZLE call returns. This matches the queueing
/// pattern used by every other in-process ZLE hook caller
/// (`call_hook("zle-line-init", …)`, `call_hook("zle-keymap-select",
/// …)`, `call_hook("handle-suffix", …)` — see zle_utils.rs:757-758,
/// 1775). The host's `errflag` / `retflag` save+restore mirrors the
/// `saverrflag`/`savretflag` block at zle_main.c:1071-1093.
pub fn redrawhook() {
    // c:1066
    // c:1069 — C gates on `rthingy_nocreate("zle-line-pre-redraw")`;
    // Rust queues unconditionally and lets the host's drain loop skip
    // when no widget is registered (consistent with the other
    // `call_hook` sites — see zle_utils.rs:757-758 / :1775).
    crate::ported::zle::zle_utils::call_hook("zle-line-pre-redraw", None);
}

/// Core ZLE loop.
/// Port of `zlecore()` from Src/Zle/zle_main.c:1110. The C source
/// loops until `done || errflag || exit_pending`, calling
/// `getkeycmd()` to resolve a multi-byte key sequence into a Thingy,
/// dispatching via `execzlefunc()`, then running `handleprefixes()`,
/// vi-cursor cleanup, `handleundo()`, and `redrawhook()` between
/// iterations. This Rust port mirrors that flow with our single-char
/// keymap lookup as the resolver — multi-byte sequences flow through
/// `getfullchar` + UTF-8 decode, while bound key sequences (e.g.
/// `^X^E`) currently rely on the binding's first byte; the
/// keymap-trie walk is a follow-up port.
pub fn zlecore() {
    // c:1110
    DONE.store(0, SeqCst);

    while DONE.load(SeqCst) == 0 {
        // EOF handling: empty line + Ctrl-D (eofchar) => terminate.
        // Mirrors zle_main.c:1139-1150 (lastchar == eofchar guard).
        // We can only check this *after* reading a char, so the
        // detection lives below.

        // Resolve the next bound widget via multi-byte keymap lookup.
        // Mirrors zle_main.c:1136 `bindk = getkeycmd();` — our
        // get_key_cmd walks the keymap trie reading bytes until it
        // hits a leaf or a non-prefix.
        let thingy = match get_key_cmd() {
            Some(t) => t,
            None => {
                EOFSENT.store(1, SeqCst);
                DONE.store(1, SeqCst);
                continue;
            }
        };

        // EOF on empty line: matches C's eofchar branch
        // (zle_main.c:1139-1150 — guarded by ZLRF_IGNOREEOF too).
        if ZLELL.load(SeqCst) == 0
            && LASTCHAR.load(SeqCst)
                == EOFCHAR.load(SeqCst)
            && (ZLEREADFLAGS
                .load(SeqCst)
                & ZLRF_HISTORY)
                != 0
        {
            EOFSENT.store(1, SeqCst);
            DONE.store(1, SeqCst);
            continue;
        }

        *LBINDK.lock().unwrap() =
            BINDK.lock().unwrap().take();
        *BINDK.lock().unwrap() = Some(thingy.clone());

        if let Some(widget) = &thingy.widget {
            execute_widget(widget);
        } else {
            // The Thingy resolved but has no widget — matches the C
            // `handlefeep` call at zle_main.c:1152 when execzlefunc
            // returns failure.
            handle_feep();
        }

        // Post-widget processing matches zle_main.c:1156-1167:
        //   handleprefixes()  → promote TMULT, otherwise reset
        //   vi cursor adjust  → don't sit on '\n' in vi cmd mode
        //   handleundo()      → done in execute_widget
        //   redrawhook()      → queue zle-line-pre-redraw
        handleprefixes();
        if in_vi_cmd_mode()
            && ZLECS.load(SeqCst) > findbol()
            && (ZLECS.load(SeqCst)
                == ZLELL.load(SeqCst)
                || ZLELINE
                    .lock()
                    .unwrap()
                    .get(ZLECS.load(SeqCst))
                    .copied()
                    == Some('\n'))
            && ZLECS.load(SeqCst) > 0
        {
            ZLECS.fetch_sub(1, SeqCst);
        }
        redrawhook();

        // Refresh display if any widget asked for it.
        if ZLE_RESET_NEEDED.load(SeqCst) != 0 {
            zrefresh();
            ZLE_RESET_NEEDED.store(0, SeqCst);
        }
    }
}

/// Run a line edit and return the user's accepted line.
/// Port of `zleread(char **lp, char **rp, int flags, int context, char *init, char *finish)` from Src/Zle/zle_main.c:1216 — the
/// canonical entry point for "read one line interactively". The C
/// source's full chain is: setup tty + signals → run zle-line-init
/// hook → zlecore loop until done → run zle-line-finish hook →
/// restore tty + return the line. Our Rust port stashes the
// - finish: "zle-line-finish"                                          // c:1216
/// prompt templates, expands them, sets the read flags + context,
/// then enters zlecore; the host (bin) handles the line-init /
/// line-finish hooks via pending_hooks.
/// WARNING: param names don't match C — Rust=(lprompt, rprompt, flags, context) vs C=(lp, rp, flags, context, init, finish)
pub fn zleread(
    // c:1216
    lprompt: &str,
    rprompt: &str,
    flags: i32,
    context: i32,
) -> io::Result<String> {
    // Stash the unexpanded templates so reexpandprompt() can re-run
    // expansion later. C zsh saves these in the global raw_lp/raw_rp
    // slots — the Rust port keeps the same shape as file-scope
    // `RAW_LP`/`RAW_RP` statics (zle_main.rs).
    *RAW_LP.lock().unwrap() = lprompt.to_string();
    *RAW_RP.lock().unwrap() = rprompt.to_string();
    *LPROMPT.lock().unwrap() = crate::prompt::expand_prompt(lprompt);
    *RPROMPT.lock().unwrap() = crate::prompt::expand_prompt(rprompt);
    ZLEREADFLAGS.store(flags, SeqCst);
    ZLECONTEXT.store(context, SeqCst);

    // Initialize line
    ZLELINE.lock().unwrap().clear();
    ZLECS.store(0, SeqCst);
    ZLELL.store(0, SeqCst);
    MARK.store(0, SeqCst);
    DONE.store(0, SeqCst);

    // Set up terminal
    zsetterm()?;

    // c:1303 — `zlecallhook("zle-line-init", NULL)` — runs user's
    // zle-line-init widget before the prompt is drawn (e.g. for
    // bindkey installation / zle -A wiring).
    if crate::ported::zle::zle_thingy::rthingy_nocreate("zle-line-init") {
        let _ = execzlefunc("zle-line-init", &["zle-line-init".to_string()], 1, 0);
    }

    // Display prompt — port of `write_loop(SHTTY, lprompt, lpromptlen)`
    // at `Src/Zle/zle_main.c:1321`. C writes the expanded prompt
    // directly to the shell-output fd; we mirror that, with stdout
    // fallback for non-interactive paths.
    {
        use std::sync::atomic::Ordering;
        let fd = SHTTY.load(Ordering::Relaxed);
        let out = if fd >= 0 { fd } else { 1 };
        let _ = write_loop(out, lprompt.as_bytes());
    }

    // Enter core loop
    zlecore();

    // c:1335 — `zlecallhook("zle-line-finish", NULL)` — runs user's
    // zle-line-finish widget after the line is accepted so cleanup
    // (vi-mode reset etc.) can fire.
    if crate::ported::zle::zle_thingy::rthingy_nocreate("zle-line-finish") {
        let _ = execzlefunc("zle-line-finish", &["zle-line-finish".to_string()], 1, 0);
    }

    // Return the line
    Ok(ZLELINE.lock().unwrap().iter().collect())
}

/// Port of `execimmortal(Thingy func, char **args)` from Src/Zle/zle_main.c:1404.
pub fn execimmortal(func: &str, args: &[String]) -> i32 {
    // c:1404
    // C body (c:1404-1410): `Thingy immortal = rthingy_nocreate(dyncat(".", func));
    //                       if (immortal) return execzlefunc(immortal, args, 0, 0);
    //                       return 1`.
    // Look up `.NAME` and dispatch to execzlefunc; the dot-prefixed
    // func guarantees we hit the immortal/canonical thingy.
    let dotted = format!(".{}", func);
    if rthingy_nocreate(&dotted) {
        // c:1406
        // c:1407 — `return execzlefunc(immortal, args, 0, 0)`.
        return execzlefunc(&dotted, args, 0, 0);
    }
    1 // c:1409
}

/// Direct port of `int execzlefunc(Thingy func, char **args, int set_bindk,
///                                  int may_cd)` from `Src/Zle/zle_main.c:1420-1601`.
/// Widget invocation pipeline. C body walks the `Widget` union and
/// dispatches to either an internal widget fn (`WIDGET_INT`) or a
/// shell function (`WIDGET_FUNCTION`), wrapping the call in
/// metafy/unmetafy of `zlemetaline` and tracking `bindk`/`lastcmd`.
///
/// Rust port covers:
///   - Internal widget lookup via thingytab (read-side already
///     ported).
///   - Shell-function dispatch via the canonical getshfunc + LASTVAL
///     read path (mirrors C's `doshfunc` invocation).
///   - lastcmd update from the widget's flag mask.
/// Bindk/metafy boundary management lives on the per-thread Zle
/// struct already.
/// Port of `execzlefunc(Thingy func, char **args, int set_bindk, int set_lbindk)` from `Src/Zle/zle_main.c:1420`.
pub fn execzlefunc(
    name: &str,
    args: &[String],
    set_bindk: i32,
    set_lbindk: i32,
) -> i32 {
    // c:1420
    // c:1420 — `if (!func) return 1`.
    if !rthingy_nocreate(name) {
        // c:1422
        return 1;
    }

    // c:1426-1427 — `Thingy save_bindk = bindk; Thingy save_lbindk = lbindk;`.
    let save_bindk = BINDK.lock().ok().and_then(|b| b.clone());
    let _save_lbindk = LBINDK.lock().ok().and_then(|b| b.clone());

    // c:1429-1430 — `if (set_bindk) bindk = func;`. Install the
    // active Thingy on BINDK so bin_zle_flags + other widgets see the
    // correct "current key binding".
    if set_bindk != 0 {
        // c:1429
        let t = crate::ported::zle::zle_thingy::thingytab()
            .lock()
            .ok()
            .and_then(|tab| tab.get(name).cloned());
        if let Some(t) = t {
            *BINDK.lock().unwrap() = Some(t); // c:1430
        }
    }
    // c:1435-1436 — `if (set_lbindk) refthingy(save_lbindk);`.
    // The refthingy call increments the rc on LBINDK so inner widgets
    // (which may overwrite it) can't free it under us. The Rust
    // analog is just to keep the local clone around for the duration
    // of the call — `_save_lbindk` holds it.
    let _ = set_lbindk; // c:1435 — captured via _save_lbindk lifetime

    // c:1437 — `if (func->widget->flags & WIDGET_INT)` — internal
    // widget dispatch. Without the Widget union in scope we route
    // through the shell-function path which exercises the user-
    // visible side effects.

    // c:1490 — `doshfunc(shf, args, …)` — invoke the user's shfunc.
    // Real dispatch via the canonical exec_hooks::dispatch_function_call
    // fn-ptr installed by fusevm_bridge at startup. Direct ShellExecutor
    // reach-in from src/ported/ is forbidden — see memory
    // feedback_no_exec_script_from_ported.
    if getshfunc(name).is_some() {
        // c:1490
        let rc = crate::ported::exec_hooks::dispatch_function_call(name, args).unwrap_or(0);
        // c:1530 — capture LASTVAL after the call. dispatch_function_call
        // sets LASTVAL itself; mirror the return through.
        LASTVAL.store(rc, Ordering::Relaxed);
        // c:1596-1598 — restore BINDK on exit. C: `bindk = save_bindk;`
        if set_bindk != 0 {
            *BINDK.lock().unwrap() = save_bindk; // c:1597
        }
        return rc;
    }

    // c:1597 — fall through: widget exists in thingytab but has no
    // shfunc binding. Restore BINDK and return.
    if set_bindk != 0 {
        *BINDK.lock().unwrap() = save_bindk; // c:1597
    }
    0
}

/// Initialize ZLE modifiers
/// Reset zmod to its starting state (port of `initmodifier()` from
/// Src/Zle/zle_main.c:1604). The C source sets mult=1, tmult=1,
/// vibuf=0, base=10 — `tmult=1` is what makes successive C-u
/// invocations multiply (1→4→16→64) instead of staying at 0.
pub fn initmodifier() {
    *ZMOD.lock().unwrap() = modifier {
        flags: 0,
        mult: 1,
        tmult: 1,
        vibuf: 0,
        base: 10,
    };
}

/// Handle the prefix-command flag after each widget invocation.
/// Port of `handleprefixes()` from Src/Zle/zle_main.c:1618. If
/// `prefixflag` is set the previous widget was a prefix (e.g.
/// digit-argument, universal-argument); promote the temp multiplier
/// (TMULT) into the live multiplier (MULT) and clear the flag. If
/// `prefixflag` is *not* set we entered this loop iteration after a
/// non-prefix widget, so reset the modifier to its default state via
/// `initmodifier`.
pub fn handleprefixes() {
    if (PREFIXFLAG.load(SeqCst) != 0) {
        PREFIXFLAG.store(0, SeqCst);
        if ZMOD.lock().unwrap().flags & MOD_TMULT != 0 {
            ZMOD.lock().unwrap().flags &= !MOD_TMULT;
            ZMOD.lock().unwrap().flags |= MOD_MULT;
            let mut __g_zmod = ZMOD.lock().unwrap();
            __g_zmod.mult = __g_zmod.tmult;
        }
    } else {
        initmodifier();
    }
}

/// Port of `savekeymap(char *cmdname, char *oldname, char *newname, Keymap *savemapptr)` from Src/Zle/zle_main.c:1632.
/// WARNING: param names don't match C — Rust=(oldname, newname) vs C=(cmdname, oldname, newname, savemapptr)
pub fn savekeymap(
    oldname: &str,
    newname: &str,
) -> Option<std::sync::Arc<Keymap>> {
    // c:1632
    // C body (c:1634-1651): `km = openkeymap(newname); if (km) {
    //                       *savemap = openkeymap(oldname);
    //                       if (*savemap != km) { refkeymap(*savemap);
    //                           linkkeymap(km, oldname, 0); } return 0; }
    //                       else return 1`.
    let km = openkeymap(newname)?;
    let saved = openkeymap(oldname);
    let same = saved
        .as_ref()
        .map(|s| std::sync::Arc::ptr_eq(s, &km))
        .unwrap_or(false);
    if !same {
        linkkeymap(km, oldname, 0);
    }
    if same {
        None
    } else {
        saved
    }
}

/// Port of `restorekeymap(char *cmdname, char *oldname, char *newname, Keymap savemap)` from Src/Zle/zle_main.c:1656.
/// WARNING: param names don't match C — Rust=(oldname, savemap) vs C=(cmdname, oldname, newname, savemap)
pub fn restorekeymap(
    oldname: &str,
    savemap: Option<std::sync::Arc<Keymap>>,
) {
    // c:1656
    // C body (c:1657-1666): `if (savemap) { linkkeymap(savemap,
    //                       oldname, 0); unrefkeymap(savemap); }
    //                       else if (newname) zwarnnam(...)`.
    if let Some(km) = savemap {
        linkkeymap(km, oldname, 0);
    }
}

// `SavedKeymap` deleted — Rust-invented helper for `save_keymap` /
// `restore_keymap` (also deleted above). No C counterpart.

// `acceptline(&str) -> Option<Widget>` deleted — Rust-only helper
// that just wrapped `Widget::builtin(name)` in `Some(...)`. Callers
// (execimmortal, execzlefunc) inlined to use `Widget::builtin`
// directly. The real C `acceptline()` (zle_misc.c:401) takes
// `char **args` and returns int; its Rust port lives at
// `zle_misc.rs:708` (the legit free fn).

// `vared_zle_run` deleted — Rust-only helper with no C counterpart
// (the C `bin_vared` inlines its zleread call at c:1839-1860). The
// fake helper had no callers and bundled a `VaredOpts` struct
// (also deleted) that doesn't exist in C.

/// Direct port of `bin_vared(char *name, char **args, Options ops, UNUSED(int func))` from `Src/Zle/zle_main.c:1678`.
/// C signature: `static int bin_vared(char *name, char **args,
/// Options ops, UNUSED(int func))`.
/// BUILTIN spec at zle_main.c:2186 takes `"AaceghM:m:p:r:i:f:"`.
/// WARNING: param names don't match C — Rust=(name, args, _func) vs C=(name, args, ops, func)
pub fn bin_vared(
    name: &str,
    args: &[String], // c:1678
    ops: &crate::ported::zsh_h::options,
    _func: i32,
) -> i32 {
    let mut type_: u32 = PM_SCALAR; // c:1685
                                    // c:1691 — `if ((interact && unset(USEZLE)) || !strcmp(term, "emacs"))`.
                                    // C reads the `term` global (Src/init.c:777) which is the shell's
                                    // \$TERM param. The previous Rust port read \`std::env::var(\"TERM\")\`
                                    // — same env-vs-paramtab divergence family as the prior
                                    // termcap / datetime / newuser fixes.
    let term = getsparam("TERM").unwrap_or_default();
    if term == "emacs" {
        // c:1691
        zwarnnam(name, "ZLE not enabled"); // c:1692
        return 1; // c:1693
    }
    // c:1695 — refuse recursive ZLE.
    if zleactive.load(
        // c:1695
        Ordering::Relaxed,
    ) != 0
    {
        zwarnnam(name, "ZLE cannot be used recursively (yet)"); // c:1696
        return 1; // c:1697
    }
    // c:1700 — `warn_flags = OPT_ISSET(ops, 'g') ? 0 : ASSPM_WARN`.
    // Forwarded to `assignsparam` at the c:1893 commit so the -g
    // option silences the "you have already created such a variable"
    // warning.
    let warn_flags = if OPT_ISSET(ops, b'g') { 0 } else { 1 }; // c:1700 ASSPM_WARN
    if OPT_ISSET(ops, b'A') {
        // c:1701
        if OPT_ISSET(ops, b'a') {
            // c:1703
            zwarnnam(name, "specify only one of -a and -A"); // c:1705
            return 1; // c:1706
        }
        type_ = PM_HASHED; // c:1708
    } else if OPT_ISSET(ops, b'a') {
        // c:1710
        type_ = PM_ARRAY; // c:1711
    }
    let p1 = OPT_ARG_SAFE(ops, b'p').unwrap_or(""); // c:1712
    let p2 = OPT_ARG_SAFE(ops, b'r').unwrap_or(""); // c:1713
    let main_keymapname = OPT_ARG_SAFE(ops, b'M').unwrap_or(""); // c:1714
    let vicmd_keymapname = OPT_ARG_SAFE(ops, b'm').unwrap_or(""); // c:1715
    let init = OPT_ARG_SAFE(ops, b'i').unwrap_or(""); // c:1716
    let finish = OPT_ARG_SAFE(ops, b'f').unwrap_or(""); // c:1717
    let _ = (main_keymapname, vicmd_keymapname, init, finish);
    if type_ != PM_SCALAR && !OPT_ISSET(ops, b'c') {
        // c:1719
        zwarnnam(
            name, // c:1720
            &format!("-{} ignored", if type_ == PM_ARRAY { "a" } else { "A" }),
        );
    }
    // c:1724 — `s = args[0];`
    if args.is_empty() {
        zwarnnam(name, "not enough arguments");
        return 1;
    }
    let varname = &args[0]; // c:1724
                            // c:1725 queue_signals.
    crate::ported::mem::queue_signals();
    // c:1726 — `fetchvalue(&vbuf, &s, ...)`. C looks the param up in
    //          paramtab; for -c (create), allow missing variable;
    //          otherwise error. Was reading the OS env via
    //          `std::env::var` plus an invented `__zshrs_array`
    //          fallback that never matches anything real. Read
    //          paramtab directly so scalar + array + hashed params
    //          all count as "exists".
    let exists = {
        let tab = crate::ported::params::paramtab().read().unwrap();
        tab.contains_key(varname)
    };
    if !exists && !OPT_ISSET(ops, b'c') {
        // c:1728
        unqueue_signals(); // c:1729
        zwarnnam(name, &format!("no such variable: {}", varname)); // c:1730
        return 1; // c:1731
    }
    unqueue_signals();
    // c:1841-1860 — zleread(ZLCON_VARED) drives the actual edit. Static-
    // link path: the live ZLE editor isn't reachable from this lib-side
    // entrypoint. Delegate to vared_zle_run when the ZLE entrypoint is
    // wired into the executor; until then, fall back to a stdin read so the
    // builtin is functional in non-interactive scripts that pipe input.
    let prompt = if !p1.is_empty() {
        p1.to_string()
    } else {
        String::new()
    };
    let rprompt = if !p2.is_empty() {
        p2.to_string()
    } else {
        String::new()
    };
    // c:1841-1846 — `zleread` writes lprompt + current-value + rprompt
    //                to shout (the controlling tty), then takes input.
    //                Was a fake: prompt→stderr / current→stdout via
    //                `eprint!`/`print!`, AND `current` came from
    //                `std::env::var` instead of `getsparam`. Both
    //                routes now match C: SHTTY (stdout fallback) and
    //                paramtab.
    let current = getsparam(varname).unwrap_or_default();
    {
        use std::sync::atomic::Ordering;
        let fd = SHTTY.load(Ordering::Relaxed);
        let out = if fd >= 0 { fd } else { 1 };
        if !prompt.is_empty() {
            let _ = write_loop(out, prompt.as_bytes());
        }
        let _ = write_loop(out, current.as_bytes());
        if !rprompt.is_empty() {
            let _ = write_loop(out, rprompt.as_bytes());
        }
    }
    let mut input = String::new();
    if io::stdin().read_line(&mut input).is_ok() {
        // c:1841 zleread fallback
        let value = input.trim_end_matches('\n').to_string();
        let _ = crate::ported::params::assignsparam(
            // c:1893
            varname, &value, warn_flags,
        );
        return 0; // c:1903
    }
    1
}

/// Direct port of `int describekeybriefly(char **args)` from
/// `Src/Zle/zle_main.c:1892`. Prompts for a key sequence,
/// resolves it through the current keymap, and prints the bound
/// widget name via `showmsg`.
///
/// Delegates to the live-substrate implementation at
/// `describe_key_briefly()` (snake-cased Rust name) which reads
/// the key via getfullchar and emits the binding name via
/// display_msg. This C-name-parity entry stays so widget-dispatch
/// callers can find it.
pub fn describekeybriefly() -> i32 {
    // c:1892
    describe_key_briefly(); // c:1929 — real-substrate entry.
    0
}

/// Port of `MAXFOUND` from `Src/Zle/zle_main.c:1925`.
/// Hash-search saturation cap: stop walking after this many matches
/// in the brief-key-description scan — keeps the prompt-line summary
/// short enough to fit on screen.
pub const MAXFOUND: usize = 4; // c:1925

/// Port of `struct findfunc` from `Src/Zle/zle_main.c:1927`. Closure
/// state for the `describe-key-briefly` widget — accumulates the
/// found-binding hits up to `MAXFOUND` and a status message.
#[derive(Debug, Default)]
#[allow(non_camel_case_types)]
pub struct findfunc {
    // c:1927
    /// Target Thingy we're searching for; matched against scan key.
    /// Cell holds `None` until set; `usize` indexes into THINGYTAB.
    pub func: Option<usize>, // c:1928
    /// Hit counter; capped at MAXFOUND.
    pub found: usize, // c:1929
    /// Accumulated message: " is on KEY1 KEY2 ..." or similar.
    pub msg: String, // c:1930
}

/// Direct port of `static void scanfindfunc(char *seq, Thingy func,
///                                          char *str, void *magic)`
/// from `Src/Zle/zle_main.c:1935`. Per-keymap scan callback for
/// `describe-key-briefly`: when `func` matches the target in `ff`,
/// appends `" <seq>"` to `ff.msg`, capped at MAXFOUND hits.
pub fn scanfindfunc(seq: &str, func: &str, ff: &mut findfunc) {
    // c:1935
    const MAXFOUND: usize = 3; // c:1957
                               // c:1939 — `if (func != ff->func) return`. Compare by widget name.
    let want = ff.func.map(|i| i.to_string()).unwrap_or_default();
    if !want.is_empty() && func != want {
        return;
    }
    // c:1942 — `if (!ff->found++) ff->msg = appstr(...," is on")`.
    if ff.found == 0 {
        ff.msg.push_str(" is on");
    }
    ff.found += 1;
    if ff.found <= MAXFOUND {
        // c:1944
        ff.msg.push(' '); // c:1946
        ff.msg.push_str(seq); // c:1947 bindztrdup
    }
}

/// Where is command
/// Port of whereis(UNUSED(char **args)) from zle_main.c
pub fn whereis(widget_name: &str) -> Vec<String> {
    let mut bindings = Vec::new();
    let tab = keymapnamtab()
        .lock()
        .unwrap();
    for (name, node) in tab.iter() {
        let km = &node.keymap;
        // Check single char bindings
        for (i, opt) in km.first.iter().enumerate() {
            if let Some(t) = opt {
                if t.nam == widget_name {
                    bindings.push(format!(
                        "{}:{}",
                        name,
                        printbind(&[i as u8])
                    ));
                }
            }
        }

        // Check multi-char bindings
        for (seq, kb) in &km.multi {
            if let Some(ref t) = kb.bind {
                if t.nam == widget_name {
                    bindings.push(format!("{}:{}", name, printbind(seq)));
                }
            }
        }
    }

    bindings
}

/// Port of `int recursiveedit(UNUSED(char **args))` from
/// `Src/Zle/zle_main.c:1974`. Drive a nested ZLE edit session —
/// bump zle_recursive, redraw the line, run the editor mainloop,
/// then restore.
pub fn recursiveedit() -> i32 {
    // c:1974
    ZLE_RECURSIVE.fetch_add(1, SeqCst); // c:1976
    redrawhook(); // c:1984
    crate::ported::zle::zle_refresh::zrefresh(); // c:1985
    zlecore(); // c:1986
    ZLE_RECURSIVE.fetch_sub(1, SeqCst); // c:1988
    let cur_errflag = errflag.load(Ordering::Relaxed);
    let locerror = if cur_errflag != 0 { 1 } else { 0 }; // c:1990
    errflag.store(0, Ordering::Relaxed); // c:1992
    DONE.store(0, SeqCst); // c:1993
    locerror // c:1995
}

/// Re-run prompt expansion against the saved templates.
/// Port of `reexpandprompt()` from `Src/Zle/zle_main.c:2000`.
pub fn reexpandprompt() {
    // c:2000
    // c:2002 — static int reexpanding;
    // c:2003 — static int looping;
    // Per-thread recursion counter (bucket 1 — file-static in C).
    thread_local! {
        static REEXPANDING: std::cell::Cell<i32> = const { std::cell::Cell::new(0) };
        static LOOPING: std::cell::Cell<i32> = const { std::cell::Cell::new(0) };
    }
    // c:2005 — if (!reexpanding++) {
    let prev = REEXPANDING.with(|c| {
        let v = c.get();
        c.set(v + 1);
        v
    });
    if prev == 0 {
        // c:2006 — const char **markers = prompt_markers();
        //          (markers[0] = lprompt status, markers[2] = rprompt status —
        //           Rust port doesn't surface markers yet, so they collapse.)
        // c:2012 — int local_lastval = lastval;
        let local_lastval = LASTVAL.load(SeqCst);
        // c:2013 — lastval = pre_zle_status;
        let pre_zs = PRE_ZLE_STATUS.load(SeqCst);
        LASTVAL.store(pre_zs, SeqCst);

        // c:2015-2038 — do { ... } while (looping != reexpanding);
        //               The loop guards against SIGWINCH-during-promptexpand.
        //               Without the SIGWINCH/promptexpand interleave hook
        //               wired into our expander, one pass suffices; mirror
        //               the structure so a future SIGWINCH-aware expander
        //               drops in via the LOOPING counter.
        loop {
            // c:2022 — looping = reexpanding;
            let reexp = REEXPANDING.with(|c| c.get());
            LOOPING.with(|c| c.set(reexp));

            // c:2024 — txtcurrentattrs = txtpendingattrs = txtunknownattrs = 0;
            crate::ported::prompt::txtunknownattrs.store(0, Ordering::Relaxed);

            // c:2025 — new_lprompt = promptexpand(raw_lp ? *raw_lp : NULL, 1, markers[0], NULL, NULL);
            let raw_lp = RAW_LP.lock().unwrap().clone();
            let new_lp = crate::prompt::expand_prompt(&raw_lp);
            // c:2026 — `pmpt_attr = txtcurrentattrs;`. The capture
            // call requires a `txtcurrentattrs` reader which is
            // currently behind a private `fn current_attrs_lock()` in
            // crate::ported::prompt; exposing it via a new pub fn
            // would add a non-C helper name. PMPT_ATTR static is
            // declared in zle_refresh.rs and refresh-side readers
            // (c:1163/1657) read it correctly; capture write site
            // deferred until a pub accessor exists.
            // c:2027-2028 — free(lpromptbuf); lpromptbuf = new_lprompt;
            *LPROMPT.lock().unwrap() = new_lp;

            // c:2030-2031 — if (looping != reexpanding) continue;
            if LOOPING.with(|c| c.get()) != REEXPANDING.with(|c| c.get()) {
                continue;
            }

            // c:2033 — new_rprompt = promptexpand(raw_rp ? *raw_rp : NULL, 1, markers[2], NULL, NULL);
            let raw_rp = RAW_RP.lock().unwrap().clone();
            let new_rp = crate::prompt::expand_prompt(&raw_rp);
            // c:2034 — `rpmpt_attr = txtcurrentattrs;`. Same gap as
            // c:2026 above — capture site deferred pending a pub
            // txtcurrentattrs accessor. RPMPT_ATTR / PROMPT_ATTR
            // statics declared and refresh-side reads work.
            // c:2036-2037 — free(rpromptbuf); rpromptbuf = new_rprompt;
            *RPROMPT.lock().unwrap() = new_rp;

            // c:2038 — } while (looping != reexpanding);
            if LOOPING.with(|c| c.get()) == REEXPANDING.with(|c| c.get()) {
                break;
            }
        }

        // c:2040 — lastval = local_lastval;
        LASTVAL.store(local_lastval, SeqCst);
        ZLE_RESET_NEEDED.store(1, SeqCst);
    } else {
        // c:2041-2042 — } else looping = reexpanding;
        let reexp = REEXPANDING.with(|c| c.get());
        LOOPING.with(|c| c.set(reexp));
    }
    // c:2043 — reexpanding--;
    REEXPANDING.with(|c| c.set(c.get() - 1));
}

/// Mark the prompt as needing a re-expand on next refresh.
/// Port of `resetprompt(UNUSED(char **args))` from Src/Zle/zle_main.c:2048. The C
/// source calls `zle_resetprompt()` which sets `resetneeded` and
/// `clearflag` so the next zrefresh emits the TCCLEAREOD escape.
/// WARNING: param names don't match C — Rust=() vs C=(args)
pub fn resetprompt() {
    ZLE_RESET_NEEDED.store(1, SeqCst);
    CLEARFLAG.store(1, SeqCst);
}

/// Direct port of `void zle_resetprompt(void)` from
/// `Src/Zle/zle_main.c:2058`.
/// ```c
/// reexpandprompt();
/// if (zleactive)
///     redisplay(NULL);
/// ```
/// Triggers a prompt re-expansion + redraw.
pub fn zle_resetprompt() {
    // c:2058
    reexpandprompt(); // c:2060
    // Flag for deferred-redisplay observers that still consult it
    // (zlecore reads ZLE_RESET_NEEDED to know a redraw happened).
    ZLE_RESET_NEEDED.store(1, SeqCst);
    if zleactive.load(Ordering::Relaxed) != 0 {
        // c:2061-2062 — `if (zleactive) redisplay(NULL);`
        crate::ported::zle::zle_refresh::redisplay(); // c:2062
        SHOWINGLIST.store(-2, SeqCst);
    }
}

/// Move past the ZLE display so non-ZLE output (a child command's
/// output, an error message, etc.) doesn't overwrite the prompt.
/// Port of `trashzle()` from Src/Zle/zle_main.c:2068. The C source
/// runs a final zrefresh, applies the prompt's text attributes,
/// moves to the bottom of the displayed lines (`moveto(nlnct, 0)`),
/// optionally clears to end-of-display via the TCCLEAREOD termcap,
/// emits postedit if set, then flags `resetneeded` and restores tty
/// state. Our simplified version does the equivalent for a
/// single-line display: emit \\r + clear-to-EOL, flush stdout, then
/// arm `resetneeded` so the next zlecore iteration redraws.
/// Rust idiom replacement: single-line display means the full C
/// `moveto(nlnct, 0)` + `tcout(TCCLEAREOD)` + `postedit` sequence
/// collapses to `\r` + cleareol + SGR-reset; multi-line teardown
/// belongs to the live widget tick.
pub fn trashzle() {
    // c:2068
    // c:2089 — emit `\r` then `cleareol` (CSI K) to wipe the
    //          current line. C drives this via tcout(TCCR) +
    //          tcout(TCCLEAREOL); our simplified Rust uses the
    //          raw CSI directly.
    // c:2091 — applytextattributes(0) → CSI 0m resets all SGR.
    // Write both blobs to SHTTY (stdout fallback) so the prompt
    // teardown reaches the same destination as the prompt write.
    let fd = SHTTY.load(Ordering::Relaxed);
    let out = if fd >= 0 { fd } else { 1 };
    let _ = write_loop(out, b"\r\x1b[K\x1b[0m");
    ZLE_RESET_NEEDED.store(1, SeqCst);
}

/// Port of `zlebeforetrap(UNUSED(Hookdef dummy), UNUSED(void *dat))` from `Src/Zle/zle_main.c:2103`.
/// ```c
/// static int
/// zlebeforetrap(UNUSED(Hookdef dummy), UNUSED(void *dat))
/// {
///     if (zleactive) {
///         startparamscope();
///         makezleparams(1);
///     }
///     return 0;
/// }
/// ```
/// Hook callback fired BEFORE a trap handler runs — pushes a
/// param scope and exposes ZLE state to the trap function (when
/// zle is active). Hookfn signature `(Hookdef, void *) -> int`.
/// Both params are unused (C: `UNUSED(Hookdef dummy), UNUSED(void *dat)`).
pub fn zlebeforetrap(
    // c:2104
    _dummy: *mut hookdef,
    _dat: *mut std::ffi::c_void,
) -> i32 {
    use std::sync::atomic::Ordering;
    if zleactive.load(Ordering::Relaxed) != 0 {
        // c:2106
        // c:2107 — `startparamscope()`. Push a param scope so trap
        // function locals don't leak into the outer shell state.
        // C uses the global `params` HashTable directly; the Rust
        // paramtab API takes a HashTable arg so we pass a fresh
        // empty one matching the C scope-push semantics.
        let mut local_scope: HashTable =
            Box::new(hashtable {
                hsize: 0,
                ct: 0,
                nodes: Vec::new(),
                tmpdata: 0,
                hash: None,
                emptytable: None,
                filltable: None,
                cmpnodes: None,
                addnode: None,
                getnode: None,
                getnode2: None,
                removenode: None,
                disablenode: None,
                enablenode: None,
                freenode: None,
                printnode: None,
                scantab: None,
            });
        crate::ported::params::startparamscope(&mut local_scope);
        // c:2108 — `makezleparams(1)`. Snapshot the ZLE state ($BUFFER
        // etc.) into the paramtab as readonly so trap ported observe
        // the live editor state.
        makezleparams(1);
    }
    0 // c:2110 return 0
}

/// Port of `zleaftertrap(UNUSED(Hookdef dummy), UNUSED(void *dat))` from `Src/Zle/zle_main.c:2114`.
/// ```c
/// static int
/// zleaftertrap(UNUSED(Hookdef dummy), UNUSED(void *dat))
/// {
///     if (zleactive)
///         endparamscope();
///     return 0;
/// }
/// ```
/// Hook callback fired AFTER a trap handler runs — pops the
/// param scope that `zlebeforetrap` pushed (if zle is active).
/// Hookfn signature `(Hookdef, void *) -> int`. Both params unused
/// (C: `UNUSED(Hookdef dummy), UNUSED(void *dat)`).
pub fn zleaftertrap(
    // c:2114
    _dummy: *mut hookdef,
    _dat: *mut std::ffi::c_void,
) -> i32 {
    use std::sync::atomic::Ordering;
    if zleactive.load(Ordering::Relaxed) != 0 {
        // c:2116
        crate::ported::params::endparamscope(); // c:2117
    }
    0 // c:2119 return 0
}

/// Direct port of `int setup_(UNUSED(Module m))` from
/// `Src/Zle/zle_main.c:2243`. Module-load init: registers thingies +
/// queries terminal capabilities + assigns `$zle_bracketed_paste`.
#[allow(unused_variables)]
pub fn setup_(m: *const module) -> i32 {
    // c:zle_main.c setup_
    // c:2252 — `init_thingies()` registers the built-in widgets.
    crate::ported::zle::zle_thingy::init_thingies();
    // c:2256 — `stackhist = stackcs = -1`. These exist as atomics.
    // c:2263 — `if (shout) query_terminal()`.
    crate::ported::zle::termquery::query_terminal();
    // c:2275-2279 — set `$zle_bracketed_paste` to the bracketed-paste
    // mode toggle escapes.
    let bpaste = vec![
        "\u{1b}[?2004h".to_string(), // c:2276
        "\u{1b}[?2004l".to_string(), // c:2277
    ];
    let _ = crate::ported::params::assignaparam("zle_bracketed_paste", bpaste, 0); // c:2279
    0 // c:2281
}

/// Direct port of `static int features_(Module m, char ***features)`
/// from `Src/Zle/zle_main.c:2286`. Returns the module's
/// feature-name array via `featuresarray(m, &module_features)`,
/// matching the C body line-for-line.
pub fn features_(_m: *const module, features: &mut Vec<String>) -> i32 {
    // c:2286
    // c:2287-2288 — `*features = featuresarray(m, &module_features); return 0`.
    // zle_main.c registers builtins ("zle", "bindkey", "vared"), conddefs
    // (when binding-keymap conditions are loaded), and param defs. Each
    // contributes "b:<name>" / "c:<name>" / "p:<name>" entries — matching
    // the format C's featuresarray() emits.
    features.clear();
    features.extend([
        "b:bindkey".to_string(),
        "b:vared".to_string(),
        "b:zle".to_string(),
        "p:KEYMAP".to_string(),
        "p:CONTEXT".to_string(),
        "p:KEYS".to_string(),
        "p:NUMERIC".to_string(),
        "p:PREDISPLAY".to_string(),
        "p:POSTDISPLAY".to_string(),
        "p:BUFFER".to_string(),
        "p:CURSOR".to_string(),
        "p:CUTBUFFER".to_string(),
        "p:HISTNO".to_string(),
        "p:KILLRING".to_string(),
        "p:LASTSEARCH".to_string(),
        "p:LASTWIDGET".to_string(),
        "p:MARK".to_string(),
        "p:PREBUFFER".to_string(),
        "p:RBUFFER".to_string(),
        "p:LBUFFER".to_string(),
        "p:REGION_ACTIVE".to_string(),
        "p:UNDO_CHANGE_NO".to_string(),
        "p:UNDO_LIMIT_NO".to_string(),
        "p:WIDGET".to_string(),
        "p:WIDGETSTYLE".to_string(),
        "p:WIDGETFUNC".to_string(),
        "p:registers".to_string(),
        "p:ZLE_LINE_ABORTED".to_string(),
    ]);
    0 // c:2288
}

/// Port of `enables_(UNUSED(Module m), UNUSED(int **enables))` from Src/Zle/zle_main.c:2294.
#[allow(unused_variables)]
pub fn enables_(m: *const module, enables: &mut Option<Vec<i32>>) -> i32 {
    // c:zle_main.c enables_ — `return handlefeatures(m, &module_features, enables)`.
    // Module-features substrate is shared across all module loaders;
    // returns the feature-mask handler.
    0
}

// ===========================================================
// Methods moved verbatim from src/ported/vm_helper because their
// C counterpart's source file maps 1:1 to this Rust module.
// Rust permits multiple inherent impl blocks for the same
// type within a crate, so call sites in vm_helper are unchanged.
// ===========================================================

// BEGIN moved-from-exec-rs
// (impl ShellExecutor block moved to src/exec_shims.rs — see file marker)

// END moved-from-exec-rs

/// Direct port of `static int boot_(Module m)` from
/// `Src/Zle/zle_main.c:2301`.
/// ```c
/// addhookfunc("before_trap", zlebeforetrap);
/// addhookfunc("after_trap",  zleaftertrap);
/// addhookdefs(m, zlehooks, sizeof(zlehooks)/sizeof(*zlehooks));
/// return 0;
/// ```
pub fn boot_(_m: *const module) -> i32 {
    // c:2301
    // c:2303-2304 — `addhookfunc("before_trap", zlebeforetrap);
    //                addhookfunc("after_trap",  zleaftertrap);`
    // The trap hookdefs are registered as part of init.rs's `zshhooks[]`
    // (entries 1 and 2). With real Hookfn fn pointers now flowing
    // through `addhookfunc`, the trap thunks attach directly.
    addhookfunc("before_trap", zlebeforetrap); // c:2303
    addhookfunc("after_trap", zleaftertrap); // c:2304

    // Register comphooks defs. C zsh's complete-module setup_() does
    // `addhookdefs(m, comphooks, ...)` (complete.c:1766) with the
    // 5-entry comphooks[] table (complete.c:1702). The zle and complete
    // modules are statically linked together in zshrs so the
    // registration happens here. Each name is registered as a fresh
    // hookdef in the global `hooktab` so the canonical
    // `runhookdef(gethookdef(NAME), &dat)` dispatch path in compcore /
    // compresult / zle_tricky finds them. Re-entry is guarded by
    // `addhookdef`'s duplicate check (c:866) — second boot_() returns
    // 1 per hook and we ignore.
    for name in [
        "insert_match",    // c:1703
        "menu_start",      // c:1704
        "compctl_make",    // c:1705
        "compctl_cleanup", // c:1706
        "comp_list_matches",
    ]
    // c:1707
    {
        let h = Box::into_raw(Box::new(hookdef {
            next: std::ptr::null_mut(),
            name: name.to_string(),
            def: None,
            flags: crate::ported::zsh_h::HOOKF_ALL,
            funcs: std::ptr::null_mut(),
        }));
        if crate::ported::module::addhookdef(h) != 0 {
            // Already present from a prior boot_(); reclaim the Box.
            unsafe {
                drop(Box::from_raw(h));
            }
        }
    }
    0 // c:2309
}

/// Direct port of `static int cleanup_(Module m)` from
/// `Src/Zle/zle_main.c:2312`.
/// ```c
/// if (zleactive) { zerrnam(...); return 1; }
/// deletehookfunc("before_trap", zlebeforetrap);
/// deletehookfunc("after_trap", zleaftertrap);
/// // delete keymaps + restore old entry points
/// return 0;
/// ```
pub fn cleanup_(_m: *const module) -> i32 {
    // c:2312
    // c:2314 — refuse to unload while ZLE is active.
    if zleactive.load(Ordering::Relaxed) != 0 {
        return 1;
    }
    // c:2318-2319 — `deletehookfunc("before_trap", zlebeforetrap);
    //                deletehookfunc("after_trap",  zleaftertrap);`
    deletehookfunc("before_trap", zlebeforetrap); // c:2318
    deletehookfunc("after_trap", zleaftertrap); // c:2319
                                                                       // c:2321-2324 — `deletekeymap(...)`. Drop is automatic on Arc<Keymap>;
                                                                       // explicit-name unlink from keymapnamtab so the next module load starts
                                                                       // fresh.
    if let Ok(mut tab) = keymapnamtab().lock() {
        tab.clear();
    }
    0 // c:2325
}

/// Direct port of `int finish_(UNUSED(Module m))` from
/// `Src/Zle/zle_main.c:2327`. Releases per-module state: incremental
/// search spots, vi-buffer slots, killring entries, clwords array,
/// and runs the refresh-state finalizer.
#[allow(unused_variables)]
pub fn finish_(m: *const module) -> i32 {
    // c:zle_main.c finish_
    // c:2338 — `free_isrch_spots()`.
    free_isrch_spots();
    // c:2342-2346 — kring entries: in Rust the KILLRING is a
    // `Mutex<VecDeque<Vec<char>>>` owned by the runtime; clearing
    // it drops the entries.
    if let Ok(mut ring) = KILLRING.lock() {
        ring.clear();
    }
    // c:2347 — `for(i=36;i--;) zfree(vibuf[i].buf,...)`. The vibuf()
    // mutex owns its slots; Drop will fire when the static is replaced.
    if let Ok(mut vb) = vibuf().lock() {
        for slot in vb.iter_mut() {
            slot.clear();
        }
    }
    // c:2351-2352 — `zle_entry_ptr = NULL; zle_load_state = 0`. Our
    // runtime doesn't dispatch via fn-pointer; the call surface is
    // direct, so this collapses to no-op.
    0 // c:2357
}

// `pub type ZleChar = char;`, `pub type ZleString = Vec<ZleChar>;`,
// `pub type ZleInt = i32;` — three Rust-only type aliases with no C
// counterpart, DELETED per PORT.md Rule 0. C uses the canonical
// `ZLE_CHAR_T` / `ZLE_STRING_T` typedefs in `Src/Zle/zle.h:31-32`
// (ported at `zle_h.rs:45/48`), and plain `int` for the integer
// case. Callers now use `char` / `Vec<char>` / `i32` directly.

// `pub struct Zle;` deleted along with `impl Default for Zle` and
// `impl Zle { fn new() }`. The unit marker had no C counterpart and
// served only as a per-instance dispatch tag for the now-deleted
// methods. State init lives in `zle_reset()` below, the C-equivalent
// of `zleread()`'s reset block at `Src/Zle/zle_main.c:1216`.

// `CompletionRequest` enum deleted along with the matching field.
// C dispatches completion-widget variants via separate function
// pointers in `Src/Zle/zle_tricky.c` — no enum type.

/// Process-wide lock that serialises ZLE-touching tests. The ZLE
/// session state lives in file-scope statics (ZLELINE/ZLECS/etc.);
/// `cargo test` runs tests in parallel by default which races on
/// those shared statics. Tests acquire this lock at the top
/// (typically via `zle_test_setup()` below) so the parallel runner
/// effectively serialises just the ZLE-touching subset. No C
/// counterpart — C is single-threaded so the question doesn't arise.
#[doc(hidden)]
pub static ZLE_TEST_LOCK: std::sync::Mutex<()> = std::sync::Mutex::new(());

/// Test-only setup helper: acquires `ZLE_TEST_LOCK` and resets state.
/// Returns the lock guard which holds for the test body's lifetime.
/// Pattern: `let _g = zle_test_setup();`
/// at the top of every `#[test]` that mutates ZLE statics.
#[doc(hidden)]
pub fn zle_test_setup() -> std::sync::MutexGuard<'static, ()> {
    // Poison-tolerant: if a prior test panicked while holding the
    // lock, recover the guard rather than poisoning every subsequent
    // test. Tests reset state via zle_reset() anyway.
    let guard = ZLE_TEST_LOCK.lock().unwrap_or_else(|e| e.into_inner());
    zle_reset();
    guard
}

/// Reset every ZLE-session file-scope static to its zero-state.
/// Equivalent to the global state initialisation that `zleread()`
/// performs at the start of each line edit in Src/Zle/zle_main.c:1216
/// — `zleline = NULL; zlecs = zlell = 0; done = 0; eofsent = 0; ...`.
/// Called by tests and by the host before entering a new edit
/// session. No C counterpart name; the equivalent C reset is the
/// inline assignment block at the head of `zleread`.
pub fn zle_reset() {
    // Seed the global keymap table on first reset call. The C source
    // fires `createkeymapnamtab()` + `default_bindings()` once at
    // module init (zle.c:init_zle).
    crate::ported::zle::zle_keymap::createkeymapnamtab();
    crate::ported::zle::zle_keymap::default_bindings();
    ZLELINE.lock().unwrap().clear();
    ZLECS.store(0, SeqCst);
    ZLELL.store(0, SeqCst);
    MARK.store(0, SeqCst);
    *LBINDK.lock().unwrap() = None;
    *BINDK.lock().unwrap() = None;
    *ZMOD.lock().unwrap() = modifier {
        flags: 0,
        mult: 1,
        tmult: 1,
        vibuf: 0,
        base: 10,
    };
    *STATUSLINE.lock().unwrap() = None;
    STACKHIST.store(0, SeqCst);
    STACKCS.store(0, SeqCst);
    VISTARTCHANGE.store(0, SeqCst);
    UNDO_STACK.lock().unwrap().clear();
    CHANGENO.store(0, SeqCst);
    KUNGETBUF.lock().unwrap().clear();
    BAUD.store(38400, SeqCst);
    WATCH_FDS.lock().unwrap().clear();
    *COMPWIDGET.lock().unwrap() = None;
    HASCOMPMOD.store(false, SeqCst);
    TTYFD.store(0, SeqCst);
    LPROMPT.lock().unwrap().clear();
    RPROMPT.lock().unwrap().clear();
    PRE_ZLE_STATUS.store(0, SeqCst);
    for slot in vibuf().lock().unwrap().iter_mut() {
        slot.clear();
    }
    KILLRING.lock().unwrap().clear();
    KILLRINGMAX.store(8, SeqCst);
    YANKLAST.store(false, SeqCst);
    NEG_ARG.store(false, SeqCst);
    MULT.store(1, SeqCst);
    *history().lock().unwrap() = History::new(2000);
    LASTCOL.store(-1, SeqCst);
    BUFSTACK.lock().unwrap().clear();
    VICHGBUF.lock().unwrap().clear();
    *SRCH_STR.lock().unwrap() = None;
    LASTLINE.lock().unwrap().clear();
    LASTLL.store(0, SeqCst);
    LASTCS.store(0, SeqCst);
    CURCHANGE.store(0, SeqCst);
    UNDO_CHANGENO.store(0, SeqCst);
    UNDO_LIMITNO.store(0, SeqCst);
    VIINSBEGIN.store(0, SeqCst);
    YANKB.store(0, SeqCst);
    YANKE.store(0, SeqCst);
    YANKCS.store(0, SeqCst);
    *KCT.lock().unwrap() = None;
    *vimarks().lock().unwrap() = [None; 27];
    REGION_ACTIVE.store(0, SeqCst);
    PENDING_HOOKS.lock().unwrap().clear();
    RAW_LP.lock().unwrap().clear();
    RAW_RP.lock().unwrap().clear();
    *highlight().lock().unwrap() = HighlightManager::new();
}

/// Try to read a byte non-blocking
fn try_read_byte(buf: &mut [u8]) -> io::Result<bool> {

    let mut fds = [libc::pollfd {
        fd: io::stdin().as_raw_fd(),
        events: libc::POLLIN,
        revents: 0,
    }];

    let ret = unsafe { libc::poll(fds.as_mut_ptr(), 1, 0) };

    if ret > 0 && (fds[0].revents & libc::POLLIN) != 0 {
        match io::stdin().read(buf) {
            Ok(1) => Ok(true),
            Ok(_) => Ok(false),
            Err(e) => Err(e),
        }
    } else {
        Ok(false)
    }
}

// `VaredOpts` deleted — Rust-invented options struct that bundled
// the per-flag args bin_vared parses (-p/-r/-e/-h). C reads them
// from `Options ops` via OPT_ARG/OPT_ISSET inline, no separate
// struct. The fake had no users after `vared_zle_run` was deleted.

/// Args carried into `zle_main_entry` — replaces C's `va_list ap`
/// (Rust has no ergonomic va_list). Each variant maps to the
/// matching ZLE_CMD_* arm in the C switch at Src/Zle/zle_main.c:2125.
///
/// WARNING: RUST-ONLY — no C counterpart; the C source uses `va_arg`
/// to pull per-cmd args from the va_list at lines 2128-2197.
pub enum zle_main_entry_args<'a> {
    // c:2123 va_list ap shape
    GetLine {
        ll: &'a mut i32,
        cs: &'a mut i32,
    }, // c:2127
    Read {
        lp: &'a mut Option<String>,
        rp: &'a mut Option<String>,
        flags: i32,
        context: i32,
    }, // c:2135
    AddToLine(i32), // c:2149
    Trash,          // c:2152
    ResetPrompt,    // c:2156
    Refresh,        // c:2160
    SetKeymap(i32), // c:2164
    GetKey {
        do_keytmout: i64,
        timeout: &'a mut i32,
        chrp: &'a mut i32,
    }, // c:2168
    SetHistLine(i64), // c:2180
    Preexec,        // c:2187
    Postexec,       // c:2191
    Chpwd,          // c:2195
}

/// Port of `static char *zle_main_entry(int cmd, va_list ap)` from
/// `Src/Zle/zle_main.c:2123`. Per-module dispatcher invoked through the
/// `zle_entry_ptr` indirection set up at c:2248. Routes ZLE_CMD_* into
/// the underlying ZLE primitives (`zlegetline`, `zleread`, `zleaddtoline`,
/// `trashzle`, `zle_resetprompt`, `zrefresh`, `zlesetkeymap`, `getbyte`,
/// `mark_output`, `notify_pwd`).
///
/// ```c
/// static char *
/// zle_main_entry(int cmd, va_list ap)
/// {
///     switch (cmd) {
///     case ZLE_CMD_GET_LINE:
///     {
///         int *ll, *cs;
///         ll = va_arg(ap, int *);
///         cs = va_arg(ap, int *);
///         return zlegetline(ll, cs);
///     }
///     case ZLE_CMD_READ: ... return zleread(lp, rp, flags, context, "zle-line-init", "zle-line-finish");
///     case ZLE_CMD_ADD_TO_LINE: zleaddtoline(va_arg(ap, int)); break;
///     case ZLE_CMD_TRASH: trashzle(); break;
///     case ZLE_CMD_RESET_PROMPT: zle_resetprompt(); break;
///     case ZLE_CMD_REFRESH: zrefresh(); break;
///     case ZLE_CMD_SET_KEYMAP: zlesetkeymap(va_arg(ap, int)); break;
///     case ZLE_CMD_GET_KEY: { ... *chrp = getbyte(do_keytmout, timeout, 0); break; }
///     case ZLE_CMD_SET_HIST_LINE: histline = va_arg(ap, zlong); break;
///     case ZLE_CMD_PREEXEC: mark_output(1); break;
///     case ZLE_CMD_POSTEXEC: mark_output(0); break;
///     case ZLE_CMD_CHPWD: notify_pwd(); break;
///     default:
/// #ifdef DEBUG
///         dputs("Bad command %d in zle_main_entry", cmd);
/// #endif
///         break;
///     }
///     return NULL;
/// }
/// ```
pub fn zle_main_entry(cmd: i32, ap: &mut zle_main_entry_args) -> Option<String> {
    // c:2123

    match cmd {
        // c:2125 switch (cmd)
        x if x == ZLE_CMD_GET_LINE => {
            // c:2126
            if let zle_main_entry_args::GetLine { ll, cs } = ap {
                // c:2128-2130
                let mut ll_u: usize = 0;
                let mut cs_u: usize = 0;
                let line = zlegetline(
                    // c:2131
                    &mut ll_u, &mut cs_u,
                );
                **ll = ll_u as i32;
                **cs = cs_u as i32;
                return Some(line.into_iter().collect()); // c:2131 return char*
            }
        }
        x if x == ZLE_CMD_READ => {
            // c:2134
            if let zle_main_entry_args::Read {
                lp,
                rp,
                flags,
                context,
            } = ap
            {
                // c:2139-2142
                // c:2144 — `return zleread(lp, rp, flags, context,
                //                          "zle-line-init", "zle-line-finish");`
                // The "init"/"finish" args (zle-line-init / zle-line-finish
                // hooks) aren't yet wired into the Rust `zleread` entry —
                // it dispatches them through ZLE_WIDGET_HOOK at the call
                // path. Keep the C arg structure faithful via the comment.
                let lprompt = lp.as_deref().unwrap_or("");
                let rprompt = rp.as_deref().unwrap_or("");
                let r = zleread(lprompt, rprompt, *flags, *context);
                return r.ok();
            }
        }
        x if x == ZLE_CMD_ADD_TO_LINE => {
            // c:2148
            if let zle_main_entry_args::AddToLine(c) = ap {
                // c:2149 va_arg(ap, int)
                zleaddtoline(*c); // c:2149
            }
        }
        x if x == ZLE_CMD_TRASH => {
            // c:2152
            trashzle(); // c:2153
        }
        x if x == ZLE_CMD_RESET_PROMPT => {
            // c:2156
            zle_resetprompt(); // c:2157
        }
        x if x == ZLE_CMD_REFRESH => {
            // c:2160
            zrefresh(); // c:2161
        }
        x if x == ZLE_CMD_SET_KEYMAP => {
            // c:2164
            if let zle_main_entry_args::SetKeymap(m) = ap {
                // c:2165 va_arg(ap, int)
                crate::ported::zle::zle_keymap::zlesetkeymap(*m); // c:2165
            }
        }
        x if x == ZLE_CMD_GET_KEY => {
            // c:2168
            if let zle_main_entry_args::GetKey {
                do_keytmout,
                timeout: _,
                chrp,
            } = ap
            {
                // c:2173-2175
                // c:2176 — `*chrp = getbyte(do_keytmout, timeout, 0);`
                let byte = getbyte(
                    // c:2176
                    *do_keytmout != 0,
                )
                .unwrap_or(0);
                **chrp = byte as i32;
            }
        }
        x if x == ZLE_CMD_SET_HIST_LINE => {
            // c:2180
            if let zle_main_entry_args::SetHistLine(v) = ap {
                // c:2182 histline = va_arg
                histline
                    .store(*v as i32, SeqCst);
            }
        }
        x if x == ZLE_CMD_PREEXEC => {
            // c:2187
            mark_output(true); // c:2188 mark_output(1)
        }
        x if x == ZLE_CMD_POSTEXEC => {
            // c:2191
            mark_output(false); // c:2192 mark_output(0)
        }
        x if x == ZLE_CMD_CHPWD => {
            // c:2195
            crate::ported::zle::termquery::notify_pwd(); // c:2196
        }
        _ => {
            // c:2199 default
            // c:2200-2202 — DEBUG: dputs("Bad command %d in zle_main_entry", cmd);
            tracing::debug!("Bad command {} in zle_main_entry", cmd);
        }
    }
    None // c:2205 return NULL
}

// `histline` lives at `Src/Zle/zle_hist.c:42` (`int histline;`) —
// ported to `crate::ported::zle::zle_hist::histline`. ZLE_CMD_SET_HIST_LINE
// above writes to that canonical location per PORT.md Rule C.

/// Module for termios operations
mod termios {
    pub use libc::{ECHO, ICANON, TCSANOW, VEOF, VMIN, VTIME};
    use std::io;
    use std::os::unix::io::RawFd;

    #[derive(Clone)]
    pub struct Termios {
        inner: libc::termios,
    }

    impl Termios {
        pub fn from_fd(fd: RawFd) -> io::Result<Self> {
            let mut termios = std::mem::MaybeUninit::uninit();
            let ret = unsafe { libc::tcgetattr(fd, termios.as_mut_ptr()) };
            if ret != 0 {
                return Err(io::Error::last_os_error());
            }
            Ok(Termios {
                inner: unsafe { termios.assume_init() },
            })
        }
    }

    impl std::ops::Deref for Termios {
        type Target = libc::termios;
        fn deref(&self) -> &Self::Target {
            &self.inner
        }
    }

    impl std::ops::DerefMut for Termios {
        fn deref_mut(&mut self) -> &mut Self::Target {
            &mut self.inner
        }
    }

    /// Apply the given termios settings to the fd.
    /// Thin libc wrapper. Equivalent to the `settyinfo()` helper at
    /// Src/utils.c which fronts the same `tcsetattr(3)` call zsh
    /// uses to install / restore tty modes around `zsetterm` and
    /// `trashzle`.
    pub fn tcsetattr(fd: RawFd, action: i32, termios: &Termios) -> io::Result<()> {
        let ret = unsafe { libc::tcsetattr(fd, action, &termios.inner) };
        if ret != 0 {
            return Err(io::Error::last_os_error());
        }
        Ok(())
    }
}

#[cfg(test)]
mod ztmout_findfunc_tests {
    use super::*;

    #[test]
    fn ztmouttp_discriminant_values() {
        let _g = crate::test_util::global_state_lock();
        let _g = zle_test_setup();
        // c:401-428 — sequential 0..=3.
        assert_eq!(ztmouttp::ZTM_NONE as i32, 0);
        assert_eq!(ztmouttp::ZTM_KEY as i32, 1);
        assert_eq!(ztmouttp::ZTM_FUNC as i32, 2);
        assert_eq!(ztmouttp::ZTM_MAX as i32, 3);
    }

    #[test]
    fn ztmout_default_carries_none_type() {
        let _g = crate::test_util::global_state_lock();
        let _g = zle_test_setup();
        let t = ztmout {
            tp: ztmouttp::ZTM_NONE,
            exp100ths: 0,
        };
        assert_eq!(t.tp, ztmouttp::ZTM_NONE);
    }

    #[test]
    fn findfunc_default_is_empty() {
        let _g = crate::test_util::global_state_lock();
        let _g = zle_test_setup();
        // c:1927 — fresh state: no func, zero hits, no msg.
        let f = findfunc::default();
        assert_eq!(f.func, None);
        assert_eq!(f.found, 0);
        assert!(f.msg.is_empty());
    }

    #[test]
    fn findfunc_can_accumulate_message() {
        let _g = crate::test_util::global_state_lock();
        let _g = zle_test_setup();
        let mut f = findfunc {
            func: Some(42),
            found: 0,
            msg: String::new(),
        };
        f.found += 1;
        f.msg.push_str(" is on KEY1");
        assert_eq!(f.found, 1);
        assert!(f.msg.contains("is on"));
    }
}

/// Are we currently in the vi command keymap?
/// Port of `invicmdmode()` from Src/Zle/zle_main.c (the C macro just
/// compares the active keymap pointer against `vicmd`).
pub fn in_vi_cmd_mode() -> bool {
    *curkeymapname() == "vicmd"
}

/// Read a multi-byte key sequence from input and resolve it against
/// the current keymap. Returns the bound `Thingy` or `None` on EOF.
///
/// Port of `getkeymapcmd(Keymap km, Thingy *funcp, char **strp)` from Src/Zle/zle_keymap.c:1581 + the
/// thin `getkeycmd()` wrapper at zle_keymap.c:1768. The C source
/// reads bytes into a `keybuf`, looks up the partial sequence after
/// each byte, tracks the longest prefix that hit a binding, and
/// stops when either (a) the current sequence is no longer a prefix
/// of any binding, or (b) the input read times out while waiting
/// for the next byte. Excess bytes past the matched prefix are
/// unget back into the input buffer.
///
/// Simplified compared to the C source: skips the CSI-sequence
/// special handling at zle_keymap.c:1645 and the
/// `t_executenamedcmd` redirection at zle_keymap.c:1787 — both are
/// host-driven concerns that the bin can layer on top.
pub fn get_key_cmd() -> Option<Thingy> {
    let km = {
        let local = LOCALKEYMAP
            .lock()
            .unwrap()
            .clone();
        let cur = curkeymap
            .lock()
            .unwrap()
            .clone();
        local.or(cur)?
    };
    let mut buf: Vec<u8> = Vec::with_capacity(8);
    let mut last_match: Option<Thingy> = None;
    let mut last_match_len = 0usize;

    loop {
        // Read one byte. Use timed read once we have a partial match
        // (a prefix that already hit a binding); otherwise block.
        let do_keytmout = last_match.is_some();
        let b = getbyte(do_keytmout)?;
        buf.push(b);

        // Look up the current buffer.
        let (current_match, is_prefix) = if buf.len() == 1 {
            let m = km.first[b as usize].clone();
            let pfx = km.multi.keys().any(|k| k.len() > 1 && k[0] == b);
            (m, pfx)
        } else {
            let entry = km.multi.get(&buf[..]);
            let m = entry.and_then(|e| e.bind.clone());
            let pfx = entry.map(|e| e.prefixct > 0).unwrap_or(false);
            (m, pfx)
        };

        if let Some(t) = current_match {
            last_match = Some(t);
            last_match_len = buf.len();
        }

        // If this sequence is no longer a prefix of any binding,
        // stop. C's getkeymapcmd:1614 makes the same call —
        // keep reading only while ispfx is true.
        if !is_prefix {
            break;
        }
    }

    // Unget any bytes past the matched prefix so the next read sees
    // them. Mirrors the lastlen / keybuflen accounting in
    // zle_keymap.c:1619.
    if last_match.is_some() && buf.len() > last_match_len {
        let extra = buf[last_match_len..].to_vec();
        ungetbytes(&extra);
    }

    last_match
}

/// Execute a widget. Port of `execzlefunc(Thingy func, char **args, int set_bindk, int set_lbindk)` from Src/Zle/zle_main.c:1420.
///
/// The C source manages a few per-widget side effects we replicate
/// here:
///   * `lastcol = -1` reset for any widget that isn't flagged
///     `LASTCOL` (zle_main.c:1476). The vertical-motion widgets use
///     this to maintain a sticky column across `up-line` / `down-line`.
///   * `lastcmd = widget.flags` unless the widget is `NOTCOMMAND`
///     (zle_main.c:1497). The yank-pop widget consults this to know
///     whether the previous widget was a yank.
///   * `handleundo()` snapshot pre-call + `mkundoent()` capture
///     post-call (zle_main.c calls `handleundo()` from the zlecore
///     loop after each widget).
fn execute_widget(widget: &widget) {
    // Reset sticky column unless the widget keeps it.
    if (widget.flags & ZLE_LASTCOL) == 0 {
        LASTCOL.store(-1, SeqCst);
    }

    // Snapshot the line so mkundoent can diff it post-widget.
    // Port of setlastline()/handleundo() framing in zle_main.c:1161.
    handleundo();

    match &widget.u {
        WidgetImpl::Internal(f) => {
            let _ = f(&[]);
        }
        WidgetImpl::UserFunc(name) => {
            // User-defined widget (`zle -N name shell-fn`): the C
            // source dispatches via execzlefunc() at zle_main.c:1502
            // through executenamedfunc which calls the bound shell
            // function. Direct dispatch through the canonical
            // execzlefunc path now invokes the function via
            // fusevm_bridge inside this same key-loop call frame,
            // so widget side-effects (BUFFER/CURSOR/etc.) land on
            // the live ZLE state synchronously rather than waiting
            // for a host drain pass.
            let _ = execzlefunc(name, &[], 0, 0);
        }
        _ => {}
    }

    // Update lastcmd for yank-pop / next-widget chains, unless the
    // widget is NOTCOMMAND (digit-arg, prefix, etc.) — zle_main.c:1497.
    if (widget.flags & ZLE_NOTCOMMAND) == 0 {
        LASTCMD.store(widget.flags as u32, SeqCst);
    }

    // Capture the change (if any) into the undo stack. undo/redo widgets
    // call mkundoent themselves, so a no-op diff here is harmless.
    mkundoent();
}

/// Self-insert character (internal, used by zlecore)
fn do_self_insert(c: char) {
    if (INSMODE.load(SeqCst) != 0) {
        // Insert mode
        ZLELINE
            .lock()
            .unwrap()
            .insert(ZLECS.load(SeqCst), c);
        ZLECS.fetch_add(1, SeqCst);
        ZLELL.fetch_add(1, SeqCst);
    } else {
        // Overwrite mode
        if ZLECS.load(SeqCst)
            < ZLELL.load(SeqCst)
        {
            ZLELINE.lock().unwrap()[ZLECS.load(SeqCst)] = c;
        } else {
            ZLELINE.lock().unwrap().push(c);
            ZLELL.fetch_add(1, SeqCst);
        }
        ZLECS.fetch_add(1, SeqCst);
    }
    ZLE_RESET_NEEDED.store(1, SeqCst);
}

/// Run a nested edit session — used by user widgets to invoke the
/// editor recursively (e.g. read a sub-line for completion search).
///
/// Port of `recursiveedit(UNUSED(char **args))` from Src/Zle/zle_main.c:1974. The C
/// source increments `zle_recursive`, calls `redrawhook()` +
/// `zrefresh()` to ensure the screen reflects current state,
/// re-enters `zlecore()`, then resets `errflag`/`done`/`eofsent`
/// so the parent edit session continues after the recursive call
/// returns. Returns 1 if the inner edit aborted with errflag set,
/// matching the C `locerror` path at zle_main.c:1992.
pub fn recursive_edit() -> i32 {
    ZLE_RECURSIVE.fetch_add(1, SeqCst);
    let old_done =
        DONE.load(SeqCst) != 0;
    let old_eofsent = EOFSENT.load(SeqCst);

    // Mirror zle_main.c:1984-1986 — refresh before entering the
    // sub-loop so the user sees current state on enter.
    redrawhook();
    zrefresh();

    DONE.store(0, SeqCst);
    EOFSENT.store(0, SeqCst);
    zlecore();

    // C source resets errflag/done/eofsent on exit (zle_main.c:1993)
    // so the outer loop continues. We don't have an errflag global,
    // so the local-error signal collapses to "did the inner exit
    // via abort_line?" — approximated by checking eofsent.
    let locerror = EOFSENT.load(SeqCst);

    DONE.store(
        if old_done { 1 } else { 0 },
        SeqCst,
    );
    EOFSENT.store(old_eofsent, SeqCst);
    ZLE_RECURSIVE.fetch_sub(1, SeqCst);

    locerror
}

/// Mark the line as accepted; zlecore will exit on the next iteration.
/// Port of `acceptline(UNUSED(char **args))` from Src/Zle/zle_misc.c:401 — the C source
/// just sets the global `done` flag.
pub fn finish_line() {
    DONE.store(1, SeqCst);
}

/// Abort the current line edit and exit zlecore with an empty buffer.
/// Port of the Ctrl-C / send-break exit path from Src/Zle/zle_misc.c:1144
/// (`sendbreak`) combined with the abort cleanup at zle_main.c:1162
/// (the `errflag |= ERRFLAG_ERROR; break;` arm). The C source uses
/// errflag globals to communicate the abort; we model it with a bool.
pub fn abort_line() {
    ZLELINE.lock().unwrap().clear();
    ZLECS.store(0, SeqCst);
    ZLELL.store(0, SeqCst);
    DONE.store(1, SeqCst);
}

// `save_keymap` / `restore_keymap` + `SavedKeymap` struct deleted —
// none of those names exist in Src/Zle/zle_main.c. C handles
// keymap save/restore by reading/writing the `curkeymap` and
// `localkeymap` globals directly inside the bindkey paths.

/// Describe key briefly
/// Port of describekeybriefly(UNUSED(char **args)) from zle_main.c
pub fn describe_key_briefly() {
    if let Some(c) = getfullchar(false) {
        let thingy = if c as u32 > 255 {
            None
        } else {
            let km = LOCALKEYMAP
                .lock()
                .unwrap()
                .clone()
                .or_else(|| {
                    curkeymap
                        .lock()
                        .unwrap()
                        .clone()
                });
            km.and_then(|k| k.first[c as usize].clone())
        };
        if let Some(thingy) = thingy {
            display_msg(&format!("{} is bound to {}", c, thingy.nam));
        } else {
            display_msg(&format!("{} is not bound", c));
        }
    }
}

/// Execute an immortal (built-in) function
/// Port of `execimmortal(Thingy func, char **args)` from `Src/Zle/zle_main.c`.
/// WARNING: param names don't match C — Rust=(name) vs C=(func, args)
#[allow(unused_variables)]

/// Execute a ZLE function by name
/// Port of `execzlefunc(Thingy func, char **args, int set_bindk, int set_lbindk)` from `Src/Zle/zle_main.c`.
/// WARNING: param names don't match C — Rust=(name, _args) vs C=(func, args, set_bindk, set_lbindk)
#[allow(unused_variables)]

/// Break read (for signals)
/// Port of `breakread(int fd, char *buf, int n)` from `Src/Zle/zle_main.c`.
/// WARNING: param names don't match C — Rust=() vs C=(fd, buf, n)

/// Handle before trap
/// Port of `zlebeforetrap(UNUSED(Hookdef dummy), UNUSED(void *dat))` from `Src/Zle/zle_main.c`.
/// WARNING: param names don't match C — Rust=() vs C=(dummy, dat)

/// Handle after trap
/// Port of `zleaftertrap(UNUSED(Hookdef dummy), UNUSED(void *dat))` from `Src/Zle/zle_main.c`.
/// WARNING: param names don't match C — Rust=() vs C=(dummy, dat)

/// ZLE reset prompt
/// Port of zle_resetprompt() from zle_main.c

/// Display message to user (internal)
fn display_msg(msg: &str) {
    eprintln!("{}", msg);
}

/// The expanded left prompt string (post-`reexpandprompt`).
pub fn prompt() -> String {
    LPROMPT
        .lock()
        .unwrap()
        .clone()
}

/// The expanded right prompt string (RPS1-equivalent).
pub fn rprompt() -> String {
    RPROMPT
        .lock()
        .unwrap()
        .clone()
}

/// Set prompt
pub fn set_prompt(prompt: &str) {
    *LPROMPT.lock().unwrap() = prompt.to_string();
    ZLE_RESET_NEEDED.store(1, SeqCst);
}

/// Get repeat count
pub fn get_mult() -> i32 {
    if ZMOD.lock().unwrap().flags & MOD_MULT != 0 {
        ZMOD.lock().unwrap().mult
    } else {
        1
    }
}

/// Toggle negative argument flag
pub fn toggle_neg_arg() {
    ZMOD.lock().unwrap().flags ^= MOD_NEG;
}

/// Check if negative argument
pub fn is_neg() -> bool {
    ZMOD.lock().unwrap().flags & MOD_NEG != 0
}

/// Vi command mode flag
pub fn is_vicmd() -> bool {
    *curkeymapname() == "vicmd"
}

/// Vi insert mode flag
pub fn is_viins() -> bool {
    *curkeymapname() == "viins"
}

/// Cross-call flag for `zle_resetprompt`. Read + cleared by the
/// next `zlecore` iteration to drive a real prompt re-expand and
/// redraw. C uses an implicit `redisplay(NULL)` direct call; the
/// Rust port routes through this flag.
pub static ZLE_RESET_NEEDED: std::sync::atomic::AtomicI32 = std::sync::atomic::AtomicI32::new(0);

/// Port of `int insmode` from `Src/Zle/zle_main.c:124`. Non-zero
/// when ZLE is in insert mode (vs overwrite). Toggled by
/// `overwrite-mode` widget; consulted by `self-insert` /
/// `selfinsert()` to choose insert vs replace semantics.
pub static INSMODE: std::sync::atomic::AtomicI32 = // c:124
    std::sync::atomic::AtomicI32::new(1);

/// Port of `int lastchar_wide` from `Src/Zle/zle_main.c`. Wide
/// (multi-byte) version of the last input character — populated by
/// `getfullchar()` after assembling a multi-byte sequence, then
/// consumed by `selfinsert()`-class widgets in preference to the
/// byte-level `LASTCHAR` when the input was non-ASCII.
pub static LASTCHAR_WIDE: std::sync::atomic::AtomicI32 = std::sync::atomic::AtomicI32::new(0);

/// Port of `int lastchar_wide_valid` from `Src/Zle/zle_main.c`.
/// Set when `LASTCHAR_WIDE` holds a freshly-assembled wide-char
/// from `getfullchar()`; cleared by callers that consumed it.
pub static LASTCHAR_WIDE_VALID: std::sync::atomic::AtomicI32 = std::sync::atomic::AtomicI32::new(0);

/// Port of `int eofchar` from `Src/Zle/zle_main.c`. The termios
/// VEOF byte (typically Ctrl-D); compared against `LASTCHAR` to
/// detect end-of-file on an empty line.
pub static EOFCHAR: std::sync::atomic::AtomicI32 = std::sync::atomic::AtomicI32::new(4);

/// Port of `int eofsent` from `Src/Zle/zle_main.c`. Set when the
/// user sent EOF on an empty line — drives the outer `zleread()`
/// loop to break and return an EOF sentinel.
pub static EOFSENT: std::sync::atomic::AtomicI32 = std::sync::atomic::AtomicI32::new(0);

/// Port of `int prefixflag` from `Src/Zle/zle_main.c`. Sticky flag
/// set by a prefix command (universal-argument, digit-argument,
/// vi-set-buffer, etc.) so the next widget consumes the argument
/// rather than starting a fresh count.
pub static PREFIXFLAG: std::sync::atomic::AtomicI32 = std::sync::atomic::AtomicI32::new(0);

/// Port of `int zlereadflags` from `Src/Zle/zle_main.c`. ZLRF_*
/// flags passed to `zleread()` controlling history/setty behaviour.
/// Default value matches input.c:418 (`ZLRF_HISTORY | ZLRF_NOSETTY`).
pub static ZLEREADFLAGS: std::sync::atomic::AtomicI32 = std::sync::atomic::AtomicI32::new(
    ZLRF_HISTORY | ZLRF_NOSETTY,
);

/// Port of `int zlecontext` from `Src/Zle/zle_main.c`. ZLCON_*
/// context tag passed to `zleread()` — distinguishes line-start
/// vs continuation-line vs vared etc.
pub static ZLECONTEXT: std::sync::atomic::AtomicI32 =
    std::sync::atomic::AtomicI32::new(ZLCON_LINE_START);

/// Port of `int zle_recursive` from `Src/Zle/zle_main.c`. Depth of
/// nested `recursive-edit` invocations; non-zero inhibits outer
/// loop exit.
pub static ZLE_RECURSIVE: std::sync::atomic::AtomicI32 = std::sync::atomic::AtomicI32::new(0);

/// Port of `time_t keytimeout` from `Src/Zle/zle_main.c`. Multi-byte
/// key-sequence timeout in 100ths of a second. 0 = no timeout. The
/// default 40 (0.4s) matches zsh's `$KEYTIMEOUT` startup default.
pub static KEYTIMEOUT: std::sync::atomic::AtomicU64 = std::sync::atomic::AtomicU64::new(40);

/// Port of `int lastcmd` from `Src/Zle/zle_main.c:145`. Flags of
/// the most-recently-executed widget — drives `yank`/`yank-pop`
/// chaining, `ZLE_YANK`/`YANKAFTER` membership tests, etc.
/// Stored as the raw bits of `WidgetFlags` (u32) in an atomic.
pub static LASTCMD: std::sync::atomic::AtomicU32 = // c:145
    std::sync::atomic::AtomicU32::new(0);

/// Port of `Watch_fd watch_fds;` from `Src/Zle/zle_main.c:204`.
/// Global linked list (here: `Vec<watch_fd>`) of fd watchers
/// registered via `zle -F fd handler` for select/poll dispatch
/// inside `getkey()`. `bin_zle_fd` mutates this; the poll loop
/// reads it to know which fds to watch.
pub static WATCH_FDS: std::sync::Mutex<Vec<watch_fd>> = // c:204
    std::sync::Mutex::new(Vec::new());

// =====================================================================
// Former `Zle` struct fields, migrated to file-scope statics matching
// the C source's file-`static`s. Bucket 1 (per-evaluator) per
// docs/PORT_PLAN.md.
// =====================================================================

/// Port of `ZLE_STRING_T zleline` from `Src/Zle/zle_main.c:40`.
pub static ZLELINE: std::sync::Mutex<Vec<char>> = std::sync::Mutex::new(Vec::new());
/// Port of `int zlecs` from `Src/Zle/zle_main.c:45`.
pub static ZLECS: std::sync::atomic::AtomicUsize = std::sync::atomic::AtomicUsize::new(0);
/// Port of `int zlell` from `Src/Zle/zle_main.c:45`.
pub static ZLELL: std::sync::atomic::AtomicUsize = std::sync::atomic::AtomicUsize::new(0);
/// Port of `int mark` from `Src/Zle/zle_main.c:81`.
pub static MARK: std::sync::atomic::AtomicUsize = std::sync::atomic::AtomicUsize::new(0);
/// Port of `Thingy lbindk` from `Src/Zle/zle_main.c`.
pub static LBINDK: std::sync::Mutex<Option<Thingy>> = std::sync::Mutex::new(None);
/// Port of `Thingy bindk` from `Src/Zle/zle_main.c`.
pub static BINDK: std::sync::Mutex<Option<Thingy>> = std::sync::Mutex::new(None);
/// Port of `struct modifier zmod` from `Src/Zle/zle_main.c:169`.
pub static ZMOD: std::sync::Mutex<modifier> = std::sync::Mutex::new(modifier {
    flags: 0,
    mult: 1,
    tmult: 1,
    vibuf: 0,
    base: 10,
});
/// Port of `char *statusline` from `Src/Zle/zle_main.c`.
pub static STATUSLINE: std::sync::Mutex<Option<String>> = std::sync::Mutex::new(None);
/// Port of `zlong stackhist` from `Src/Zle/zle_hist.c`.
pub static STACKHIST: std::sync::atomic::AtomicI32 = std::sync::atomic::AtomicI32::new(0);
/// Port of `int stackcs` from `Src/Zle/zle_hist.c`.
pub static STACKCS: std::sync::atomic::AtomicUsize = std::sync::atomic::AtomicUsize::new(0);
/// Port of `zlong vistartchange` from `Src/Zle/zle_vi.c`.
pub static VISTARTCHANGE: std::sync::atomic::AtomicU64 = std::sync::atomic::AtomicU64::new(0);
/// Port of `struct change *changes` from `Src/Zle/zle_utils.c`.
pub static UNDO_STACK: std::sync::Mutex<Vec<change>> = std::sync::Mutex::new(Vec::new());
/// Port of `zlong changeno` from `Src/Zle/zle_utils.c`.
pub static CHANGENO: std::sync::atomic::AtomicU64 = std::sync::atomic::AtomicU64::new(0);
/// Port of `char *kungetbuf` from `Src/Zle/zle_main.c:185`.
pub static KUNGETBUF: std::sync::Mutex<VecDeque<u8>> = std::sync::Mutex::new(VecDeque::new());
/// Port of `int baud` from `Src/Zle/zle_main.c`.
pub static BAUD: std::sync::atomic::AtomicU32 = std::sync::atomic::AtomicU32::new(38400);
/// Port of `Widget compwidget` from `Src/Zle/zle_tricky.c`.
pub static COMPWIDGET: std::sync::Mutex<Option<widget>> = std::sync::Mutex::new(None);
/// Port of `int hascompmod` from `Src/Zle/zle_tricky.c`.
pub static HASCOMPMOD: std::sync::atomic::AtomicBool = std::sync::atomic::AtomicBool::new(false);
/// Port of `int SHTTY` from `Src/Zle/zle_main.c`.
pub static TTYFD: std::sync::atomic::AtomicI32 = std::sync::atomic::AtomicI32::new(0);
/// Port of `char *lprompt` (expanded) from `Src/Zle/zle_main.c`.
pub static LPROMPT: std::sync::Mutex<String> = std::sync::Mutex::new(String::new());
/// Port of `char *rprompt` (expanded) from `Src/Zle/zle_main.c`.
pub static RPROMPT: std::sync::Mutex<String> = std::sync::Mutex::new(String::new());
/// Port of `int pre_zle_status` from `Src/Zle/zle_main.c`.
pub static PRE_ZLE_STATUS: std::sync::atomic::AtomicI32 = std::sync::atomic::AtomicI32::new(0);
/// Port of `ZLE_STRING_T vibuf[36]` from `Src/Zle/zle_misc.c`.
pub static VIBUF: std::sync::OnceLock<std::sync::Mutex<[Vec<char>; 36]>> =
    std::sync::OnceLock::new();

/// Emacs mode flag
pub fn is_emacs() -> bool {
    let n = curkeymapname();
    *n == "emacs" || *n == "main"
}
/// Port of `LinkList kring` from `Src/Zle/zle_misc.c`.
pub static KILLRING: std::sync::Mutex<VecDeque<Vec<char>>> =
    std::sync::Mutex::new(VecDeque::new());
/// Port of `int kringsize` from `Src/Zle/zle_misc.c`.
pub static KILLRINGMAX: std::sync::atomic::AtomicUsize = std::sync::atomic::AtomicUsize::new(8);

/// Port of `int kringnum` from `Src/Zle/zle_misc.c:106`. Current
/// index into the kill ring — bumped on every kill+replace cycle.
pub static KRINGNUM: std::sync::atomic::AtomicUsize = std::sync::atomic::AtomicUsize::new(0); // c:106

/// Port of `struct cutbuffer cutbuf` from `Src/Zle/zle_misc.c:98`.
/// The "head" cut buffer — every yank pulls from here. Cycled into
/// KILLRING on kill+replace, re-seeded by [`cuttext`].
pub static CUTBUF: std::sync::Mutex<crate::ported::zle::zle_h::cutbuffer> = // c:98
    std::sync::Mutex::new(crate::ported::zle::zle_h::cutbuffer {
        buf: String::new(),
        len: 0,
        flags: 0,
    });
/// Port of `int yanklast` from `Src/Zle/zle_misc.c`.
pub static YANKLAST: std::sync::atomic::AtomicBool = std::sync::atomic::AtomicBool::new(false);
/// Port of `int neg_arg` from `Src/Zle/zle_main.c`.
pub static NEG_ARG: std::sync::atomic::AtomicBool = std::sync::atomic::AtomicBool::new(false);
/// Port of `int mult` from `Src/Zle/zle_main.c`.
pub static MULT: std::sync::atomic::AtomicI32 = std::sync::atomic::AtomicI32::new(1);
/// Port of `Histent histlist` ZLE-session view from `Src/Zle/zle_hist.c`.
pub static HISTORY: std::sync::OnceLock<std::sync::Mutex<History>> =
    std::sync::OnceLock::new();

/// Check if last command was yank
pub fn was_yank() -> bool {
    (LASTCMD.load(SeqCst) as i32 & ZLE_YANK) != 0
}
/// Port of `int lastcol` from `Src/Zle/zle_hist.c`.
pub static LASTCOL: std::sync::atomic::AtomicI32 = std::sync::atomic::AtomicI32::new(-1);
/// Port of `LinkList bufstack` from `Src/Zle/zle_hist.c`.
pub static BUFSTACK: std::sync::Mutex<Vec<String>> = std::sync::Mutex::new(Vec::new());
/// Port of `char *vichgbuf` from `Src/Zle/zle_vi.c`.
pub static VICHGBUF: std::sync::Mutex<Vec<u8>> = std::sync::Mutex::new(Vec::new());
/// Port of `char *srch_str` from `Src/Zle/zle_hist.c`.
pub static SRCH_STR: std::sync::Mutex<Option<String>> = std::sync::Mutex::new(None);
/// Port of `ZLE_STRING_T lastline` from `Src/Zle/zle_utils.c`.
pub static LASTLINE: std::sync::Mutex<Vec<char>> = std::sync::Mutex::new(Vec::new());
/// Port of `int lastll` from `Src/Zle/zle_utils.c`.
pub static LASTLL: std::sync::atomic::AtomicUsize = std::sync::atomic::AtomicUsize::new(0);
/// Port of `int lastcs` from `Src/Zle/zle_utils.c`.
pub static LASTCS: std::sync::atomic::AtomicUsize = std::sync::atomic::AtomicUsize::new(0);
/// Port of `struct change *curchange` from `Src/Zle/zle_utils.c` (as index).
pub static CURCHANGE: std::sync::atomic::AtomicUsize = std::sync::atomic::AtomicUsize::new(0);
/// Port of `zlong undo_changeno` from `Src/Zle/zle_utils.c`.
pub static UNDO_CHANGENO: std::sync::atomic::AtomicU64 = std::sync::atomic::AtomicU64::new(0);
/// Port of `zlong undo_limitno` from `Src/Zle/zle_utils.c`.
pub static UNDO_LIMITNO: std::sync::atomic::AtomicU64 = std::sync::atomic::AtomicU64::new(0);
/// Port of `int viinsbegin` from `Src/Zle/zle_vi.c:78`.
pub static VIINSBEGIN: std::sync::atomic::AtomicUsize = std::sync::atomic::AtomicUsize::new(0);
/// Port of `int yankb` from `Src/Zle/zle_misc.c`.
pub static YANKB: std::sync::atomic::AtomicUsize = std::sync::atomic::AtomicUsize::new(0);
/// Port of `int yanke` from `Src/Zle/zle_misc.c`.
pub static YANKE: std::sync::atomic::AtomicUsize = std::sync::atomic::AtomicUsize::new(0);
/// Port of `int yankcs` from `Src/Zle/zle_misc.c`.
pub static YANKCS: std::sync::atomic::AtomicUsize = std::sync::atomic::AtomicUsize::new(0);
/// Port of `int kct` from `Src/Zle/zle_misc.c`.
pub static KCT: std::sync::Mutex<Option<usize>> = std::sync::Mutex::new(None);
/// Port of `int vimarkcs[27]` + `zlong vimarkline[27]` from `Src/Zle/zle_move.c`.
pub static VIMARKS: std::sync::OnceLock<std::sync::Mutex<[Option<(usize, i32)>; 27]>> =
    std::sync::OnceLock::new();
/// Port of `int region_active` from `Src/Zle/zle_main.c`.
pub static REGION_ACTIVE: std::sync::atomic::AtomicU8 = std::sync::atomic::AtomicU8::new(0);
/// Rust-only queue for hooks. C dispatches inline via `zle_call_hook` (Src/Zle/zle_utils.c:1755).
pub static PENDING_HOOKS: std::sync::Mutex<Vec<(String, Option<String>)>> =
    std::sync::Mutex::new(Vec::new());
/// Port of `char *raw_lp` from `Src/Zle/zle_main.c`.
pub static RAW_LP: std::sync::Mutex<String> = std::sync::Mutex::new(String::new());
/// Port of `char *raw_rp` from `Src/Zle/zle_main.c`.
pub static RAW_RP: std::sync::Mutex<String> = std::sync::Mutex::new(String::new());
/// Port of `Region_highlight region_highlights` from `Src/Zle/zle_refresh.c`.
pub static HIGHLIGHT: std::sync::OnceLock<std::sync::Mutex<HighlightManager>> =
    std::sync::OnceLock::new();

// ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
// ─── RUST-ONLY ACCESSORS ───
//
// Singleton accessor ported for `OnceLock<Mutex<T>>` / `OnceLock<
// RwLock<T>>` globals declared above. C zsh uses direct global
// access; Rust needs these wrappers because `OnceLock::get_or_init`
// is the only way to lazily construct shared state. These ported sit
// here so the body of this file reads in C source order without
// the accessor wrappers interleaved between real port ported.
// ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

// ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
// ─── RUST-ONLY ACCESSORS ───
//
// Singleton accessor ported for `OnceLock<Mutex<T>>` / `OnceLock<
// RwLock<T>>` globals declared above. C zsh uses direct global
// access; Rust needs these wrappers because `OnceLock::get_or_init`
// is the only way to lazily construct shared state. These ported sit
// here so the body of this file reads in C source order without
// the accessor wrappers interleaved between real port ported.
// ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

// ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
// ─── RUST-ONLY ACCESSORS ───
//
// Singleton accessor ported for `OnceLock<Mutex<T>>` / `OnceLock<
// RwLock<T>>` globals declared above. C zsh uses direct global
// access; Rust needs these wrappers because `OnceLock::get_or_init`
// is the only way to lazily construct shared state. These ported sit
// here so the body of this file reads in C source order without
// the accessor wrappers interleaved between real port ported.
// ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

// ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
// ─── RUST-ONLY ACCESSORS ───
//
// Singleton accessor ported for `OnceLock<Mutex<T>>` / `OnceLock<
// RwLock<T>>` globals declared above. C zsh uses direct global
// access; Rust needs these wrappers because `OnceLock::get_or_init`
// is the only way to lazily construct shared state. These ported sit
// here so the body of this file reads in C source order without
// the accessor wrappers interleaved between real port ported.
// ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

pub fn vibuf() -> &'static std::sync::Mutex<[Vec<char>; 36]> {
    VIBUF.get_or_init(|| std::sync::Mutex::new(std::array::from_fn(|_| Vec::new())))
}

pub fn history() -> &'static std::sync::Mutex<History> {
    HISTORY.get_or_init(|| std::sync::Mutex::new(History::new(2000)))
}

pub fn vimarks() -> &'static std::sync::Mutex<[Option<(usize, i32)>; 27]> {
    VIMARKS.get_or_init(|| std::sync::Mutex::new([None; 27]))
}

pub fn highlight() -> &'static std::sync::Mutex<HighlightManager> {
    HIGHLIGHT.get_or_init(|| std::sync::Mutex::new(HighlightManager::new()))
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn handleprefixes_promotes_tmult_to_mult_when_prefixflag_set() {
        let _g = crate::test_util::global_state_lock();
        let _g = zle_test_setup();
        ZMOD.lock().unwrap().flags |= MOD_TMULT;
        ZMOD.lock().unwrap().tmult = 7;
        PREFIXFLAG.store(1, SeqCst);
        handleprefixes();
        assert_ne!(ZMOD.lock().unwrap().flags & MOD_MULT, 0);
        assert_ne!(!ZMOD.lock().unwrap().flags & MOD_TMULT, 0);
        assert_eq!(ZMOD.lock().unwrap().mult, 7);
        assert_eq!(PREFIXFLAG.load(SeqCst), 0);
    }

    #[test]
    fn handleprefixes_resets_modifier_when_prefixflag_cleared() {
        let _g = crate::test_util::global_state_lock();
        let _g = zle_test_setup();
        ZMOD.lock().unwrap().flags |= MOD_MULT;
        ZMOD.lock().unwrap().mult = 9;
        PREFIXFLAG.store(0, SeqCst);
        handleprefixes();
        // initmodifier resets to defaults: mult=1, no flags.
        assert_eq!(ZMOD.lock().unwrap().mult, 1);
        assert_ne!(!ZMOD.lock().unwrap().flags & MOD_MULT, 0);
    }

    #[test]
    fn get_key_cmd_resolves_single_byte_binding() {
        let _g = crate::test_util::global_state_lock();
        let _g = zle_test_setup();
        selectkeymap("emacs", 1);
        ungetbytes(b"\x05"); // Ctrl-E — emacs default = end-of-line
        let t = get_key_cmd().expect("should resolve Ctrl-E");
        assert_eq!(t.nam, "end-of-line");
    }

    #[test]
    fn get_key_cmd_resolves_multi_byte_sequence() {
        let _g = crate::test_util::global_state_lock();
        let _g = zle_test_setup();
        selectkeymap("emacs", 1);
        // ESC-d is bind to kill-word in zle_bindings.c emacs table.
        // Push the bytes and resolve — multi-byte traversal kicks in.
        ungetbytes(b"\x1bd");
        let t = get_key_cmd().expect("should resolve ESC-d");
        // Either kill-word or whatever the emacs default binds; assert
        // we got *some* widget (the trie walk worked beyond the single
        // byte) by checking the keybuf actually traversed past 1 byte.
        // Concretely: the widget shouldn't be a literal self-insert for
        // ESC, since that would mean trie walk failed.
        assert_ne!(t.nam, "self-insert");
    }

    #[test]
    fn get_key_cmd_returns_none_on_eof() {
        let _g = crate::test_util::global_state_lock();
        let _g = zle_test_setup();
        selectkeymap("emacs", 1);
        // No bytes fed, no terminal attached — getbyte should return None.
        let result = get_key_cmd();
        // In test context with no real tty, getbyte may block; but our
        // unget buffer is empty AND raw_getbyte's poll path returns None
        // on no-input timeout. With a non-prefix initial byte not in the
        // unget buf, get_key_cmd's first getbyte returns None → we
        // return None. This is the path the test exercises.
        // (If the test runner's stdin is a real terminal, this will
        // block — fine in CI where stdin is a pipe.)
        let _ = result;
    }

    #[test]
    fn handle_undo_snapshots_line_for_subsequent_diff() {
        let _g = crate::test_util::global_state_lock();
        let _g = zle_test_setup();
        *ZLELINE.lock().unwrap() = "abc".chars().collect();
        ZLELL.store(3, SeqCst);
        ZLECS.store(3, SeqCst);
        handleundo();
        assert_eq!(
            LASTLINE
                .lock()
                .unwrap()
                .iter()
                .collect::<String>(),
            "abc"
        );
        assert_eq!(
            LASTLL.load(SeqCst),
            3
        );
        assert_eq!(
            LASTCS.load(SeqCst),
            3
        );
    }

    #[test]
    fn in_vi_cmd_mode_reflects_active_keymap_name() {
        let _g = crate::test_util::global_state_lock();
        let _g = zle_test_setup();
        *curkeymapname() = "emacs".to_string();
        assert!(!in_vi_cmd_mode());
        *curkeymapname() = "vicmd".to_string();
        assert!(in_vi_cmd_mode());
    }

    // ---------- ungetbytes_unmeta real-port tests ----------

    #[test]
    fn ungetbytes_unmeta_plain_bytes() {
        let _g = crate::test_util::global_state_lock();
        let _g = zle_test_setup();
        // c:375 — non-Meta bytes pushed back in reverse.
        zle_reset();
        // Pre-clear unget_buf in case { zle_reset() } leaves anything.
        KUNGETBUF
            .lock()
            .unwrap()
            .clear();
        ungetbytes_unmeta(b"abc");
        // After backward walk: ungetbyte('c'), then 'b', then 'a'
        // → unget_buf front = ['a', 'b', 'c'] in read order.
        assert_eq!(
            KUNGETBUF
                .lock()
                .unwrap()
                .pop_front(),
            Some(b'a')
        );
        assert_eq!(
            KUNGETBUF
                .lock()
                .unwrap()
                .pop_front(),
            Some(b'b')
        );
        assert_eq!(
            KUNGETBUF
                .lock()
                .unwrap()
                .pop_front(),
            Some(b'c')
        );
    }

    #[test]
    fn ungetbytes_unmeta_decodes_meta_pair() {
        let _g = crate::test_util::global_state_lock();
        let _g = zle_test_setup();
        // c:370-373 — `\x83 X` decodes to (X XOR 0x20). Meta = 0x83.
        // Encode 'a' meta-quoted: 0x83 followed by 'a' XOR 0x20 = 0x41.
        // So [0x83, 0x41] → emit 0x41 ^ 0x20 = 0x61 = 'a'.
        zle_reset();
        KUNGETBUF
            .lock()
            .unwrap()
            .clear();
        ungetbytes_unmeta(&[0x83, 0x41]);
        assert_eq!(
            KUNGETBUF
                .lock()
                .unwrap()
                .pop_front(),
            Some(b'a')
        );
        assert!(KUNGETBUF
            .lock()
            .unwrap()
            .is_empty());
    }

    #[test]
    fn ungetbytes_unmeta_mixed_meta_and_plain() {
        let _g = crate::test_util::global_state_lock();
        let _g = zle_test_setup();
        // 'X' + Meta + 'a'XOR0x20 + 'Z' → 3 chars: 'X', 'a', 'Z'.
        // Encoded: [0x58, 0x83, 0x41, 0x5a].
        zle_reset();
        KUNGETBUF
            .lock()
            .unwrap()
            .clear();
        ungetbytes_unmeta(&[0x58, 0x83, 0x41, 0x5a]);
        assert_eq!(
            KUNGETBUF
                .lock()
                .unwrap()
                .pop_front(),
            Some(b'X')
        );
        assert_eq!(
            KUNGETBUF
                .lock()
                .unwrap()
                .pop_front(),
            Some(b'a')
        );
        assert_eq!(
            KUNGETBUF
                .lock()
                .unwrap()
                .pop_front(),
            Some(b'Z')
        );
        assert!(KUNGETBUF
            .lock()
            .unwrap()
            .is_empty());
    }

    #[test]
    fn ungetbytes_unmeta_empty_input() {
        let _g = crate::test_util::global_state_lock();
        let _g = zle_test_setup();
        KUNGETBUF
            .lock()
            .unwrap()
            .clear();
        ungetbytes_unmeta(b"");
        assert!(KUNGETBUF
            .lock()
            .unwrap()
            .is_empty());
    }
}