xacli_core/io/output/

command.rs

use std::{
    fmt,
    io::{self, Write},
};

// ========== 基础类型定义 ==========

/// ANSI 颜色类型
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub enum Color {
    Black,
    Red,
    Green,
    Yellow,
    Blue,
    Magenta,
    Cyan,
    White,
    BrightBlack,
    BrightRed,
    BrightGreen,
    BrightYellow,
    BrightBlue,
    BrightMagenta,
    BrightCyan,
    BrightWhite,
    /// 8位颜色 (0-255)
    Indexed(u8),
    /// RGB 颜色 (r, g, b)
    Rgb(u8, u8, u8),
    /// 重置颜色
    Reset,
}

/// 文本属性
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub enum Attribute {
    Bold,
    Dim,
    Italic,
    Underline,
    SlowBlink,
    RapidBlink,
    Reverse,
    Hidden,
    Strikethrough,
}

/// 清除类型
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum ClearType {
    All,
    FromCursorDown,
    FromCursorUp,
    CurrentLine,
    UntilNewLine,
}

/// 鼠标按钮
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum MouseButton {
    Left,
    Right,
    Middle,
}

/// 鼠标事件类型
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum MouseEventKind {
    Down(MouseButton),
    Up(MouseButton),
    Drag(MouseButton),
    Move,
    ScrollUp,
    ScrollDown,
}

/// 鼠标事件
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct MouseEvent {
    pub kind: MouseEventKind,
    pub column: u16,
    pub row: u16,
    pub modifiers: Modifiers,
}

/// 修饰键
#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
pub struct Modifiers {
    pub shift: bool,
    pub control: bool,
    pub alt: bool,
    pub meta: bool,
}

/// 键盘按键
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub enum KeyCode {
    Char(char),
    Enter,
    Esc,
    Backspace,
    Tab,
    Space,
    Left,
    Right,
    Up,
    Down,
    Home,
    End,
    PageUp,
    PageDown,
    Delete,
    Insert,
    F(u8),
    Null,
    CapsLock,
    ScrollLock,
    NumLock,
    PrintScreen,
    Pause,
    Menu,
    KeypadBegin,
}

/// 键盘事件
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct KeyEvent {
    pub code: KeyCode,
    pub modifiers: Modifiers,
}

// ========== OutputCommand 枚举 ==========

/// 完整的终端控制命令枚举
#[derive(Debug, Clone)]
pub enum OutputCommand {
    // ========== 光标控制 ==========
    /// 移动光标到指定位置 (列, 行)，从 (1,1) 开始
    MoveTo(u16, u16),
    /// 光标上移 n 行
    MoveUp(u16),
    /// 光标下移 n 行
    MoveDown(u16),
    /// 光标左移 n 列
    MoveLeft(u16),
    /// 光标右移 n 列
    MoveRight(u16),
    /// 光标移动到下一行，列位置不变
    MoveToNextLine(u16),
    /// 光标移动到上一行，列位置不变
    MoveToPreviousLine(u16),
    /// 光标移动到指定列
    MoveToColumn(u16),
    /// 保存光标位置
    SavePosition,
    /// 恢复光标位置
    RestorePosition,
    /// 获取光标位置（返回 (列, 行)）
    GetPosition,
    /// 隐藏光标
    Hide,
    /// 显示光标
    Show,
    /// 启用光标闪烁
    EnableBlinking,
    /// 禁用光标闪烁
    DisableBlinking,
    /// 设置光标形状
    SetCursorStyle(CursorStyle),

    // ========== 文本输出 ==========
    /// 打印文本
    Print(String),
    /// 打印一行文本（自动换行）
    PrintLine(String),
    /// 打印带样式的文本
    PrintStyled(StyledText),

    // ========== 颜色和样式 ==========
    /// 设置前景色
    SetForegroundColor(Color),
    /// 设置背景色
    SetBackgroundColor(Color),
    /// 重置颜色（前景和背景）
    ResetColor,
    /// 同时设置前景和背景色
    SetColors(Color, Color),
    /// 设置文本属性
    SetAttribute(Attribute),
    /// 重置所有样式
    ResetAttributes,
    /// 启用/禁用自动换行
    SetLineWrap(bool),

    // ========== 终端控制 ==========
    /// 清除屏幕
    Clear(ClearType),
    /// 滚动屏幕
    ScrollUp(u16),
    ScrollDown(u16),
    /// 设置终端大小
    SetSize(u16, u16),
    /// 获取终端大小
    GetSize,
    /// 进入备用屏幕缓冲区
    EnterAlternateScreen,
    /// 退出备用屏幕缓冲区
    LeaveAlternateScreen,
    /// 设置终端标题
    SetTitle(String),
    /// 启用鼠标捕获
    EnableMouseCapture,
    /// 禁用鼠标捕获
    DisableMouseCapture,
    /// 启用焦点事件报告
    EnableFocusReporting,
    /// 禁用焦点事件报告
    DisableFocusReporting,

    // ========== 事件相关 ==========
    /// 推送键盘事件（用于模拟输入）
    PushKeyboardEvent(KeyEvent),
    /// 推送鼠标事件（用于模拟输入）
    PushMouseEvent(MouseEvent),

    // ========== 高级/组合命令 ==========
    /// 执行多个命令
    Batch(Vec<OutputCommand>),
    /// 条件执行
    If(bool, Box<OutputCommand>, Option<Box<OutputCommand>>),
    /// 循环执行
    Repeat(u32, Box<OutputCommand>),
}

/// 光标样式
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum CursorStyle {
    Default,
    BlinkingBlock,
    SteadyBlock,
    BlinkingUnderline,
    SteadyUnderline,
    BlinkingBar,
    SteadyBar,
}

/// 带样式的文本
#[derive(Debug, Clone)]
pub struct StyledText {
    pub text: String,
    pub foreground: Option<Color>,
    pub background: Option<Color>,
    pub attributes: Vec<Attribute>,
}

// ========== ANSI 转义序列实现 ==========

impl OutputCommand {
    /// 执行命令
    pub fn execute(&self, writer: &mut dyn Write) -> io::Result<()> {
        self.write_ansi(writer, true)
    }

    /// 排队命令（不立即刷新）
    pub fn queue(&self, writer: &mut dyn Write) -> io::Result<()> {
        self.write_ansi(writer, false)
    }

    /// 将命令写入 ANSI 序列
    fn write_ansi(&self, writer: &mut dyn Write, flush: bool) -> io::Result<()> {
        match self {
            // ========== 光标控制 ==========
            OutputCommand::MoveTo(col, row) => {
                // CSI n ; m H - 光标定位
                write!(writer, "\x1b[{};{}H", row, col)?;
            }
            OutputCommand::MoveUp(n) => {
                // CSI n A - 光标上移
                if *n > 0 {
                    write!(writer, "\x1b[{}A", n)?;
                }
            }
            OutputCommand::MoveDown(n) => {
                // CSI n B - 光标下移
                if *n > 0 {
                    write!(writer, "\x1b[{}B", n)?;
                }
            }
            OutputCommand::MoveLeft(n) => {
                // CSI n D - 光标左移
                if *n > 0 {
                    write!(writer, "\x1b[{}D", n)?;
                }
            }
            OutputCommand::MoveRight(n) => {
                // CSI n C - 光标右移
                if *n > 0 {
                    write!(writer, "\x1b[{}C", n)?;
                }
            }
            OutputCommand::MoveToNextLine(n) => {
                // CSI n E - 光标移动到下几行的开头
                if *n > 0 {
                    write!(writer, "\x1b[{}E", n)?;
                }
            }
            OutputCommand::MoveToPreviousLine(n) => {
                // CSI n F - 光标移动到上几行的开头
                if *n > 0 {
                    write!(writer, "\x1b[{}F", n)?;
                }
            }
            OutputCommand::MoveToColumn(col) => {
                // CSI n G - 光标移动到指定列
                write!(writer, "\x1b[{}G", col)?;
            }
            OutputCommand::SavePosition => {
                // ESC 7 - 保存光标位置
                write!(writer, "\x1b7")?;
            }
            OutputCommand::RestorePosition => {
                // ESC 8 - 恢复光标位置
                write!(writer, "\x1b8")?;
            }
            OutputCommand::GetPosition => {
                // CSI 6 n - 请求光标位置（终端会响应）
                write!(writer, "\x1b[6n")?;
            }
            OutputCommand::Hide => {
                // CSI ? 25 l - 隐藏光标
                write!(writer, "\x1b[?25l")?;
            }
            OutputCommand::Show => {
                // CSI ? 25 h - 显示光标
                write!(writer, "\x1b[?25h")?;
            }
            OutputCommand::EnableBlinking => {
                // CSI ? 12 h - 启用光标闪烁
                write!(writer, "\x1b[?12h")?;
            }
            OutputCommand::DisableBlinking => {
                // CSI ? 12 l - 禁用光标闪烁
                write!(writer, "\x1b[?12l")?;
            }
            OutputCommand::SetCursorStyle(style) => {
                // CSI Ps SP q - 设置光标样式
                let ps = match style {
                    CursorStyle::Default => 0,
                    CursorStyle::BlinkingBlock => 1,
                    CursorStyle::SteadyBlock => 2,
                    CursorStyle::BlinkingUnderline => 3,
                    CursorStyle::SteadyUnderline => 4,
                    CursorStyle::BlinkingBar => 5,
                    CursorStyle::SteadyBar => 6,
                };
                write!(writer, "\x1b[{} q", ps)?;
            }

            // ========== 文本输出 ==========
            OutputCommand::Print(text) => {
                write!(writer, "{}", text)?;
            }
            OutputCommand::PrintLine(text) => {
                write!(writer, "{}\r\n", text)?;
            }
            OutputCommand::PrintStyled(styled) => {
                // 应用样式
                if let Some(fg) = &styled.foreground {
                    Self::write_color(writer, fg, true)?;
                }
                if let Some(bg) = &styled.background {
                    Self::write_color(writer, bg, false)?;
                }
                for attr in &styled.attributes {
                    Self::write_attribute(writer, *attr, true)?;
                }

                // 写入文本
                write!(writer, "{}", styled.text)?;

                // 重置样式
                if !styled.attributes.is_empty() {
                    write!(writer, "\x1b[0m")?;
                }
            }

            // ========== 颜色和样式 ==========
            OutputCommand::SetForegroundColor(color) => {
                Self::write_color(writer, color, true)?;
            }
            OutputCommand::SetBackgroundColor(color) => {
                Self::write_color(writer, color, false)?;
            }
            OutputCommand::ResetColor => {
                // 重置颜色（前景色和背景色）
                write!(writer, "\x1b[39;49m")?;
            }
            OutputCommand::SetColors(fg, bg) => {
                Self::write_color(writer, fg, true)?;
                Self::write_color(writer, bg, false)?;
            }
            OutputCommand::SetAttribute(attr) => {
                Self::write_attribute(writer, *attr, true)?;
            }
            OutputCommand::ResetAttributes => {
                // 重置所有属性
                write!(writer, "\x1b[0m")?;
            }
            OutputCommand::SetLineWrap(enable) => {
                if *enable {
                    // CSI ? 7 h - 启用自动换行
                    write!(writer, "\x1b[?7h")?;
                } else {
                    // CSI ? 7 l - 禁用自动换行
                    write!(writer, "\x1b[?7l")?;
                }
            }

            // ========== 终端控制 ==========
            OutputCommand::Clear(clear_type) => {
                match clear_type {
                    ClearType::All => {
                        // CSI 2 J - 清除整个屏幕
                        write!(writer, "\x1b[2J")?;
                    }
                    ClearType::FromCursorDown => {
                        // CSI 0 J - 清除从光标到屏幕末尾
                        write!(writer, "\x1b[0J")?;
                    }
                    ClearType::FromCursorUp => {
                        // CSI 1 J - 清除从光标到屏幕开头
                        write!(writer, "\x1b[1J")?;
                    }
                    ClearType::CurrentLine => {
                        // CSI 2 K - 清除整行
                        write!(writer, "\x1b[2K")?;
                    }
                    ClearType::UntilNewLine => {
                        // CSI 0 K - 清除从光标到行尾
                        write!(writer, "\x1b[0K")?;
                    }
                }
            }
            OutputCommand::ScrollUp(lines) => {
                // CSI n S - 向上滚动 n 行
                if *lines > 0 {
                    write!(writer, "\x1b[{}S", lines)?;
                }
            }
            OutputCommand::ScrollDown(lines) => {
                // CSI n T - 向下滚动 n 行
                if *lines > 0 {
                    write!(writer, "\x1b[{}T", lines)?;
                }
            }
            OutputCommand::SetSize(cols, rows) => {
                // 大多数终端不支持动态调整大小
                // 但我们可以输出一个请求（不是所有终端都支持）
                write!(writer, "\x1b[8;{};{}t", rows, cols)?;
            }
            OutputCommand::GetSize => {
                // CSI 18 t - 获取终端大小
                write!(writer, "\x1b[18t")?;
            }
            OutputCommand::EnterAlternateScreen => {
                // CSI ? 1049 h - 进入备用屏幕缓冲区
                write!(writer, "\x1b[?1049h")?;
            }
            OutputCommand::LeaveAlternateScreen => {
                // CSI ? 1049 l - 退出备用屏幕缓冲区
                write!(writer, "\x1b[?1049l")?;
            }
            OutputCommand::SetTitle(title) => {
                // OSC 0 ; title BEL - 设置窗口标题
                write!(writer, "\x1b]0;{}\x07", title)?;
            }
            OutputCommand::EnableMouseCapture => {
                // CSI ? 1000 h - 启用鼠标报告
                write!(writer, "\x1b[?1000h")?;
                // CSI ? 1002 h - 启用鼠标拖动报告
                write!(writer, "\x1b[?1002h")?;
                // CSI ? 1006 h - 启用 SGR 扩展鼠标模式
                write!(writer, "\x1b[?1006h")?;
            }
            OutputCommand::DisableMouseCapture => {
                // CSI ? 1006 l - 禁用 SGR 扩展鼠标模式
                write!(writer, "\x1b[?1006l")?;
                // CSI ? 1002 l - 禁用鼠标拖动报告
                write!(writer, "\x1b[?1002l")?;
                // CSI ? 1000 l - 禁用鼠标报告
                write!(writer, "\x1b[?1000l")?;
            }
            OutputCommand::EnableFocusReporting => {
                // CSI ? 1004 h - 启用焦点事件报告
                write!(writer, "\x1b[?1004h")?;
            }
            OutputCommand::DisableFocusReporting => {
                // CSI ? 1004 l - 禁用焦点事件报告
                write!(writer, "\x1b[?1004l")?;
            }

            // ========== 事件相关 ==========
            OutputCommand::PushKeyboardEvent(event) => {
                // 键盘事件通常不能直接输出到终端
                // 这通常用于模拟或测试
                // 我们只是记录，不实际输出
                let _ = event;
            }
            OutputCommand::PushMouseEvent(event) => {
                // 同上，只是记录
                let _ = event;
            }

            // ========== 高级/组合命令 ==========
            OutputCommand::Batch(commands) => {
                for cmd in commands {
                    cmd.write_ansi(writer, false)?;
                }
            }
            OutputCommand::If(condition, then_cmd, else_cmd) => {
                if *condition {
                    then_cmd.write_ansi(writer, false)?;
                } else if let Some(else_cmd) = else_cmd {
                    else_cmd.write_ansi(writer, false)?;
                }
            }
            OutputCommand::Repeat(count, cmd) => {
                for _ in 0..*count {
                    cmd.write_ansi(writer, false)?;
                }
            }
        }

        if flush {
            writer.flush()?;
        }

        Ok(())
    }

    /// 写入颜色 ANSI 序列
    fn write_color(writer: &mut dyn Write, color: &Color, is_foreground: bool) -> io::Result<()> {
        let code = match color {
            Color::Black => {
                if is_foreground {
                    30
                } else {
                    40
                }
            }
            Color::Red => {
                if is_foreground {
                    31
                } else {
                    41
                }
            }
            Color::Green => {
                if is_foreground {
                    32
                } else {
                    42
                }
            }
            Color::Yellow => {
                if is_foreground {
                    33
                } else {
                    43
                }
            }
            Color::Blue => {
                if is_foreground {
                    34
                } else {
                    44
                }
            }
            Color::Magenta => {
                if is_foreground {
                    35
                } else {
                    45
                }
            }
            Color::Cyan => {
                if is_foreground {
                    36
                } else {
                    46
                }
            }
            Color::White => {
                if is_foreground {
                    37
                } else {
                    47
                }
            }
            Color::BrightBlack => {
                if is_foreground {
                    90
                } else {
                    100
                }
            }
            Color::BrightRed => {
                if is_foreground {
                    91
                } else {
                    101
                }
            }
            Color::BrightGreen => {
                if is_foreground {
                    92
                } else {
                    102
                }
            }
            Color::BrightYellow => {
                if is_foreground {
                    93
                } else {
                    103
                }
            }
            Color::BrightBlue => {
                if is_foreground {
                    94
                } else {
                    104
                }
            }
            Color::BrightMagenta => {
                if is_foreground {
                    95
                } else {
                    105
                }
            }
            Color::BrightCyan => {
                if is_foreground {
                    96
                } else {
                    106
                }
            }
            Color::BrightWhite => {
                if is_foreground {
                    97
                } else {
                    107
                }
            }
            Color::Indexed(n) => {
                if is_foreground {
                    write!(writer, "\x1b[38;5;{}m", n)?;
                    return Ok(());
                } else {
                    write!(writer, "\x1b[48;5;{}m", n)?;
                    return Ok(());
                }
            }
            Color::Rgb(r, g, b) => {
                if is_foreground {
                    write!(writer, "\x1b[38;2;{};{};{}m", r, g, b)?;
                    return Ok(());
                } else {
                    write!(writer, "\x1b[48;2;{};{};{}m", r, g, b)?;
                    return Ok(());
                }
            }
            Color::Reset => {
                if is_foreground {
                    write!(writer, "\x1b[39m")?;
                } else {
                    write!(writer, "\x1b[49m")?;
                }
                return Ok(());
            }
        };

        write!(writer, "\x1b[{}m", code)
    }

    /// 写入属性 ANSI 序列
    fn write_attribute(writer: &mut dyn Write, attr: Attribute, enable: bool) -> io::Result<()> {
        let code = match attr {
            Attribute::Bold => {
                if enable {
                    1
                } else {
                    22
                }
            }
            Attribute::Dim => {
                if enable {
                    2
                } else {
                    22
                }
            }
            Attribute::Italic => {
                if enable {
                    3
                } else {
                    23
                }
            }
            Attribute::Underline => {
                if enable {
                    4
                } else {
                    24
                }
            }
            Attribute::SlowBlink => {
                if enable {
                    5
                } else {
                    25
                }
            }
            Attribute::RapidBlink => {
                if enable {
                    6
                } else {
                    25
                }
            }
            Attribute::Reverse => {
                if enable {
                    7
                } else {
                    27
                }
            }
            Attribute::Hidden => {
                if enable {
                    8
                } else {
                    28
                }
            }
            Attribute::Strikethrough => {
                if enable {
                    9
                } else {
                    29
                }
            }
        };

        write!(writer, "\x1b[{}m", code)
    }

    // ========== 便利构造函数 ==========

    /// 创建打印命令
    pub fn print<S: Into<String>>(text: S) -> Self {
        OutputCommand::Print(text.into())
    }

    /// 创建打印行命令
    pub fn print_line<S: Into<String>>(text: S) -> Self {
        OutputCommand::PrintLine(text.into())
    }

    /// 创建移动光标命令
    pub fn move_to(col: u16, row: u16) -> Self {
        OutputCommand::MoveTo(col, row)
    }

    /// 创建清屏命令
    pub fn clear(clear_type: ClearType) -> Self {
        OutputCommand::Clear(clear_type)
    }

    /// 创建设置颜色命令
    pub fn set_colors(foreground: Color, background: Color) -> Self {
        OutputCommand::SetColors(foreground, background)
    }

    /// 创建批处理命令
    pub fn batch<I>(commands: I) -> Self
    where
        I: IntoIterator<Item = OutputCommand>,
    {
        OutputCommand::Batch(commands.into_iter().collect())
    }

    /// 创建条件命令
    pub fn if_then_else<C, T, E>(condition: bool, then_cmd: C, else_cmd: Option<E>) -> Self
    where
        C: Into<OutputCommand>,
        E: Into<OutputCommand>,
    {
        let then_box = Box::new(then_cmd.into());
        let else_box = else_cmd.map(|cmd| Box::new(cmd.into()));
        OutputCommand::If(condition, then_box, else_box)
    }

    /// 创建重复命令
    pub fn repeat<C>(count: u32, cmd: C) -> Self
    where
        C: Into<OutputCommand>,
    {
        OutputCommand::Repeat(count, Box::new(cmd.into()))
    }

    /// 创建带样式的文本
    pub fn styled_text<S, F, B, A>(
        text: S,
        foreground: Option<F>,
        background: Option<B>,
        attributes: A,
    ) -> StyledText
    where
        S: Into<String>,
        F: Into<Color>,
        B: Into<Color>,
        A: IntoIterator<Item = Attribute>,
    {
        StyledText {
            text: text.into(),
            foreground: foreground.map(|c| c.into()),
            background: background.map(|c| c.into()),
            attributes: attributes.into_iter().collect(),
        }
    }

    /// 从带样式的文本创建命令
    pub fn print_styled(styled: StyledText) -> Self {
        OutputCommand::PrintStyled(styled)
    }
}

// ========== 为 StyledText 实现方法 ==========

impl StyledText {
    /// 创建新的带样式文本
    pub fn new<S: Into<String>>(text: S) -> Self {
        StyledText {
            text: text.into(),
            foreground: None,
            background: None,
            attributes: Vec::new(),
        }
    }

    /// 设置前景色
    pub fn with_foreground(mut self, color: Color) -> Self {
        self.foreground = Some(color);
        self
    }

    /// 设置背景色
    pub fn with_background(mut self, color: Color) -> Self {
        self.background = Some(color);
        self
    }

    /// 添加属性
    pub fn with_attribute(mut self, attribute: Attribute) -> Self {
        self.attributes.push(attribute);
        self
    }

    /// 添加多个属性
    pub fn with_attributes<I>(mut self, attributes: I) -> Self
    where
        I: IntoIterator<Item = Attribute>,
    {
        self.attributes.extend(attributes);
        self
    }
}

// ========== 实现 Display trait ==========

impl fmt::Display for OutputCommand {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        match self {
            OutputCommand::MoveTo(col, row) => write!(f, "MoveTo({}, {})", col, row),
            OutputCommand::MoveUp(n) => write!(f, "MoveUp({})", n),
            OutputCommand::MoveDown(n) => write!(f, "MoveDown({})", n),
            OutputCommand::MoveLeft(n) => write!(f, "MoveLeft({})", n),
            OutputCommand::MoveRight(n) => write!(f, "MoveRight({})", n),
            OutputCommand::MoveToNextLine(n) => write!(f, "MoveToNextLine({})", n),
            OutputCommand::MoveToPreviousLine(n) => write!(f, "MoveToPreviousLine({})", n),
            OutputCommand::MoveToColumn(col) => write!(f, "MoveToColumn({})", col),
            OutputCommand::SavePosition => write!(f, "SavePosition"),
            OutputCommand::RestorePosition => write!(f, "RestorePosition"),
            OutputCommand::GetPosition => write!(f, "GetPosition"),
            OutputCommand::Hide => write!(f, "Hide"),
            OutputCommand::Show => write!(f, "Show"),
            OutputCommand::EnableBlinking => write!(f, "EnableBlinking"),
            OutputCommand::DisableBlinking => write!(f, "DisableBlinking"),
            OutputCommand::SetCursorStyle(style) => write!(f, "SetCursorStyle({:?})", style),

            OutputCommand::Print(text) => write!(f, "Print({:?})", text),
            OutputCommand::PrintLine(text) => write!(f, "PrintLine({:?})", text),
            OutputCommand::PrintStyled(styled) => write!(f, "PrintStyled({:?})", styled.text),

            OutputCommand::SetForegroundColor(color) => {
                write!(f, "SetForegroundColor({:?})", color)
            }
            OutputCommand::SetBackgroundColor(color) => {
                write!(f, "SetBackgroundColor({:?})", color)
            }
            OutputCommand::ResetColor => write!(f, "ResetColor"),
            OutputCommand::SetColors(fg, bg) => write!(f, "SetColors({:?}, {:?})", fg, bg),
            OutputCommand::SetAttribute(attr) => write!(f, "SetAttribute({:?})", attr),
            OutputCommand::ResetAttributes => write!(f, "ResetAttributes"),
            OutputCommand::SetLineWrap(enable) => write!(f, "SetLineWrap({})", enable),

            OutputCommand::Clear(clear_type) => write!(f, "Clear({:?})", clear_type),
            OutputCommand::ScrollUp(lines) => write!(f, "ScrollUp({})", lines),
            OutputCommand::ScrollDown(lines) => write!(f, "ScrollDown({})", lines),
            OutputCommand::SetSize(cols, rows) => write!(f, "SetSize({}, {})", cols, rows),
            OutputCommand::GetSize => write!(f, "GetSize"),
            OutputCommand::EnterAlternateScreen => write!(f, "EnterAlternateScreen"),
            OutputCommand::LeaveAlternateScreen => write!(f, "LeaveAlternateScreen"),
            OutputCommand::SetTitle(title) => write!(f, "SetTitle({:?})", title),
            OutputCommand::EnableMouseCapture => write!(f, "EnableMouseCapture"),
            OutputCommand::DisableMouseCapture => write!(f, "DisableMouseCapture"),
            OutputCommand::EnableFocusReporting => write!(f, "EnableFocusReporting"),
            OutputCommand::DisableFocusReporting => write!(f, "DisableFocusReporting"),

            OutputCommand::PushKeyboardEvent(event) => write!(f, "PushKeyboardEvent({:?})", event),
            OutputCommand::PushMouseEvent(event) => write!(f, "PushMouseEvent({:?})", event),

            OutputCommand::Batch(commands) => write!(f, "Batch[{} commands]", commands.len()),
            OutputCommand::If(cond, then_cmd, else_cmd) => {
                if let Some(else_cmd) = else_cmd {
                    write!(f, "If({}, {:?}, {:?})", cond, then_cmd, else_cmd)
                } else {
                    write!(f, "If({}, {:?})", cond, then_cmd)
                }
            }
            OutputCommand::Repeat(count, cmd) => write!(f, "Repeat({}, {:?})", count, cmd),
        }
    }
}

impl fmt::Display for Color {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        match self {
            Color::Black => write!(f, "Black"),
            Color::Red => write!(f, "Red"),
            Color::Green => write!(f, "Green"),
            Color::Yellow => write!(f, "Yellow"),
            Color::Blue => write!(f, "Blue"),
            Color::Magenta => write!(f, "Magenta"),
            Color::Cyan => write!(f, "Cyan"),
            Color::White => write!(f, "White"),
            Color::BrightBlack => write!(f, "BrightBlack"),
            Color::BrightRed => write!(f, "BrightRed"),
            Color::BrightGreen => write!(f, "BrightGreen"),
            Color::BrightYellow => write!(f, "BrightYellow"),
            Color::BrightBlue => write!(f, "BrightBlue"),
            Color::BrightMagenta => write!(f, "BrightMagenta"),
            Color::BrightCyan => write!(f, "BrightCyan"),
            Color::BrightWhite => write!(f, "BrightWhite"),
            Color::Indexed(n) => write!(f, "Indexed({})", n),
            Color::Rgb(r, g, b) => write!(f, "Rgb({}, {}, {})", r, g, b),
            Color::Reset => write!(f, "Reset"),
        }
    }
}

impl fmt::Display for Attribute {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        match self {
            Attribute::Bold => write!(f, "Bold"),
            Attribute::Dim => write!(f, "Dim"),
            Attribute::Italic => write!(f, "Italic"),
            Attribute::Underline => write!(f, "Underline"),
            Attribute::SlowBlink => write!(f, "SlowBlink"),
            Attribute::RapidBlink => write!(f, "RapidBlink"),
            Attribute::Reverse => write!(f, "Reverse"),
            Attribute::Hidden => write!(f, "Hidden"),
            Attribute::Strikethrough => write!(f, "Strikethrough"),
        }
    }
}

impl fmt::Display for ClearType {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        match self {
            ClearType::All => write!(f, "All"),
            ClearType::FromCursorDown => write!(f, "FromCursorDown"),
            ClearType::FromCursorUp => write!(f, "FromCursorUp"),
            ClearType::CurrentLine => write!(f, "CurrentLine"),
            ClearType::UntilNewLine => write!(f, "UntilNewLine"),
        }
    }
}