rgpui 1.3.0

use crate::{
    Bounds, Context, EntityInputHandler as _, Hsla, Path, PathBuilder, Pixels, SharedString,
    TextRun, TextStyle, Window, point, px,
};
use ropey::RopeSlice;

use super::{
    Indent, IndentInline, InputState, LastLayout, Outdent, OutdentInline, RopeExt as _,
    input::element::TextElement, input::mode::InputMode,
};

/// 制表符大小设置，用于缩进计算。
#[derive(Debug, Copy, Clone)]
pub struct TabSize {
    /// 默认是 2
    pub tab_size: usize,
    /// 设置为 true 时使用 `\t` 作为 tab 缩进，默认是 false
    pub hard_tabs: bool,
}

impl Default for TabSize {
    fn default() -> Self {
        Self {
            tab_size: 2,
            hard_tabs: false,
        }
    }
}

impl TabSize {
    pub(super) fn to_string(&self) -> SharedString {
        if self.hard_tabs {
            "\t".into()
        } else {
            " ".repeat(self.tab_size).into()
        }
    }

    /// 计算行的缩进大小（以空格计）。
    pub fn indent_count(&self, line: &RopeSlice) -> usize {
        let mut count = 0;
        for ch in line.chars() {
            match ch {
                '\t' => count += self.tab_size,
                ' ' => count += 1,
                _ => break,
            }
        }

        count
    }
}

impl InputMode {
    #[inline]
    pub(super) fn is_indentable(&self) -> bool {
        match self {
            InputMode::PlainText { multi_line, .. } => *multi_line,
            _ => false,
        }
    }
}

impl TextElement {
    /// 测量给定列数在像素中的缩进宽度。
    fn measure_indent_width(&self, style: &TextStyle, column: usize, window: &Window) -> Pixels {
        let font_size = style.font_size.to_pixels(window.rem_size());
        let layout = window.text_system().shape_line(
            crate::SharedString::from(" ".repeat(column)),
            font_size,
            &[TextRun {
                len: column,
                font: style.font(),
                color: Hsla::default(),
                background_color: None,
                strikethrough: None,
                underline: None,
            }],
            None,
        );

        layout.width
    }

    /// 布局缩进参考线路径。
    pub(super) fn layout_indent_guides(
        &self,
        state: &InputState,
        bounds: &Bounds<Pixels>,
        last_layout: &LastLayout,
        text_style: &TextStyle,
        window: &mut Window,
    ) -> Option<Path<Pixels>> {
        if !state.mode.has_indent_guides() {
            return None;
        }

        let indent_width =
            self.measure_indent_width(text_style, state.mode.tab_size().tab_size, window);

        let tab_size = state.mode.tab_size();
        let line_height = last_layout.line_height;
        let mut builder = PathBuilder::stroke(px(1.));
        let mut offset_y = last_layout.visible_top;
        let mut last_indents = vec![];

        for (&buffer_line, line_layout) in last_layout
            .visible_buffer_lines
            .iter()
            .zip(last_layout.lines.iter())
        {
            let line = state.core.text.slice_line(buffer_line);
            let mut current_indents = vec![];
            if line.len() > 0 {
                let indent_count = tab_size.indent_count(&line);
                for offset in (0..indent_count).step_by(tab_size.tab_size) {
                    let x = if indent_count > 0 {
                        indent_width * offset as f32 / tab_size.tab_size as f32
                    } else {
                        px(0.)
                    };

                    let pos = point(x + last_layout.line_number_width, offset_y);

                    builder.move_to(pos);
                    builder.line_to(point(pos.x, pos.y + line_height));
                    current_indents.push(pos.x);
                }
            } else if last_indents.len() > 0 {
                for x in &last_indents {
                    let pos = point(*x, offset_y);
                    builder.move_to(pos);
                    builder.line_to(point(pos.x, pos.y + line_height));
                }
                current_indents = last_indents.clone();
            }

            offset_y += line_layout.wrapped_lines.len() * line_height;
            last_indents = current_indents;
        }

        builder.translate(bounds.origin);
        let path = builder.build().unwrap();
        Some(path)
    }

    /// 布局标尺路径（O5）：每列一条贯穿可视高度的竖线。
    ///
    /// 列为字符数；x 按数字 advance 折算（等宽字体精确，变宽字体近似，文档注明）；
    /// 视口固定（不随横向滚动，v1 约束）；空列表返回 `None`。
    /// 颜色不在此解析（prepaint 持有 state 读锁，`cx` 可变借用冲突），paint 阶段读
    /// `ruler_color`（`None` 跟主题边框色）。
    /// `editor` feature 门控（读门控字段）。
    #[cfg(feature = "editor")]
    pub(super) fn layout_rulers(
        &self,
        state: &InputState,
        bounds: &Bounds<Pixels>,
        last_layout: &LastLayout,
        text_style: &TextStyle,
        window: &mut Window,
    ) -> Option<Path<Pixels>> {
        if state.rulers.is_empty() {
            return None;
        }
        // 数字 advance：塑形十个数字取均值（与缩进测量同款手法）。
        let font_size = text_style.font_size.to_pixels(window.rem_size());
        let digits = crate::SharedString::from("0123456789");
        let shaped = window.text_system().shape_line(
            digits,
            font_size,
            &[TextRun {
                len: 10,
                font: text_style.font(),
                color: Hsla::default(),
                background_color: None,
                strikethrough: None,
                underline: None,
            }],
            None,
        );
        let digit_advance = shaped.width() * 0.1;
        let mut builder = PathBuilder::stroke(px(1.));
        let height = bounds.size.height;
        for column in &state.rulers {
            let x = last_layout.line_number_width + digit_advance * (*column as f32);
            builder.move_to(point(x, px(0.)));
            builder.line_to(point(x, height));
        }
        builder.translate(bounds.origin);
        let path = builder.build().unwrap();
        Some(path)
    }
}

impl InputState {
    /// 设置多行模式是否显示缩进参考线，默认 false（编辑器显式打开）。
    ///
    /// 仅多行生效（单行忽略）。
    pub fn indent_guides(mut self, indent_guides: bool) -> Self {
        debug_assert!(self.mode.is_multi_line());
        if let InputMode::PlainText {
            indent_guides: l, ..
        } = &mut self.mode
        {
            *l = indent_guides;
        }
        self
    }

    /// 运行时设置是否显示缩进参考线，仅多行生效（单行忽略）。
    pub fn set_indent_guides(
        &mut self,
        indent_guides: bool,
        _: &mut Window,
        cx: &mut Context<Self>,
    ) {
        debug_assert!(self.mode.is_multi_line());
        if let InputMode::PlainText {
            indent_guides: l, ..
        } = &mut self.mode
        {
            *l = indent_guides;
        }
        cx.notify();
    }

    #[cfg(feature = "editor")]
    /// 设置标尺列（builder 版，字符数；空即关，O5）。
    ///
    /// 等宽字体精确（x 按数字 advance 折算），变宽字体近似；视口固定不随横向滚动。
    pub fn rulers(mut self, columns: Vec<usize>) -> Self {
        self.rulers = columns;
        self
    }

    #[cfg(feature = "editor")]
    /// 设置标尺列（创建后修改；空即关）。
    pub fn set_rulers(&mut self, columns: Vec<usize>, cx: &mut Context<Self>) {
        self.rulers = columns;
        cx.notify();
    }

    #[cfg(feature = "editor")]
    /// 设置标尺颜色（`None` 跟主题边框色）。
    pub fn set_ruler_color(&mut self, color: Option<Hsla>, cx: &mut Context<Self>) {
        self.ruler_color = color;
        cx.notify();
    }

    /// 设置输入框的制表符大小，仅多行生效（单行/自动增长忽略）。
    pub fn tab_size(mut self, tab: TabSize) -> Self {
        debug_assert!(self.mode.is_multi_line());
        match &mut self.mode {
            InputMode::PlainText { tab: t, .. } => *t = tab,
            _ => {}
        }
        self
    }

    /// 内联缩进（Tab 键），光标处插入缩进。
    pub(super) fn indent_inline(
        &mut self,
        _: &IndentInline,
        window: &mut Window,
        cx: &mut Context<Self>,
    ) {
        self.indent(false, window, cx);
    }

    /// 块级缩进（Cmd+]），为选区每行行首插入缩进。
    pub(super) fn indent_block(&mut self, _: &Indent, window: &mut Window, cx: &mut Context<Self>) {
        self.indent(true, window, cx);
    }

    /// 内联减少缩进（Shift+Tab），删除光标前一个缩进。
    pub(super) fn outdent_inline(
        &mut self,
        _: &OutdentInline,
        window: &mut Window,
        cx: &mut Context<Self>,
    ) {
        self.outdent(false, window, cx);
    }

    /// 块级减少缩进（Cmd+[），删除选区每行行首缩进。
    pub(super) fn outdent_block(
        &mut self,
        _: &Outdent,
        window: &mut Window,
        cx: &mut Context<Self>,
    ) {
        self.outdent(true, window, cx);
    }

    /// 对选区执行缩进。`block` 为 true 时即使无选区也缩进整行。
    pub(super) fn indent(&mut self, block: bool, window: &mut Window, cx: &mut Context<Self>) {
        if self.read_only {
            cx.propagate();
            return;
        }
        if !self.mode.is_indentable() {
            cx.propagate();
            return;
        };

        let tab_indent = self.mode.tab_size().to_string();
        let selected_range = self.core.selected_range;
        let mut added_len = 0;
        let is_selected = !self.core.selected_range.is_empty();

        if is_selected || block {
            let start_offset = self.start_of_line_of_selection(window, cx);
            let mut offset = start_offset;

            let selected_text = self
                .text_for_range(
                    self.range_to_utf16(&(offset..selected_range.end)),
                    &mut None,
                    window,
                    cx,
                )
                .unwrap_or("".into());

            for line in selected_text.split('\n') {
                self.replace_text_in_range_silent(
                    Some(self.range_to_utf16(&(offset..offset))),
                    &tab_indent,
                    window,
                    cx,
                );
                added_len += tab_indent.len();
                // +1 为 "\n"，`\r` 已包含在 `line` 中。
                offset += line.len() + tab_indent.len() + 1;
            }

            if is_selected {
                self.core.selected_range = (start_offset..selected_range.end + added_len).into();
            } else {
                self.core.selected_range =
                    (selected_range.start + added_len..selected_range.end + added_len).into();
            }
        } else {
            // 无选区
            let offset = self.core.selected_range.start;
            self.replace_text_in_range_silent(
                Some(self.range_to_utf16(&(offset..offset))),
                &tab_indent,
                window,
                cx,
            );
            added_len = tab_indent.len();

            self.core.selected_range =
                (selected_range.start + added_len..selected_range.end + added_len).into();
        }
    }

    /// 对选区执行减少缩进。`block` 为 true 时即使无选区也减少整行缩进。
    pub(super) fn outdent(&mut self, block: bool, window: &mut Window, cx: &mut Context<Self>) {
        if self.read_only {
            cx.propagate();
            return;
        }
        if !self.mode.is_indentable() {
            cx.propagate();
            return;
        };

        let tab_indent = self.mode.tab_size().to_string();
        let selected_range = self.core.selected_range;
        let mut removed_len = 0;
        let is_selected = !self.core.selected_range.is_empty();

        if is_selected || block {
            let start_offset = self.start_of_line_of_selection(window, cx);
            let mut offset = start_offset;

            let selected_text = self
                .text_for_range(
                    self.range_to_utf16(&(offset..selected_range.end)),
                    &mut None,
                    window,
                    cx,
                )
                .unwrap_or("".into());

            for line in selected_text.split('\n') {
                if line.starts_with(tab_indent.as_ref()) {
                    self.replace_text_in_range_silent(
                        Some(self.range_to_utf16(&(offset..offset + tab_indent.len()))),
                        "",
                        window,
                        cx,
                    );
                    removed_len += tab_indent.len();

                    // +1 为 "\n"
                    offset += line.len().saturating_sub(tab_indent.len()) + 1;
                } else {
                    offset += line.len() + 1;
                }
            }

            if is_selected {
                self.core.selected_range =
                    (start_offset..selected_range.end.saturating_sub(removed_len)).into();
            } else {
                self.core.selected_range = (selected_range.start.saturating_sub(removed_len)
                    ..selected_range.end.saturating_sub(removed_len))
                    .into();
            }
        } else {
            // 无选区
            let start_offset = self.core.selected_range.start;
            let offset = self.start_of_line_of_selection(window, cx);
            let offset = self.offset_from_utf16(self.offset_to_utf16(offset));
            // FIXME: 提升性能
            if self
                .core
                .text
                .slice(offset..self.core.text.len())
                .to_string()
                .starts_with(tab_indent.as_ref())
            {
                self.replace_text_in_range_silent(
                    Some(self.range_to_utf16(&(offset..offset + tab_indent.len()))),
                    "",
                    window,
                    cx,
                );
                removed_len = tab_indent.len();
                let new_offset = start_offset.saturating_sub(removed_len);
                self.core.selected_range = (new_offset..new_offset).into();
            }
        }
    }
}

#[cfg(test)]
mod tests {
    use ropey::RopeSlice;

    use super::TabSize;

    #[test]
    fn test_tab_size() {
        let tab = TabSize {
            tab_size: 2,
            hard_tabs: false,
        };
        assert_eq!(tab.to_string(), "  ");
        let tab = TabSize {
            tab_size: 4,
            hard_tabs: false,
        };
        assert_eq!(tab.to_string(), "    ");

        let tab = TabSize {
            tab_size: 2,
            hard_tabs: true,
        };
        assert_eq!(tab.to_string(), "\t");
        let tab = TabSize {
            tab_size: 4,
            hard_tabs: true,
        };
        assert_eq!(tab.to_string(), "\t");
    }

    #[test]
    fn test_tab_size_indent_count() {
        let tab = TabSize {
            tab_size: 4,
            hard_tabs: false,
        };
        assert_eq!(tab.indent_count(&RopeSlice::from("abc")), 0);
        assert_eq!(tab.indent_count(&RopeSlice::from("  abc")), 2);
        assert_eq!(tab.indent_count(&RopeSlice::from("    abc")), 4);
        assert_eq!(tab.indent_count(&RopeSlice::from("\tabc")), 4);
        assert_eq!(tab.indent_count(&RopeSlice::from("  \tabc")), 6);
        assert_eq!(tab.indent_count(&RopeSlice::from(" \t abc  ")), 6);
        assert_eq!(tab.indent_count(&RopeSlice::from("abc")), 0);
    }
}