wedi 0.8.7

use anyhow::Result;
use std::path::Path;
use wedi_core::{
    buffer::{EncodingConfig, RopeBuffer},
    clipboard::ClipboardManager,
    comment::CommentHandler,
    cursor::Cursor,
    keymap::{handle_key_event, Command, Direction},
    search::Search,
    terminal::{InputEvent, Terminal},
    utils::visual_width,
    view::{Selection, View},
};

#[cfg(feature = "syntax-highlighting")]
use wedi_core::highlight::{HighlightCache, HighlightConfig, HighlightEngine};

pub struct Editor {
    buffer: RopeBuffer,
    cursor: Cursor,
    view: View,
    terminal: Terminal,
    clipboard: ClipboardManager,
    internal_clipboard: String, // 內部剪貼簿作為後備
    search: Search,
    search_mode: bool, // 搜尋模式開關（Ctrl+F 開啟，ESC 關閉）
    comment_handler: CommentHandler,
    should_quit: bool,
    selection: Option<Selection>,
    selection_mode: bool, // F1 選擇模式開關
    message: Option<String>,
    quit_times: u8, // 追蹤連續按 Ctrl+Q 的次數
    debug_mode: bool,

    // 語法高亮（可選功能）
    #[cfg(feature = "syntax-highlighting")]
    pub(crate) highlight_engine: Option<HighlightEngine>,
    #[cfg(feature = "syntax-highlighting")]
    pub(crate) highlight_cache: HighlightCache,
    #[cfg(feature = "syntax-highlighting")]
    #[allow(dead_code)]
    highlight_config: HighlightConfig,
    #[cfg(feature = "syntax-highlighting")]
    highlight_enabled: bool,
}

impl Editor {
    pub fn new(
        file_path: Option<&Path>,
        debug_mode: bool,
        encoding_config: &EncodingConfig,
        #[cfg(feature = "syntax-highlighting")] theme: Option<&str>,
        #[cfg(feature = "syntax-highlighting")] language: Option<&str>,
    ) -> Result<Self> {
        let buffer = if let Some(path) = file_path {
            // 使用新的方法，支持指定編碼
            RopeBuffer::from_file_with_encoding(path, encoding_config)?
        } else {
            let mut buffer = RopeBuffer::new();
            // 如果指定了讀取編碼，設置編碼
            if let Some(enc) = encoding_config.read_encoding {
                if cfg!(debug_assertions) {
                    eprintln!(
                        "[DEBUG] Editor::new() - Setting read_encoding from config: {}",
                        enc.name()
                    );
                }
                buffer.set_read_encoding(enc);
            }
            // 如果指定了存檔編碼，設置存檔編碼
            if let Some(enc) = encoding_config.save_encoding {
                if cfg!(debug_assertions) {
                    eprintln!(
                        "[DEBUG] Editor::new() - Setting save_encoding from config: {}",
                        enc.name()
                    );
                }
                buffer.set_save_encoding(enc);
            }

            if cfg!(debug_assertions) {
                eprintln!(
                    "[DEBUG] Editor::new() - Final buffer save_encoding: {}",
                    if let Some(enc) = encoding_config.save_encoding {
                        enc.name()
                    } else if let Some(enc) = encoding_config.read_encoding {
                        enc.name()
                    } else {
                        "system default"
                    }
                );
            }

            buffer
        };

        let terminal = Terminal::new()?;
        let view = View::new(&terminal);
        let clipboard = ClipboardManager::new()?;

        let mut comment_handler = CommentHandler::new();
        if let Some(path) = file_path {
            comment_handler.detect_from_path(path);
        }

        // 語法高亮初始化
        #[cfg(feature = "syntax-highlighting")]
        let (highlight_engine, highlight_cache, highlight_config) = {
            let mut config = HighlightConfig::default();

            // 如果提供了自定義主題，使用它；否則使用默認主題
            if let Some(custom_theme) = theme {
                config.theme = custom_theme.to_string();
            }

            let mut engine = if config.enabled {
                HighlightEngine::new(Some(&config.theme), config.true_color).ok()
            } else {
                None
            };

            // 設定語法類型：優先使用命令列指定的語言，否則從檔案路徑自動檢測
            if let Some(ref mut eng) = engine.as_mut() {
                if let Some(lang) = language {
                    // 使用者指定了語言，嘗試設定
                    if let Err(e) = eng.set_syntax_by_name(lang) {
                        eprintln!("Warning: {}", e);
                        // 失敗時回退到自動檢測
                        if let Some(path) = file_path {
                            eng.set_file(Some(path));
                        }
                    }
                } else if let Some(path) = file_path {
                    // 沒有指定語言，從檔案路徑自動檢測
                    eng.set_file(Some(path));
                }
            }

            (engine, HighlightCache::new(), config)
        };

        Ok(Self {
            buffer,
            cursor: Cursor::new(),
            view,
            terminal,
            clipboard,
            internal_clipboard: String::new(), // 初始化內部剪貼簿
            search: Search::new(),
            search_mode: false, // 預設關閉搜尋模式
            comment_handler,
            should_quit: false,
            selection: None,
            selection_mode: false, // 預設關閉選擇模式
            message: None,
            quit_times: 0,
            debug_mode,

            #[cfg(feature = "syntax-highlighting")]
            highlight_engine,
            #[cfg(feature = "syntax-highlighting")]
            highlight_cache,
            #[cfg(feature = "syntax-highlighting")]
            highlight_config,
            #[cfg(feature = "syntax-highlighting")]
            highlight_enabled: true, // 預設啟用語法高亮
        })
    }

    pub fn run(&mut self) -> Result<()> {
        Terminal::enter_raw_mode()?;
        Terminal::clear_screen()?;

        while !self.should_quit {
            let debug_info = if self.debug_mode {
                Some(self.get_debug_info())
            } else {
                None
            };

            // ⚠️ 重要：在計算高亮之前先更新 offset_row
            // 避免跳頁後 highlighted_lines 使用舊的 offset_row
            let has_debug_ruler = self.debug_mode;
            self.view
                .scroll_if_needed(&self.cursor, &self.buffer, has_debug_ruler);

            // 獲取語法高亮行
            #[cfg(feature = "syntax-highlighting")]
            let highlighted_lines = {
                if self.highlight_enabled {
                    let start_row = self.view.offset_row;
                    let end_row = start_row + self.view.screen_rows;
                    self.get_highlighted_lines(start_row, end_row)
                } else {
                    std::collections::HashMap::new()
                }
            };

            self.view.render(
                &self.buffer,
                &self.cursor,
                self.selection.as_ref(),
                if self.debug_mode {
                    debug_info.as_deref()
                } else {
                    self.message.as_deref()
                },
                #[cfg(feature = "syntax-highlighting")]
                Some(&highlighted_lines),
            )?;

            // 使用 read_input() 支援 Bracketed Paste
            match Terminal::read_input()? {
                InputEvent::Key(key_event) => {
                    if let Some(command) = handle_key_event(key_event, self.selection_mode) {
                        self.handle_command(command)?;
                    }
                }
                InputEvent::Paste(text) => {
                    // 直接處理貼上的文字
                    self.handle_command(Command::PasteText(text))?;
                }
            }
        }

        Terminal::exit_raw_mode()?;
        Ok(())
    }

    fn handle_command(&mut self, command: Command) -> Result<()> {
        // 任何非 Quit 的命令都重置 quit_times
        if !matches!(command, Command::Quit) {
            self.quit_times = 0;
        }

        match command {
            // 字符輸入
            Command::Insert(ch) => {
                if self.has_selection() {
                    self.delete_selection();
                }

                let pos = self.cursor.char_position(&self.buffer);
                self.buffer.insert_char(pos, ch);

                // 優化：僅失效當前行（除非是換行符，需要重建整個緩存）
                if ch == '\n' {
                    self.view.invalidate_cache(); // 換行影響多行佈局
                    #[cfg(feature = "syntax-highlighting")]
                    self.highlight_cache.clear(); // 語法高亮快取也需要清除
                    self.cursor.row += 1;
                    self.cursor.reset_to_line_start();
                } else {
                    self.view.invalidate_line(self.cursor.row); // 僅失效當前行
                    #[cfg(feature = "syntax-highlighting")]
                    self.invalidate_highlight_cache(self.cursor.row); // 語法高亮快取失效
                    self.cursor.set_position(
                        &self.buffer,
                        &self.view,
                        self.cursor.row,
                        self.cursor.col + 1,
                    );
                }

                self.selection = None;
                self.selection_mode = false; // 輸入後關閉選擇模式
            }

            // 刪除操作
            Command::Backspace => {
                if self.has_selection() {
                    self.delete_selection();
                } else if self.cursor.col > 0 {
                    // 行內刪除
                    let new_col = self.cursor.col - 1;
                    let pos = self.buffer.line_to_char(self.cursor.row) + new_col;
                    self.buffer.delete_char(pos);
                    self.view.invalidate_line(self.cursor.row); // 僅失效當前行
                    #[cfg(feature = "syntax-highlighting")]
                    self.invalidate_highlight_cache(self.cursor.row);
                    self.cursor
                        .set_position(&self.buffer, &self.view, self.cursor.row, new_col);
                } else if self.cursor.row > 0 {
                    // 刪除換行符，合併到上一行
                    let new_row = self.cursor.row - 1;
                    let prev_line_len = self
                        .buffer
                        .get_line_content(new_row)
                        .trim_end_matches(['\n', '\r'])
                        .chars()
                        .count();

                    let pos = self.buffer.line_to_char(new_row) + prev_line_len;
                    self.buffer.delete_char(pos);
                    self.view.invalidate_cache(); // 行合併影響多行
                    #[cfg(feature = "syntax-highlighting")]
                    self.highlight_cache.clear();

                    self.cursor
                        .set_position(&self.buffer, &self.view, new_row, prev_line_len);
                }
                self.selection_mode = false; // 刪除後關閉選擇模式
            }

            Command::Delete => {
                if self.has_selection() {
                    self.delete_selection();
                } else {
                    let pos = self.cursor.char_position(&self.buffer);
                    let line_content = self.buffer.get_line_content(self.cursor.row);
                    let at_line_end = self.cursor.col
                        >= line_content.trim_end_matches(['\n', '\r']).chars().count();

                    self.buffer.delete_char(pos);

                    // 優化：如果在行尾刪除（會合併下一行），需要完全失效；否則僅失效當前行
                    if at_line_end {
                        self.view.invalidate_cache(); // 行合併影響多行
                        #[cfg(feature = "syntax-highlighting")]
                        self.highlight_cache.clear();
                    } else {
                        self.view.invalidate_line(self.cursor.row); // 僅失效當前行
                        #[cfg(feature = "syntax-highlighting")]
                        self.invalidate_highlight_cache(self.cursor.row);
                    }
                }
                self.selection_mode = false; // 刪除後關閉選擇模式
            }

            Command::DeleteLine => {
                if self.has_selection() {
                    // 選取模式下刪除所有包含選取的整行
                    if let Some(sel) = self.selection {
                        let (start_row, _) = sel.start.min(sel.end);
                        let (end_row, _) = sel.start.max(sel.end);

                        // 從後往前刪除，避免行號變化影響
                        for row in (start_row..=end_row).rev() {
                            if row < self.buffer.line_count() {
                                self.buffer.delete_line(row);
                            }
                        }

                        self.view.invalidate_cache();
                        #[cfg(feature = "syntax-highlighting")]
                        self.highlight_cache.clear();

                        // 確保光標在有效範圍內
                        self.cursor.row = start_row.min(self.buffer.line_count().saturating_sub(1));
                        self.cursor.reset_to_line_start();
                        self.selection = None;
                    }
                } else {
                    // 記錄是否在最後一行
                    let was_last_line = self.cursor.row == self.buffer.line_count() - 1;

                    self.buffer.delete_line(self.cursor.row);
                    self.view.invalidate_cache();
                    #[cfg(feature = "syntax-highlighting")]
                    self.highlight_cache.clear();

                    // 如果刪除的是最後一行且不是唯一一行，光標上移
                    if was_last_line && self.cursor.row > 0 {
                        self.cursor.row -= 1;
                    }

                    // 確保光標在有效範圍內
                    if self.cursor.row >= self.buffer.line_count() && self.buffer.line_count() > 0 {
                        self.cursor.row = self.buffer.line_count() - 1;
                    }

                    self.cursor.reset_to_line_start();
                }
                self.selection_mode = false; // 刪除後關閉選擇模式
            }

            // 光標移動
            Command::MoveUp => {
                self.cursor.move_up(&self.buffer, &self.view);
                self.selection = None;
            }
            Command::MoveDown => {
                self.cursor.move_down(&self.buffer, &self.view);
                self.selection = None;
            }
            Command::MoveLeft => {
                self.cursor.move_left(&self.buffer, &self.view);
                self.selection = None;
            }
            Command::MoveRight => {
                self.cursor.move_right(&self.buffer, &self.view);
                self.selection = None;
            }
            Command::MoveHome => {
                self.cursor.move_to_line_start();
                self.selection = None;
            }
            Command::MoveEnd => {
                self.cursor.move_to_line_end(&self.buffer, &self.view);
                self.selection = None;
            }
            Command::PageUp => {
                let effective_rows = self.view.get_effective_screen_rows(self.debug_mode);
                self.cursor
                    .move_page_up(&self.buffer, &self.view, effective_rows);
                self.selection = None;
            }
            Command::PageDown => {
                let effective_rows = self.view.get_effective_screen_rows(self.debug_mode);
                self.cursor
                    .move_page_down(&self.buffer, &self.view, effective_rows);
                self.selection = None;
            }

            Command::MoveToFileStart => {
                self.cursor.move_to_file_start(&self.view);
                self.selection = None;
            }
            Command::MoveToFileEnd => {
                self.cursor.move_to_file_end(&self.buffer, &self.view);
                self.selection = None;
            }

            Command::JumpTenthUp => {
                let total_lines = self.buffer.line_count();
                let jump_distance = total_lines.max(10) / 10; // 至少跳 1 行
                self.cursor.row = self.cursor.row.saturating_sub(jump_distance);
                self.cursor.set_position(
                    &self.buffer,
                    &self.view,
                    self.cursor.row,
                    self.cursor.col,
                );
                self.selection = None;
            }

            Command::JumpTenthDown => {
                let total_lines = self.buffer.line_count();
                let jump_distance = total_lines.max(10) / 10;
                let new_row = self
                    .cursor
                    .row
                    .saturating_add(jump_distance)
                    .min(total_lines.saturating_sub(1));
                self.cursor.row = new_row;
                self.cursor.set_position(
                    &self.buffer,
                    &self.view,
                    self.cursor.row,
                    self.cursor.col,
                );
                self.selection = None;
            }

            // 選擇操作
            Command::ExtendSelection(direction) => {
                if self.selection.is_none() {
                    self.selection = Some(Selection {
                        start: (self.cursor.row, self.cursor.col),
                        end: (self.cursor.row, self.cursor.col),
                    });
                }

                match direction {
                    Direction::Up => self.cursor.move_up(&self.buffer, &self.view),
                    Direction::Down => self.cursor.move_down(&self.buffer, &self.view),
                    Direction::Left => self.cursor.move_left(&self.buffer, &self.view),
                    Direction::Right => self.cursor.move_right(&self.buffer, &self.view),
                    Direction::Home => self.cursor.move_to_line_start(),
                    Direction::End => self.cursor.move_to_line_end(&self.buffer, &self.view),
                    Direction::FileStart => {
                        self.cursor.move_to_file_start(&self.view);
                    }
                    Direction::FileEnd => {
                        self.cursor.move_to_file_end(&self.buffer, &self.view);
                    }
                    Direction::PageUp => {
                        let effective_rows = self.view.get_effective_screen_rows(self.debug_mode);
                        self.cursor
                            .move_page_up(&self.buffer, &self.view, effective_rows)
                    }
                    Direction::PageDown => {
                        let effective_rows = self.view.get_effective_screen_rows(self.debug_mode);
                        self.cursor
                            .move_page_down(&self.buffer, &self.view, effective_rows)
                    }
                    Direction::TenthUp => {
                        let total_lines = self.buffer.line_count();
                        let jump_distance = total_lines.max(10) / 10;
                        self.cursor.row = self.cursor.row.saturating_sub(jump_distance);
                        self.cursor.set_position(
                            &self.buffer,
                            &self.view,
                            self.cursor.row,
                            self.cursor.col,
                        );
                    }
                    Direction::TenthDown => {
                        let total_lines = self.buffer.line_count();
                        let jump_distance = total_lines.max(10) / 10;
                        let new_row = self
                            .cursor
                            .row
                            .saturating_add(jump_distance)
                            .min(total_lines.saturating_sub(1));
                        self.cursor.row = new_row;
                        self.cursor.set_position(
                            &self.buffer,
                            &self.view,
                            self.cursor.row,
                            self.cursor.col,
                        );
                    }
                }

                if let Some(sel) = &mut self.selection {
                    sel.end = (self.cursor.row, self.cursor.col);
                }
            }

            Command::SelectAll => {
                let last_line = self.buffer.line_count().saturating_sub(1);
                let last_col = self
                    .buffer
                    .get_line_content(last_line)
                    .trim_end_matches(['\n', '\r'])
                    .chars()
                    .count();

                self.selection = Some(Selection {
                    start: (0, 0),
                    end: (last_line, last_col),
                });
                self.cursor.row = last_line;
                self.cursor.col = last_col;
            }

            Command::ClearSelection => {
                self.selection = None;
            }

            Command::ClearMessage => {
                self.selection = None;
                self.selection_mode = false; // ESC 關閉選擇模式但保留選擇範圍
                self.search_mode = false; // ESC 關閉搜尋模式（保留搜尋結果）
                self.message = None;
            }

            // 選擇模式切換
            Command::ToggleSelectionMode => {
                self.selection_mode = !self.selection_mode;

                // 開啟選擇模式時，如果沒有選擇範圍，初始化選擇
                if self.selection_mode && self.selection.is_none() {
                    self.selection = Some(Selection {
                        start: (self.cursor.row, self.cursor.col),
                        end: (self.cursor.row, self.cursor.col),
                    });
                }

                self.message = Some(format!(
                    "Selection Mode: {}",
                    if self.selection_mode { "ON" } else { "OFF" }
                ));
            }

            // 剪貼板操作
            Command::Copy => {
                let text = self.get_copy_text();
                self.set_clipboard_text(text, true);
                // 複製後關閉選擇模式並清除選擇範圍
                self.selection_mode = false;
                self.selection = None;
            }

            Command::Cut => {
                let text = self.get_copy_text();
                self.set_clipboard_text(text, true);

                // 剪切後刪除內容
                if self.has_selection() {
                    self.delete_selection();
                } else {
                    // 記錄是否在最後一行
                    let was_last_line = self.cursor.row == self.buffer.line_count() - 1;

                    self.buffer.delete_line(self.cursor.row);
                    self.view.invalidate_cache();

                    // 如果刪除的是最後一行且不是唯一一行，光標上移
                    if was_last_line && self.cursor.row > 0 {
                        self.cursor.row -= 1;
                    }

                    // 確保光標在有效範圍內
                    if self.cursor.row >= self.buffer.line_count() && self.buffer.line_count() > 0 {
                        self.cursor.row = self.buffer.line_count() - 1;
                    }

                    self.cursor.col = 0;
                    self.cursor.desired_visual_col = 0;
                }

                // 剪切後關閉選擇模式並清除選擇
                self.selection_mode = false;
            }

            Command::Paste => {
                let text = self.get_clipboard_text(true);
                self.paste_text(text);
                self.selection_mode = false; // 貼上後關閉選擇模式
            }

            // 內部剪貼板操作（僅使用內部剪貼簿）
            Command::CopyInternal => {
                let text = self.get_copy_text();
                self.set_clipboard_text(text, false);
                self.selection_mode = false; // 複製後關閉選擇模式
                self.selection = None; // 複製後清除選擇範圍
            }

            Command::CutInternal => {
                let text = self.get_copy_text();
                self.set_clipboard_text(text, false);

                // 剪切後刪除內容
                if self.has_selection() {
                    self.delete_selection();
                } else {
                    // 記錄是否在最後一行
                    let was_last_line = self.cursor.row == self.buffer.line_count() - 1;

                    self.buffer.delete_line(self.cursor.row);
                    self.view.invalidate_cache();

                    // 如果刪除的是最後一行且不是唯一一行，光標上移
                    if was_last_line && self.cursor.row > 0 {
                        self.cursor.row -= 1;
                    }

                    // 確保光標在有效範圍內
                    if self.cursor.row >= self.buffer.line_count() && self.buffer.line_count() > 0 {
                        self.cursor.row = self.buffer.line_count() - 1;
                    }

                    self.cursor.col = 0;
                    self.cursor.desired_visual_col = 0;
                }
                self.selection_mode = false; // 剪切後關閉選擇模式
            }

            Command::PasteInternal => {
                let text = self.get_clipboard_text(false);
                self.paste_text(text);
                self.selection_mode = false; // 貼上後關閉選擇模式
            }

            // Bracketed Paste 直接貼上文字
            Command::PasteText(text) => {
                if self.has_selection() {
                    self.delete_selection();
                }
                self.paste_text(text);
                self.selection_mode = false; // 貼上後關閉選擇模式
            }

            // 文件操作
            Command::Save => {
                if let Err(e) = self.buffer.save() {
                    self.message = Some(format!("Save failed: {}", e));
                } else {
                    self.message = Some("File saved".to_string());
                }
            }

            Command::Quit => {
                if self.buffer.is_modified() {
                    if self.quit_times > 0 {
                        // 第二次按 Ctrl+Q，強制退出
                        self.should_quit = true;
                    } else {
                        // 第一次按 Ctrl+Q，顯示警告
                        self.quit_times = 1;
                        self.message = Some(
                            "Unsaved changes! Press Ctrl+Q again to force quit, or Ctrl+W to save"
                                .to_string(),
                        );
                    }
                } else {
                    self.should_quit = true;
                }
            }

            // 視窗調整
            Command::Resize => {
                self.view.update_size();
            }

            // 撤銷/重做
            Command::Undo => {
                if let Some(pos) = self.buffer.undo() {
                    self.view.invalidate_cache();
                    // 將光標移動到撤銷操作的位置
                    let row = self.buffer.char_to_line(pos);
                    let line_start = self.buffer.line_to_char(row);
                    let col = pos - line_start;

                    self.cursor.row = row;
                    self.cursor.col = col;
                    self.cursor.desired_visual_col = col;
                    self.message = Some("Undo".to_string());
                } else {
                    self.message = Some("Nothing to undo".to_string());
                }
            }

            Command::Redo => {
                if let Some(pos) = self.buffer.redo() {
                    self.view.invalidate_cache();
                    // 將光標移動到重做操作的位置
                    let row = self.buffer.char_to_line(pos);
                    let line_start = self.buffer.line_to_char(row);
                    let col = pos - line_start;

                    self.cursor.row = row;
                    self.cursor.col = col;
                    self.cursor.desired_visual_col = col;
                    self.message = Some("Redo".to_string());
                } else {
                    self.message = Some("Nothing to redo".to_string());
                }
            }

            // 搜索
            Command::Find => {
                // 獲取搜索查詢，使用上次的搜索詞作為預設值
                let default_query = self.search.get_query();
                if let Ok(Some(query)) = crate::dialog::prompt_with_default(
                    "Search:",
                    default_query,
                    self.terminal.size(),
                ) {
                    if !query.is_empty() {
                        self.search.set_query(query.clone());
                        self.search.find_matches(&self.buffer);
                        self.search_mode = true; // 開啟搜尋模式

                        if self.search.match_count() > 0 {
                            if let Some((row, col)) = self.search.next_match() {
                                self.cursor.row = row;
                                self.cursor.col = col;
                                self.cursor.desired_visual_col = col;
                                self.message = Some(format!(
                                    "Found {} matches (ESC to exit search mode)",
                                    self.search.match_count()
                                ));
                            }
                        } else {
                            self.message = Some(format!("No matches found for '{}'", query));
                            self.search_mode = false; // 沒有結果就關閉搜尋模式
                        }
                    }
                }
            }

            Command::FindNext => {
                if self.search_mode && self.search.match_count() > 0 {
                    if let Some((row, col)) = self.search.next_match() {
                        self.cursor.row = row;
                        self.cursor.col = col;
                        self.cursor.desired_visual_col = col;
                        self.message = Some(format!(
                            "Match {}/{} (ESC to exit search mode)",
                            self.search.current_index() + 1,
                            self.search.match_count()
                        ));
                    }
                } else {
                    // 沒有搜尋模式時，執行 PageDown
                    return self.handle_command(Command::PageDown);
                }
            }

            Command::FindPrev => {
                if self.search_mode && self.search.match_count() > 0 {
                    if let Some((row, col)) = self.search.prev_match() {
                        self.cursor.row = row;
                        self.cursor.col = col;
                        self.cursor.desired_visual_col = col;
                        self.message = Some(format!(
                            "Match {}/{} (ESC to exit search mode)",
                            self.search.current_index() + 1,
                            self.search.match_count()
                        ));
                    }
                } else {
                    // 沒有搜尋模式時，執行 PageUp
                    return self.handle_command(Command::PageUp);
                }
            }

            // 視圖控制
            Command::ToggleLineNumbers => {
                self.view.toggle_line_numbers();
            }

            // 切換顯示模式（單行/多行）
            Command::ToggleDisplayMode => {
                self.view.toggle_display_mode();
                self.message = Some(format!(
                    "Display Mode: {}",
                    self.view.get_display_mode_name()
                ));
            }

            // 註解切換
            Command::ToggleComment => {
                if !self.comment_handler.has_comment_style() {
                    self.message = Some("No comment style for this file type".to_string());
                } else if self.has_selection() {
                    // 多行選擇：智能切換註解
                    if let Some(sel) = self.selection {
                        let (start_row, _) = sel.start.min(sel.end);
                        let (end_row, _) = sel.start.max(sel.end);

                        // 檢查是否有任何一行沒有註解
                        let mut has_uncommented = false;
                        for row in start_row..=end_row {
                            let line_content = self.buffer.get_line_content(row);
                            if !self.comment_handler.is_commented(&line_content) {
                                has_uncommented = true;
                                break;
                            }
                        }

                        // 如果有任何一行沒註解，全部加註解；否則全部取消註解
                        let should_add_comment = has_uncommented;

                        // 從後往前處理，避免行號變化
                        for row in (start_row..=end_row).rev() {
                            let line_content = self.buffer.get_line_content(row);

                            let new_line = if should_add_comment {
                                // 全部加註解（即使已經有註解的也保持不變）
                                if self.comment_handler.is_commented(&line_content) {
                                    Some(line_content.clone())
                                } else {
                                    self.comment_handler.add_comment(&line_content)
                                }
                            } else {
                                // 全部取消註解
                                self.comment_handler.remove_comment(&line_content)
                            };

                            if let Some(new_line) = new_line {
                                // 計算行的起始和結束位置
                                let line_start = self.buffer.line_to_char(row);
                                let line_end = if row + 1 < self.buffer.line_count() {
                                    self.buffer.line_to_char(row + 1)
                                } else {
                                    self.buffer.len_chars()
                                };

                                // 刪除舊行（包括換行符）
                                self.buffer.delete_range(line_start, line_end);

                                // 插入新行（保留換行符）
                                let new_line_with_newline = if line_content.ends_with('\n')
                                    || line_content.ends_with("\r\n")
                                {
                                    format!("{}\n", new_line.trim_end_matches(['\n', '\r']))
                                } else {
                                    new_line.trim_end_matches(['\n', '\r']).to_string()
                                };
                                self.buffer.insert(line_start, &new_line_with_newline);
                            }
                        }

                        self.view.invalidate_cache();

                        // 保留選擇狀態（不清除選取）
                        self.cursor.row = start_row;
                        self.cursor.col = 0;
                        self.cursor.desired_visual_col = 0;

                        let action = if should_add_comment {
                            "Added"
                        } else {
                            "Removed"
                        };
                        self.message = Some(format!("{} comments", action));
                    }
                } else {
                    // 單行：直接切換註解
                    let line_content = self.buffer.get_line_content(self.cursor.row);
                    if let Some(new_line) = self.comment_handler.toggle_line_comment(&line_content)
                    {
                        // 計算行的起始和結束位置
                        let line_start = self.buffer.line_to_char(self.cursor.row);
                        let line_end = if self.cursor.row + 1 < self.buffer.line_count() {
                            self.buffer.line_to_char(self.cursor.row + 1)
                        } else {
                            self.buffer.len_chars()
                        };

                        // 刪除舊行（包括換行符）
                        self.buffer.delete_range(line_start, line_end);

                        // 插入新行（保留換行符）
                        let new_line_with_newline =
                            if line_content.ends_with('\n') || line_content.ends_with("\r\n") {
                                format!("{}\n", new_line.trim_end_matches(['\n', '\r']))
                            } else {
                                new_line.trim_end_matches(['\n', '\r']).to_string()
                            };
                        self.buffer.insert(line_start, &new_line_with_newline);

                        self.view.invalidate_cache();

                        self.message = Some("Toggled comment".to_string());
                    }
                }
            }

            // 縮排（Tab 鍵）
            Command::Indent => {
                if self.has_selection() {
                    // 多行選擇：對每行添加 4 個空格
                    if let Some(sel) = self.selection {
                        let (start_row, _) = sel.start.min(sel.end);
                        let (end_row, _) = sel.start.max(sel.end);

                        // 從後往前處理，避免行號變化
                        for row in (start_row..=end_row).rev() {
                            let line_start = self.buffer.line_to_char(row);
                            self.buffer.insert(line_start, "    ");
                        }

                        self.view.invalidate_cache();

                        // 保留選擇狀態
                        self.cursor.row = start_row;
                        self.cursor.col = 0;
                        self.cursor.desired_visual_col = 0;
                    }
                } else {
                    // 單行：在光標位置插入 4 個空格
                    let pos = self.cursor.char_position(&self.buffer);
                    self.buffer.insert(pos, "    ");
                    self.view.invalidate_cache();
                    self.cursor.col += 4;
                    self.cursor.desired_visual_col = self.cursor.col;
                }
            }

            // 退位（Shift+Tab 鍵）
            Command::Unindent => {
                if self.has_selection() {
                    // 多行選擇：對每行刪除最多 4 個前導空格
                    if let Some(sel) = self.selection {
                        let (start_row, _) = sel.start.min(sel.end);
                        let (end_row, _) = sel.start.max(sel.end);

                        // 從後往前處理，避免行號變化
                        for row in (start_row..=end_row).rev() {
                            let line_content = self.buffer.get_line_content(row);
                            let spaces_to_remove = line_content
                                .chars()
                                .take_while(|&c| c == ' ')
                                .take(4)
                                .count();

                            if spaces_to_remove > 0 {
                                let line_start = self.buffer.line_to_char(row);
                                self.buffer
                                    .delete_range(line_start, line_start + spaces_to_remove);
                            }
                        }

                        self.view.invalidate_cache();

                        // 保留選擇狀態
                        self.cursor.row = start_row;
                        self.cursor.col = 0;
                        self.cursor.desired_visual_col = 0;
                    }
                } else {
                    // 單行：刪除光標前最多 4 個空格
                    let line_content = self.buffer.get_line_content(self.cursor.row);
                    let before_cursor: String =
                        line_content.chars().take(self.cursor.col).collect();
                    let spaces_to_remove = before_cursor
                        .chars()
                        .rev()
                        .take_while(|&c| c == ' ')
                        .take(4)
                        .count();

                    if spaces_to_remove > 0 {
                        let line_start = self.buffer.line_to_char(self.cursor.row);
                        let delete_start = line_start + self.cursor.col - spaces_to_remove;
                        self.buffer
                            .delete_range(delete_start, delete_start + spaces_to_remove);
                        self.view.invalidate_cache();
                        self.cursor.col -= spaces_to_remove;
                        self.cursor.desired_visual_col = self.cursor.col;
                    }
                }
            }

            // 跳轉到行
            Command::GoToLine => {
                if let Ok(Some(line_str)) =
                    crate::dialog::prompt("Go to line:", self.terminal.size())
                {
                    if let Ok(line_num) = line_str.trim().parse::<usize>() {
                        if line_num > 0 && line_num <= self.buffer.line_count() {
                            self.cursor.row = line_num - 1;
                            self.cursor.col = 0;
                            self.cursor.desired_visual_col = 0;
                            self.message = Some(format!("Jumped to line {}", line_num));
                        } else {
                            self.message = Some(format!("Invalid line number: {}", line_num));
                        }
                    } else {
                        self.message = Some("Please enter a valid number".to_string());
                    }
                }
            }

            // 編碼切換
            Command::ChangeEncoding => {
                if let Ok(Some(encoding_str)) =
                    crate::dialog::prompt("Change encoding to:", self.terminal.size())
                {
                    if let Some(encoding) = Self::parse_encoding(&encoding_str) {
                        // 檢查是否有檔案路徑（區分已存在檔案和新建檔案）
                        if self.buffer.has_file_path() {
                            // 已存在的檔案：需要重新載入
                            if self.buffer.is_modified() {
                                // 有未保存的修改，顯示確認對話框
                                if let Ok(confirmed) = crate::dialog::confirm(
                                    "Unsaved changes will be lost. Continue?",
                                    self.terminal.size(),
                                ) {
                                    if confirmed {
                                        match self.buffer.reload_with_encoding(encoding) {
                                            Ok(_) => {
                                                // 重新載入成功，重置游標
                                                self.cursor.row = 0;
                                                self.cursor.col = 0;
                                                self.cursor.desired_visual_col = 0;
                                                self.cursor.visual_line_index = 0;
                                                self.view.invalidate_cache();
                                                self.message = Some(format!(
                                                    "Encoding changed to {} (file reloaded)",
                                                    encoding.name()
                                                ));
                                            }
                                            Err(e) => {
                                                self.message =
                                                    Some(format!("Failed to reload file: {}", e));
                                            }
                                        }
                                    }
                                }
                            } else {
                                // 沒有未保存的修改，直接重新載入
                                match self.buffer.reload_with_encoding(encoding) {
                                    Ok(_) => {
                                        self.cursor.row = 0;
                                        self.cursor.col = 0;
                                        self.cursor.desired_visual_col = 0;
                                        self.cursor.visual_line_index = 0;
                                        self.view.invalidate_cache();
                                        self.message = Some(format!(
                                            "Encoding changed to {} (file reloaded)",
                                            encoding.name()
                                        ));
                                    }
                                    Err(e) => {
                                        self.message =
                                            Some(format!("Failed to reload file: {}", e));
                                    }
                                }
                            }
                        } else {
                            // 新建檔案：只設定編碼，不重新載入
                            self.buffer.change_encoding(encoding);
                            self.message = Some(format!(
                                "Encoding set to {} (will be used on save)",
                                encoding.name()
                            ));
                        }
                    } else {
                        self.message = Some(format!("Unsupported encoding: {}", encoding_str));
                    }
                }
            }

            // 切換語法高亮
            #[cfg(feature = "syntax-highlighting")]
            Command::ToggleSyntaxHighlight => {
                self.highlight_enabled = !self.highlight_enabled;
                self.message = Some(format!(
                    "Syntax Highlight: {}",
                    if self.highlight_enabled {
                        "Enabled"
                    } else {
                        "Disabled"
                    }
                ));
            }

            // 顯示幫助
            Command::ShowHelp => {
                // 保存當前終端狀態
                if let Err(e) = crate::dialog::show_help(self.terminal.size()) {
                    self.message = Some(format!("Failed to show help: {}", e));
                }
                // 重新繪製編輯器畫面
                self.view.invalidate_cache();
            }
        }

        Ok(())
    }

    fn has_selection(&self) -> bool {
        self.selection.is_some()
    }

    /// 獲取要複製/剪切的文本
    /// 如果有選擇範圍，返回選擇的文本；否則返回當前整行（帶換行符）
    fn get_copy_text(&self) -> String {
        if self.has_selection() {
            self.get_selected_text()
        } else {
            // 複製當前整行（完整內容，包括尾部空格和換行符）
            let line_text = self.buffer.get_line_full(self.cursor.row);
            // 確保以換行符結尾（用於識別整行貼上）
            if line_text.ends_with('\n') {
                line_text
            } else {
                format!("{}\n", line_text)
            }
        }
    }

    /// 設置剪貼簿內容
    /// use_system: true 表示使用系統剪貼簿，false 表示僅使用內部剪貼簿
    fn set_clipboard_text(&mut self, text: String, use_system: bool) {
        if use_system {
            // 嘗試系統剪貼簿，失敗則回退到內部剪貼簿
            if self.clipboard.set_text(&text).is_err() && !self.clipboard.is_available() {
                self.message = Some("Copied (internal clipboard)".to_string());
            }
            self.internal_clipboard = text; // 同步到內部剪貼簿
        } else {
            // 僅使用內部剪貼簿
            self.internal_clipboard = text;
            self.message = Some("Copied (internal clipboard)".to_string());
        }
    }

    /// 獲取剪貼簿內容
    /// use_system: true 表示優先使用系統剪貼簿，false 表示僅使用內部剪貼簿
    fn get_clipboard_text(&mut self, use_system: bool) -> String {
        if use_system {
            // 嘗試從系統剪貼簿獲取，失敗則使用內部剪貼簿
            self.clipboard.get_text().unwrap_or_else(|_| {
                if self.internal_clipboard.is_empty() {
                    if !self.clipboard.is_available() {
                        self.message = Some("Nothing to paste (internal clipboard)".to_string());
                    }
                    String::new()
                } else {
                    self.internal_clipboard.clone()
                }
            })
        } else {
            // 僅使用內部剪貼簿
            if self.internal_clipboard.is_empty() {
                self.message = Some("Nothing to paste (internal clipboard)".to_string());
                String::new()
            } else {
                self.internal_clipboard.clone()
            }
        }
    }

    /// 執行貼上操作
    fn paste_text(&mut self, text: String) {
        if text.is_empty() {
            return;
        }

        if self.has_selection() {
            self.delete_selection();
        }

        // 檢查是否為整行貼上（文字以換行結尾）
        let is_whole_line = text.ends_with('\n');

        if is_whole_line {
            // 整行貼上：在光標所在行的開始處插入
            let line_start = self.buffer.line_to_char(self.cursor.row);
            self.buffer.insert(line_start, &text);
            self.view.invalidate_cache();

            // 計算插入了多少行
            let inserted_lines = text.chars().filter(|&c| c == '\n').count();

            // 光標移動到被擠下去的原行首
            self.cursor.row += inserted_lines;
            self.cursor.col = 0;
            self.cursor.desired_visual_col = 0;
        } else {
            // 普通貼上：在光標位置插入
            let pos = self.cursor.char_position(&self.buffer);
            self.buffer.insert(pos, &text);
            self.view.invalidate_cache();
            // 移動到貼上內容末尾
            for ch in text.chars() {
                if ch == '\n' {
                    self.cursor.row += 1;
                    self.cursor.col = 0;
                } else {
                    self.cursor.col += 1;
                }
            }
            self.cursor.desired_visual_col = self.cursor.col;
        }
    }

    fn get_selected_text(&self) -> String {
        if let Some(sel) = self.selection {
            let (start_row, start_col) = sel.start.min(sel.end);
            let (end_row, end_col) = sel.start.max(sel.end);

            let mut text = String::new();

            for row in start_row..=end_row {
                let line = self.buffer.get_line_content(row);
                let line = line.trim_end_matches(['\n', '\r']);

                if row == start_row && row == end_row {
                    // 單行選擇
                    let chars: Vec<char> = line.chars().collect();
                    text.push_str(
                        &chars[start_col..end_col.min(chars.len())]
                            .iter()
                            .collect::<String>(),
                    );
                } else if row == start_row {
                    // 第一行
                    let chars: Vec<char> = line.chars().collect();
                    text.push_str(&chars[start_col..].iter().collect::<String>());
                    text.push('\n');
                } else if row == end_row {
                    // 最後一行
                    let chars: Vec<char> = line.chars().collect();
                    text.push_str(&chars[..end_col.min(chars.len())].iter().collect::<String>());
                } else {
                    // 中間行
                    text.push_str(line);
                    text.push('\n');
                }
            }

            text
        } else {
            String::new()
        }
    }

    fn delete_selection(&mut self) {
        if let Some(sel) = self.selection {
            let (start_row, start_col) = sel.start.min(sel.end);
            let (end_row, end_col) = sel.start.max(sel.end);

            let start_pos = self.buffer.line_to_char(start_row) + start_col;
            let end_pos = self.buffer.line_to_char(end_row) + end_col;

            self.buffer.delete_range(start_pos, end_pos);
            self.view.invalidate_cache();

            self.cursor
                .set_position(&self.buffer, &self.view, start_row, start_col);
            self.selection = None;
        }
    }

    fn get_debug_info(&self) -> String {
        let total_lines = self.buffer.line_count();
        let screen_rows = self.view.screen_rows;
        let logical_row = self.cursor.row;
        let logical_col = self.cursor.col;
        let visual_line_index = self.cursor.visual_line_index;

        // 計算可用列寬度
        let available_width = self.view.get_available_width(&self.buffer);

        // 計算當前行的視覺列位置和總字符數
        let (
            visual_col_in_line,
            line_char_count,
            line_visual_width,
            total_visual_lines,
            current_visual_line_width,
        ) = if let Some(line) = self.buffer.line(logical_row) {
            let line_str = line.to_string();
            let line_str = line_str.trim_end_matches(['\n', '\r']);
            let visual_col = self.view.logical_col_to_visual_col(line_str, logical_col);
            let char_count = line_str.chars().count();

            // 計算在當前視覺行內的列位置
            let visual_lines = self
                .view
                .calculate_visual_lines_for_row(&self.buffer, logical_row);
            let total_visual_lines = visual_lines.len();
            let mut accumulated = 0;
            for line in visual_lines
                .iter()
                .take(visual_line_index.min(visual_lines.len()))
            {
                accumulated += visual_width(line);
            }
            let col_in_visual_line = visual_col.saturating_sub(accumulated);

            // 計算整行的視覺寬度
            let line_visual_width = visual_width(line_str);

            // 計算當前視覺行的寬度
            let current_visual_line_width = if visual_line_index < visual_lines.len() {
                visual_width(&visual_lines[visual_line_index])
            } else {
                0
            };

            (
                col_in_visual_line,
                char_count,
                line_visual_width,
                total_visual_lines,
                current_visual_line_width,
            )
        } else {
            (0, 0, 0, 0, 0)
        };

        // 計算選取的邏輯字數和顯示寬度
        let (selection_char_count, selection_visual_width) = if self.selection.is_some() {
            let selected_text = self.get_selected_text();
            let char_count = selected_text.chars().count();
            let visual_width = visual_width(&selected_text);
            (char_count, visual_width)
        } else {
            (0, 0)
        };

        format!(
            "DEBUG | AA:{}x{} LL:L{}/{}:C{}/{}:{} VL:L{}/{}:C{}/{} SC:{}:{}",
            screen_rows,
            available_width,
            logical_row + 1,
            total_lines,
            logical_col,
            line_char_count,
            line_visual_width,
            visual_line_index + 1,
            total_visual_lines,
            visual_col_in_line,
            current_visual_line_width,
            selection_char_count,
            selection_visual_width
        )
    }

    /// 獲取語法高亮後的行
    ///
    /// 使用增量處理策略：智慧選擇起始行，維護語法狀態的正確性和效能平衡
    #[cfg(feature = "syntax-highlighting")]
    pub fn get_highlighted_lines(
        &mut self,
        start_row: usize,
        end_row: usize,
    ) -> std::collections::HashMap<usize, String> {
        use wedi_core::highlight::CachedLine;

        let mut result = std::collections::HashMap::new();

        // 檢查是否有語法高亮引擎
        let Some(ref engine) = self.highlight_engine else {
            return result;
        };

        // 建立高亮器
        let Some(mut highlighter) = engine.create_highlighter() else {
            return result;
        };

        // 增量處理策略：智慧選擇起始行
        // 1. 小檔案或接近檔案開頭：從第 0 行開始（保證正確性）
        // 2. 大檔案：從 start_row - BUFFER 開始，平衡效能和正確性
        const BUFFER_LINES: usize = 100; // 緩衝範圍
        const SMALL_FILE_THRESHOLD: usize = 500; // 小檔案閾值

        let total_lines = self.buffer.line_count();
        let is_small_file = total_lines <= SMALL_FILE_THRESHOLD;
        let is_near_start = start_row < BUFFER_LINES;

        // 決定處理起始行
        let process_start = if is_small_file || is_near_start {
            0 // 小檔案或接近開頭，從第 0 行開始確保正確性
        } else {
            start_row.saturating_sub(BUFFER_LINES) // 大檔案，從緩衝區開始
        };

        // 循序處理（維護跨行狀態）
        for row in process_start..=end_row.min(total_lines.saturating_sub(1)) {
            let line_text = match self.buffer.line(row) {
                Some(line) => {
                    // ⚠️ 重要：保留換行符！syntect 需要換行符才能正確解析語法狀態
                    // 參考：與 cate 專案相同的修復
                    let mut text = line.to_string();
                    // 確保有換行符（syntect 需要）
                    if !text.ends_with('\n') && !text.ends_with("\r\n") {
                        text.push('\n');
                    }
                    text
                }
                None => continue,
            };

            // 檢查快取
            if self.highlight_cache.is_valid(row, &line_text) {
                if row >= start_row {
                    // 在可見區域內，使用快取
                    if let Some(cached) = self.highlight_cache.get(row) {
                        result.insert(row, cached.highlighted.clone());
                    }
                }
                // 即使不在可見區域，也要處理這一行以維護狀態
                let _ = highlighter.highlight_line(&line_text);
            } else {
                // 快取失效，重新高亮
                let mut highlighted = highlighter.highlight_line(&line_text);

                // ⚠️ 修復：去除末尾的換行符，避免在 Linux 終端產生殘影
                // syntect 需要換行符來解析語法狀態，但渲染時不應輸出換行符
                highlighted = highlighted.trim_end_matches(&['\n', '\r'][..]).to_string();

                // 更新快取
                self.highlight_cache.insert(
                    row,
                    CachedLine {
                        text: line_text,
                        highlighted: highlighted.clone(),
                    },
                );

                // 如果在可見區域，加入結果
                if row >= start_row {
                    result.insert(row, highlighted);
                }
            }
        }

        result
    }

    /// 使語法高亮快取失效（編輯操作後調用）
    #[cfg(feature = "syntax-highlighting")]
    pub fn invalidate_highlight_cache(&mut self, from_line: usize) {
        use wedi_core::highlight::EditType;
        self.highlight_cache
            .invalidate_from_edit(from_line, EditType::CharInsert);
    }

    // 解析編碼字串
    fn parse_encoding(enc_str: &str) -> Option<&'static encoding_rs::Encoding> {
        match enc_str.to_lowercase().as_str() {
            "utf-8" | "utf8" => Some(encoding_rs::UTF_8),
            "utf-16le" | "utf16le" => Some(encoding_rs::UTF_16LE),
            "utf-16be" | "utf16be" => Some(encoding_rs::UTF_16BE),
            "gbk" | "cp936" => Some(encoding_rs::GBK),
            "shift-jis" | "shift_jis" | "sjis" => Some(encoding_rs::SHIFT_JIS),
            "big5" | "cp950" => encoding_rs::Encoding::for_label(b"big5"),
            "cp1252" | "windows-1252" => Some(encoding_rs::WINDOWS_1252),
            _ => encoding_rs::Encoding::for_label(enc_str.as_bytes()),
        }
    }
}