Skip to main content

ftui_widgets/
table.rs

1use crate::block::Block;
2use crate::mouse::MouseResult;
3use crate::undo_support::{TableUndoExt, UndoSupport, UndoWidgetId};
4use crate::{
5    MeasurableWidget, SizeConstraints, StatefulWidget, Widget, apply_style, clear_text_area,
6    set_style_area,
7};
8use ftui_core::event::{MouseButton, MouseEvent, MouseEventKind};
9use ftui_core::geometry::{Rect, Size};
10use ftui_layout::{Constraint, Flex};
11use ftui_render::buffer::Buffer;
12use ftui_render::cell::Cell;
13use ftui_render::frame::{Frame, HitId, HitRegion};
14use ftui_style::{
15    Style, TableEffectResolver, TableEffectScope, TableEffectTarget, TableSection, TableTheme,
16};
17use ftui_text::{Line, Span, Text};
18use std::any::Any;
19
20fn text_into_owned(text: Text<'_>) -> Text<'static> {
21    Text::from_lines(
22        text.into_iter()
23            .map(|line| Line::from_spans(line.into_iter().map(Span::into_owned))),
24    )
25}
26
27/// A row in a table.
28#[derive(Debug, Clone, Default)]
29pub struct Row {
30    cells: Vec<Text<'static>>,
31    height: u16,
32    style: Style,
33    bottom_margin: u16,
34}
35
36impl Row {
37    /// Create a new row from an iterator of cell contents.
38    #[must_use]
39    pub fn new<'a>(cells: impl IntoIterator<Item = impl Into<Text<'a>>>) -> Self {
40        Self {
41            cells: cells
42                .into_iter()
43                .map(|c| text_into_owned(c.into()))
44                .collect(),
45            height: 1,
46            style: Style::default(),
47            bottom_margin: 0,
48        }
49    }
50
51    /// Set the row height in lines.
52    ///
53    /// Values below 1 clamp to a single visible line so rows always consume
54    /// vertical space deterministically.
55    #[must_use]
56    pub fn height(mut self, height: u16) -> Self {
57        self.height = height.max(1);
58        self
59    }
60
61    /// Set the row style.
62    #[must_use]
63    pub fn style(mut self, style: Style) -> Self {
64        self.style = style;
65        self
66    }
67
68    /// Set the bottom margin after this row.
69    #[must_use]
70    pub fn bottom_margin(mut self, margin: u16) -> Self {
71        self.bottom_margin = margin;
72        self
73    }
74}
75
76/// A widget to display data in a table.
77#[derive(Debug, Clone, Default)]
78pub struct Table<'a> {
79    rows: Vec<Row>,
80    widths: Vec<Constraint>,
81    header: Option<Row>,
82    block: Option<Block<'a>>,
83    style: Style,
84    highlight_style: Style,
85    theme: TableTheme,
86    theme_phase: f32,
87    column_spacing: u16,
88    /// Optional hit ID for mouse interaction.
89    /// When set, each table row registers a hit region with the hit grid.
90    hit_id: Option<HitId>,
91    /// Optional data hash to enable caching of filtered and sorted indices.
92    data_hash: Option<u64>,
93}
94
95impl<'a> Table<'a> {
96    /// Create a new table with the given rows and column width constraints.
97    #[must_use]
98    pub fn new(
99        rows: impl IntoIterator<Item = Row>,
100        widths: impl IntoIterator<Item = Constraint>,
101    ) -> Self {
102        let rows: Vec<Row> = rows.into_iter().collect();
103        let widths: Vec<Constraint> = widths.into_iter().collect();
104
105        Self {
106            rows,
107            widths,
108            header: None,
109            block: None,
110            style: Style::default(),
111            highlight_style: Style::default(),
112            theme: TableTheme::default(),
113            theme_phase: 0.0,
114            column_spacing: 1,
115            hit_id: None,
116            data_hash: None,
117        }
118    }
119
120    /// Set an explicit data hash to enable caching of filtered and sorted indices.
121    ///
122    /// This is highly recommended for large tables. When provided, the table widget
123    /// will cache the result of filtering and sorting in the `TableState`, skipping
124    /// expensive O(N) re-evaluation on frames where the hash, filter, and sort
125    /// parameters have not changed.
126    #[must_use]
127    pub fn data_hash(mut self, hash: u64) -> Self {
128        self.data_hash = Some(hash);
129        self
130    }
131
132    /// Set the header row.
133    #[must_use]
134    pub fn header(mut self, header: Row) -> Self {
135        self.header = Some(header);
136        self
137    }
138
139    /// Set the surrounding block.
140    #[must_use]
141    pub fn block(mut self, block: Block<'a>) -> Self {
142        self.block = Some(block);
143        self
144    }
145
146    /// Set the base table style.
147    #[must_use]
148    pub fn style(mut self, style: Style) -> Self {
149        self.style = style;
150        self
151    }
152
153    /// Set the style for the selected row.
154    #[must_use]
155    pub fn highlight_style(mut self, style: Style) -> Self {
156        self.highlight_style = style;
157        self
158    }
159
160    /// Set the table theme (base/states/effects).
161    #[must_use]
162    pub fn theme(mut self, theme: TableTheme) -> Self {
163        self.theme = theme;
164        self
165    }
166
167    /// Set the explicit animation phase for theme effects.
168    ///
169    /// Phase is deterministic and should be supplied by the caller (e.g. from tick count).
170    #[must_use]
171    pub fn theme_phase(mut self, phase: f32) -> Self {
172        self.theme_phase = phase;
173        self
174    }
175
176    /// Set the spacing between columns.
177    #[must_use]
178    pub fn column_spacing(mut self, spacing: u16) -> Self {
179        self.column_spacing = spacing;
180        self
181    }
182
183    /// Set a hit ID for mouse interaction.
184    ///
185    /// When set, each table row will register a hit region with the frame's
186    /// hit grid (if enabled). The hit data will be the row's index, allowing
187    /// click handlers to determine which row was clicked.
188    #[must_use]
189    pub fn hit_id(mut self, id: HitId) -> Self {
190        self.hit_id = Some(id);
191        self
192    }
193
194    fn filtered_and_sorted_indices(&self, state: &mut TableState) -> std::sync::Arc<[usize]> {
195        if let Some(hash) = self.data_hash
196            && let Some((cached_hash, cached_filter, cached_sort_col, cached_sort_asc, indices)) =
197                &state.cached_display_indices
198            && *cached_hash == hash
199            && *cached_filter == state.filter
200            && *cached_sort_col == state.sort_column
201            && *cached_sort_asc == state.sort_ascending
202        {
203            return std::sync::Arc::clone(indices);
204        }
205
206        let mut indices: Vec<usize> = (0..self.rows.len()).collect();
207
208        // 1. Filter
209        if !state.filter.trim().is_empty() {
210            let query = state.filter.trim().to_lowercase();
211            indices.retain(|&i| {
212                let row = &self.rows[i];
213                row.cells.iter().any(|cell| {
214                    // Optimization: check single-span content directly to avoid allocation
215                    // from to_plain_text().
216                    if let Some(line) = cell.lines().first()
217                        && cell.lines().len() == 1
218                        && line.spans().len() == 1
219                    {
220                        return crate::contains_ignore_case(&line.spans()[0].content, &query);
221                    }
222                    crate::contains_ignore_case(&cell.to_plain_text(), &query)
223                })
224            });
225        }
226
227        // 2. Sort
228        if let Some(col_idx) = state.sort_column {
229            use std::borrow::Cow;
230            let mut sort_keys: Vec<(usize, Cow<str>)> = indices
231                .iter()
232                .map(|&i| {
233                    let cell_text = self.rows[i].cells.get(col_idx);
234                    let key = match cell_text {
235                        Some(text) => {
236                            // Optimization: Borrow content directly if simple (1 line, 1 span)
237                            if let Some(line) = text.lines().first() {
238                                if text.lines().len() == 1 && line.spans().len() == 1 {
239                                    Cow::Borrowed(line.spans()[0].content.as_ref())
240                                } else {
241                                    Cow::Owned(text.to_plain_text())
242                                }
243                            } else {
244                                Cow::Borrowed("")
245                            }
246                        }
247                        None => Cow::Borrowed(""),
248                    };
249                    (i, key)
250                })
251                .collect();
252
253            if state.sort_ascending {
254                sort_keys.sort_unstable_by(|a, b| a.1.cmp(&b.1));
255            } else {
256                sort_keys.sort_unstable_by(|a, b| b.1.cmp(&a.1));
257            }
258
259            indices = sort_keys.into_iter().map(|(i, _)| i).collect();
260        }
261
262        let arc_indices: std::sync::Arc<[usize]> = indices.into();
263
264        if let Some(hash) = self.data_hash {
265            state.cached_display_indices = Some((
266                hash,
267                state.filter.clone(),
268                state.sort_column,
269                state.sort_ascending,
270                std::sync::Arc::clone(&arc_indices),
271            ));
272        }
273
274        arc_indices
275    }
276
277    fn requires_measurement(constraints: &[Constraint]) -> bool {
278        constraints.iter().any(|c| {
279            matches!(
280                c,
281                Constraint::FitContent | Constraint::FitContentBounded { .. } | Constraint::FitMin
282            )
283        })
284    }
285
286    fn compute_intrinsic_widths(rows: &[Row], header: Option<&Row>, col_count: usize) -> Vec<u16> {
287        if col_count == 0 {
288            return Vec::new();
289        }
290
291        let mut col_widths: Vec<u16> = vec![0; col_count];
292
293        if let Some(header) = header {
294            for (i, cell) in header.cells.iter().enumerate().take(col_count) {
295                let cell_width = cell
296                    .lines()
297                    .iter()
298                    .take(header.height as usize)
299                    .map(|l| l.width())
300                    .max()
301                    .unwrap_or(0)
302                    .min(u16::MAX as usize) as u16;
303                col_widths[i] = col_widths[i].max(cell_width);
304            }
305        }
306
307        for row in rows {
308            for (i, cell) in row.cells.iter().enumerate().take(col_count) {
309                let cell_width = cell
310                    .lines()
311                    .iter()
312                    .take(row.height as usize)
313                    .map(|l| l.width())
314                    .max()
315                    .unwrap_or(0)
316                    .min(u16::MAX as usize) as u16;
317                col_widths[i] = col_widths[i].max(cell_width);
318            }
319        }
320
321        col_widths
322    }
323}
324
325impl<'a> Widget for Table<'a> {
326    fn render(&self, area: Rect, frame: &mut Frame) {
327        let mut state = TableState::default();
328        StatefulWidget::render(self, area, frame, &mut state);
329    }
330}
331
332impl ftui_a11y::Accessible for Table<'_> {
333    fn accessibility_nodes(&self, area: Rect) -> Vec<ftui_a11y::node::A11yNodeInfo> {
334        use ftui_a11y::node::{A11yNodeInfo, A11yRole};
335
336        let base_id = crate::a11y_node_id(area);
337        let row_count = self.rows.len();
338        let col_count = self.widths.len();
339
340        let title = self
341            .block
342            .as_ref()
343            .and_then(|b| b.title_text())
344            .unwrap_or_default();
345
346        let mut table_node = A11yNodeInfo::new(base_id, A11yRole::Table, area)
347            .with_description(format!("{row_count} rows, {col_count} columns"));
348        if !title.is_empty() {
349            table_node = table_node.with_name(title);
350        }
351
352        vec![table_node]
353    }
354}
355
356pub type CachedTableDisplayIndices = (u64, String, Option<usize>, bool, std::sync::Arc<[usize]>);
357
358/// Mutable state for a [`Table`] widget.
359#[derive(Debug, Clone, Default)]
360pub struct TableState {
361    /// Unique ID for undo tracking.
362    #[allow(dead_code)]
363    undo_id: UndoWidgetId,
364    /// Index of the currently selected row, if any.
365    pub selected: Option<usize>,
366    /// Index of the currently hovered row, if any.
367    pub hovered: Option<usize>,
368    /// Scroll offset (first visible row index).
369    pub offset: usize,
370    /// Optional persistence ID for state saving/restoration.
371    /// When set, this state can be persisted via the [`Stateful`] trait.
372    persistence_id: Option<String>,
373    /// Current sort column (for undo support).
374    pub sort_column: Option<usize>,
375    /// Sort ascending (for undo support).
376    pub sort_ascending: bool,
377    /// Filter text (for undo support).
378    pub filter: String,
379    /// Cache for stable layout resizing (temporal coherence).
380    coherence: ftui_layout::CoherenceCache,
381    /// Cached display indices (data_hash, filter, sort_column, sort_ascending, indices)
382    #[doc(hidden)]
383    pub cached_display_indices: Option<CachedTableDisplayIndices>,
384    /// Cached intrinsic column widths (data_hash, widths)
385    #[doc(hidden)]
386    pub cached_intrinsic_widths: Option<(u64, std::sync::Arc<[u16]>)>,
387}
388
389impl TableState {
390    /// Set the selected row index.
391    pub fn select(&mut self, index: Option<usize>) {
392        self.selected = index;
393    }
394
395    /// Create a new TableState with a persistence ID for state saving.
396    #[must_use]
397    pub fn with_persistence_id(mut self, id: impl Into<String>) -> Self {
398        self.persistence_id = Some(id.into());
399        self
400    }
401
402    /// Get the persistence ID, if set.
403    #[must_use = "use the persistence id (if any)"]
404    pub fn persistence_id(&self) -> Option<&str> {
405        self.persistence_id.as_deref()
406    }
407}
408
409// ============================================================================
410// Stateful Persistence Implementation
411// ============================================================================
412
413/// Persistable state for a [`TableState`].
414///
415/// This struct contains only the fields that should be persisted across
416/// sessions. Derived/cached values are not included.
417#[derive(Clone, Debug, Default, PartialEq)]
418#[cfg_attr(
419    feature = "state-persistence",
420    derive(serde::Serialize, serde::Deserialize)
421)]
422pub struct TablePersistState {
423    /// Selected row index.
424    pub selected: Option<usize>,
425    /// Scroll offset (first visible row).
426    pub offset: usize,
427    /// Current sort column index.
428    pub sort_column: Option<usize>,
429    /// Sort direction (true = ascending, false = descending).
430    pub sort_ascending: bool,
431    /// Active filter text.
432    pub filter: String,
433}
434
435impl crate::stateful::Stateful for TableState {
436    type State = TablePersistState;
437
438    fn state_key(&self) -> crate::stateful::StateKey {
439        crate::stateful::StateKey::new("Table", self.persistence_id.as_deref().unwrap_or("default"))
440    }
441
442    fn save_state(&self) -> TablePersistState {
443        TablePersistState {
444            selected: self.selected,
445            offset: self.offset,
446            sort_column: self.sort_column,
447            sort_ascending: self.sort_ascending,
448            filter: self.filter.clone(),
449        }
450    }
451
452    fn restore_state(&mut self, state: TablePersistState) {
453        // Restore values directly; clamping to valid ranges happens during render
454        self.selected = state.selected;
455        self.hovered = None;
456        self.offset = state.offset;
457        self.sort_column = state.sort_column;
458        self.sort_ascending = state.sort_ascending;
459        self.filter = state.filter;
460    }
461}
462
463// ============================================================================
464// Undo Support Implementation
465// ============================================================================
466
467/// Snapshot of TableState for undo.
468#[derive(Debug, Clone)]
469pub struct TableStateSnapshot {
470    selected: Option<usize>,
471    offset: usize,
472    sort_column: Option<usize>,
473    sort_ascending: bool,
474    filter: String,
475}
476
477impl UndoSupport for TableState {
478    fn undo_widget_id(&self) -> UndoWidgetId {
479        self.undo_id
480    }
481
482    fn create_snapshot(&self) -> Box<dyn Any + Send> {
483        Box::new(TableStateSnapshot {
484            selected: self.selected,
485            offset: self.offset,
486            sort_column: self.sort_column,
487            sort_ascending: self.sort_ascending,
488            filter: self.filter.clone(),
489        })
490    }
491
492    fn restore_snapshot(&mut self, snapshot: &dyn Any) -> bool {
493        if let Some(snap) = snapshot.downcast_ref::<TableStateSnapshot>() {
494            self.selected = snap.selected;
495            self.hovered = None;
496            self.offset = snap.offset;
497            self.sort_column = snap.sort_column;
498            self.sort_ascending = snap.sort_ascending;
499            self.filter = snap.filter.clone();
500            true
501        } else {
502            false
503        }
504    }
505}
506
507impl TableUndoExt for TableState {
508    fn sort_state(&self) -> (Option<usize>, bool) {
509        (self.sort_column, self.sort_ascending)
510    }
511
512    fn set_sort_state(&mut self, column: Option<usize>, ascending: bool) {
513        self.sort_column = column;
514        self.sort_ascending = ascending;
515    }
516
517    fn filter_text(&self) -> &str {
518        &self.filter
519    }
520
521    fn set_filter_text(&mut self, filter: &str) {
522        self.filter = filter.to_string();
523    }
524}
525
526impl TableState {
527    /// Get the undo widget ID.
528    ///
529    /// This can be used to associate undo commands with this state instance.
530    #[must_use]
531    pub fn undo_id(&self) -> UndoWidgetId {
532        self.undo_id
533    }
534
535    /// Get the current sort column.
536    #[must_use = "use the sort column (if any)"]
537    pub fn sort_column(&self) -> Option<usize> {
538        self.sort_column
539    }
540
541    /// Get whether the sort is ascending.
542    #[must_use]
543    pub fn sort_ascending(&self) -> bool {
544        self.sort_ascending
545    }
546
547    /// Set the sort state.
548    pub fn set_sort(&mut self, column: Option<usize>, ascending: bool) {
549        self.sort_column = column;
550        self.sort_ascending = ascending;
551    }
552
553    /// Get the filter text.
554    #[must_use]
555    pub fn filter(&self) -> &str {
556        &self.filter
557    }
558
559    /// Set the filter text.
560    pub fn set_filter(&mut self, filter: impl Into<String>) {
561        self.filter = filter.into();
562    }
563
564    /// Handle a mouse event for this table.
565    ///
566    /// # Hit data convention
567    ///
568    /// The hit data (`u64`) encodes the row index. When the table renders with
569    /// a `hit_id`, each visible row registers `HitRegion::Content` with
570    /// `data = row_index as u64`.
571    ///
572    /// # Arguments
573    ///
574    /// * `event` — the mouse event from the terminal
575    /// * `hit` — result of `frame.hit_test(event.x, event.y)`, if available
576    /// * `expected_id` — the `HitId` this table was rendered with
577    /// * `row_count` — total number of rows in the table
578    pub fn handle_mouse(
579        &mut self,
580        event: &MouseEvent,
581        hit: Option<(HitId, HitRegion, u64)>,
582        expected_id: HitId,
583        row_count: usize,
584    ) -> MouseResult {
585        match event.kind {
586            MouseEventKind::Down(MouseButton::Left) => {
587                if let Some((id, HitRegion::Content, data)) = hit
588                    && id == expected_id
589                {
590                    let index = data as usize;
591                    if index < row_count {
592                        // Deterministic "double click": second click on the already-selected row activates.
593                        if self.selected == Some(index) {
594                            return MouseResult::Activated(index);
595                        }
596                        self.select(Some(index));
597                        return MouseResult::Selected(index);
598                    }
599                }
600                MouseResult::Ignored
601            }
602            MouseEventKind::Moved => {
603                if let Some((id, HitRegion::Content, data)) = hit
604                    && id == expected_id
605                {
606                    let index = data as usize;
607                    if index < row_count {
608                        let changed = self.hovered != Some(index);
609                        self.hovered = Some(index);
610                        return if changed {
611                            MouseResult::HoverChanged
612                        } else {
613                            MouseResult::Ignored
614                        };
615                    }
616                }
617                // Mouse moved off the widget or to non-content region
618                if self.hovered.is_some() {
619                    self.hovered = None;
620                    MouseResult::HoverChanged
621                } else {
622                    MouseResult::Ignored
623                }
624            }
625            MouseEventKind::ScrollUp => {
626                self.scroll_up(3);
627                MouseResult::Scrolled
628            }
629            MouseEventKind::ScrollDown => {
630                self.scroll_down(3, row_count);
631                MouseResult::Scrolled
632            }
633            _ => MouseResult::Ignored,
634        }
635    }
636
637    /// Scroll the table up by the given number of rows.
638    pub fn scroll_up(&mut self, rows: usize) {
639        self.offset = self.offset.saturating_sub(rows);
640    }
641
642    /// Scroll the table down by the given number of rows.
643    ///
644    /// Clamps so that the last row can still appear at the top of the viewport.
645    pub fn scroll_down(&mut self, rows: usize, row_count: usize) {
646        self.offset = self
647            .offset
648            .saturating_add(rows)
649            .min(row_count.saturating_sub(1));
650    }
651}
652
653impl<'a> StatefulWidget for Table<'a> {
654    type State = TableState;
655
656    fn render(&self, area: Rect, frame: &mut Frame, state: &mut Self::State) {
657        if frame.a11y_enabled() {
658            frame.push_a11y_nodes(ftui_a11y::Accessible::accessibility_nodes(self, area));
659        }
660        #[cfg(feature = "tracing")]
661        let _widget_span = tracing::debug_span!(
662            "widget_render",
663            widget = "Table",
664            x = area.x,
665            y = area.y,
666            w = area.width,
667            h = area.height
668        )
669        .entered();
670
671        if area.is_empty() {
672            return;
673        }
674
675        let apply_styling = frame.degradation.apply_styling();
676        let theme = &self.theme;
677        let effects_enabled = apply_styling && !theme.effects.is_empty();
678        let has_column_effects = effects_enabled && theme_has_column_effects(theme);
679        let effect_resolver = theme.effect_resolver();
680        let effects = if effects_enabled {
681            Some((&effect_resolver, self.theme_phase))
682        } else {
683            None
684        };
685
686        // Render block if present
687        let table_area = match &self.block {
688            Some(b) => {
689                let mut block = b.clone();
690                if apply_styling {
691                    block = block.border_style(theme.border);
692                }
693                block.render(area, frame);
694                block.inner(area)
695            }
696            None => area,
697        };
698
699        if table_area.is_empty() {
700            return;
701        }
702
703        // Push scissor to prevent rows from spilling out of the table area.
704        // This is critical for rows with height > 1 that are partially visible at the bottom.
705        frame.buffer.push_scissor(table_area);
706
707        // Clear the full owned viewport up front so empty tables, shorter rows,
708        // and shorter headers cannot leak prior buffer content.
709        let fill_style = if apply_styling {
710            self.style.merge(&theme.row)
711        } else {
712            Style::default()
713        };
714        clear_text_area(frame, table_area, fill_style);
715
716        let header_height = self
717            .header
718            .as_ref()
719            .map(|h| h.height.saturating_add(h.bottom_margin))
720            .unwrap_or(0);
721
722        if header_height > table_area.height {
723            frame.buffer.pop_scissor();
724            return;
725        }
726
727        // Viewport geometry for rows (below the header).
728        let rows_height = table_area.height.saturating_sub(header_height);
729        let rows_top = table_area.y.saturating_add(header_height);
730        let rows_max_y = table_area.bottom();
731
732        // Calculate display indices (filtered & sorted)
733        let display_indices = self.filtered_and_sorted_indices(state);
734        let row_count = display_indices.len();
735
736        // Clamp offset to valid range
737        if row_count == 0 {
738            state.offset = 0;
739        } else {
740            state.offset = state.offset.min(row_count.saturating_sub(1));
741
742            // If we're scrolled near the end and the viewport grows, keep the bottom
743            // visible and pull the offset back to fill the viewport with as much
744            // context as fits (avoids rendering a mostly-empty table).
745            let available_height = rows_height;
746            let mut accumulated = 0u16;
747            let mut bottom_offset = row_count.saturating_sub(1);
748            for i in (0..row_count).rev() {
749                let row = &self.rows[display_indices[i]];
750                let total_row_height = if i == row_count - 1 {
751                    row.height
752                } else {
753                    row.height.saturating_add(row.bottom_margin)
754                };
755
756                if total_row_height > available_height.saturating_sub(accumulated) {
757                    break;
758                }
759
760                accumulated = accumulated.saturating_add(total_row_height);
761                bottom_offset = i;
762            }
763
764            state.offset = state.offset.min(bottom_offset);
765        }
766
767        // Ensure selection is valid and present in current filtered view
768        if let Some(selected) = state.selected {
769            if display_indices.is_empty() {
770                state.selected = None;
771            } else if !display_indices.contains(&selected) {
772                state.selected = display_indices.first().copied();
773            }
774        }
775
776        // Ensure visible range includes selected item
777        if let Some(selected) = state.selected
778            && let Some(selected_display_idx) =
779                display_indices.iter().position(|&idx| idx == selected)
780        {
781            if selected_display_idx < state.offset {
782                state.offset = selected_display_idx;
783            } else {
784                // Check if selected is visible; if not, scroll down
785                let mut current_y = rows_top;
786                let max_y = rows_max_y;
787                let mut last_visible = state.offset;
788
789                for (i, &row_idx) in display_indices.iter().enumerate().skip(state.offset) {
790                    let row = &self.rows[row_idx];
791                    if row.height > max_y.saturating_sub(current_y) {
792                        break;
793                    }
794                    current_y = current_y
795                        .saturating_add(row.height)
796                        .saturating_add(row.bottom_margin);
797                    last_visible = i;
798                }
799
800                if selected_display_idx > last_visible {
801                    let mut new_offset = selected_display_idx;
802                    let mut accumulated_height: u16 = 0;
803                    let available_height = rows_height;
804
805                    for i in (0..=selected_display_idx).rev() {
806                        let row = &self.rows[display_indices[i]];
807                        let total_row_height = if i == selected_display_idx {
808                            row.height
809                        } else {
810                            row.height.saturating_add(row.bottom_margin)
811                        };
812
813                        if total_row_height > available_height.saturating_sub(accumulated_height) {
814                            if i == selected_display_idx {
815                                new_offset = selected_display_idx;
816                            } else {
817                                new_offset = i + 1;
818                            }
819                            break;
820                        }
821
822                        accumulated_height = accumulated_height.saturating_add(total_row_height);
823                        new_offset = i;
824                    }
825                    state.offset = new_offset;
826                }
827            }
828        }
829
830        #[cfg(feature = "tracing")]
831        let table_span = tracing::debug_span!(
832            "table.render",
833            total_rows = self.rows.len(),
834            visible_rows = row_count,
835            offset = state.offset,
836            viewport_height = rows_height,
837            rendered_rows = tracing::field::Empty,
838        );
839        #[cfg(feature = "tracing")]
840        let _table_span_guard = table_span.clone().entered();
841
842        // Calculate column widths
843        let flex = Flex::horizontal()
844            .constraints(self.widths.clone())
845            .gap(self.column_spacing);
846
847        let intrinsic_col_widths = if Self::requires_measurement(&self.widths) {
848            if let Some(hash) = self.data_hash {
849                if let Some((cached_hash, ref widths)) = state.cached_intrinsic_widths
850                    && cached_hash == hash
851                    && widths.len() == self.widths.len()
852                {
853                    widths.clone()
854                } else {
855                    let widths: std::sync::Arc<[u16]> =
856                        Self::compute_intrinsic_widths(&self.rows, None, self.widths.len()).into();
857                    state.cached_intrinsic_widths = Some((hash, widths.clone()));
858                    widths
859                }
860            } else {
861                Self::compute_intrinsic_widths(&self.rows, None, self.widths.len()).into()
862            }
863        } else {
864            std::sync::Arc::new([])
865        };
866
867        // We need a dummy rect with correct width to solve horizontal constraints
868        let column_rects = flex.split_with_measurer_stably(
869            Rect::new(table_area.x, table_area.y, table_area.width, 1),
870            |idx, _| {
871                // Use cached intrinsic widths (rows) and merge with header width
872                let row_width = intrinsic_col_widths.get(idx).copied().unwrap_or(0);
873                let header_width = self
874                    .header
875                    .as_ref()
876                    .and_then(|h| h.cells.get(idx))
877                    .map(|c| c.width().min(u16::MAX as usize) as u16)
878                    .unwrap_or(0);
879                ftui_layout::LayoutSizeHint::exact(row_width.max(header_width))
880            },
881            &mut state.coherence,
882        );
883
884        let mut y = table_area.y;
885        let max_y = table_area.bottom();
886        let divider_char = divider_char(self.block.as_ref());
887
888        // Render header
889        if let Some(header) = &self.header {
890            if y >= max_y {
891                frame.buffer.pop_scissor();
892                return;
893            }
894            let row_area = Rect::new(table_area.x, y, table_area.width, header.height);
895            // Include bottom margin for dividers to avoid gaps
896            let divider_area = Rect::new(
897                table_area.x,
898                y,
899                table_area.width,
900                header.height.saturating_add(header.bottom_margin),
901            );
902
903            let header_style = if apply_styling {
904                let mut style = self.style;
905                style = theme.header.merge(&style);
906                header.style.merge(&style)
907            } else {
908                Style::default()
909            };
910
911            clear_text_area(frame, row_area, header_style);
912
913            if apply_styling && let Some((resolver, phase)) = effects {
914                for (col_idx, rect) in column_rects.iter().enumerate() {
915                    let cell_area = Rect::new(rect.x, y, rect.width, header.height);
916                    let scope = TableEffectScope {
917                        section: TableSection::Header,
918                        row: None,
919                        column: Some(col_idx),
920                    };
921                    let style = resolver.resolve(header_style, scope, phase);
922                    set_style_area(&mut frame.buffer, cell_area, style);
923                }
924            }
925
926            let divider_style = if apply_styling {
927                theme.divider.merge(&header_style)
928            } else {
929                Style::default()
930            };
931            draw_vertical_dividers(
932                &mut frame.buffer,
933                divider_area,
934                &column_rects,
935                divider_char,
936                divider_style,
937            );
938
939            render_row(
940                header,
941                &column_rects,
942                frame,
943                y,
944                header_style,
945                TableSection::Header,
946                None,
947                effects,
948                effects.is_some(),
949            );
950
951            // Draw sort indicator
952            if let Some(col) = state.sort_column
953                && col < column_rects.len()
954            {
955                let rect = column_rects[col];
956                let symbol = if state.sort_ascending { "▲" } else { "▼" };
957                // Draw at end of cell
958                let x = rect.right().saturating_sub(1);
959                if x >= rect.x {
960                    crate::draw_text_span(frame, x, y, symbol, header_style, rect.right());
961                }
962            }
963
964            y = y
965                .saturating_add(header.height)
966                .saturating_add(header.bottom_margin);
967        }
968
969        // Render rows
970        if row_count == 0 {
971            #[cfg(feature = "tracing")]
972            table_span.record("rendered_rows", 0_u64);
973            frame.buffer.pop_scissor();
974            return;
975        }
976
977        let mut rendered_rows = 0usize;
978        for (i, &row_idx) in display_indices.iter().enumerate().skip(state.offset) {
979            if y >= max_y {
980                break;
981            }
982
983            let row = &self.rows[row_idx];
984            let is_selected = state.selected == Some(row_idx);
985            let is_hovered = state.hovered == Some(row_idx);
986            let row_area = Rect::new(table_area.x, y, table_area.width, row.height);
987            // Include bottom margin for dividers
988            let divider_area = Rect::new(
989                table_area.x,
990                y,
991                table_area.width,
992                row.height.saturating_add(row.bottom_margin),
993            );
994
995            let row_style = if apply_styling {
996                // 1. Base: Table style
997                let mut style = self.style;
998                // 2. Theme Stripe
999                let stripe = if i % 2 == 0 { theme.row } else { theme.row_alt };
1000                style = stripe.merge(&style);
1001                // 3. Row Specific
1002                style = row.style.merge(&style);
1003                // 4. Theme Selection
1004                if is_selected {
1005                    style = theme.row_selected.merge(&style);
1006                }
1007                // 5. Theme Hover
1008                if is_hovered {
1009                    style = theme.row_hover.merge(&style);
1010                }
1011                // 6. Manual Highlight
1012                if is_selected {
1013                    style = self.highlight_style.merge(&style);
1014                }
1015                style
1016            } else {
1017                Style::default()
1018            };
1019
1020            clear_text_area(frame, row_area, row_style);
1021
1022            if apply_styling && let Some((resolver, phase)) = effects {
1023                if has_column_effects {
1024                    for (col_idx, rect) in column_rects.iter().enumerate() {
1025                        let cell_area = Rect::new(rect.x, y, rect.width, row.height);
1026                        let scope = TableEffectScope {
1027                            section: TableSection::Body,
1028                            row: Some(i),
1029                            column: Some(col_idx),
1030                        };
1031                        let style = resolver.resolve(row_style, scope, phase);
1032                        set_style_area(&mut frame.buffer, cell_area, style);
1033                    }
1034                } else {
1035                    let scope = TableEffectScope::row(TableSection::Body, i);
1036                    let style = resolver.resolve(row_style, scope, phase);
1037                    set_style_area(&mut frame.buffer, row_area, style);
1038                }
1039            }
1040
1041            let divider_style = if apply_styling {
1042                theme.divider.merge(&row_style)
1043            } else {
1044                Style::default()
1045            };
1046            draw_vertical_dividers(
1047                &mut frame.buffer,
1048                divider_area,
1049                &column_rects,
1050                divider_char,
1051                divider_style,
1052            );
1053
1054            render_row(
1055                row,
1056                &column_rects,
1057                frame,
1058                y,
1059                row_style,
1060                TableSection::Body,
1061                Some(i),
1062                effects,
1063                has_column_effects,
1064            );
1065
1066            // Register hit region for this row (if hit testing enabled)
1067            if let Some(id) = self.hit_id {
1068                // Register the original row_idx so click handlers know the actual data item
1069                frame.register_hit(row_area, id, HitRegion::Content, row_idx as u64);
1070            }
1071
1072            rendered_rows = rendered_rows.saturating_add(1);
1073            y = y
1074                .saturating_add(row.height)
1075                .saturating_add(row.bottom_margin);
1076        }
1077
1078        #[cfg(feature = "tracing")]
1079        table_span.record("rendered_rows", rendered_rows as u64);
1080        frame.buffer.pop_scissor();
1081    }
1082}
1083
1084#[allow(clippy::too_many_arguments)]
1085fn render_row(
1086    row: &Row,
1087    col_rects: &[Rect],
1088    frame: &mut Frame,
1089    y: u16,
1090    base_style: Style,
1091    section: TableSection,
1092    row_idx: Option<usize>,
1093    effects: Option<(&TableEffectResolver<'_>, f32)>,
1094    column_effects: bool,
1095) {
1096    let apply_styling = frame.degradation.apply_styling();
1097    let row_effect_base = if apply_styling {
1098        if let Some((resolver, phase)) = effects {
1099            if !column_effects {
1100                let scope = TableEffectScope {
1101                    section,
1102                    row: row_idx,
1103                    column: None,
1104                };
1105                Some(resolver.resolve(base_style, scope, phase))
1106            } else {
1107                None
1108            }
1109        } else {
1110            None
1111        }
1112    } else {
1113        None
1114    };
1115
1116    for (col_idx, cell_text) in row.cells.iter().enumerate() {
1117        if col_idx >= col_rects.len() {
1118            break;
1119        }
1120        let rect = col_rects[col_idx];
1121        let cell_area = Rect::new(rect.x, y, rect.width, row.height);
1122        let scope = if effects.is_some() {
1123            Some(TableEffectScope {
1124                section,
1125                row: row_idx,
1126                column: if column_effects { Some(col_idx) } else { None },
1127            })
1128        } else {
1129            None
1130        };
1131        let column_effect_base = if apply_styling && column_effects {
1132            if let (Some((resolver, phase)), Some(scope)) = (effects, scope) {
1133                Some(resolver.resolve(base_style, scope, phase))
1134            } else {
1135                None
1136            }
1137        } else {
1138            None
1139        };
1140
1141        for (line_idx, line) in cell_text.lines().iter().enumerate() {
1142            if line_idx as u16 >= row.height {
1143                break;
1144            }
1145
1146            let mut x = cell_area.x;
1147            for span in line.spans() {
1148                // At NoStyling+, ignore span-level styles
1149                let mut span_style = if apply_styling {
1150                    match span.style {
1151                        Some(s) => s.merge(&base_style),
1152                        None => base_style,
1153                    }
1154                } else {
1155                    Style::default()
1156                };
1157
1158                if let (Some((resolver, phase)), Some(scope)) = (effects, scope) {
1159                    if span.style.is_none() {
1160                        if let Some(base_effect) = column_effect_base.or(row_effect_base) {
1161                            span_style = base_effect;
1162                        } else {
1163                            span_style = resolver.resolve(span_style, scope, phase);
1164                        }
1165                    } else {
1166                        span_style = resolver.resolve(span_style, scope, phase);
1167                    }
1168                }
1169
1170                x = crate::draw_text_span_with_link(
1171                    frame,
1172                    x,
1173                    cell_area.y.saturating_add(line_idx as u16),
1174                    &span.content,
1175                    span_style,
1176                    cell_area.right(),
1177                    span.link.as_deref(),
1178                );
1179                if x >= cell_area.right() {
1180                    break;
1181                }
1182            }
1183        }
1184    }
1185}
1186
1187fn theme_has_column_effects(theme: &TableTheme) -> bool {
1188    theme.effects.iter().any(|rule| {
1189        matches!(
1190            rule.target,
1191            TableEffectTarget::Column(_) | TableEffectTarget::ColumnRange { .. }
1192        )
1193    })
1194}
1195
1196fn divider_char(block: Option<&Block<'_>>) -> char {
1197    block
1198        .map(|b| b.border_set().vertical)
1199        .unwrap_or(crate::borders::BorderSet::SQUARE.vertical)
1200}
1201
1202fn draw_vertical_dividers(
1203    buf: &mut Buffer,
1204    row_area: Rect,
1205    col_rects: &[Rect],
1206    divider_char: char,
1207    style: Style,
1208) {
1209    if col_rects.len() < 2 || row_area.is_empty() {
1210        return;
1211    }
1212
1213    for pair in col_rects.windows(2) {
1214        let left = pair[0];
1215        let right = pair[1];
1216        let gap = right.x.saturating_sub(left.right());
1217        if gap == 0 {
1218            continue;
1219        }
1220        let x = left.right();
1221        if x >= row_area.right() {
1222            continue;
1223        }
1224        let mut cell = Cell::from_char(divider_char);
1225        apply_style(&mut cell, style);
1226        for y in row_area.y..row_area.bottom() {
1227            buf.set_fast(x, y, cell);
1228        }
1229    }
1230}
1231
1232impl MeasurableWidget for Table<'_> {
1233    fn measure(&self, _available: Size) -> SizeConstraints {
1234        if self.rows.is_empty() && self.header.is_none() {
1235            return SizeConstraints::ZERO;
1236        }
1237
1238        let col_count = self.widths.len();
1239        if col_count == 0 {
1240            return SizeConstraints::ZERO;
1241        }
1242
1243        let row_widths = Self::compute_intrinsic_widths(&self.rows, None, col_count);
1244
1245        // Total width = sum of max(row_width, header_width) + column spacing
1246        let separator_width = if col_count > 1 {
1247            ((col_count - 1) as u16).saturating_mul(self.column_spacing)
1248        } else {
1249            0
1250        };
1251
1252        let mut summed_col_width = 0u16;
1253        for (i, &r_w) in row_widths.iter().enumerate() {
1254            let h_w = self
1255                .header
1256                .as_ref()
1257                .and_then(|h| h.cells.get(i))
1258                .map(|c| c.width().min(u16::MAX as usize) as u16)
1259                .unwrap_or(0);
1260            summed_col_width = summed_col_width.saturating_add(r_w.max(h_w));
1261        }
1262
1263        let content_width = summed_col_width.saturating_add(separator_width);
1264
1265        // Total height = header height + row heights + margins
1266        // Use saturating arithmetic to prevent overflow with many rows
1267        let header_height = self
1268            .header
1269            .as_ref()
1270            .map(|h| h.height.saturating_add(h.bottom_margin))
1271            .unwrap_or(0);
1272
1273        let rows_height: u16 = self.rows.iter().fold(0u16, |acc, r| {
1274            acc.saturating_add(r.height.saturating_add(r.bottom_margin))
1275        });
1276
1277        let content_height = header_height.saturating_add(rows_height);
1278
1279        // Add block overhead if present
1280        let (block_width, block_height) = self
1281            .block
1282            .as_ref()
1283            .map(|b| {
1284                let inner = b.inner(Rect::new(0, 0, 100, 100));
1285                let w_overhead = 100u16.saturating_sub(inner.width);
1286                let h_overhead = 100u16.saturating_sub(inner.height);
1287                (w_overhead, h_overhead)
1288            })
1289            .unwrap_or((0, 0));
1290
1291        let total_width = content_width.saturating_add(block_width);
1292        let total_height = content_height.saturating_add(block_height);
1293
1294        SizeConstraints {
1295            min: Size::new(
1296                (col_count as u16).saturating_add(block_width),
1297                header_height.max(1).saturating_add(block_height),
1298            ),
1299            preferred: Size::new(total_width, total_height),
1300            max: Some(Size::new(total_width, total_height)), // Fixed content size
1301        }
1302    }
1303
1304    fn has_intrinsic_size(&self) -> bool {
1305        !self.rows.is_empty() || self.header.is_some()
1306    }
1307}
1308
1309#[cfg(test)]
1310mod tests {
1311    use super::*;
1312    use ftui_render::buffer::Buffer;
1313    use ftui_render::cell::PackedRgba;
1314    use ftui_render::grapheme_pool::GraphemePool;
1315    use ftui_text::{Line, Span};
1316    #[cfg(feature = "tracing")]
1317    use std::sync::{Arc, Mutex};
1318    #[cfg(feature = "tracing")]
1319    use tracing::Subscriber;
1320    #[cfg(feature = "tracing")]
1321    use tracing_subscriber::Layer;
1322    #[cfg(feature = "tracing")]
1323    use tracing_subscriber::layer::{Context, SubscriberExt};
1324
1325    fn cell_char(buf: &Buffer, x: u16, y: u16) -> Option<char> {
1326        buf.get(x, y).and_then(|c| c.content.as_char())
1327    }
1328
1329    fn cell_fg(buf: &Buffer, x: u16, y: u16) -> Option<PackedRgba> {
1330        buf.get(x, y).map(|c| c.fg)
1331    }
1332
1333    fn row_text(buf: &Buffer, y: u16) -> String {
1334        let width = buf.width();
1335        let mut actual = String::new();
1336        for x in 0..width {
1337            let ch = buf
1338                .get(x, y)
1339                .and_then(|cell| cell.content.as_char())
1340                .unwrap_or(' ');
1341            actual.push(ch);
1342        }
1343        actual.trim().to_string()
1344    }
1345
1346    fn raw_row_text(buf: &Buffer, y: u16) -> String {
1347        let width = buf.width();
1348        let mut actual = String::new();
1349        for x in 0..width {
1350            let ch = buf
1351                .get(x, y)
1352                .and_then(|cell| cell.content.as_char())
1353                .unwrap_or(' ');
1354            actual.push(ch);
1355        }
1356        actual
1357    }
1358
1359    #[cfg(feature = "tracing")]
1360    #[derive(Debug, Default)]
1361    struct TableTraceState {
1362        span_count: usize,
1363        has_total_rows_field: bool,
1364        has_rendered_rows_field: bool,
1365        total_rows: Vec<u64>,
1366        rendered_rows: Vec<u64>,
1367    }
1368
1369    #[cfg(feature = "tracing")]
1370    struct TableTraceCapture {
1371        state: Arc<Mutex<TableTraceState>>,
1372    }
1373
1374    #[cfg(feature = "tracing")]
1375    #[derive(Default)]
1376    struct TableRenderVisitor {
1377        total_rows: Option<u64>,
1378        rendered_rows: Option<u64>,
1379    }
1380
1381    #[cfg(feature = "tracing")]
1382    impl tracing::field::Visit for TableRenderVisitor {
1383        fn record_u64(&mut self, field: &tracing::field::Field, value: u64) {
1384            match field.name() {
1385                "total_rows" => self.total_rows = Some(value),
1386                "rendered_rows" => self.rendered_rows = Some(value),
1387                _ => {}
1388            }
1389        }
1390
1391        fn record_i64(&mut self, field: &tracing::field::Field, value: i64) {
1392            if let Ok(value) = u64::try_from(value) {
1393                self.record_u64(field, value);
1394            }
1395        }
1396
1397        fn record_debug(&mut self, field: &tracing::field::Field, value: &dyn std::fmt::Debug) {
1398            let value = format!("{value:?}");
1399            if let Ok(parsed) = value.parse::<u64>() {
1400                self.record_u64(field, parsed);
1401            }
1402        }
1403    }
1404
1405    #[cfg(feature = "tracing")]
1406    impl<S> Layer<S> for TableTraceCapture
1407    where
1408        S: Subscriber + for<'lookup> tracing_subscriber::registry::LookupSpan<'lookup>,
1409    {
1410        fn on_new_span(
1411            &self,
1412            attrs: &tracing::span::Attributes<'_>,
1413            _id: &tracing::Id,
1414            _ctx: Context<'_, S>,
1415        ) {
1416            if attrs.metadata().name() != "table.render" {
1417                return;
1418            }
1419
1420            let mut visitor = TableRenderVisitor::default();
1421            attrs.record(&mut visitor);
1422            let fields = attrs.metadata().fields();
1423
1424            let mut state = self.state.lock().expect("table trace state lock");
1425            state.span_count += 1;
1426            state.has_total_rows_field |= fields.field("total_rows").is_some();
1427            state.has_rendered_rows_field |= fields.field("rendered_rows").is_some();
1428            if let Some(total_rows) = visitor.total_rows {
1429                state.total_rows.push(total_rows);
1430            }
1431            if let Some(rendered_rows) = visitor.rendered_rows {
1432                state.rendered_rows.push(rendered_rows);
1433            }
1434        }
1435
1436        fn on_record(
1437            &self,
1438            id: &tracing::Id,
1439            values: &tracing::span::Record<'_>,
1440            ctx: Context<'_, S>,
1441        ) {
1442            let Some(span_ref) = ctx.span(id) else {
1443                return;
1444            };
1445            if span_ref.metadata().name() != "table.render" {
1446                return;
1447            }
1448
1449            let mut visitor = TableRenderVisitor::default();
1450            values.record(&mut visitor);
1451
1452            let mut state = self.state.lock().expect("table trace state lock");
1453            if let Some(total_rows) = visitor.total_rows {
1454                state.total_rows.push(total_rows);
1455            }
1456            if let Some(rendered_rows) = visitor.rendered_rows {
1457                state.rendered_rows.push(rendered_rows);
1458            }
1459        }
1460    }
1461
1462    // --- Row builder tests ---
1463
1464    #[test]
1465    fn row_new_from_strings() {
1466        let row = Row::new(["A", "B", "C"]);
1467        assert_eq!(row.cells.len(), 3);
1468        assert_eq!(row.height, 1);
1469        assert_eq!(row.bottom_margin, 0);
1470    }
1471
1472    #[test]
1473    fn row_builder_methods() {
1474        let row = Row::new(["X"])
1475            .height(3)
1476            .bottom_margin(1)
1477            .style(Style::new().bold());
1478        assert_eq!(row.height, 3);
1479        assert_eq!(row.bottom_margin, 1);
1480        assert!(row.style.has_attr(ftui_style::StyleFlags::BOLD));
1481    }
1482
1483    #[test]
1484    fn row_height_zero_clamps_to_one() {
1485        let row = Row::new(["X"]).height(0);
1486        assert_eq!(row.height, 1);
1487    }
1488
1489    // --- TableState tests ---
1490
1491    #[test]
1492    fn table_state_default() {
1493        let state = TableState::default();
1494        assert_eq!(state.selected, None);
1495        assert_eq!(state.offset, 0);
1496    }
1497
1498    #[test]
1499    fn table_state_select() {
1500        let mut state = TableState::default();
1501        state.select(Some(5));
1502        assert_eq!(state.selected, Some(5));
1503        assert_eq!(state.offset, 0);
1504    }
1505
1506    #[test]
1507    fn table_state_deselect_preserves_offset() {
1508        let mut state = TableState {
1509            offset: 10,
1510            ..Default::default()
1511        };
1512        state.select(Some(3));
1513        assert_eq!(state.selected, Some(3));
1514        state.select(None);
1515        assert_eq!(state.selected, None);
1516        assert_eq!(state.offset, 10);
1517    }
1518
1519    #[test]
1520    fn table_state_scroll_down_is_overflow_safe() {
1521        // Ensure `scroll_down` cannot wrap on invalid persisted offsets.
1522        let mut state = TableState {
1523            offset: usize::MAX - 1,
1524            ..Default::default()
1525        };
1526        state.scroll_down(10, 100);
1527        assert_eq!(state.offset, 99);
1528    }
1529
1530    // --- Table rendering tests ---
1531
1532    #[test]
1533    fn render_zero_area() {
1534        let table = Table::new([Row::new(["A"])], [Constraint::Fixed(5)]);
1535        let area = Rect::new(0, 0, 0, 0);
1536        let mut pool = GraphemePool::new();
1537        let mut frame = Frame::new(1, 1, &mut pool);
1538        Widget::render(&table, area, &mut frame);
1539        // Should not panic
1540    }
1541
1542    #[test]
1543    fn render_empty_rows() {
1544        let table = Table::new(Vec::<Row>::new(), [Constraint::Fixed(5)]);
1545        let area = Rect::new(0, 0, 10, 5);
1546        let mut pool = GraphemePool::new();
1547        let mut frame = Frame::new(10, 5, &mut pool);
1548        Widget::render(&table, area, &mut frame);
1549        // Should not panic; no content rendered
1550    }
1551
1552    #[test]
1553    fn render_empty_rows_clears_stale_viewport() {
1554        let table = Table::new(Vec::<Row>::new(), [Constraint::Fixed(5)]);
1555        let area = Rect::new(0, 0, 10, 3);
1556        let mut pool = GraphemePool::new();
1557        let mut frame = Frame::new(10, 3, &mut pool);
1558        frame.buffer.fill(area, Cell::from_char('X'));
1559
1560        Widget::render(&table, area, &mut frame);
1561
1562        assert_eq!(raw_row_text(&frame.buffer, 0), "          ");
1563        assert_eq!(raw_row_text(&frame.buffer, 1), "          ");
1564        assert_eq!(raw_row_text(&frame.buffer, 2), "          ");
1565    }
1566
1567    #[test]
1568    fn render_single_row_single_column() {
1569        let table = Table::new([Row::new(["Hello"])], [Constraint::Fixed(10)]);
1570        let area = Rect::new(0, 0, 10, 3);
1571        let mut pool = GraphemePool::new();
1572        let mut frame = Frame::new(10, 3, &mut pool);
1573        Widget::render(&table, area, &mut frame);
1574
1575        assert_eq!(cell_char(&frame.buffer, 0, 0), Some('H'));
1576        assert_eq!(cell_char(&frame.buffer, 1, 0), Some('e'));
1577        assert_eq!(cell_char(&frame.buffer, 4, 0), Some('o'));
1578    }
1579
1580    #[test]
1581    fn render_shorter_cell_clears_stale_suffix() {
1582        let area = Rect::new(0, 0, 10, 1);
1583        let mut pool = GraphemePool::new();
1584        let mut frame = Frame::new(10, 1, &mut pool);
1585
1586        let long = Table::new([Row::new(["Hello"])], [Constraint::Fixed(10)]);
1587        Widget::render(&long, area, &mut frame);
1588
1589        let short = Table::new([Row::new(["Hi"])], [Constraint::Fixed(10)]);
1590        Widget::render(&short, area, &mut frame);
1591
1592        assert_eq!(raw_row_text(&frame.buffer, 0), "Hi        ");
1593    }
1594
1595    #[test]
1596    fn render_multiple_rows() {
1597        let table = Table::new(
1598            [Row::new(["AA", "BB"]), Row::new(["CC", "DD"])],
1599            [Constraint::Fixed(4), Constraint::Fixed(4)],
1600        );
1601        let area = Rect::new(0, 0, 10, 3);
1602        let mut pool = GraphemePool::new();
1603        let mut frame = Frame::new(10, 3, &mut pool);
1604        Widget::render(&table, area, &mut frame);
1605
1606        // First row
1607        assert_eq!(cell_char(&frame.buffer, 0, 0), Some('A'));
1608        // Second row
1609        assert_eq!(cell_char(&frame.buffer, 0, 1), Some('C'));
1610    }
1611
1612    #[test]
1613    fn render_with_header() {
1614        let header = Row::new(["Name", "Val"]);
1615        let table = Table::new(
1616            [Row::new(["foo", "42"])],
1617            [Constraint::Fixed(5), Constraint::Fixed(4)],
1618        )
1619        .header(header);
1620
1621        let area = Rect::new(0, 0, 10, 3);
1622        let mut pool = GraphemePool::new();
1623        let mut frame = Frame::new(10, 3, &mut pool);
1624        Widget::render(&table, area, &mut frame);
1625
1626        // Header on row 0
1627        assert_eq!(cell_char(&frame.buffer, 0, 0), Some('N'));
1628        // Data on row 1
1629        assert_eq!(cell_char(&frame.buffer, 0, 1), Some('f'));
1630    }
1631
1632    #[test]
1633    fn render_shorter_header_clears_stale_suffix() {
1634        let area = Rect::new(0, 0, 10, 2);
1635        let mut pool = GraphemePool::new();
1636        let mut frame = Frame::new(10, 2, &mut pool);
1637
1638        let long =
1639            Table::new([Row::new(["row"])], [Constraint::Fixed(10)]).header(Row::new(["Header"]));
1640        Widget::render(&long, area, &mut frame);
1641
1642        let short =
1643            Table::new([Row::new(["row"])], [Constraint::Fixed(10)]).header(Row::new(["H"]));
1644        Widget::render(&short, area, &mut frame);
1645
1646        assert_eq!(raw_row_text(&frame.buffer, 0), "H         ");
1647    }
1648
1649    #[test]
1650    fn zero_height_row_clamps_and_preserves_vertical_flow() {
1651        let table = Table::new(
1652            [Row::new(["A"]).height(0), Row::new(["B"])],
1653            [Constraint::Fixed(3)],
1654        );
1655        let area = Rect::new(0, 0, 3, 2);
1656        let mut pool = GraphemePool::new();
1657        let mut frame = Frame::new(3, 2, &mut pool);
1658        Widget::render(&table, area, &mut frame);
1659
1660        assert_eq!(cell_char(&frame.buffer, 0, 0), Some('A'));
1661        assert_eq!(cell_char(&frame.buffer, 0, 1), Some('B'));
1662    }
1663
1664    #[test]
1665    fn zero_height_header_clamps_to_one_and_offsets_rows() {
1666        let header = Row::new(["H"]).height(0);
1667        let table = Table::new([Row::new(["D"])], [Constraint::Fixed(3)]).header(header);
1668
1669        let area = Rect::new(0, 0, 3, 2);
1670        let mut pool = GraphemePool::new();
1671        let mut frame = Frame::new(3, 2, &mut pool);
1672        Widget::render(&table, area, &mut frame);
1673
1674        assert_eq!(cell_char(&frame.buffer, 0, 0), Some('H'));
1675        assert_eq!(cell_char(&frame.buffer, 0, 1), Some('D'));
1676    }
1677
1678    #[test]
1679    fn render_with_block() {
1680        let table = Table::new([Row::new(["X"])], [Constraint::Fixed(5)]).block(Block::bordered());
1681
1682        let area = Rect::new(0, 0, 10, 5);
1683        let mut pool = GraphemePool::new();
1684        let mut frame = Frame::new(10, 5, &mut pool);
1685        Widget::render(&table, area, &mut frame);
1686
1687        // Content should be inside the block border + padding
1688        assert_eq!(cell_char(&frame.buffer, 2, 2), Some('X'));
1689    }
1690
1691    #[test]
1692    fn stateful_render_with_selection() {
1693        let table = Table::new(
1694            [Row::new(["A"]), Row::new(["B"]), Row::new(["C"])],
1695            [Constraint::Fixed(5)],
1696        )
1697        .highlight_style(Style::new().bold());
1698
1699        let area = Rect::new(0, 0, 5, 3);
1700        let mut pool = GraphemePool::new();
1701        let mut frame = Frame::new(5, 3, &mut pool);
1702        let mut state = TableState::default();
1703        state.select(Some(1));
1704
1705        StatefulWidget::render(&table, area, &mut frame, &mut state);
1706        // Selected row should have the highlight style applied
1707        // Row 1 (index 1) should render "B"
1708        assert_eq!(cell_char(&frame.buffer, 0, 1), Some('B'));
1709    }
1710
1711    #[test]
1712    fn row_style_merge_precedence_and_span_override() {
1713        let base_fg = PackedRgba::rgb(10, 0, 0);
1714        let selected_fg = PackedRgba::rgb(20, 0, 0);
1715        let hovered_fg = PackedRgba::rgb(30, 0, 0);
1716        let table_fg = PackedRgba::rgb(40, 0, 0);
1717        let row_fg = PackedRgba::rgb(50, 0, 0);
1718        let highlight_fg = PackedRgba::rgb(60, 0, 0);
1719        let span_fg = PackedRgba::rgb(70, 0, 0);
1720
1721        let base_row = Style::new().fg(base_fg);
1722        let theme = TableTheme {
1723            row: base_row,
1724            row_alt: base_row,
1725            row_selected: Style::new().fg(selected_fg),
1726            row_hover: Style::new().fg(hovered_fg),
1727            ..Default::default()
1728        };
1729
1730        let text = Text::from_line(Line::from_spans([
1731            Span::raw("A"),
1732            Span::styled("B", Style::new().fg(span_fg)),
1733        ]));
1734
1735        let table = Table::new(
1736            [Row::new([text]).style(Style::new().fg(row_fg))],
1737            [Constraint::Fixed(2)],
1738        )
1739        .style(Style::new().fg(table_fg))
1740        .highlight_style(Style::new().fg(highlight_fg))
1741        .theme(theme);
1742
1743        let area = Rect::new(0, 0, 2, 1);
1744        let mut pool = GraphemePool::new();
1745        let mut frame = Frame::new(2, 1, &mut pool);
1746        let mut state = TableState {
1747            selected: Some(0),
1748            hovered: Some(0),
1749            ..Default::default()
1750        };
1751
1752        StatefulWidget::render(&table, area, &mut frame, &mut state);
1753
1754        assert_eq!(cell_fg(&frame.buffer, 0, 0), Some(highlight_fg));
1755        assert_eq!(cell_fg(&frame.buffer, 1, 0), Some(span_fg));
1756    }
1757
1758    #[test]
1759    fn selection_below_offset_adjusts_offset() {
1760        let mut state = TableState {
1761            offset: 5,
1762            selected: Some(2), // Selected is below offset
1763            persistence_id: None,
1764            ..Default::default()
1765        };
1766
1767        let table = Table::new(
1768            (0..10).map(|i| Row::new([format!("Row {i}")])),
1769            [Constraint::Fixed(10)],
1770        );
1771        let area = Rect::new(0, 0, 10, 3);
1772        let mut pool = GraphemePool::new();
1773        let mut frame = Frame::new(10, 3, &mut pool);
1774        StatefulWidget::render(&table, area, &mut frame, &mut state);
1775
1776        // Offset should have been adjusted down to selected
1777        assert_eq!(state.offset, 2);
1778    }
1779
1780    #[test]
1781    fn table_clamps_offset_to_fill_viewport_on_resize() {
1782        let rows: Vec<Row> = (0..10).map(|i| Row::new([format!("Row {i}")])).collect();
1783        let table = Table::new(rows, [Constraint::Min(10)]);
1784
1785        let mut pool = GraphemePool::new();
1786        let mut state = TableState {
1787            offset: 7,
1788            ..Default::default()
1789        };
1790
1791        // Small viewport: show 7, 8, 9.
1792        let area_small = Rect::new(0, 0, 10, 3);
1793        let mut frame_small = Frame::new(10, 3, &mut pool);
1794        StatefulWidget::render(&table, area_small, &mut frame_small, &mut state);
1795        assert_eq!(state.offset, 7);
1796        assert_eq!(row_text(&frame_small.buffer, 0), "Row 7");
1797        assert_eq!(row_text(&frame_small.buffer, 2), "Row 9");
1798
1799        // Larger viewport: offset should pull back to fill (5..9).
1800        let area_large = Rect::new(0, 0, 10, 5);
1801        let mut frame_large = Frame::new(10, 5, &mut pool);
1802        StatefulWidget::render(&table, area_large, &mut frame_large, &mut state);
1803        assert_eq!(state.offset, 5);
1804        assert_eq!(row_text(&frame_large.buffer, 0), "Row 5");
1805        assert_eq!(row_text(&frame_large.buffer, 4), "Row 9");
1806    }
1807
1808    #[test]
1809    fn table_clamps_offset_to_fill_viewport_with_variable_row_heights() {
1810        // Rows 0..8: height 1
1811        // Row 9: height 5
1812        // View height 10 should show rows 4..9 (with row 9 taking 5 lines).
1813        let mut rows: Vec<Row> = (0..9).map(|i| Row::new([format!("Row {i}")])).collect();
1814        rows.push(Row::new(["Row 9"]).height(5));
1815        let table = Table::new(rows, [Constraint::Min(10)]);
1816
1817        let mut pool = GraphemePool::new();
1818        let mut state = TableState {
1819            offset: 9,
1820            ..Default::default()
1821        };
1822
1823        let area = Rect::new(0, 0, 10, 10);
1824        let mut frame = Frame::new(10, 10, &mut pool);
1825        StatefulWidget::render(&table, area, &mut frame, &mut state);
1826
1827        assert_eq!(state.offset, 4);
1828        assert_eq!(row_text(&frame.buffer, 0), "Row 4");
1829    }
1830
1831    #[test]
1832    fn selection_invalid_index_falls_back_to_first_row() {
1833        let table = Table::new([Row::new(["A"]), Row::new(["B"])], [Constraint::Fixed(5)]);
1834        let area = Rect::new(0, 0, 5, 2);
1835        let mut pool = GraphemePool::new();
1836        let mut frame = Frame::new(5, 2, &mut pool);
1837        let mut state = TableState {
1838            offset: 0,
1839            selected: Some(99),
1840            persistence_id: None,
1841            ..Default::default()
1842        };
1843
1844        StatefulWidget::render(&table, area, &mut frame, &mut state);
1845        assert_eq!(state.selected, Some(0));
1846    }
1847
1848    #[test]
1849    fn selection_with_header_accounts_for_header_height() {
1850        let header = Row::new(["H"]);
1851        let table =
1852            Table::new([Row::new(["A"]), Row::new(["B"])], [Constraint::Fixed(5)]).header(header);
1853
1854        let area = Rect::new(0, 0, 5, 2);
1855        let mut pool = GraphemePool::new();
1856        let mut frame = Frame::new(5, 2, &mut pool);
1857        let mut state = TableState {
1858            offset: 0,
1859            selected: Some(1),
1860            persistence_id: None,
1861            ..Default::default()
1862        };
1863
1864        StatefulWidget::render(&table, area, &mut frame, &mut state);
1865        assert_eq!(state.offset, 1);
1866    }
1867
1868    #[test]
1869    fn rows_overflow_area_truncated() {
1870        let table = Table::new(
1871            (0..20).map(|i| Row::new([format!("R{i}")])),
1872            [Constraint::Fixed(5)],
1873        );
1874        let area = Rect::new(0, 0, 5, 3);
1875        let mut pool = GraphemePool::new();
1876        let mut frame = Frame::new(5, 3, &mut pool);
1877        Widget::render(&table, area, &mut frame);
1878
1879        // Only first 3 rows fit
1880        assert_eq!(cell_char(&frame.buffer, 0, 0), Some('R'));
1881        assert_eq!(cell_char(&frame.buffer, 1, 0), Some('0'));
1882        assert_eq!(cell_char(&frame.buffer, 1, 2), Some('2'));
1883    }
1884
1885    #[test]
1886    fn column_spacing_applied() {
1887        let table = Table::new(
1888            [Row::new(["A", "B"])],
1889            [Constraint::Fixed(3), Constraint::Fixed(3)],
1890        )
1891        .column_spacing(2);
1892
1893        let area = Rect::new(0, 0, 10, 1);
1894        let mut pool = GraphemePool::new();
1895        let mut frame = Frame::new(10, 1, &mut pool);
1896        Widget::render(&table, area, &mut frame);
1897
1898        // "A" starts at x=0, "B" starts at x=3+2=5 (column width + gap)
1899        assert_eq!(cell_char(&frame.buffer, 0, 0), Some('A'));
1900    }
1901
1902    #[test]
1903    fn divider_style_overrides_row_style() {
1904        let row_fg = PackedRgba::rgb(120, 10, 10);
1905        let divider_fg = PackedRgba::rgb(0, 200, 0);
1906        let row_style = Style::new().fg(row_fg);
1907        let theme = TableTheme {
1908            row: row_style,
1909            row_alt: row_style,
1910            divider: Style::new().fg(divider_fg),
1911            ..Default::default()
1912        };
1913
1914        let table = Table::new(
1915            [Row::new(["AA", "BB"])],
1916            [Constraint::Fixed(2), Constraint::Fixed(2)],
1917        )
1918        .theme(theme);
1919
1920        let area = Rect::new(0, 0, 5, 1);
1921        let mut pool = GraphemePool::new();
1922        let mut frame = Frame::new(5, 1, &mut pool);
1923        Widget::render(&table, area, &mut frame);
1924
1925        assert_eq!(cell_fg(&frame.buffer, 2, 0), Some(divider_fg));
1926    }
1927
1928    #[test]
1929    fn block_border_uses_theme_border_style() {
1930        let border_fg = PackedRgba::rgb(1, 2, 3);
1931        let theme = TableTheme {
1932            border: Style::new().fg(border_fg),
1933            ..Default::default()
1934        };
1935
1936        let table = Table::new([Row::new(["X"])], [Constraint::Fixed(1)])
1937            .block(Block::bordered())
1938            .theme(theme);
1939
1940        let area = Rect::new(0, 0, 3, 3);
1941        let mut pool = GraphemePool::new();
1942        let mut frame = Frame::new(3, 3, &mut pool);
1943        Widget::render(&table, area, &mut frame);
1944
1945        assert_eq!(cell_fg(&frame.buffer, 0, 0), Some(border_fg));
1946    }
1947
1948    #[test]
1949    fn render_clips_long_cell_to_column_width() {
1950        let table = Table::new([Row::new(["ABCDE"])], [Constraint::Fixed(3)]);
1951        let area = Rect::new(0, 0, 3, 1);
1952        let mut pool = GraphemePool::new();
1953        let mut frame = Frame::new(4, 1, &mut pool);
1954        Widget::render(&table, area, &mut frame);
1955
1956        assert_eq!(cell_char(&frame.buffer, 0, 0), Some('A'));
1957        assert_eq!(cell_char(&frame.buffer, 1, 0), Some('B'));
1958        assert_eq!(cell_char(&frame.buffer, 2, 0), Some('C'));
1959        assert_ne!(cell_char(&frame.buffer, 3, 0), Some('D'));
1960    }
1961
1962    #[test]
1963    fn render_multiline_cell_respects_row_height() {
1964        let table = Table::new([Row::new(["A\nB"]).height(1)], [Constraint::Fixed(3)]);
1965        let area = Rect::new(0, 0, 3, 2);
1966        let mut pool = GraphemePool::new();
1967        let mut frame = Frame::new(3, 2, &mut pool);
1968        Widget::render(&table, area, &mut frame);
1969
1970        assert_eq!(cell_char(&frame.buffer, 0, 0), Some('A'));
1971        assert_ne!(cell_char(&frame.buffer, 0, 1), Some('B'));
1972    }
1973
1974    #[test]
1975    fn render_multiline_cell_draws_second_line_when_height_allows() {
1976        let table = Table::new([Row::new(["A\nB"]).height(2)], [Constraint::Fixed(3)]);
1977        let area = Rect::new(0, 0, 3, 2);
1978        let mut pool = GraphemePool::new();
1979        let mut frame = Frame::new(3, 2, &mut pool);
1980        Widget::render(&table, area, &mut frame);
1981
1982        assert_eq!(cell_char(&frame.buffer, 0, 0), Some('A'));
1983        assert_eq!(cell_char(&frame.buffer, 0, 1), Some('B'));
1984    }
1985
1986    #[test]
1987    fn more_cells_than_columns_truncated() {
1988        let table = Table::new(
1989            [Row::new(["A", "B", "C", "D"])],
1990            [Constraint::Fixed(3), Constraint::Fixed(3)],
1991        );
1992        let area = Rect::new(0, 0, 8, 1);
1993        let mut pool = GraphemePool::new();
1994        let mut frame = Frame::new(8, 1, &mut pool);
1995        Widget::render(&table, area, &mut frame);
1996        // Should not panic; extra cells beyond column count are skipped
1997    }
1998
1999    #[test]
2000    fn header_too_tall_for_area() {
2001        let header = Row::new(["H"]).height(10);
2002        let table = Table::new([Row::new(["X"])], [Constraint::Fixed(5)]).header(header);
2003
2004        let area = Rect::new(0, 0, 5, 3);
2005        let mut pool = GraphemePool::new();
2006        let mut frame = Frame::new(5, 3, &mut pool);
2007        Widget::render(&table, area, &mut frame);
2008        // Header doesn't fit; should return early without rendering data
2009    }
2010
2011    #[test]
2012    fn row_with_bottom_margin() {
2013        let table = Table::new(
2014            [Row::new(["A"]).bottom_margin(1), Row::new(["B"])],
2015            [Constraint::Fixed(5)],
2016        );
2017        let area = Rect::new(0, 0, 5, 4);
2018        let mut pool = GraphemePool::new();
2019        let mut frame = Frame::new(5, 4, &mut pool);
2020        Widget::render(&table, area, &mut frame);
2021
2022        // Row "A" at y=0, margin leaves y=1 empty, row "B" at y=2
2023        assert_eq!(cell_char(&frame.buffer, 0, 0), Some('A'));
2024        assert_eq!(cell_char(&frame.buffer, 0, 2), Some('B'));
2025    }
2026
2027    #[test]
2028    fn table_registers_hit_regions() {
2029        let table = Table::new(
2030            [Row::new(["A"]), Row::new(["B"]), Row::new(["C"])],
2031            [Constraint::Fixed(5)],
2032        )
2033        .hit_id(HitId::new(99));
2034
2035        let area = Rect::new(0, 0, 5, 3);
2036        let mut pool = GraphemePool::new();
2037        let mut frame = Frame::with_hit_grid(5, 3, &mut pool);
2038        let mut state = TableState::default();
2039        StatefulWidget::render(&table, area, &mut frame, &mut state);
2040
2041        // Each row should have a hit region with the row index as data
2042        let hit0 = frame.hit_test(2, 0);
2043        let hit1 = frame.hit_test(2, 1);
2044        let hit2 = frame.hit_test(2, 2);
2045
2046        assert_eq!(hit0, Some((HitId::new(99), HitRegion::Content, 0)));
2047        assert_eq!(hit1, Some((HitId::new(99), HitRegion::Content, 1)));
2048        assert_eq!(hit2, Some((HitId::new(99), HitRegion::Content, 2)));
2049    }
2050
2051    #[test]
2052    fn table_no_hit_without_hit_id() {
2053        let table = Table::new([Row::new(["A"])], [Constraint::Fixed(5)]);
2054        let area = Rect::new(0, 0, 5, 1);
2055        let mut pool = GraphemePool::new();
2056        let mut frame = Frame::with_hit_grid(5, 1, &mut pool);
2057        let mut state = TableState::default();
2058        StatefulWidget::render(&table, area, &mut frame, &mut state);
2059
2060        // No hit region should be registered
2061        assert!(frame.hit_test(2, 0).is_none());
2062    }
2063
2064    #[test]
2065    fn table_no_hit_without_hit_grid() {
2066        let table = Table::new([Row::new(["A"])], [Constraint::Fixed(5)]).hit_id(HitId::new(1));
2067        let area = Rect::new(0, 0, 5, 1);
2068        let mut pool = GraphemePool::new();
2069        let mut frame = Frame::new(5, 1, &mut pool); // No hit grid
2070        let mut state = TableState::default();
2071        StatefulWidget::render(&table, area, &mut frame, &mut state);
2072
2073        // hit_test returns None when no hit grid
2074        assert!(frame.hit_test(2, 0).is_none());
2075    }
2076
2077    // --- MeasurableWidget tests ---
2078
2079    #[test]
2080    fn measure_empty_table() {
2081        let table = Table::new(Vec::<Row>::new(), [Constraint::Fixed(5)]);
2082        let c = table.measure(Size::MAX);
2083        assert_eq!(c, SizeConstraints::ZERO);
2084    }
2085
2086    #[test]
2087    fn measure_empty_columns() {
2088        let table = Table::new([Row::new(["A"])], Vec::<Constraint>::new());
2089        let c = table.measure(Size::MAX);
2090        assert_eq!(c, SizeConstraints::ZERO);
2091    }
2092
2093    #[test]
2094    fn measure_single_row() {
2095        let table = Table::new([Row::new(["Hello"])], [Constraint::Fixed(10)]);
2096        let c = table.measure(Size::MAX);
2097
2098        assert_eq!(c.preferred.width, 5); // "Hello" is 5 chars
2099        assert_eq!(c.preferred.height, 1); // 1 row
2100        assert!(table.has_intrinsic_size());
2101    }
2102
2103    #[test]
2104    fn measure_multiple_columns() {
2105        let table = Table::new(
2106            [Row::new(["A", "BB", "CCC"])],
2107            [
2108                Constraint::Fixed(5),
2109                Constraint::Fixed(5),
2110                Constraint::Fixed(5),
2111            ],
2112        )
2113        .column_spacing(2);
2114
2115        let c = table.measure(Size::MAX);
2116
2117        // Widths: 1 + 2 + 3 = 6, plus 2 gaps of 2 = 4 → total 10
2118        assert_eq!(c.preferred.width, 10);
2119        assert_eq!(c.preferred.height, 1);
2120    }
2121
2122    #[test]
2123    fn measure_respects_row_height_and_column_spacing() {
2124        let table = Table::new(
2125            [Row::new(["A", "BB"]).height(2)],
2126            [Constraint::FitContent, Constraint::FitContent],
2127        )
2128        .column_spacing(2);
2129
2130        let c = table.measure(Size::MAX);
2131
2132        assert_eq!(c.preferred.width, 5);
2133        assert_eq!(c.preferred.height, 2);
2134    }
2135
2136    #[test]
2137    fn measure_accounts_for_wide_glyphs() {
2138        let table = Table::new(
2139            [Row::new(["界", "A"])],
2140            [Constraint::FitContent, Constraint::FitContent],
2141        )
2142        .column_spacing(1);
2143
2144        let c = table.measure(Size::MAX);
2145
2146        assert_eq!(c.preferred.width, 4);
2147        assert_eq!(c.preferred.height, 1);
2148    }
2149
2150    #[test]
2151    fn measure_with_header() {
2152        let header = Row::new(["Name", "Value"]);
2153        let table = Table::new(
2154            [Row::new(["foo", "42"])],
2155            [Constraint::Fixed(5), Constraint::Fixed(5)],
2156        )
2157        .header(header);
2158
2159        let c = table.measure(Size::MAX);
2160
2161        // Header "Name" and "Value" are wider than "foo" and "42"
2162        // Widths: max(4, 3) = 4, max(5, 2) = 5, plus 1 gap = 10
2163        assert_eq!(c.preferred.width, 10);
2164        // Height: 1 header + 1 data row = 2
2165        assert_eq!(c.preferred.height, 2);
2166    }
2167
2168    #[test]
2169    fn measure_with_row_margins() {
2170        let table = Table::new(
2171            [
2172                Row::new(["A"]).bottom_margin(2),
2173                Row::new(["B"]).bottom_margin(1),
2174            ],
2175            [Constraint::Fixed(5)],
2176        );
2177
2178        let c = table.measure(Size::MAX);
2179
2180        // Heights: (1 + 2) + (1 + 1) = 5
2181        assert_eq!(c.preferred.height, 5);
2182    }
2183
2184    #[test]
2185    fn measure_column_widths_from_max_cell() {
2186        let table = Table::new(
2187            [Row::new(["A", "BB"]), Row::new(["CCC", "D"])],
2188            [Constraint::Fixed(5), Constraint::Fixed(5)],
2189        )
2190        .column_spacing(1);
2191
2192        let c = table.measure(Size::MAX);
2193
2194        // Column 0: max(1, 3) = 3
2195        // Column 1: max(2, 1) = 2
2196        // Total: 3 + 2 + 1 gap = 6
2197        assert_eq!(c.preferred.width, 6);
2198        assert_eq!(c.preferred.height, 2);
2199    }
2200
2201    #[test]
2202    fn measure_min_is_column_count() {
2203        let table = Table::new(
2204            [Row::new(["A", "B", "C"])],
2205            [
2206                Constraint::Fixed(5),
2207                Constraint::Fixed(5),
2208                Constraint::Fixed(5),
2209            ],
2210        );
2211
2212        let c = table.measure(Size::MAX);
2213
2214        // Minimum width should be at least the number of columns
2215        assert_eq!(c.min.width, 3);
2216        assert_eq!(c.min.height, 1);
2217    }
2218
2219    #[test]
2220    fn measure_has_intrinsic_size() {
2221        let empty = Table::new(Vec::<Row>::new(), [Constraint::Fixed(5)]);
2222        assert!(!empty.has_intrinsic_size());
2223
2224        let with_rows = Table::new([Row::new(["X"])], [Constraint::Fixed(5)]);
2225        assert!(with_rows.has_intrinsic_size());
2226
2227        let header_only =
2228            Table::new(Vec::<Row>::new(), [Constraint::Fixed(5)]).header(Row::new(["Header"]));
2229        assert!(header_only.has_intrinsic_size());
2230    }
2231
2232    // --- Stateful Persistence tests ---
2233
2234    use crate::stateful::Stateful;
2235
2236    #[test]
2237    fn table_state_with_persistence_id() {
2238        let state = TableState::default().with_persistence_id("my-table");
2239        assert_eq!(state.persistence_id(), Some("my-table"));
2240    }
2241
2242    #[test]
2243    fn table_state_default_no_persistence_id() {
2244        let state = TableState::default();
2245        assert_eq!(state.persistence_id(), None);
2246    }
2247
2248    #[test]
2249    fn table_state_save_restore_round_trip() {
2250        let mut state = TableState::default().with_persistence_id("test");
2251        state.select(Some(5));
2252        state.offset = 3;
2253        state.set_sort(Some(2), true);
2254        state.set_filter("search term");
2255
2256        let saved = state.save_state();
2257        assert_eq!(saved.selected, Some(5));
2258        assert_eq!(saved.offset, 3);
2259        assert_eq!(saved.sort_column, Some(2));
2260        assert!(saved.sort_ascending);
2261        assert_eq!(saved.filter, "search term");
2262
2263        // Reset state
2264        state.select(None);
2265        state.offset = 0;
2266        state.set_sort(None, false);
2267        state.set_filter("");
2268        assert_eq!(state.selected, None);
2269        assert_eq!(state.offset, 0);
2270        assert_eq!(state.sort_column(), None);
2271        assert!(!state.sort_ascending());
2272        assert!(state.filter().is_empty());
2273
2274        // Restore
2275        state.restore_state(saved);
2276        assert_eq!(state.selected, Some(5));
2277        assert_eq!(state.offset, 3);
2278        assert_eq!(state.sort_column(), Some(2));
2279        assert!(state.sort_ascending());
2280        assert_eq!(state.filter(), "search term");
2281    }
2282
2283    #[test]
2284    fn table_state_key_uses_persistence_id() {
2285        let state = TableState::default().with_persistence_id("main-data-table");
2286        let key = state.state_key();
2287        assert_eq!(key.widget_type, "Table");
2288        assert_eq!(key.instance_id, "main-data-table");
2289    }
2290
2291    #[test]
2292    fn table_state_key_default_when_no_id() {
2293        let state = TableState::default();
2294        let key = state.state_key();
2295        assert_eq!(key.widget_type, "Table");
2296        assert_eq!(key.instance_id, "default");
2297    }
2298
2299    #[test]
2300    fn table_persist_state_default() {
2301        let persist = TablePersistState::default();
2302        assert_eq!(persist.selected, None);
2303        assert_eq!(persist.offset, 0);
2304        assert_eq!(persist.sort_column, None);
2305        assert!(!persist.sort_ascending);
2306        assert!(persist.filter.is_empty());
2307    }
2308
2309    // ============================================================================
2310    // Undo Support Tests
2311    // ============================================================================
2312
2313    #[test]
2314    fn table_state_undo_widget_id_unique() {
2315        let state1 = TableState::default();
2316        let state2 = TableState::default();
2317        assert_ne!(state1.undo_id(), state2.undo_id());
2318    }
2319
2320    #[test]
2321    fn table_state_undo_snapshot_and_restore() {
2322        let mut state = TableState::default();
2323        state.select(Some(5));
2324        state.offset = 2;
2325        state.set_sort(Some(1), false);
2326        state.set_filter("test filter");
2327
2328        // Create snapshot
2329        let snapshot = state.create_snapshot();
2330
2331        // Modify state
2332        state.select(Some(10));
2333        state.offset = 7;
2334        state.set_sort(Some(3), true);
2335        state.set_filter("new filter");
2336
2337        assert_eq!(state.selected, Some(10));
2338        assert_eq!(state.offset, 7);
2339        assert_eq!(state.sort_column(), Some(3));
2340        assert!(state.sort_ascending());
2341        assert_eq!(state.filter(), "new filter");
2342
2343        // Restore snapshot
2344        assert!(state.restore_snapshot(&*snapshot));
2345
2346        // Verify restored state
2347        assert_eq!(state.selected, Some(5));
2348        assert_eq!(state.offset, 2);
2349        assert_eq!(state.sort_column(), Some(1));
2350        assert!(!state.sort_ascending());
2351        assert_eq!(state.filter(), "test filter");
2352    }
2353
2354    #[test]
2355    fn table_state_undo_ext_sort() {
2356        let mut state = TableState::default();
2357
2358        // Initial state
2359        assert_eq!(state.sort_state(), (None, false));
2360
2361        // Set sort
2362        state.set_sort_state(Some(2), true);
2363        assert_eq!(state.sort_state(), (Some(2), true));
2364
2365        // Change sort
2366        state.set_sort_state(Some(0), false);
2367        assert_eq!(state.sort_state(), (Some(0), false));
2368    }
2369
2370    #[test]
2371    fn table_state_undo_ext_filter() {
2372        let mut state = TableState::default();
2373
2374        // Initial state
2375        assert_eq!(state.filter_text(), "");
2376
2377        // Set filter
2378        state.set_filter_text("search term");
2379        assert_eq!(state.filter_text(), "search term");
2380
2381        // Clear filter
2382        state.set_filter_text("");
2383        assert_eq!(state.filter_text(), "");
2384    }
2385
2386    #[test]
2387    fn table_state_restore_wrong_snapshot_type_fails() {
2388        use std::any::Any;
2389        let mut state = TableState::default();
2390        let wrong_snapshot: Box<dyn Any + Send> = Box::new(42i32);
2391        assert!(!state.restore_snapshot(&*wrong_snapshot));
2392    }
2393
2394    // --- Mouse handling tests ---
2395
2396    use crate::mouse::MouseResult;
2397    use ftui_core::event::{MouseButton, MouseEvent, MouseEventKind};
2398
2399    #[test]
2400    fn table_state_click_selects() {
2401        let mut state = TableState::default();
2402        let event = MouseEvent::new(MouseEventKind::Down(MouseButton::Left), 5, 2);
2403        let hit = Some((HitId::new(1), HitRegion::Content, 4u64));
2404        let result = state.handle_mouse(&event, hit, HitId::new(1), 10);
2405        assert_eq!(result, MouseResult::Selected(4));
2406        assert_eq!(state.selected, Some(4));
2407    }
2408
2409    #[test]
2410    fn table_state_second_click_activates() {
2411        let mut state = TableState::default();
2412        state.select(Some(4));
2413
2414        let event = MouseEvent::new(MouseEventKind::Down(MouseButton::Left), 5, 2);
2415        let hit = Some((HitId::new(1), HitRegion::Content, 4u64));
2416        let result = state.handle_mouse(&event, hit, HitId::new(1), 10);
2417        assert_eq!(result, MouseResult::Activated(4));
2418        assert_eq!(state.selected, Some(4));
2419    }
2420
2421    #[test]
2422    fn table_state_click_wrong_id_ignored() {
2423        let mut state = TableState::default();
2424        let event = MouseEvent::new(MouseEventKind::Down(MouseButton::Left), 5, 2);
2425        let hit = Some((HitId::new(99), HitRegion::Content, 4u64));
2426        let result = state.handle_mouse(&event, hit, HitId::new(1), 10);
2427        assert_eq!(result, MouseResult::Ignored);
2428    }
2429
2430    #[test]
2431    fn table_state_hover_updates() {
2432        let mut state = TableState::default();
2433        let event = MouseEvent::new(MouseEventKind::Moved, 5, 2);
2434        let hit = Some((HitId::new(1), HitRegion::Content, 3u64));
2435        let result = state.handle_mouse(&event, hit, HitId::new(1), 10);
2436        assert_eq!(result, MouseResult::HoverChanged);
2437        assert_eq!(state.hovered, Some(3));
2438    }
2439
2440    #[test]
2441    #[allow(clippy::field_reassign_with_default)]
2442    fn table_state_hover_same_index_ignored() {
2443        let mut state = {
2444            let mut s = TableState::default();
2445            s.hovered = Some(3);
2446            s
2447        };
2448        let event = MouseEvent::new(MouseEventKind::Moved, 5, 2);
2449        let hit = Some((HitId::new(1), HitRegion::Content, 3u64));
2450        let result = state.handle_mouse(&event, hit, HitId::new(1), 10);
2451        assert_eq!(result, MouseResult::Ignored);
2452        assert_eq!(state.hovered, Some(3));
2453    }
2454
2455    #[test]
2456    #[allow(clippy::field_reassign_with_default)]
2457    fn table_state_hover_clears() {
2458        let mut state = {
2459            let mut s = TableState::default();
2460            s.hovered = Some(5);
2461            s
2462        };
2463        let event = MouseEvent::new(MouseEventKind::Moved, 5, 2);
2464        // No hit (mouse moved off the table)
2465        let result = state.handle_mouse(&event, None, HitId::new(1), 10);
2466        assert_eq!(result, MouseResult::HoverChanged);
2467        assert_eq!(state.hovered, None);
2468    }
2469
2470    #[test]
2471    fn table_state_hover_clear_when_already_none() {
2472        let mut state = TableState::default();
2473        let event = MouseEvent::new(MouseEventKind::Moved, 5, 2);
2474        let result = state.handle_mouse(&event, None, HitId::new(1), 10);
2475        assert_eq!(result, MouseResult::Ignored);
2476    }
2477
2478    #[test]
2479    #[allow(clippy::field_reassign_with_default)]
2480    fn table_state_scroll_wheel_up() {
2481        let mut state = {
2482            let mut s = TableState::default();
2483            s.offset = 10;
2484            s
2485        };
2486        let event = MouseEvent::new(MouseEventKind::ScrollUp, 0, 0);
2487        let result = state.handle_mouse(&event, None, HitId::new(1), 20);
2488        assert_eq!(result, MouseResult::Scrolled);
2489        assert_eq!(state.offset, 7);
2490    }
2491
2492    #[test]
2493    fn table_state_scroll_wheel_down() {
2494        let mut state = TableState::default();
2495        let event = MouseEvent::new(MouseEventKind::ScrollDown, 0, 0);
2496        let result = state.handle_mouse(&event, None, HitId::new(1), 20);
2497        assert_eq!(result, MouseResult::Scrolled);
2498        assert_eq!(state.offset, 3);
2499    }
2500
2501    #[test]
2502    #[allow(clippy::field_reassign_with_default)]
2503    fn table_state_scroll_down_clamps() {
2504        let mut state = {
2505            let mut s = TableState::default();
2506            s.offset = 18;
2507            s
2508        };
2509        state.scroll_down(5, 20);
2510        assert_eq!(state.offset, 19);
2511    }
2512
2513    #[test]
2514    #[allow(clippy::field_reassign_with_default)]
2515    fn table_state_scroll_up_clamps() {
2516        let mut state = {
2517            let mut s = TableState::default();
2518            s.offset = 1;
2519            s
2520        };
2521        state.scroll_up(5);
2522        assert_eq!(state.offset, 0);
2523    }
2524
2525    // ============================================================================
2526    // Edge-Case Tests (bd-2rvwb)
2527    // ============================================================================
2528
2529    #[test]
2530    fn row_with_fewer_cells_than_columns() {
2531        // Row has 1 cell but table declares 3 columns — extra columns should be empty
2532        let table = Table::new(
2533            [Row::new(["A"])],
2534            [
2535                Constraint::Fixed(3),
2536                Constraint::Fixed(3),
2537                Constraint::Fixed(3),
2538            ],
2539        );
2540        let area = Rect::new(0, 0, 12, 1);
2541        let mut pool = GraphemePool::new();
2542        let mut frame = Frame::new(12, 1, &mut pool);
2543        Widget::render(&table, area, &mut frame);
2544
2545        assert_eq!(cell_char(&frame.buffer, 0, 0), Some('A'));
2546        // Columns 2 and 3 should not contain data characters
2547        assert_ne!(cell_char(&frame.buffer, 4, 0), Some('A'));
2548    }
2549
2550    #[test]
2551    fn column_spacing_zero() {
2552        // No gap between columns — cells should be adjacent
2553        let table = Table::new(
2554            [Row::new(["AB", "CD"])],
2555            [Constraint::Fixed(2), Constraint::Fixed(2)],
2556        )
2557        .column_spacing(0);
2558
2559        let area = Rect::new(0, 0, 4, 1);
2560        let mut pool = GraphemePool::new();
2561        let mut frame = Frame::new(4, 1, &mut pool);
2562        Widget::render(&table, area, &mut frame);
2563
2564        assert_eq!(cell_char(&frame.buffer, 0, 0), Some('A'));
2565        assert_eq!(cell_char(&frame.buffer, 1, 0), Some('B'));
2566        assert_eq!(cell_char(&frame.buffer, 2, 0), Some('C'));
2567        assert_eq!(cell_char(&frame.buffer, 3, 0), Some('D'));
2568    }
2569
2570    #[test]
2571    fn render_with_nonzero_origin() {
2572        // Table rendered at offset position, not (0,0)
2573        let table = Table::new([Row::new(["X"])], [Constraint::Fixed(3)]);
2574        let area = Rect::new(5, 3, 3, 1);
2575        let mut pool = GraphemePool::new();
2576        let mut frame = Frame::new(10, 6, &mut pool);
2577        Widget::render(&table, area, &mut frame);
2578
2579        assert_eq!(cell_char(&frame.buffer, 5, 3), Some('X'));
2580        // Nothing at (0,0)
2581        assert_ne!(cell_char(&frame.buffer, 0, 0), Some('X'));
2582    }
2583
2584    #[test]
2585    fn single_row_height_exceeds_area() {
2586        // Row is taller than the viewport — should be clipped via scissor
2587        let table = Table::new([Row::new(["T"]).height(10)], [Constraint::Fixed(3)]);
2588        let area = Rect::new(0, 0, 3, 2);
2589        let mut pool = GraphemePool::new();
2590        let mut frame = Frame::new(3, 2, &mut pool);
2591        Widget::render(&table, area, &mut frame);
2592
2593        // First line of the row should still render
2594        assert_eq!(cell_char(&frame.buffer, 0, 0), Some('T'));
2595    }
2596
2597    #[test]
2598    fn selection_and_hover_on_same_row() {
2599        // Both selected and hovered on same row — both styles should merge
2600        let selected_fg = PackedRgba::rgb(100, 0, 0);
2601        let hovered_fg = PackedRgba::rgb(0, 100, 0);
2602        let highlight_fg = PackedRgba::rgb(0, 0, 100);
2603
2604        let theme = TableTheme {
2605            row_selected: Style::new().fg(selected_fg),
2606            row_hover: Style::new().fg(hovered_fg),
2607            ..Default::default()
2608        };
2609
2610        let table = Table::new([Row::new(["X"])], [Constraint::Fixed(3)])
2611            .highlight_style(Style::new().fg(highlight_fg))
2612            .theme(theme);
2613
2614        let area = Rect::new(0, 0, 3, 1);
2615        let mut pool = GraphemePool::new();
2616        let mut frame = Frame::new(3, 1, &mut pool);
2617        let mut state = TableState {
2618            selected: Some(0),
2619            hovered: Some(0),
2620            ..Default::default()
2621        };
2622
2623        StatefulWidget::render(&table, area, &mut frame, &mut state);
2624        // Highlight style wins (applied last in merge chain)
2625        assert_eq!(cell_fg(&frame.buffer, 0, 0), Some(highlight_fg));
2626    }
2627
2628    #[test]
2629    fn alternating_row_styles() {
2630        // Even/odd rows should get different theme styles
2631        let even_fg = PackedRgba::rgb(10, 10, 10);
2632        let odd_fg = PackedRgba::rgb(20, 20, 20);
2633        let theme = TableTheme {
2634            row: Style::new().fg(even_fg),
2635            row_alt: Style::new().fg(odd_fg),
2636            ..Default::default()
2637        };
2638
2639        let table = Table::new(
2640            [Row::new(["E"]), Row::new(["O"]), Row::new(["E2"])],
2641            [Constraint::Fixed(3)],
2642        )
2643        .theme(theme);
2644
2645        let area = Rect::new(0, 0, 3, 3);
2646        let mut pool = GraphemePool::new();
2647        let mut frame = Frame::new(3, 3, &mut pool);
2648        Widget::render(&table, area, &mut frame);
2649
2650        // Row 0 is even, row 1 is odd, row 2 is even
2651        assert_eq!(cell_fg(&frame.buffer, 0, 0), Some(even_fg));
2652        assert_eq!(cell_fg(&frame.buffer, 0, 1), Some(odd_fg));
2653        assert_eq!(cell_fg(&frame.buffer, 0, 2), Some(even_fg));
2654    }
2655
2656    #[test]
2657    fn scroll_up_from_zero_stays_zero() {
2658        let mut state = TableState::default();
2659        state.scroll_up(10);
2660        assert_eq!(state.offset, 0);
2661    }
2662
2663    #[test]
2664    fn scroll_down_with_zero_rows() {
2665        let mut state = TableState::default();
2666        state.scroll_down(5, 0);
2667        assert_eq!(state.offset, 0);
2668    }
2669
2670    #[test]
2671    fn scroll_down_with_single_row() {
2672        let mut state = TableState::default();
2673        state.scroll_down(5, 1);
2674        assert_eq!(state.offset, 0);
2675    }
2676
2677    #[test]
2678    fn mouse_click_on_row_exceeding_row_count() {
2679        // Hit data row index >= row_count should be ignored
2680        let mut state = TableState::default();
2681        let event = MouseEvent::new(MouseEventKind::Down(MouseButton::Left), 0, 0);
2682        let hit = Some((HitId::new(1), HitRegion::Content, 100u64));
2683        let result = state.handle_mouse(&event, hit, HitId::new(1), 5);
2684        assert_eq!(result, MouseResult::Ignored);
2685        assert_eq!(state.selected, None);
2686    }
2687
2688    #[test]
2689    fn mouse_right_click_ignored() {
2690        let mut state = TableState::default();
2691        let event = MouseEvent::new(MouseEventKind::Down(MouseButton::Right), 0, 0);
2692        let hit = Some((HitId::new(1), HitRegion::Content, 2u64));
2693        let result = state.handle_mouse(&event, hit, HitId::new(1), 5);
2694        assert_eq!(result, MouseResult::Ignored);
2695    }
2696
2697    #[test]
2698    fn mouse_hover_on_row_exceeding_row_count() {
2699        let mut state = TableState::default();
2700        let event = MouseEvent::new(MouseEventKind::Moved, 0, 0);
2701        let hit = Some((HitId::new(1), HitRegion::Content, 100u64));
2702        let result = state.handle_mouse(&event, hit, HitId::new(1), 5);
2703        // Moves off widget, hover cleared (was None, stays None)
2704        assert_eq!(result, MouseResult::Ignored);
2705        assert_eq!(state.hovered, None);
2706    }
2707
2708    #[test]
2709    fn select_deselect_preserves_offset_then_reselect() {
2710        let mut state = TableState {
2711            offset: 15,
2712            ..Default::default()
2713        };
2714        state.select(Some(20));
2715        assert_eq!(state.selected, Some(20));
2716        assert_eq!(state.offset, 15); // offset not reset on select
2717
2718        state.select(None);
2719        assert_eq!(state.offset, 15); // preserve viewport on deselect
2720
2721        state.select(Some(3));
2722        assert_eq!(state.selected, Some(3));
2723        assert_eq!(state.offset, 15); // still preserved after reselect
2724    }
2725
2726    #[test]
2727    fn offset_clamped_when_rows_empty() {
2728        let table = Table::new(Vec::<Row>::new(), [Constraint::Fixed(5)]);
2729        let area = Rect::new(0, 0, 5, 3);
2730        let mut pool = GraphemePool::new();
2731        let mut frame = Frame::new(5, 3, &mut pool);
2732        let mut state = TableState {
2733            offset: 999,
2734            ..Default::default()
2735        };
2736        StatefulWidget::render(&table, area, &mut frame, &mut state);
2737        assert_eq!(state.offset, 0);
2738    }
2739
2740    #[test]
2741    fn selection_clamps_when_rows_empty() {
2742        let table = Table::new(Vec::<Row>::new(), [Constraint::Fixed(5)]);
2743        let area = Rect::new(0, 0, 5, 3);
2744        let mut pool = GraphemePool::new();
2745        let mut frame = Frame::new(5, 3, &mut pool);
2746        let mut state = TableState {
2747            selected: Some(5),
2748            ..Default::default()
2749        };
2750        StatefulWidget::render(&table, area, &mut frame, &mut state);
2751        assert_eq!(state.selected, None);
2752    }
2753
2754    #[test]
2755    fn header_with_bottom_margin_offsets_rows() {
2756        let header = Row::new(["H"]).bottom_margin(2);
2757        let table = Table::new([Row::new(["D"])], [Constraint::Fixed(3)]).header(header);
2758
2759        let area = Rect::new(0, 0, 3, 5);
2760        let mut pool = GraphemePool::new();
2761        let mut frame = Frame::new(3, 5, &mut pool);
2762        Widget::render(&table, area, &mut frame);
2763
2764        // Header at y=0, margin of 2, data at y=3
2765        assert_eq!(cell_char(&frame.buffer, 0, 0), Some('H'));
2766        assert_eq!(cell_char(&frame.buffer, 0, 3), Some('D'));
2767    }
2768
2769    #[test]
2770    fn block_plus_header_fill_entire_area() {
2771        // Block chrome is 4 rows (borders + padding), header takes 1 row — 5 rows total.
2772        // With area height=5, no data rows should render.
2773        let header = Row::new(["H"]);
2774        let table = Table::new([Row::new(["X"])], [Constraint::Fixed(3)])
2775            .block(Block::bordered())
2776            .header(header);
2777
2778        let area = Rect::new(0, 0, 5, 5);
2779        let mut pool = GraphemePool::new();
2780        let mut frame = Frame::new(5, 5, &mut pool);
2781        Widget::render(&table, area, &mut frame);
2782
2783        // Header should render inside the border + padding
2784        assert_eq!(cell_char(&frame.buffer, 2, 2), Some('H'));
2785        // Data row "X" should NOT appear (no room)
2786        let data_rendered =
2787            (0..5).any(|x| (0..5).any(|y| cell_char(&frame.buffer, x, y) == Some('X')));
2788        assert!(!data_rendered);
2789    }
2790
2791    #[test]
2792    fn min_constraint_measure() {
2793        let table = Table::new([Row::new(["AB"])], [Constraint::Min(10)]);
2794        let c = table.measure(Size::MAX);
2795        // Preferred width based on content, not the constraint minimum
2796        assert_eq!(c.preferred.width, 2);
2797        assert_eq!(c.preferred.height, 1);
2798    }
2799
2800    #[test]
2801    fn percentage_constraint_render() {
2802        // Percentage constraints should not panic and produce reasonable layout
2803        let table = Table::new(
2804            [Row::new(["A", "B"])],
2805            [Constraint::Percentage(50.0), Constraint::Percentage(50.0)],
2806        );
2807        let area = Rect::new(0, 0, 20, 1);
2808        let mut pool = GraphemePool::new();
2809        let mut frame = Frame::new(20, 1, &mut pool);
2810        Widget::render(&table, area, &mut frame);
2811
2812        assert_eq!(cell_char(&frame.buffer, 0, 0), Some('A'));
2813    }
2814
2815    #[test]
2816    fn fit_content_constraint_measure() {
2817        let table = Table::new(
2818            [Row::new(["Hello", "World"])],
2819            [Constraint::FitContent, Constraint::FitContent],
2820        )
2821        .column_spacing(1);
2822
2823        let c = table.measure(Size::MAX);
2824        // "Hello" = 5, "World" = 5, spacing = 1 → 11
2825        assert_eq!(c.preferred.width, 11);
2826    }
2827
2828    #[test]
2829    fn measure_with_block_adds_overhead() {
2830        let table_no_block = Table::new([Row::new(["X"])], [Constraint::Fixed(3)]);
2831        let table_with_block =
2832            Table::new([Row::new(["X"])], [Constraint::Fixed(3)]).block(Block::bordered());
2833
2834        let c_no = table_no_block.measure(Size::MAX);
2835        let c_with = table_with_block.measure(Size::MAX);
2836
2837        // Block chrome (borders + padding) adds 4 to width and 4 to height.
2838        assert_eq!(c_with.preferred.width, c_no.preferred.width + 4);
2839        assert_eq!(c_with.preferred.height, c_no.preferred.height + 4);
2840    }
2841
2842    #[test]
2843    fn variable_height_rows_selection_scrolls_down() {
2844        // Rows: height 1, 1, 5, 1, 1. Viewport=4 rows.
2845        // Select row 4 (past the tall row) should adjust offset.
2846        let rows = vec![
2847            Row::new(["A"]),
2848            Row::new(["B"]),
2849            Row::new(["C"]).height(5),
2850            Row::new(["D"]),
2851            Row::new(["E"]),
2852        ];
2853        let table = Table::new(rows, [Constraint::Fixed(5)]);
2854        let area = Rect::new(0, 0, 5, 4);
2855        let mut pool = GraphemePool::new();
2856        let mut frame = Frame::new(5, 4, &mut pool);
2857        let mut state = TableState {
2858            selected: Some(4),
2859            ..Default::default()
2860        };
2861        StatefulWidget::render(&table, area, &mut frame, &mut state);
2862
2863        // Selection should be visible; offset adjusted
2864        assert!(state.offset > 0);
2865        assert_eq!(state.selected, Some(4));
2866    }
2867
2868    #[test]
2869    fn many_rows_with_margins_viewport_clamping() {
2870        // 20 rows each with bottom_margin=1, viewport=5 lines.
2871        // Each row occupies 2 lines (1 content + 1 margin). Max 2 rows visible.
2872        let rows: Vec<Row> = (0..20)
2873            .map(|i| Row::new([format!("R{i}")]).bottom_margin(1))
2874            .collect();
2875        let table = Table::new(rows, [Constraint::Fixed(5)]);
2876        let area = Rect::new(0, 0, 5, 5);
2877        let mut pool = GraphemePool::new();
2878        let mut frame = Frame::new(5, 5, &mut pool);
2879        let mut state = TableState {
2880            offset: 19,
2881            ..Default::default()
2882        };
2883        StatefulWidget::render(&table, area, &mut frame, &mut state);
2884
2885        // Offset should be clamped back to fill viewport
2886        assert!(state.offset < 19);
2887    }
2888
2889    #[test]
2890    fn render_area_width_one() {
2891        // Extremely narrow area — should not panic
2892        let table = Table::new([Row::new(["Hello"])], [Constraint::Fixed(5)]);
2893        let area = Rect::new(0, 0, 1, 1);
2894        let mut pool = GraphemePool::new();
2895        let mut frame = Frame::new(1, 1, &mut pool);
2896        Widget::render(&table, area, &mut frame);
2897
2898        assert_eq!(cell_char(&frame.buffer, 0, 0), Some('H'));
2899    }
2900
2901    #[test]
2902    fn render_area_height_one() {
2903        // Minimal height — should show first row
2904        let table = Table::new([Row::new(["A"]), Row::new(["B"])], [Constraint::Fixed(3)]);
2905        let area = Rect::new(0, 0, 3, 1);
2906        let mut pool = GraphemePool::new();
2907        let mut frame = Frame::new(3, 1, &mut pool);
2908        Widget::render(&table, area, &mut frame);
2909
2910        assert_eq!(cell_char(&frame.buffer, 0, 0), Some('A'));
2911    }
2912
2913    #[test]
2914    fn hit_regions_with_offset() {
2915        // When scrolled, hit data should still encode logical row index
2916        let table = Table::new(
2917            (0..10).map(|i| Row::new([format!("R{i}")])),
2918            [Constraint::Fixed(5)],
2919        )
2920        .hit_id(HitId::new(42));
2921
2922        let area = Rect::new(0, 0, 5, 3);
2923        let mut pool = GraphemePool::new();
2924        let mut frame = Frame::with_hit_grid(5, 3, &mut pool);
2925        let mut state = TableState {
2926            offset: 5,
2927            ..Default::default()
2928        };
2929        StatefulWidget::render(&table, area, &mut frame, &mut state);
2930
2931        // Row at y=0 should be logical row 5
2932        let hit0 = frame.hit_test(2, 0);
2933        assert_eq!(hit0, Some((HitId::new(42), HitRegion::Content, 5)));
2934
2935        let hit1 = frame.hit_test(2, 1);
2936        assert_eq!(hit1, Some((HitId::new(42), HitRegion::Content, 6)));
2937    }
2938
2939    #[test]
2940    fn table_state_sort_defaults() {
2941        let state = TableState::default();
2942        assert_eq!(state.sort_column(), None);
2943        assert!(!state.sort_ascending());
2944        assert!(state.filter().is_empty());
2945    }
2946
2947    #[test]
2948    fn table_state_set_sort_toggle() {
2949        let mut state = TableState::default();
2950        state.set_sort(Some(0), true);
2951        assert_eq!(state.sort_column(), Some(0));
2952        assert!(state.sort_ascending());
2953
2954        // Toggle direction
2955        state.set_sort(Some(0), false);
2956        assert!(!state.sort_ascending());
2957
2958        // Change column
2959        state.set_sort(Some(3), true);
2960        assert_eq!(state.sort_column(), Some(3));
2961
2962        // Clear sort
2963        state.set_sort(None, false);
2964        assert_eq!(state.sort_column(), None);
2965    }
2966
2967    #[test]
2968    fn table_persist_round_trip_preserves_hovered_none() {
2969        let mut state = TableState::default().with_persistence_id("t");
2970        state.select(Some(3));
2971        state.hovered = Some(7);
2972        state.offset = 2;
2973
2974        let saved = state.save_state();
2975        state.restore_state(saved);
2976
2977        // hovered is deliberately NOT persisted (transient state)
2978        assert_eq!(state.hovered, None);
2979        assert_eq!(state.selected, Some(3));
2980        assert_eq!(state.offset, 2);
2981    }
2982
2983    #[test]
2984    fn undo_snapshot_clears_hovered() {
2985        let mut state = TableState::default();
2986        state.select(Some(2));
2987        state.hovered = Some(5);
2988
2989        let snap = state.create_snapshot();
2990
2991        // Modify
2992        state.select(Some(9));
2993        state.hovered = Some(8);
2994
2995        // Restore
2996        assert!(state.restore_snapshot(&*snap));
2997        assert_eq!(state.selected, Some(2));
2998        // hovered is cleared on restore (not preserved in snapshot)
2999        assert_eq!(state.hovered, None);
3000    }
3001
3002    #[test]
3003    fn wide_chars_in_render() {
3004        // CJK characters are 2 cells wide — should clip correctly.
3005        // Wide chars may use the grapheme pool, so we check the cell is populated.
3006        let table = Table::new([Row::new(["界界界"])], [Constraint::Fixed(4)]);
3007        let area = Rect::new(0, 0, 4, 1);
3008        let mut pool = GraphemePool::new();
3009        let mut frame = Frame::new(4, 1, &mut pool);
3010        Widget::render(&table, area, &mut frame);
3011
3012        // "界界界" needs 6 cells but only 4 available — first two wide chars fit.
3013        // The cell at (0,0) should have content (not empty).
3014        let cell = frame.buffer.get(0, 0).unwrap();
3015        assert!(
3016            !cell.content.is_empty(),
3017            "first cell should contain CJK content, not be empty"
3018        );
3019        // Cell at (1,0) should be a continuation marker for the wide char
3020        let cell1 = frame.buffer.get(1, 0).unwrap();
3021        assert!(
3022            cell1.content.is_continuation(),
3023            "second cell should be continuation of wide char"
3024        );
3025    }
3026
3027    #[test]
3028    fn empty_row_cells() {
3029        // Row with empty strings — should render without panic
3030        let table = Table::new(
3031            [Row::new(["", "", ""])],
3032            [
3033                Constraint::Fixed(3),
3034                Constraint::Fixed(3),
3035                Constraint::Fixed(3),
3036            ],
3037        );
3038        let area = Rect::new(0, 0, 11, 1);
3039        let mut pool = GraphemePool::new();
3040        let mut frame = Frame::new(11, 1, &mut pool);
3041        Widget::render(&table, area, &mut frame);
3042        // Should not panic; cells empty
3043    }
3044
3045    #[test]
3046    fn measure_with_many_rows_saturates() {
3047        // Height computation should use saturating arithmetic
3048        let rows: Vec<Row> = (0..10000).map(|_| Row::new(["X"]).height(100)).collect();
3049        let table = Table::new(rows, [Constraint::Fixed(3)]);
3050        let c = table.measure(Size::MAX);
3051
3052        // Should not overflow — saturates at u16::MAX
3053        assert!(c.preferred.height > 0);
3054    }
3055
3056    #[test]
3057    fn variable_height_rows_respect_viewport_visible_range() {
3058        let rows = vec![
3059            Row::new(["R0"]),
3060            Row::new(["R1"]).height(2),
3061            Row::new(["R2"]),
3062            Row::new(["R3"]),
3063        ];
3064        let table = Table::new(rows, [Constraint::Fixed(4)]);
3065        let area = Rect::new(0, 0, 4, 3);
3066        let mut pool = GraphemePool::new();
3067        let mut frame = Frame::new(4, 3, &mut pool);
3068        let mut state = TableState {
3069            offset: 1,
3070            ..Default::default()
3071        };
3072
3073        StatefulWidget::render(&table, area, &mut frame, &mut state);
3074
3075        assert_eq!(state.offset, 1);
3076        assert_eq!(row_text(&frame.buffer, 0), "R1");
3077        assert_eq!(row_text(&frame.buffer, 1), "");
3078        assert_eq!(row_text(&frame.buffer, 2), "R2");
3079    }
3080
3081    #[test]
3082    fn render_100k_rows_stays_within_8ms_frame_budget() {
3083        use std::time::{Duration, Instant};
3084
3085        let rows: Vec<Row> = (0..100_000).map(|_| Row::new(["row"])).collect();
3086        let table = Table::new(rows, [Constraint::Fixed(12)]);
3087        let area = Rect::new(0, 0, 12, 24);
3088        let mut state = TableState {
3089            offset: 50_000,
3090            ..Default::default()
3091        };
3092        let mut pool = GraphemePool::new();
3093
3094        // Warm up branch prediction and caches.
3095        let mut warmup = Frame::new(12, 24, &mut pool);
3096        StatefulWidget::render(&table, area, &mut warmup, &mut state);
3097
3098        let iterations = 20u32;
3099        let start = Instant::now();
3100        for _ in 0..iterations {
3101            let mut frame = Frame::new(12, 24, &mut pool);
3102            StatefulWidget::render(&table, area, &mut frame, &mut state);
3103        }
3104        let per_frame = start.elapsed() / iterations;
3105
3106        assert!(
3107            per_frame <= Duration::from_millis(8),
3108            "100k-row table render exceeded 8ms budget: {per_frame:?}"
3109        );
3110    }
3111
3112    #[cfg(feature = "tracing")]
3113    #[test]
3114    fn tracing_table_render_span_reports_row_counts() {
3115        let trace_state = Arc::new(Mutex::new(TableTraceState::default()));
3116        let _trace_test_guard = crate::tracing_test_support::acquire();
3117        let subscriber = tracing_subscriber::registry().with(TableTraceCapture {
3118            state: Arc::clone(&trace_state),
3119        });
3120        let _guard = tracing::subscriber::set_default(subscriber);
3121        tracing::callsite::rebuild_interest_cache();
3122
3123        let rows: Vec<Row> = (0..20).map(|i| Row::new([format!("R{i}")])).collect();
3124        let table = Table::new(rows, [Constraint::Fixed(6)]);
3125        let area = Rect::new(0, 0, 6, 4);
3126        let mut state = TableState {
3127            offset: 3,
3128            ..Default::default()
3129        };
3130        let mut pool = GraphemePool::new();
3131        let mut frame = Frame::new(6, 4, &mut pool);
3132        // Parallel workspace tests can perturb callsite interest after the
3133        // subscriber is installed, so rebuild immediately before the traced render.
3134        tracing::callsite::rebuild_interest_cache();
3135        StatefulWidget::render(&table, area, &mut frame, &mut state);
3136
3137        tracing::callsite::rebuild_interest_cache();
3138        let snapshot = trace_state.lock().expect("table trace state lock");
3139        assert!(
3140            snapshot.span_count >= 1,
3141            "expected at least one table.render span, got {}",
3142            snapshot.span_count
3143        );
3144        assert!(
3145            snapshot.has_total_rows_field,
3146            "table.render span missing total_rows field"
3147        );
3148        assert!(
3149            snapshot.has_rendered_rows_field,
3150            "table.render span missing rendered_rows field"
3151        );
3152        assert!(
3153            snapshot.total_rows.contains(&20),
3154            "expected total_rows=20 in span fields, got {:?}",
3155            snapshot.total_rows
3156        );
3157        assert!(
3158            snapshot.rendered_rows.iter().any(|&n| n > 0 && n <= 4),
3159            "expected rendered_rows between 1 and 4, got {:?}",
3160            snapshot.rendered_rows
3161        );
3162    }
3163}