codei_tui/

app.rs

use std::io;
use std::sync::{Arc, RwLock};
use std::time::{Duration, Instant};

use anyhow::Result;
use codei_agent::{AgentError, AgentEvent, AgentLoop};
use codei_commands::{filter_slash_hints, parse_input, Input, SlashCommand, SlashHint};
use codei_config::ResolvedConfig;
use codei_i18n::{t, t_fmt};
use codei_llm::Usage;
use codei_session::{Session, SessionStore};
use codei_tools::{handler_for_policy, ApprovalPolicy, SharedApprovalGate, ToolContext};
use crossterm::event::{
    self, DisableBracketedPaste, EnableBracketedPaste, Event, KeyCode, KeyEvent, KeyModifiers,
    KeyboardEnhancementFlags, PopKeyboardEnhancementFlags, PushKeyboardEnhancementFlags,
};
use crossterm::terminal::{
    disable_raw_mode, enable_raw_mode, EnterAlternateScreen, LeaveAlternateScreen,
};
use crossterm::ExecutableCommand;
use ratatui::layout::{Constraint, Direction, Layout, Margin, Rect};
use ratatui::style::{Color, Modifier, Style};
use ratatui::text::{Line, Span, Text};
use ratatui::widgets::{
    Block, Borders, Clear, List, ListItem, Paragraph, Scrollbar, ScrollbarOrientation,
    ScrollbarState, Wrap,
};
use ratatui::DefaultTerminal;
use tokio::sync::{mpsc, Mutex};
use tokio::task::JoinHandle;
use unicode_width::UnicodeWidthStr;

use crate::clipboard::copy_to_clipboard;
use crate::launch::InteractiveLaunch;
use crate::slash::{handle_slash, SlashAction, SlashContext};

const INPUT_MIN_HEIGHT: u16 = 3;
const INPUT_MAX_HEIGHT: u16 = 10;
const INPUT_HISTORY_LIMIT: usize = 200;

struct InputHistory {
    entries: Vec<String>,
    browse_index: Option<usize>,
    draft: Option<String>,
}

impl InputHistory {
    fn new() -> Self {
        Self {
            entries: Vec::new(),
            browse_index: None,
            draft: None,
        }
    }

    fn push(&mut self, line: String) {
        if line.trim().is_empty() {
            return;
        }
        if self.entries.last() != Some(&line) {
            self.entries.push(line);
            if self.entries.len() > INPUT_HISTORY_LIMIT {
                self.entries.remove(0);
            }
        }
        self.browse_index = None;
        self.draft = None;
    }

    fn browse_older(&mut self, current_input: &str) -> Option<String> {
        if self.entries.is_empty() {
            return None;
        }
        match self.browse_index {
            None => {
                self.draft = Some(current_input.to_string());
                let idx = self.entries.len() - 1;
                self.browse_index = Some(idx);
                Some(self.entries[idx].clone())
            }
            Some(0) => None,
            Some(i) => {
                let idx = i - 1;
                self.browse_index = Some(idx);
                Some(self.entries[idx].clone())
            }
        }
    }

    fn browse_newer(&mut self) -> Option<String> {
        let i = self.browse_index?;
        if i + 1 < self.entries.len() {
            let idx = i + 1;
            self.browse_index = Some(idx);
            Some(self.entries[idx].clone())
        } else {
            self.browse_index = None;
            Some(self.draft.take().unwrap_or_default())
        }
    }

    fn clear_browse(&mut self) {
        self.browse_index = None;
        self.draft = None;
    }
}

struct ChatLine {
    text: String,
    style: Style,
}

pub struct TuiOptions {
    pub auto_approve: bool,
}

pub async fn run_tui(launch: InteractiveLaunch, opts: TuiOptions) -> Result<()> {
    let InteractiveLaunch {
        config,
        provider,
        provider_name,
        model,
        session,
        store,
        mcp,
    } = launch;
    let approval_gate = Arc::new(SharedApprovalGate::new());
    let approval: Arc<dyn codei_tools::ApprovalHandler> = if opts.auto_approve {
        Arc::from(handler_for_policy(ApprovalPolicy::Never))
    } else {
        Arc::from(approval_gate.handler())
    };

    let (tx, rx) = mpsc::unbounded_channel();
    let tool_ctx = ToolContext {
        cwd: config.cwd.clone(),
        config: Arc::clone(&config),
        approval,
    };
    let provider_name = Arc::new(RwLock::new(provider_name));
    let agent = Arc::new(AgentLoop::new(
        Arc::clone(&config),
        Arc::clone(&model),
        provider,
        provider_name.read().expect("provider lock").clone(),
        tool_ctx,
        mcp,
        Some(tx),
    ));

    let mut stdout = io::stdout();
    enable_raw_mode()?;
    stdout.execute(EnableBracketedPaste)?;
    stdout.execute(PushKeyboardEnhancementFlags(
        KeyboardEnhancementFlags::DISAMBIGUATE_ESCAPE_CODES,
    ))?;
    stdout.execute(EnterAlternateScreen)?;
    let mut terminal = ratatui::init();

    let mut state = AppState {
        lines: vec![ChatLine {
            text: codei_i18n::t("app_tagline"),
            style: Style::default().fg(Color::Cyan),
        }],
        input: String::new(),
        model_name: model.read().expect("model lock").clone(),
        provider_label: provider_name.read().expect("provider lock").clone(),
        status: t("tui_status_idle"),
        assistant_buf: String::new(),
        running: false,
        pending_approval: None,
        turn_task: None,
        chat_scroll: 0,
        chat_follow_bottom: true,
        cursor_visible: true,
        last_blink: Instant::now(),
        completion_index: 0,
        slash_completion_dismissed: false,
        pending_quit: false,
        token_usage: Usage::default(),
        last_turn_usage: None,
        input_history: InputHistory::new(),
        input_cursor: 0,
        pending_cancel: false,
    };

    let mut runtime = AppRuntime {
        agent,
        session: Arc::new(Mutex::new(session)),
        store: Arc::new(store),
        config,
        model,
        provider_name,
        approval_gate,
        rx,
    };

    let result = run_app(&mut terminal, &mut runtime, &mut state).await;

    disable_raw_mode()?;
    let _ = stdout.execute(DisableBracketedPaste);
    let _ = stdout.execute(PopKeyboardEnhancementFlags);
    stdout.execute(LeaveAlternateScreen)?;
    ratatui::restore();

    result
}

struct AppRuntime {
    agent: Arc<AgentLoop>,
    session: Arc<Mutex<Session>>,
    store: Arc<SessionStore>,
    config: Arc<ResolvedConfig>,
    model: Arc<RwLock<String>>,
    provider_name: Arc<RwLock<String>>,
    approval_gate: Arc<SharedApprovalGate>,
    rx: mpsc::UnboundedReceiver<AgentEvent>,
}

struct AppState {
    lines: Vec<ChatLine>,
    input: String,
    model_name: String,
    provider_label: String,
    status: String,
    assistant_buf: String,
    running: bool,
    pending_approval: Option<codei_tools::ApprovalRequest>,
    turn_task: Option<JoinHandle<Result<codei_agent::TurnOutcome, AgentError>>>,
    chat_scroll: u16,
    chat_follow_bottom: bool,
    cursor_visible: bool,
    last_blink: Instant,
    completion_index: usize,
    slash_completion_dismissed: bool,
    pending_quit: bool,
    token_usage: Usage,
    last_turn_usage: Option<Usage>,
    input_history: InputHistory,
    input_cursor: usize,
    pending_cancel: bool,
}

async fn run_app(
    terminal: &mut DefaultTerminal,
    runtime: &mut AppRuntime,
    state: &mut AppState,
) -> Result<()> {
    loop {
        poll_turn_task(state).await;

        while let Ok(event) = runtime.rx.try_recv() {
            match event {
                AgentEvent::AssistantDelta { text } => {
                    state.assistant_buf.push_str(&text);
                    if let Some(last) = state.lines.last_mut() {
                        if last.style == Style::default() {
                            last.text.push_str(&text);
                            continue;
                        }
                    }
                    state.lines.push(ChatLine {
                        text: text.clone(),
                        style: Style::default(),
                    });
                }
                AgentEvent::ToolStarted { name, args } => {
                    flush_assistant(&mut state.lines, &mut state.assistant_buf);
                    state.lines.push(ChatLine {
                        text: format!("[tool:{name}] {args}"),
                        style: Style::default().fg(Color::Yellow),
                    });
                }
                AgentEvent::ToolFinished { name, result } => {
                    let prefix = if result.is_error {
                        t("tui_tool_status_error")
                    } else {
                        t("tui_tool_status_ok")
                    };
                    state.lines.push(ChatLine {
                        text: format!("[tool:{name}:{prefix}] {}", truncate(&result.content, 200)),
                        style: Style::default().fg(Color::DarkGray),
                    });
                }
                AgentEvent::TurnComplete { usage } => {
                    flush_assistant(&mut state.lines, &mut state.assistant_buf);
                    if let Some(u) = usage {
                        state.token_usage.add_assign(u);
                        state.last_turn_usage = Some(u);
                    }
                    state.status = t("tui_status_idle");
                    state.running = false;
                    state.turn_task = None;
                }
                AgentEvent::Error { message } => {
                    state.lines.push(ChatLine {
                        text: t_fmt("tui_error_prefix", &[("message", &message)]),
                        style: Style::default().fg(Color::Red),
                    });
                    state.status = t("tui_status_error");
                    state.running = false;
                    state.turn_task = None;
                }
            }
        }

        if state.pending_approval.is_none() {
            state.pending_approval = runtime.approval_gate.take_pending().await;
        }

        if state.last_blink.elapsed() >= Duration::from_millis(530) {
            state.cursor_visible = !state.cursor_visible;
            state.last_blink = Instant::now();
        }

        let raw_slash_hints = if state.input.contains('\n') {
            Vec::new()
        } else {
            filter_slash_hints(&state.input)
        };
        let slash_hints = if state.slash_completion_dismissed {
            Vec::new()
        } else {
            raw_slash_hints.clone()
        };
        if slash_hints.is_empty() {
            state.completion_index = 0;
        } else if state.completion_index >= slash_hints.len() {
            state.completion_index = slash_hints.len().saturating_sub(1);
        }

        terminal.draw(|frame| {
            let completion_rows = if slash_hints.is_empty() {
                0
            } else {
                slash_hints.len().min(6) as u16 + 2
            };

            let input_height = input_box_height(&state.input);

            let mut constraints = vec![
                Constraint::Min(5),
                Constraint::Length(input_height),
                Constraint::Length(1),
            ];
            if completion_rows > 0 {
                constraints.insert(1, Constraint::Length(completion_rows));
            }

            let chunks = Layout::default()
                .direction(Direction::Vertical)
                .constraints(constraints)
                .split(frame.area());

            let chat_area = chunks[0];
            let (input_idx, status_idx) = if completion_rows > 0 { (2, 3) } else { (1, 2) };

            let wrapped_lines = wrap_chat_lines(&state.lines, chat_area.width.saturating_sub(2));
            let visible_height = chat_area.height.saturating_sub(2) as usize;
            let total_lines = wrapped_lines.len();
            let max_scroll = total_lines.saturating_sub(visible_height) as u16;
            if state.chat_follow_bottom {
                state.chat_scroll = max_scroll;
            } else {
                state.chat_scroll = state.chat_scroll.min(max_scroll);
                state.chat_follow_bottom = state.chat_scroll >= max_scroll;
            }

            let chat_widget = Paragraph::new(wrapped_lines)
                .wrap(Wrap { trim: false })
                .scroll((state.chat_scroll, 0))
                .block(Block::default().borders(Borders::ALL).title(t_fmt(
                    "tui_chat_title",
                    &[
                        ("provider", &state.provider_label),
                        ("model", &state.model_name),
                        ("cwd", &runtime.config.cwd.display().to_string()),
                    ],
                )));
            frame.render_widget(chat_widget, chat_area);

            if total_lines > visible_height {
                let scrollbar = Scrollbar::new(ScrollbarOrientation::VerticalRight)
                    .begin_symbol(Some("↑"))
                    .end_symbol(Some("↓"));
                let mut scrollbar_state = ScrollbarState::new(total_lines)
                    .position(state.chat_scroll as usize)
                    .viewport_content_length(visible_height);
                frame.render_stateful_widget(
                    scrollbar,
                    chat_area.inner(Margin {
                        vertical: 1,
                        horizontal: 0,
                    }),
                    &mut scrollbar_state,
                );
            }

            if completion_rows > 0 {
                render_slash_completions(frame, chunks[1], &slash_hints, state.completion_index);
            }

            let input_area = chunks[input_idx];
            let input_title = if state.pending_cancel {
                t("tui_input_cancel")
            } else if state.pending_quit {
                t("tui_input_quit")
            } else if state.pending_approval.is_some() {
                t("tui_input_approval")
            } else if state.running {
                t("tui_input_running")
            } else {
                t("tui_input_normal")
            };
            let input_widget = Paragraph::new(input_display_text(&state.input))
                .block(Block::default().borders(Borders::ALL).title(input_title));
            frame.render_widget(input_widget, input_area);

            if state.cursor_visible
                && !state.running
                && state.pending_approval.is_none()
                && !state.pending_quit
                && !state.pending_cancel
                && input_area.width > 2
            {
                let (cursor_x, cursor_y) =
                    input_cursor_pos(&state.input, state.input_cursor, input_area);
                frame.set_cursor_position((cursor_x, cursor_y));
            }

            let status_line = Paragraph::new(t_fmt(
                "tui_status_bar",
                &[
                    ("status", &state.status),
                    (
                        "session",
                        &runtime
                            .session
                            .try_lock()
                            .map(|s| s.id.clone())
                            .unwrap_or_else(|_| "?".into()),
                    ),
                    ("input_tokens", &state.token_usage.input_tokens.to_string()),
                    (
                        "output_tokens",
                        &state.token_usage.output_tokens.to_string(),
                    ),
                ],
            ));
            frame.render_widget(status_line, chunks[status_idx]);

            if let Some(req) = &state.pending_approval {
                render_approval_modal(frame, frame.area(), req);
            } else if state.pending_cancel {
                render_cancel_modal(frame, frame.area());
            } else if state.pending_quit {
                render_quit_modal(frame, frame.area());
            }
        })?;

        if event::poll(Duration::from_millis(50))? {
            match event::read()? {
                Event::Paste(text)
                    if !state.running
                        && state.pending_approval.is_none()
                        && !state.pending_quit
                        && !state.pending_cancel =>
                {
                    insert_input_text(state, &text);
                    continue;
                }
                Event::Key(key) => {
                    if key.modifiers.contains(KeyModifiers::CONTROL)
                        && key.code == KeyCode::Char('c')
                    {
                        if state.pending_approval.is_some() {
                            runtime.approval_gate.respond(false).await;
                            state.pending_approval = None;
                        } else if state.pending_cancel {
                            cancel_running_turn(state);
                        } else if state.running {
                            state.pending_cancel = true;
                        } else if state.pending_quit {
                            break;
                        } else {
                            state.pending_quit = true;
                        }
                        continue;
                    }

                    if state.pending_cancel {
                        match key.code {
                            KeyCode::Char('y') | KeyCode::Char('Y') | KeyCode::Enter => {
                                cancel_running_turn(state);
                            }
                            KeyCode::Char('n') | KeyCode::Char('N') | KeyCode::Esc => {
                                state.pending_cancel = false;
                            }
                            _ => {}
                        }
                        continue;
                    }

                    if state.pending_quit {
                        match key.code {
                            KeyCode::Char('y') | KeyCode::Char('Y') | KeyCode::Enter => break,
                            KeyCode::Char('n') | KeyCode::Char('N') | KeyCode::Esc => {
                                state.pending_quit = false;
                            }
                            _ => {}
                        }
                        continue;
                    }

                    if state.pending_approval.is_some() {
                        match key.code {
                            KeyCode::Char('y') | KeyCode::Char('Y') => {
                                runtime.approval_gate.respond(true).await;
                                state.pending_approval = None;
                            }
                            KeyCode::Char('a') | KeyCode::Char('A') => {
                                runtime.approval_gate.approve_always().await;
                                state.pending_approval = None;
                            }
                            KeyCode::Char('n') | KeyCode::Char('N') | KeyCode::Esc => {
                                runtime.approval_gate.respond(false).await;
                                state.pending_approval = None;
                            }
                            _ => {}
                        }
                        continue;
                    }

                    if state.running {
                        continue;
                    }

                    if !raw_slash_hints.is_empty() && !state.slash_completion_dismissed {
                        match key.code {
                            KeyCode::Up => {
                                state.completion_index = state.completion_index.saturating_sub(1);
                                continue;
                            }
                            KeyCode::Down => {
                                state.completion_index = (state.completion_index + 1)
                                    .min(raw_slash_hints.len().saturating_sub(1));
                                continue;
                            }
                            KeyCode::Tab => {
                                apply_slash_completion(
                                    state,
                                    raw_slash_hints[state.completion_index],
                                );
                                continue;
                            }
                            KeyCode::Esc => {
                                state.slash_completion_dismissed = true;
                                state.completion_index = 0;
                                continue;
                            }
                            _ => {}
                        }
                    }

                    match key.code {
                        KeyCode::Up => {
                            if let Some(text) = state.input_history.browse_older(&state.input) {
                                mark_input_edited(state);
                                state.input = text;
                                state.input_cursor = state.input.len();
                            }
                            continue;
                        }
                        KeyCode::Down => {
                            if let Some(text) = state.input_history.browse_newer() {
                                mark_input_edited(state);
                                state.input = text;
                                state.input_cursor = state.input.len();
                            }
                            continue;
                        }
                        KeyCode::Left => {
                            state.input_cursor =
                                prev_char_boundary(&state.input, state.input_cursor);
                            continue;
                        }
                        KeyCode::Right => {
                            state.input_cursor =
                                next_char_boundary(&state.input, state.input_cursor);
                            continue;
                        }
                        KeyCode::PageUp => {
                            scroll_chat(state, -3);
                            continue;
                        }
                        KeyCode::PageDown => {
                            scroll_chat(state, 3);
                            continue;
                        }
                        KeyCode::Home => {
                            state.chat_scroll = 0;
                            state.chat_follow_bottom = false;
                            continue;
                        }
                        KeyCode::End => {
                            state.chat_follow_bottom = true;
                            continue;
                        }
                        KeyCode::Esc => {
                            if !state.input.is_empty() {
                                state.input.clear();
                                state.input_cursor = 0;
                                state.completion_index = 0;
                                state.slash_completion_dismissed = false;
                                state.input_history.clear_browse();
                            }
                            continue;
                        }
                        KeyCode::Char('y') | KeyCode::Char('Y')
                            if key.modifiers.contains(KeyModifiers::CONTROL)
                                && key.modifiers.contains(KeyModifiers::SHIFT) =>
                        {
                            copy_chat_with_status(state, CopyScope::All);
                            continue;
                        }
                        KeyCode::Char('l') | KeyCode::Char('L')
                            if key.modifiers.contains(KeyModifiers::CONTROL)
                                && key.modifiers.contains(KeyModifiers::SHIFT) =>
                        {
                            copy_chat_with_status(state, CopyScope::LastAssistant);
                            continue;
                        }
                        KeyCode::Enter if key_inserts_newline(&key) => {
                            insert_newline_at_cursor(state);
                        }
                        KeyCode::Enter => {
                            let line = std::mem::take(&mut state.input);
                            state.input_cursor = 0;
                            state.completion_index = 0;
                            state.input_history.clear_browse();
                            if line.trim().is_empty() {
                                continue;
                            }
                            state.input_history.push(line.clone());
                            state.chat_follow_bottom = true;
                            state.lines.push(ChatLine {
                                text: format_user_prompt(&line),
                                style: Style::default().fg(Color::Green),
                            });

                            match parse_input(&line) {
                                Input::SlashCommand(SlashCommand::Copy) => {
                                    copy_chat_with_status(state, CopyScope::All);
                                }
                                Input::SlashCommand(SlashCommand::CopyLast) => {
                                    copy_chat_with_status(state, CopyScope::LastAssistant);
                                }
                                Input::SlashCommand(cmd) => {
                                    let mut session = runtime.session.lock().await;
                                    let mut ctx = SlashContext {
                                        session: &mut session,
                                        store: &runtime.store,
                                        model: &runtime.model,
                                        provider_name: &runtime.provider_name,
                                        agent: runtime.agent.as_ref(),
                                        token_usage: &mut state.token_usage,
                                        last_turn_usage: &mut state.last_turn_usage,
                                    };
                                    match handle_slash(cmd, &mut ctx).await? {
                                        SlashAction::Exit => break,
                                        SlashAction::Message(text) => state.lines.push(ChatLine {
                                            text,
                                            style: Style::default().fg(Color::Cyan),
                                        }),
                                        SlashAction::Continue => {}
                                    }
                                    state.model_name =
                                        runtime.model.read().expect("model lock").clone();
                                    state.provider_label = runtime
                                        .provider_name
                                        .read()
                                        .expect("provider lock")
                                        .clone();
                                }
                                Input::UserMessage(msg) => {
                                    start_agent_turn(runtime, state, msg);
                                }
                            }
                        }
                        KeyCode::Backspace => backspace_at_cursor(state),
                        KeyCode::Delete => delete_at_cursor(state),
                        KeyCode::Char(c) => {
                            if key.modifiers.contains(KeyModifiers::CONTROL) {
                                if c == 'h' || c == '\x08' {
                                    backspace_at_cursor(state);
                                } else if c == 'j' {
                                    insert_newline_at_cursor(state);
                                }
                                continue;
                            }
                            if c == '\x7f' {
                                backspace_at_cursor(state);
                                continue;
                            }
                            if c == '\n' {
                                insert_newline_at_cursor(state);
                                continue;
                            }
                            if !c.is_control() {
                                insert_char_at_cursor(state, c);
                            }
                        }
                        _ => {}
                    }
                }
                _ => {}
            }
        } else if state.running {
            tokio::task::yield_now().await;
        }
    }

    Ok(())
}

fn start_agent_turn(runtime: &AppRuntime, state: &mut AppState, msg: String) {
    state.status = t("tui_status_running");
    state.running = true;
    state.chat_follow_bottom = true;
    state.assistant_buf.clear();
    state.lines.push(ChatLine {
        text: String::new(),
        style: Style::default(),
    });

    let agent = Arc::clone(&runtime.agent);
    let session = Arc::clone(&runtime.session);
    let store = Arc::clone(&runtime.store);

    state.turn_task = Some(tokio::spawn(async move {
        let mut session = session.lock().await;
        agent.run_turn(&mut session, &msg, &store).await
    }));
}

async fn poll_turn_task(state: &mut AppState) {
    let finished = state
        .turn_task
        .as_ref()
        .is_some_and(|task| task.is_finished());
    if !finished {
        return;
    }
    let Some(task) = state.turn_task.take() else {
        return;
    };
    match task.await {
        Ok(Ok(_)) => {}
        Ok(Err(err)) => {
            state.lines.push(ChatLine {
                text: t_fmt("tui_error_prefix", &[("message", &err.to_string())]),
                style: Style::default().fg(Color::Red),
            });
            state.status = t("tui_status_error");
            state.running = false;
        }
        Err(err) if err.is_cancelled() => {
            if state.running {
                finish_cancel_turn(state);
            }
        }
        Err(err) => {
            state.lines.push(ChatLine {
                text: t_fmt("tui_agent_task_failed", &[("message", &err.to_string())]),
                style: Style::default().fg(Color::Red),
            });
            state.status = t("tui_status_error");
            state.running = false;
        }
    }
}

fn key_inserts_newline(key: &KeyEvent) -> bool {
    match key.code {
        KeyCode::Enter => key
            .modifiers
            .intersects(KeyModifiers::SHIFT | KeyModifiers::ALT | KeyModifiers::CONTROL),
        KeyCode::Char('\n') => true,
        _ => false,
    }
}

fn normalize_line_endings(text: &str) -> String {
    text.replace("\r\n", "\n").replace('\r', "\n")
}

fn mark_input_edited(state: &mut AppState) {
    state.slash_completion_dismissed = false;
}

fn insert_input_text(state: &mut AppState, text: &str) {
    mark_input_edited(state);
    state.input_history.clear_browse();
    let pos = state.input_cursor.min(state.input.len());
    let normalized = normalize_line_endings(text);
    state.input.insert_str(pos, &normalized);
    state.input_cursor = pos + normalized.len();
}

fn insert_char_at_cursor(state: &mut AppState, ch: char) {
    mark_input_edited(state);
    state.input_history.clear_browse();
    let pos = state.input_cursor.min(state.input.len());
    state.input.insert(pos, ch);
    state.input_cursor = pos + ch.len_utf8();
}

fn insert_newline_at_cursor(state: &mut AppState) {
    mark_input_edited(state);
    state.input_history.clear_browse();
    let pos = state.input_cursor.min(state.input.len());
    state.input.insert(pos, '\n');
    state.input_cursor = pos + 1;
}

fn backspace_at_cursor(state: &mut AppState) {
    if state.input_cursor == 0 {
        return;
    }
    mark_input_edited(state);
    state.input_history.clear_browse();
    let start = prev_char_boundary(&state.input, state.input_cursor);
    state.input.drain(start..state.input_cursor);
    state.input_cursor = start;
}

fn delete_at_cursor(state: &mut AppState) {
    if state.input_cursor >= state.input.len() {
        return;
    }
    mark_input_edited(state);
    state.input_history.clear_browse();
    let end = next_char_boundary(&state.input, state.input_cursor);
    state.input.drain(state.input_cursor..end);
}

fn prev_char_boundary(text: &str, cursor: usize) -> usize {
    let cursor = cursor.min(text.len());
    if cursor == 0 {
        return 0;
    }
    let mut pos = cursor - 1;
    while pos > 0 && !text.is_char_boundary(pos) {
        pos -= 1;
    }
    if !text.is_char_boundary(pos) {
        return 0;
    }
    pos
}

fn next_char_boundary(text: &str, cursor: usize) -> usize {
    let cursor = cursor.min(text.len());
    if cursor >= text.len() {
        return text.len();
    }
    let mut pos = cursor + 1;
    while pos < text.len() && !text.is_char_boundary(pos) {
        pos += 1;
    }
    pos
}

fn cancel_running_turn(state: &mut AppState) {
    if let Some(task) = state.turn_task.take() {
        task.abort();
    }
    finish_cancel_turn(state);
    state.pending_cancel = false;
}

fn finish_cancel_turn(state: &mut AppState) {
    state.running = false;
    state.status = t("tui_status_idle");
    state.assistant_buf.clear();
    if let Some(last) = state.lines.last() {
        if last.style == Style::default() && last.text.is_empty() {
            state.lines.pop();
        } else if let Some(last) = state.lines.last_mut() {
            if last.style == Style::default() {
                last.text
                    .push_str(&format!("\n\n[{}]", t("tui_turn_cancelled")));
            }
        }
    }
}

fn input_display_text(input: &str) -> Text<'static> {
    Text::from(input_display_lines(input))
}

fn input_display_lines(input: &str) -> Vec<Line<'static>> {
    if input.is_empty() {
        return vec![Line::from("")];
    }
    input
        .split('\n')
        .map(|line| Line::from(line.to_string()))
        .collect()
}

fn format_user_prompt(text: &str) -> String {
    if !text.contains('\n') {
        return format!("> {text}");
    }
    text.lines()
        .map(|line| format!("> {line}"))
        .collect::<Vec<_>>()
        .join("\n")
}

fn input_box_height(text: &str) -> u16 {
    let line_count = input_display_lines(text).len().max(1);
    (line_count as u16 + 2).clamp(INPUT_MIN_HEIGHT, INPUT_MAX_HEIGHT)
}

fn input_cursor_pos(input: &str, cursor: usize, area: Rect) -> (u16, u16) {
    let inner_left = area.x + 1;
    let inner_bottom = area.y + area.height.saturating_sub(2);
    let cursor = cursor.min(input.len());
    if input.is_empty() {
        return (inner_left, area.y + 1);
    }

    let before = &input[..cursor];
    let line_idx = before.chars().filter(|&c| c == '\n').count();
    let line_start = before.rfind('\n').map(|i| i + 1).unwrap_or(0);
    let col = input[line_start..cursor].width();

    let y = area.y + 1 + line_idx as u16;
    let x = inner_left + col as u16;
    let max_x = area.x + area.width.saturating_sub(2);
    (x.min(max_x), y.min(inner_bottom))
}

fn scroll_chat(state: &mut AppState, delta: i16) {
    state.chat_follow_bottom = false;
    if delta < 0 {
        state.chat_scroll = state.chat_scroll.saturating_sub((-delta) as u16);
    } else {
        state.chat_scroll = state.chat_scroll.saturating_add(delta as u16);
    }
}

#[derive(Clone, Copy)]
enum CopyScope {
    All,
    LastAssistant,
}

fn copy_chat_with_status(state: &mut AppState, scope: CopyScope) {
    let text = match scope {
        CopyScope::All => chat_text_all(&state.lines),
        CopyScope::LastAssistant => match last_assistant_text(&state.lines) {
            Some(text) => text,
            None => {
                state.status = t("tui_copy_nothing");
                return;
            }
        },
    };
    match copy_to_clipboard(&text) {
        Ok(()) => {
            state.status = t_fmt(
                "tui_copy_ok",
                &[("count", &text.chars().count().to_string())],
            );
        }
        Err(err) => {
            state.status = t_fmt("tui_copy_failed", &[("error", &format!("{err:#}"))]);
        }
    }
}

fn chat_text_all(lines: &[ChatLine]) -> String {
    lines
        .iter()
        .map(|line| line.text.as_str())
        .collect::<Vec<_>>()
        .join("\n")
}

fn last_assistant_text(lines: &[ChatLine]) -> Option<String> {
    lines
        .iter()
        .rev()
        .find(|line| {
            line.style == Style::default()
                && !line.text.starts_with("[tool:")
                && !is_chat_error_line(&line.text)
        })
        .map(|line| line.text.clone())
}

fn apply_slash_completion(state: &mut AppState, hint: &SlashHint) {
    mark_input_edited(state);
    state.input = hint.command.to_string();
    if matches!(
        hint.command,
        "/model" | "/provider" | "/session resume" | "/skill show" | "/language"
    ) {
        state.input.push(' ');
    }
    state.input_cursor = state.input.len();
    state.input_history.clear_browse();
}

fn render_slash_completions(
    frame: &mut ratatui::Frame,
    area: Rect,
    hints: &[&SlashHint],
    selected: usize,
) {
    let items: Vec<ListItem> = hints
        .iter()
        .enumerate()
        .map(|(idx, hint)| {
            let style = if idx == selected {
                Style::default()
                    .fg(Color::Black)
                    .bg(Color::Cyan)
                    .add_modifier(Modifier::BOLD)
            } else {
                Style::default().fg(Color::Gray)
            };
            ListItem::new(Line::from(vec![
                Span::styled(format!("{:<18}", hint.command), style),
                Span::styled(t(hint.description_key), style),
            ]))
        })
        .collect();
    let widget = List::new(items).block(
        Block::default()
            .borders(Borders::ALL)
            .title(t("tui_commands_title"))
            .style(Style::default().fg(Color::DarkGray)),
    );
    frame.render_widget(Clear, area);
    frame.render_widget(widget, area);
}

fn wrap_chat_lines(lines: &[ChatLine], area_width: u16) -> Vec<Line<'static>> {
    let inner = area_width.saturating_sub(2) as usize;
    let mut rendered = Vec::new();
    for line in lines {
        for segment in wrap_text(&line.text, inner.max(1)) {
            rendered.push(Line::from(Span::styled(segment, line.style)));
        }
    }
    rendered
}

fn wrap_text(text: &str, width: usize) -> Vec<String> {
    if text.is_empty() {
        return vec![String::new()];
    }
    let mut lines = Vec::new();
    let mut current = String::new();

    for ch in text.chars() {
        if ch == '\n' {
            lines.push(std::mem::take(&mut current));
            continue;
        }
        if current.chars().count() + 1 > width && !current.is_empty() {
            lines.push(std::mem::take(&mut current));
        }
        current.push(ch);
    }
    if !current.is_empty() {
        lines.push(current);
    }

    if lines.is_empty() {
        lines.push(String::new());
    }

    // Word-aware second pass: try to break at spaces for long lines.
    let mut refined = Vec::new();
    for line in lines {
        if line.chars().count() <= width {
            refined.push(line);
            continue;
        }
        let mut rest: String = line;
        while !rest.is_empty() {
            if rest.chars().count() <= width {
                refined.push(rest);
                break;
            }
            let byte_idx = rest
                .char_indices()
                .nth(width)
                .map(|(i, _)| i)
                .unwrap_or(rest.len());
            let mut break_at = byte_idx;
            if let Some(space) = rest[..byte_idx].rfind(' ') {
                if space > 0 {
                    break_at = space;
                }
            }
            let (part, remainder) = rest.split_at(break_at);
            refined.push(part.trim_end().to_string());
            rest = remainder.trim_start().to_string();
        }
    }
    refined
}

fn render_cancel_modal(frame: &mut ratatui::Frame, area: Rect) {
    let popup = centered_rect(60, 20, area);
    frame.render_widget(Clear, popup);
    let widget = Paragraph::new(t("tui_cancel_body"))
        .wrap(Wrap { trim: false })
        .style(Style::default().add_modifier(Modifier::BOLD))
        .block(
            Block::default()
                .borders(Borders::ALL)
                .title(t("tui_cancel_title"))
                .style(Style::default().fg(Color::Yellow)),
        );
    frame.render_widget(widget, popup);
}

fn render_quit_modal(frame: &mut ratatui::Frame, area: Rect) {
    let popup = centered_rect(60, 20, area);
    frame.render_widget(Clear, popup);
    let widget = Paragraph::new(t("tui_quit_body"))
        .wrap(Wrap { trim: false })
        .style(Style::default().add_modifier(Modifier::BOLD))
        .block(
            Block::default()
                .borders(Borders::ALL)
                .title(t("tui_quit_title"))
                .style(Style::default().fg(Color::Yellow)),
        );
    frame.render_widget(widget, popup);
}

fn render_approval_modal(
    frame: &mut ratatui::Frame,
    area: Rect,
    request: &codei_tools::ApprovalRequest,
) {
    let popup = centered_rect(70, 30, area);
    frame.render_widget(Clear, popup);
    let text = t_fmt(
        "tui_tool_approval_body",
        &[
            ("name", &request.tool_name),
            ("args", &request.arguments.to_string()),
        ],
    );
    let widget = Paragraph::new(text)
        .wrap(Wrap { trim: false })
        .style(Style::default().add_modifier(Modifier::BOLD))
        .block(
            Block::default()
                .borders(Borders::ALL)
                .title(t("tui_tool_approval_title"))
                .style(Style::default().fg(Color::Yellow)),
        );
    frame.render_widget(widget, popup);
}

fn centered_rect(percent_x: u16, percent_y: u16, area: Rect) -> Rect {
    let popup_layout = Layout::default()
        .direction(Direction::Vertical)
        .constraints([
            Constraint::Percentage((100 - percent_y) / 2),
            Constraint::Percentage(percent_y),
            Constraint::Percentage((100 - percent_y) / 2),
        ])
        .split(area);
    Layout::default()
        .direction(Direction::Horizontal)
        .constraints([
            Constraint::Percentage((100 - percent_x) / 2),
            Constraint::Percentage(percent_x),
            Constraint::Percentage((100 - percent_x) / 2),
        ])
        .split(popup_layout[1])[1]
}

fn flush_assistant(lines: &mut [ChatLine], assistant_buf: &mut String) {
    if !assistant_buf.is_empty() {
        assistant_buf.clear();
    }
    let _ = lines;
}

fn truncate(s: &str, max: usize) -> String {
    if s.len() <= max {
        s.to_string()
    } else {
        format!("{}...", &s[..max])
    }
}

fn is_chat_error_line(text: &str) -> bool {
    text.starts_with("Error:") || text.starts_with("错误：")
}

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

    #[test]
    fn normalize_line_endings_unifies_crlf_and_cr() {
        assert_eq!(normalize_line_endings("a\r\nb\rc"), "a\nb\nc");
    }

    #[test]
    fn input_display_lines_preserves_trailing_newline() {
        let lines = input_display_lines("a\nb\n");
        assert_eq!(lines.len(), 3);
        assert_eq!(lines[2], Line::from(""));
    }

    #[test]
    fn key_inserts_newline_for_alt_enter_and_ctrl_enter() {
        assert!(key_inserts_newline(&KeyEvent::new(
            KeyCode::Enter,
            KeyModifiers::ALT,
        )));
        assert!(key_inserts_newline(&KeyEvent::new(
            KeyCode::Enter,
            KeyModifiers::CONTROL,
        )));
        assert!(!key_inserts_newline(&KeyEvent::new(
            KeyCode::Enter,
            KeyModifiers::empty(),
        )));
    }

    #[test]
    fn input_history_browses_submitted_messages() {
        let mut history = InputHistory::new();
        history.push("first".into());
        history.push("second".into());

        assert_eq!(history.browse_older(""), as_deref("second"));
        assert_eq!(history.browse_older("ignored"), as_deref("first"));
        assert_eq!(history.browse_older("ignored"), None);
        assert_eq!(history.browse_newer(), as_deref("second"));
        assert_eq!(history.browse_newer(), Some(String::new()));
    }

    #[test]
    fn input_history_restores_draft_after_browse() {
        let mut history = InputHistory::new();
        history.push("old".into());
        assert_eq!(history.browse_older("draft text"), as_deref("old"));
        assert_eq!(history.browse_newer(), Some("draft text".into()));
    }

    fn as_deref(value: &str) -> Option<String> {
        Some(value.to_string())
    }

    #[test]
    fn input_cursor_pos_tracks_byte_offset() {
        use ratatui::layout::Rect;

        let area = Rect::new(0, 0, 40, 5);
        let input = "ab\ncd";
        let (x, y) = input_cursor_pos(input, 4, area);
        assert_eq!(y, 2);
        assert_eq!(x, 2);
    }

    #[test]
    fn prev_char_boundary_skips_utf8() {
        let text = "aéb";
        let end = text.len();
        let mid = prev_char_boundary(text, end);
        assert_eq!(&text[..mid], "aé");
    }
}