rusticity_term/ui/cw/

logs.rs

// CloudWatch Logs UI rendering and state
use crate::app::App;
use crate::common::{
    format_bytes, format_timestamp, render_pagination_text, render_vertical_scrollbar, ColumnTrait,
    CyclicEnum, InputFocus, SortDirection, UTC_TIMESTAMP_WIDTH,
};
use crate::cw::insights::{DateRangeType, TimeUnit};
use crate::keymap::Mode;
use crate::ui::get_cursor;
use crate::ui::labeled_field;
use crate::ui::render_inner_tab_spans;
use crate::ui::table::{expanded_from_columns, render_table, Column as TableColumn, TableConfig};
use ratatui::{prelude::*, widgets::*};
use rusticity_core::{LogEvent, LogGroup, LogStream};

// State
pub struct CloudWatchLogGroupsState {
    pub log_groups: crate::table::TableState<LogGroup>,
    pub log_streams: Vec<LogStream>,
    pub log_events: Vec<LogEvent>,
    pub selected_stream: usize,
    pub selected_event: usize,
    pub loading: bool,
    pub loading_message: String,
    pub detail_tab: DetailTab,
    pub stream_filter: String,
    pub exact_match: bool,
    pub show_expired: bool,
    pub filter_mode: bool,
    pub input_focus: InputFocus,
    pub stream_page: usize,
    pub stream_sort: StreamSort,
    pub stream_sort_desc: bool,
    pub event_filter: String,
    pub event_scroll_offset: usize,
    pub event_horizontal_scroll: usize,
    pub has_older_events: bool,
    pub event_input_focus: EventFilterFocus,
    pub stream_page_size: usize,
    pub stream_current_page: usize,
    pub expanded_event: Option<usize>,
    pub expanded_stream: Option<usize>,
    pub next_backward_token: Option<String>,
    pub start_time: Option<i64>,
    pub end_time: Option<i64>,
    pub date_range_type: DateRangeType,
    pub relative_amount: String,
    pub relative_unit: TimeUnit,
}

impl CloudWatchLogGroupsState {
    pub fn new() -> Self {
        Self::default()
    }
}

impl Default for CloudWatchLogGroupsState {
    fn default() -> Self {
        Self {
            log_groups: crate::table::TableState::new(),
            log_streams: Vec::new(),
            log_events: Vec::new(),
            selected_stream: 0,
            selected_event: 0,
            loading: false,
            loading_message: String::new(),
            detail_tab: DetailTab::LogStreams,
            stream_filter: String::new(),
            exact_match: false,
            show_expired: false,
            filter_mode: false,
            input_focus: InputFocus::Filter,
            stream_page: 0,
            stream_sort: StreamSort::LastEventTime,
            stream_sort_desc: true,
            event_filter: String::new(),
            event_scroll_offset: 0,
            event_horizontal_scroll: 0,
            has_older_events: true,
            event_input_focus: EventFilterFocus::Filter,
            stream_page_size: 20,
            stream_current_page: 0,
            expanded_event: None,
            expanded_stream: None,
            next_backward_token: None,
            start_time: None,
            end_time: None,
            date_range_type: DateRangeType::Relative,
            relative_amount: String::new(),
            relative_unit: TimeUnit::Hours,
        }
    }
}

// Enums
#[derive(Debug, Clone, Copy, PartialEq)]
pub enum StreamSort {
    Name,
    CreationTime,
    LastEventTime,
}

pub const FILTER_CONTROLS: [InputFocus; 4] = [
    InputFocus::Filter,
    InputFocus::Checkbox("ExactMatch"),
    InputFocus::Checkbox("ShowExpired"),
    InputFocus::Pagination,
];

#[derive(Debug, Clone, Copy, PartialEq)]
pub enum EventFilterFocus {
    Filter,
    DateRange,
}

impl EventFilterFocus {
    const ALL: [EventFilterFocus; 2] = [EventFilterFocus::Filter, EventFilterFocus::DateRange];

    pub fn next(self) -> Self {
        let idx = Self::ALL.iter().position(|&f| f == self).unwrap_or(0);
        Self::ALL[(idx + 1) % Self::ALL.len()]
    }

    pub fn prev(self) -> Self {
        let idx = Self::ALL.iter().position(|&f| f == self).unwrap_or(0);
        Self::ALL[(idx + Self::ALL.len() - 1) % Self::ALL.len()]
    }
}

#[derive(Debug, Clone, Copy, PartialEq)]
pub enum DetailTab {
    LogStreams,
    Tags,
    AnomalyDetection,
    MetricFilter,
    SubscriptionFilters,
    ContributorInsights,
    DataProtection,
    FieldIndexes,
    Transformer,
}

impl CyclicEnum for DetailTab {
    const ALL: &'static [Self] = &[Self::LogStreams];
}

impl DetailTab {
    pub fn name(&self) -> &'static str {
        match self {
            DetailTab::LogStreams => "Log streams",
            DetailTab::Tags => "Tags",
            DetailTab::AnomalyDetection => "Anomaly detection",
            DetailTab::MetricFilter => "Metric filter",
            DetailTab::SubscriptionFilters => "Subscription filters",
            DetailTab::ContributorInsights => "Contributor insights",
            DetailTab::DataProtection => "Data protection",
            DetailTab::FieldIndexes => "Field indexes",
            DetailTab::Transformer => "Transformer",
        }
    }

    pub fn all() -> Vec<DetailTab> {
        vec![DetailTab::LogStreams]
    }
}

// Columns
#[derive(Debug, Clone, Copy, PartialEq)]
pub enum StreamColumn {
    LogStream,
    ARN,
    CreationTime,
    FirstEventTime,
    LastEventTime,
    LastIngestionTime,
    UploadSequenceToken,
}

impl StreamColumn {
    pub fn name(&self) -> &'static str {
        match self {
            StreamColumn::LogStream => "Log stream",
            StreamColumn::ARN => "ARN",
            StreamColumn::CreationTime => "Creation time",
            StreamColumn::FirstEventTime => "First event time",
            StreamColumn::LastEventTime => "Last event time",
            StreamColumn::LastIngestionTime => "Last ingestion time",
            StreamColumn::UploadSequenceToken => "Upload sequence token",
        }
    }

    pub fn width(&self) -> u16 {
        match self {
            StreamColumn::LogStream => 50,
            StreamColumn::ARN => 80,
            StreamColumn::CreationTime => UTC_TIMESTAMP_WIDTH,
            StreamColumn::FirstEventTime => UTC_TIMESTAMP_WIDTH,
            StreamColumn::LastEventTime => UTC_TIMESTAMP_WIDTH,
            StreamColumn::LastIngestionTime => UTC_TIMESTAMP_WIDTH,
            StreamColumn::UploadSequenceToken => 30,
        }
    }

    pub fn all() -> Vec<StreamColumn> {
        vec![
            StreamColumn::LogStream,
            StreamColumn::ARN,
            StreamColumn::CreationTime,
            StreamColumn::FirstEventTime,
            StreamColumn::LastEventTime,
            StreamColumn::LastIngestionTime,
            StreamColumn::UploadSequenceToken,
        ]
    }

    pub fn default_visible() -> Vec<StreamColumn> {
        vec![
            StreamColumn::LogStream,
            StreamColumn::CreationTime,
            StreamColumn::LastEventTime,
        ]
    }

    pub fn to_column(
        self,
        account_id: &str,
        region: &str,
        log_group_name: &str,
    ) -> Box<dyn crate::ui::table::Column<LogStream>> {
        use crate::common::format_optional_timestamp;
        use crate::ui::table::Column;

        struct StreamColumnImpl {
            variant: StreamColumn,
            account_id: String,
            region: String,
            log_group_name: String,
        }

        impl Column<LogStream> for StreamColumnImpl {
            fn name(&self) -> &str {
                self.variant.name()
            }

            fn width(&self) -> u16 {
                self.variant.width()
            }

            fn render(&self, item: &LogStream) -> (String, Style) {
                let text = match self.variant {
                    StreamColumn::LogStream => item.name.clone(),
                    StreamColumn::ARN => format!(
                        "arn:aws:logs:{}:{}:log-group:{}:log-stream:{}",
                        self.region, self.account_id, self.log_group_name, item.name
                    ),
                    StreamColumn::CreationTime => format_optional_timestamp(item.creation_time),
                    StreamColumn::FirstEventTime => "-".to_string(),
                    StreamColumn::LastEventTime => format_optional_timestamp(item.last_event_time),
                    StreamColumn::LastIngestionTime => "-".to_string(),
                    StreamColumn::UploadSequenceToken => "-".to_string(),
                };
                (text, Style::default())
            }
        }

        Box::new(StreamColumnImpl {
            variant: self,
            account_id: account_id.to_string(),
            region: region.to_string(),
            log_group_name: log_group_name.to_string(),
        })
    }
}

impl ColumnTrait for StreamColumn {
    fn name(&self) -> &'static str {
        self.name()
    }
}

#[derive(Debug, Clone, Copy, PartialEq)]
pub enum EventColumn {
    Timestamp,
    IngestionTime,
    Message,
    EventId,
    LogStreamName,
}

impl EventColumn {
    pub fn name(&self) -> &'static str {
        match self {
            EventColumn::Timestamp => "Timestamp",
            EventColumn::IngestionTime => "Ingestion time",
            EventColumn::Message => "Message",
            EventColumn::EventId => "Event ID",
            EventColumn::LogStreamName => "Log stream name",
        }
    }

    pub fn width(&self) -> u16 {
        match self {
            EventColumn::Timestamp => UTC_TIMESTAMP_WIDTH,
            EventColumn::IngestionTime => UTC_TIMESTAMP_WIDTH,
            EventColumn::Message => 0, // Min constraint
            EventColumn::EventId => 40,
            EventColumn::LogStreamName => 50,
        }
    }

    pub fn all() -> Vec<EventColumn> {
        vec![
            EventColumn::Timestamp,
            EventColumn::IngestionTime,
            EventColumn::Message,
            EventColumn::EventId,
            EventColumn::LogStreamName,
        ]
    }

    pub fn default_visible() -> Vec<EventColumn> {
        vec![EventColumn::Timestamp, EventColumn::Message]
    }

    pub fn to_column(self) -> Box<dyn TableColumn<LogEvent>> {
        struct EventColumnImpl {
            variant: EventColumn,
        }

        impl TableColumn<LogEvent> for EventColumnImpl {
            fn name(&self) -> &str {
                self.variant.name()
            }

            fn width(&self) -> u16 {
                self.variant.width()
            }

            fn render(&self, item: &LogEvent) -> (String, Style) {
                let text = match self.variant {
                    EventColumn::Timestamp => format_timestamp(&item.timestamp),
                    EventColumn::Message => {
                        let msg = item.message.lines().next().unwrap_or("").replace('\t', " ");
                        msg
                    }
                    EventColumn::IngestionTime => "-".to_string(),
                    EventColumn::EventId => "-".to_string(),
                    EventColumn::LogStreamName => "-".to_string(),
                };
                (text, Style::default())
            }
        }

        Box::new(EventColumnImpl { variant: self })
    }
}

impl ColumnTrait for EventColumn {
    fn name(&self) -> &'static str {
        self.name()
    }
}

// Log Group Columns
#[derive(Debug, Clone, Copy, PartialEq)]
pub enum LogGroupColumn {
    LogGroup,
    LogClass,
    Retention,
    StoredBytes,
    CreationTime,
    ARN,
}

impl LogGroupColumn {
    pub fn name(&self) -> &'static str {
        match self {
            LogGroupColumn::LogGroup => "Log group",
            LogGroupColumn::LogClass => "Log class",
            LogGroupColumn::Retention => "Retention",
            LogGroupColumn::StoredBytes => "Stored bytes",
            LogGroupColumn::CreationTime => "Creation time",
            LogGroupColumn::ARN => "ARN",
        }
    }

    pub fn width(&self) -> u16 {
        match self {
            LogGroupColumn::LogGroup => 0,
            LogGroupColumn::LogClass => 12,
            LogGroupColumn::Retention => 12,
            LogGroupColumn::StoredBytes => 15,
            LogGroupColumn::CreationTime => UTC_TIMESTAMP_WIDTH,
            LogGroupColumn::ARN => 0,
        }
    }

    pub fn all() -> Vec<LogGroupColumn> {
        vec![
            LogGroupColumn::LogGroup,
            LogGroupColumn::LogClass,
            LogGroupColumn::Retention,
            LogGroupColumn::StoredBytes,
            LogGroupColumn::CreationTime,
            LogGroupColumn::ARN,
        ]
    }

    pub fn default_visible() -> Vec<LogGroupColumn> {
        vec![LogGroupColumn::LogGroup, LogGroupColumn::StoredBytes]
    }
}

impl ColumnTrait for LogGroupColumn {
    fn name(&self) -> &'static str {
        self.name()
    }
}

// Helper functions

pub fn selected_log_group(app: &App) -> Option<&LogGroup> {
    app.log_groups_state
        .log_groups
        .items
        .get(app.log_groups_state.log_groups.selected)
}

pub fn filtered_log_groups(app: &App) -> Vec<&LogGroup> {
    if app.log_groups_state.log_groups.filter.is_empty() {
        app.log_groups_state.log_groups.items.iter().collect()
    } else {
        app.log_groups_state
            .log_groups
            .items
            .iter()
            .filter(|group| {
                if app.log_groups_state.exact_match {
                    group.name == app.log_groups_state.log_groups.filter
                } else {
                    group.name.contains(&app.log_groups_state.log_groups.filter)
                }
            })
            .collect()
    }
}

pub fn filtered_log_streams(app: &App) -> Vec<&LogStream> {
    let mut streams: Vec<&LogStream> = if app.log_groups_state.stream_filter.is_empty() {
        app.log_groups_state.log_streams.iter().collect()
    } else {
        app.log_groups_state
            .log_streams
            .iter()
            .filter(|stream| {
                if app.log_groups_state.exact_match {
                    stream.name == app.log_groups_state.stream_filter
                } else {
                    stream.name.contains(&app.log_groups_state.stream_filter)
                }
            })
            .collect()
    };

    streams.sort_by(|a, b| {
        let cmp = match app.log_groups_state.stream_sort {
            StreamSort::Name => a.name.cmp(&b.name),
            StreamSort::CreationTime => a.creation_time.cmp(&b.creation_time),
            StreamSort::LastEventTime => a.last_event_time.cmp(&b.last_event_time),
        };
        if app.log_groups_state.stream_sort_desc {
            cmp.reverse()
        } else {
            cmp
        }
    });

    streams
}

pub fn filtered_log_events(app: &App) -> Vec<&LogEvent> {
    if app.log_groups_state.event_filter.is_empty() {
        app.log_groups_state.log_events.iter().collect()
    } else {
        app.log_groups_state
            .log_events
            .iter()
            .filter(|event| event.message.contains(&app.log_groups_state.event_filter))
            .collect()
    }
}

pub fn render_groups_list(frame: &mut Frame, app: &App, area: Rect) {
    let chunks = Layout::default()
        .direction(Direction::Vertical)
        .constraints([
            Constraint::Length(3), // Filter
            Constraint::Min(0),    // Table
        ])
        .split(area);

    let placeholder = "Filter loaded log groups or try prefix search";
    let filtered_groups = filtered_log_groups(app);
    let filtered_count = filtered_groups.len();
    let page_size = app.log_groups_state.log_groups.page_size.value();
    let total_pages = filtered_count.div_ceil(page_size);
    let current_page = app.log_groups_state.log_groups.selected / page_size;
    let pagination = render_pagination_text(current_page, total_pages);

    crate::ui::filter::render_simple_filter(
        frame,
        chunks[0],
        crate::ui::filter::SimpleFilterConfig {
            filter_text: &app.log_groups_state.log_groups.filter,
            placeholder,
            pagination: &pagination,
            mode: app.mode,
            is_input_focused: app.log_groups_state.input_focus == InputFocus::Filter,
            is_pagination_focused: app.log_groups_state.input_focus == InputFocus::Pagination,
        },
    );

    let scroll_offset = app.log_groups_state.log_groups.scroll_offset;
    let start_idx = scroll_offset;
    let end_idx = (start_idx + page_size).min(filtered_groups.len());
    let paginated: Vec<&LogGroup> = filtered_groups[start_idx..end_idx].to_vec();

    let mut columns: Vec<Box<dyn TableColumn<LogGroup>>> = vec![];

    for col in &app.visible_columns {
        match col {
            LogGroupColumn::LogGroup => {
                struct LogGroupNameColumn;
                impl TableColumn<LogGroup> for LogGroupNameColumn {
                    fn name(&self) -> &str {
                        "Log group name"
                    }
                    fn width(&self) -> u16 {
                        65
                    }
                    fn render(&self, item: &LogGroup) -> (String, Style) {
                        (item.name.clone(), Style::default())
                    }
                }
                columns.push(Box::new(LogGroupNameColumn));
            }
            LogGroupColumn::LogClass => {
                struct LogClassColumn;
                impl TableColumn<LogGroup> for LogClassColumn {
                    fn name(&self) -> &str {
                        "Log class"
                    }
                    fn width(&self) -> u16 {
                        12
                    }
                    fn render(&self, item: &LogGroup) -> (String, Style) {
                        (
                            item.log_class.clone().unwrap_or_else(|| "-".to_string()),
                            Style::default(),
                        )
                    }
                }
                columns.push(Box::new(LogClassColumn));
            }
            LogGroupColumn::Retention => {
                struct RetentionColumn;
                impl TableColumn<LogGroup> for RetentionColumn {
                    fn name(&self) -> &str {
                        "Retention"
                    }
                    fn width(&self) -> u16 {
                        12
                    }
                    fn render(&self, item: &LogGroup) -> (String, Style) {
                        let retention = item
                            .retention_days
                            .map(|d| format!("{} days", d))
                            .unwrap_or_else(|| "Never".to_string());
                        (retention, Style::default())
                    }
                }
                columns.push(Box::new(RetentionColumn));
            }
            LogGroupColumn::StoredBytes => {
                struct LogGroupStoredBytesColumn;
                impl TableColumn<LogGroup> for LogGroupStoredBytesColumn {
                    fn name(&self) -> &str {
                        "Stored bytes"
                    }
                    fn width(&self) -> u16 {
                        15
                    }
                    fn render(&self, item: &LogGroup) -> (String, Style) {
                        let formatted = item
                            .stored_bytes
                            .map(format_bytes)
                            .unwrap_or_else(|| "-".to_string());
                        (formatted, Style::default())
                    }
                }
                columns.push(Box::new(LogGroupStoredBytesColumn));
            }
            LogGroupColumn::CreationTime => {
                struct CreationTimeColumn;
                impl TableColumn<LogGroup> for CreationTimeColumn {
                    fn name(&self) -> &str {
                        "Creation time"
                    }
                    fn width(&self) -> u16 {
                        27
                    }
                    fn render(&self, item: &LogGroup) -> (String, Style) {
                        let time = item
                            .creation_time
                            .map(|dt| dt.format("%Y-%m-%d %H:%M:%S (UTC)").to_string())
                            .unwrap_or_else(|| "-".to_string());
                        (time, Style::default())
                    }
                }
                columns.push(Box::new(CreationTimeColumn));
            }
            LogGroupColumn::ARN => {
                struct ArnColumn;
                impl TableColumn<LogGroup> for ArnColumn {
                    fn name(&self) -> &str {
                        "ARN"
                    }
                    fn width(&self) -> u16 {
                        80
                    }
                    fn render(&self, item: &LogGroup) -> (String, Style) {
                        (
                            item.arn.clone().unwrap_or_else(|| "-".to_string()),
                            Style::default(),
                        )
                    }
                }
                columns.push(Box::new(ArnColumn));
            }
        }
    }

    let expanded_index = app
        .log_groups_state
        .log_groups
        .expanded_item
        .and_then(|idx| {
            if idx >= start_idx && idx < end_idx {
                Some(idx - start_idx)
            } else {
                None
            }
        });

    let config = TableConfig {
        items: paginated,
        selected_index: app.log_groups_state.log_groups.selected % page_size,
        expanded_index,
        columns: &columns,
        sort_column: "",
        sort_direction: SortDirection::Asc,
        title: format!(" Log groups ({}) ", filtered_count),
        area: chunks[1],
        get_expanded_content: Some(Box::new(|group: &LogGroup| {
            expanded_from_columns(&columns, group)
        })),
        is_active: app.mode != Mode::FilterInput,
    };

    render_table(frame, config);
}

pub fn render_group_detail(frame: &mut Frame, app: &App, area: Rect) {
    frame.render_widget(Clear, area);

    let is_active = !matches!(
        app.mode,
        Mode::SpaceMenu
            | Mode::ServicePicker
            | Mode::ColumnSelector
            | Mode::ErrorModal
            | Mode::HelpModal
            | Mode::RegionPicker
            | Mode::CalendarPicker
            | Mode::TabPicker
    );
    let border_style = if is_active {
        Style::default().fg(Color::Green)
    } else {
        Style::default()
    };

    let chunks = Layout::default()
        .direction(Direction::Vertical)
        .constraints([
            Constraint::Length(10),
            Constraint::Length(1),
            Constraint::Min(0),
        ])
        .split(area);

    if let Some(group) = app.selected_log_group() {
        let detail_block = Block::default()
            .title(" Log group details ")
            .borders(Borders::ALL)
            .border_style(Style::default());
        let inner = detail_block.inner(chunks[0]);
        frame.render_widget(detail_block, chunks[0]);
        frame.render_widget(Clear, inner);

        let arn = format!(
            "arn:aws:logs:{}:{}:log-group:{}:*",
            app.config.region, app.config.account_id, group.name
        );
        let creation_time = group
            .creation_time
            .map(|t| format_timestamp(&t))
            .unwrap_or_else(|| "-".to_string());
        let stored_bytes = format_bytes(group.stored_bytes.unwrap_or(0));

        let lines = vec![
            labeled_field("Log class", "Standard"),
            labeled_field("Retention", "Never expire"),
            labeled_field("Stored bytes", stored_bytes),
            labeled_field("Creation time", creation_time),
            labeled_field("ARN", arn),
            Line::from(vec![
                Span::styled(
                    "Metric filters: ",
                    Style::default().add_modifier(Modifier::BOLD),
                ),
                Span::raw("0"),
            ]),
            Line::from(vec![
                Span::styled(
                    "Subscription filters: ",
                    Style::default().add_modifier(Modifier::BOLD),
                ),
                Span::raw("0"),
            ]),
            Line::from(vec![
                Span::styled(
                    "KMS key ID: ",
                    Style::default().add_modifier(Modifier::BOLD),
                ),
                Span::raw("-"),
            ]),
        ];

        frame.render_widget(Paragraph::new(lines), inner);
    }

    render_tab_menu(frame, app, chunks[1]);

    match app.log_groups_state.detail_tab {
        DetailTab::LogStreams => render_log_streams_table(frame, app, chunks[2], border_style),
        _ => render_tab_placeholder(frame, app, chunks[2], border_style),
    }
}

fn render_tab_menu(frame: &mut Frame, app: &App, area: Rect) {
    frame.render_widget(Clear, area);
    let all_tabs = DetailTab::all();
    let tabs: Vec<(&str, bool)> = all_tabs
        .iter()
        .map(|tab| (tab.name(), *tab == app.log_groups_state.detail_tab))
        .collect();
    let spans = render_inner_tab_spans(&tabs);

    frame.render_widget(
        Paragraph::new(Line::from(spans)).alignment(Alignment::Left),
        area,
    );
}

fn render_tab_placeholder(frame: &mut Frame, app: &App, area: Rect, border_style: Style) {
    frame.render_widget(Clear, area);
    let text = format!("{} - Coming soon", app.log_groups_state.detail_tab.name());
    let paragraph = Paragraph::new(text)
        .block(
            Block::default()
                .borders(Borders::ALL)
                .border_style(border_style),
        )
        .style(Style::default().fg(Color::Gray));
    frame.render_widget(paragraph, area);
}
fn render_log_streams_table(frame: &mut Frame, app: &App, area: Rect, _border_style: Style) {
    frame.render_widget(Clear, area);

    let chunks = Layout::default()
        .direction(Direction::Vertical)
        .constraints([Constraint::Length(3), Constraint::Min(0)])
        .split(area);

    let placeholder = "Filter loaded log streams or try prefix search";

    let exact_match_text = if app.log_groups_state.exact_match {
        "☑ Exact match"
    } else {
        "☐ Exact match"
    };
    let show_expired_text = if app.log_groups_state.show_expired {
        "☑ Show expired"
    } else {
        "☐ Show expired"
    };

    let filtered_streams = filtered_log_streams(app);
    let count = filtered_streams.len();
    let page_size = 20;
    let total_pages = count.div_ceil(page_size);
    let current_page = app.log_groups_state.selected_stream / page_size;
    let pagination = render_pagination_text(current_page, total_pages);

    crate::ui::filter::render_filter_bar(
        frame,
        crate::ui::filter::FilterConfig {
            filter_text: &app.log_groups_state.stream_filter,
            placeholder,
            mode: app.mode,
            is_input_focused: app.log_groups_state.input_focus == InputFocus::Filter,
            controls: vec![
                crate::ui::filter::FilterControl {
                    text: exact_match_text.to_string(),
                    is_focused: app.log_groups_state.input_focus
                        == InputFocus::Checkbox("ExactMatch"),
                },
                crate::ui::filter::FilterControl {
                    text: show_expired_text.to_string(),
                    is_focused: app.log_groups_state.input_focus
                        == InputFocus::Checkbox("ShowExpired"),
                },
                crate::ui::filter::FilterControl {
                    text: pagination,
                    is_focused: app.log_groups_state.input_focus == InputFocus::Pagination,
                },
            ],
            area: chunks[0],
        },
    );

    let log_group_name = app
        .selected_log_group()
        .map(|g| g.name.as_str())
        .unwrap_or("");

    let columns: Vec<Box<dyn TableColumn<LogStream>>> = app
        .visible_stream_columns
        .iter()
        .map(|col| col.to_column(&app.config.account_id, &app.config.region, log_group_name))
        .collect();

    let count_display = if count >= 100 {
        "100+".to_string()
    } else {
        count.to_string()
    };

    let sort_column = match app.log_groups_state.stream_sort {
        StreamSort::Name => "Log stream",
        StreamSort::CreationTime => "Creation time",
        StreamSort::LastEventTime => "Last event time",
    };

    let sort_direction = if app.log_groups_state.stream_sort_desc {
        SortDirection::Desc
    } else {
        SortDirection::Asc
    };

    let config = TableConfig {
        items: filtered_streams,
        selected_index: app.log_groups_state.selected_stream,
        expanded_index: app.log_groups_state.expanded_stream,
        columns: &columns,
        sort_column,
        sort_direction,
        title: format!(" Log streams ({}) ", count_display),
        area: chunks[1],
        get_expanded_content: Some(Box::new(|stream: &LogStream| {
            expanded_from_columns(&columns, stream)
        })),
        is_active: app.log_groups_state.input_focus != InputFocus::Filter,
    };

    render_table(frame, config);
}

pub fn render_events(frame: &mut Frame, app: &App, area: Rect) {
    frame.render_widget(Clear, area);

    let is_active = !matches!(
        app.mode,
        Mode::SpaceMenu
            | Mode::ServicePicker
            | Mode::ColumnSelector
            | Mode::ErrorModal
            | Mode::HelpModal
            | Mode::RegionPicker
            | Mode::CalendarPicker
            | Mode::TabPicker
    );
    let border_style = if is_active {
        Style::default().fg(Color::Green)
    } else {
        Style::default()
    };

    let chunks = Layout::default()
        .direction(Direction::Vertical)
        .constraints([Constraint::Length(3), Constraint::Min(0)])
        .split(area);

    // Filter and date range
    let filter_chunks = Layout::default()
        .direction(Direction::Horizontal)
        .constraints([Constraint::Percentage(50), Constraint::Percentage(50)])
        .split(chunks[0]);

    let cursor = get_cursor(
        app.mode == Mode::EventFilterInput
            && app.log_groups_state.event_input_focus == EventFilterFocus::Filter,
    );
    let filter_text =
        if app.log_groups_state.event_filter.is_empty() && app.mode != Mode::EventFilterInput {
            vec![
                Span::styled(
                    "Filter events - press ⏎ to search",
                    Style::default().fg(Color::DarkGray),
                ),
                Span::styled(cursor, Style::default().fg(Color::Yellow)),
            ]
        } else {
            vec![
                Span::raw(&app.log_groups_state.event_filter),
                Span::styled(cursor, Style::default().fg(Color::Yellow)),
            ]
        };

    let filter_border_style = if app.mode == Mode::EventFilterInput
        && app.log_groups_state.event_input_focus == EventFilterFocus::Filter
    {
        Style::default().fg(Color::Green)
    } else {
        Style::default()
    };

    let filter = Paragraph::new(Line::from(filter_text)).block(
        Block::default()
            .title(" Filter ")
            .borders(Borders::ALL)
            .border_style(filter_border_style),
    );

    let date_border_style = if app.mode == Mode::EventFilterInput
        && app.log_groups_state.event_input_focus == EventFilterFocus::DateRange
    {
        Style::default().fg(Color::Green)
    } else {
        Style::default()
    };

    let date_range_text = vec![
        Span::raw(format!(
            "Last [{}] <{}>",
            if app.log_groups_state.relative_amount.is_empty() {
                "_"
            } else {
                &app.log_groups_state.relative_amount
            },
            app.log_groups_state.relative_unit.name()
        )),
        Span::styled(cursor, Style::default().fg(Color::Yellow)),
    ];

    let date_range = Paragraph::new(Line::from(date_range_text)).block(
        Block::default()
            .title(" Date range ")
            .borders(Borders::ALL)
            .border_style(date_border_style),
    );

    frame.render_widget(filter, filter_chunks[0]);
    frame.render_widget(date_range, filter_chunks[1]);

    // Events table with banner
    let table_area = chunks[1];

    let header_cells = app
        .visible_event_columns
        .iter()
        .enumerate()
        .map(|(i, col)| {
            let name = if i > 0 {
                format!("⋮ {}", col.name())
            } else {
                col.name().to_string()
            };
            Cell::from(name).style(Style::default().add_modifier(Modifier::BOLD))
        });
    let header = Row::new(header_cells)
        .style(Style::default().bg(Color::White).fg(Color::Black))
        .height(1);

    let visible_events: Vec<_> = filtered_log_events(app).into_iter().collect();

    // Add banner as first row if there are older events
    let mut all_rows: Vec<Row> = Vec::new();

    if app.log_groups_state.has_older_events {
        let banner_cells = vec![
            Cell::from(""),
            Cell::from("There are older events to load. Scroll up to load more.")
                .style(Style::default().fg(Color::Yellow)),
        ];
        all_rows.push(Row::new(banner_cells).height(1));
    }

    // Calculate available width for message column
    let table_width = table_area.width.saturating_sub(4) as usize; // borders + spacing
    let fixed_width: usize = app
        .visible_event_columns
        .iter()
        .filter(|col| col.width() > 0)
        .map(|col| col.width() as usize + 1) // +1 for spacing
        .sum();
    let message_max_width = table_width.saturating_sub(fixed_width).saturating_sub(3); // -3 for highlight symbol

    let mut table_row_to_event_idx = Vec::new();
    let event_rows = visible_events.iter().enumerate().flat_map(|(idx, event)| {
        let is_expanded = app.log_groups_state.expanded_event == Some(idx);
        let is_selected = idx == app.log_groups_state.event_scroll_offset;

        let mut rows = Vec::new();

        // Main row with columns - always show first line or truncated message
        let mut cells: Vec<Cell> = Vec::new();
        for (i, col) in app.visible_event_columns.iter().enumerate() {
            let content = match col {
                EventColumn::Timestamp => {
                    let timestamp_str = format_timestamp(&event.timestamp);
                    crate::ui::table::format_expandable_with_selection(
                        &timestamp_str,
                        is_expanded,
                        is_selected,
                    )
                }
                EventColumn::Message => {
                    let msg = event
                        .message
                        .lines()
                        .next()
                        .unwrap_or("")
                        .replace('\t', " ");
                    if msg.len() > message_max_width {
                        format!("{}…", &msg[..message_max_width.saturating_sub(1)])
                    } else {
                        msg
                    }
                }
                EventColumn::IngestionTime => "-".to_string(),
                EventColumn::EventId => "-".to_string(),
                EventColumn::LogStreamName => "-".to_string(),
            };

            let cell_content = if i > 0 {
                format!("⋮ {}", content)
            } else {
                content
            };

            cells.push(Cell::from(cell_content));
        }
        table_row_to_event_idx.push(idx);
        rows.push(Row::new(cells).height(1));

        // If expanded, add empty rows to reserve space for overlay
        if is_expanded {
            // Calculate wrapped line count
            let max_width = (table_area.width.saturating_sub(3)) as usize;
            let mut line_count = 0;

            for col in &app.visible_event_columns {
                let value = match col {
                    EventColumn::Timestamp => format_timestamp(&event.timestamp),
                    EventColumn::Message => event.message.replace('\t', "    "),
                    _ => "-".to_string(),
                };
                let full_line = format!("{}: {}", col.name(), value);
                line_count += full_line.len().div_ceil(max_width);
            }

            for _ in 0..line_count {
                // Empty row to reserve space - will be covered by overlay
                table_row_to_event_idx.push(idx);
                rows.push(Row::new(vec![Cell::from("")]).height(1));
            }
        }

        rows
    });

    all_rows.extend(event_rows);

    let banner_offset = if app.log_groups_state.has_older_events {
        1
    } else {
        0
    };
    let mut table_state_index = banner_offset;
    for (i, &event_idx) in table_row_to_event_idx.iter().enumerate() {
        if event_idx == app.log_groups_state.event_scroll_offset {
            table_state_index = banner_offset + i;
            break;
        }
    }

    let widths: Vec<Constraint> = app
        .visible_event_columns
        .iter()
        .map(|col| {
            if col.width() == 0 {
                Constraint::Min(0)
            } else {
                Constraint::Length(col.width())
            }
        })
        .collect();

    let table = Table::new(all_rows, widths)
        .header(header)
        .block(
            Block::default()
                .title(format!(" Log events ({}) ", visible_events.len()))
                .borders(Borders::ALL)
                .border_style(border_style),
        )
        .column_spacing(1)
        .row_highlight_style(
            Style::default()
                .bg(Color::DarkGray)
                .add_modifier(Modifier::BOLD),
        )
        .highlight_symbol("");

    let mut state = TableState::default();
    state.select(Some(table_state_index));

    frame.render_stateful_widget(table, table_area, &mut state);

    // Render expanded content as overlay
    if let Some(expanded_idx) = app.log_groups_state.expanded_event {
        if let Some(event) = visible_events.get(expanded_idx) {
            // Find row position
            let mut row_y = 0;
            for (i, &event_idx) in table_row_to_event_idx.iter().enumerate() {
                if event_idx == expanded_idx {
                    row_y = i;
                    break;
                }
            }

            let banner_offset = if app.log_groups_state.has_older_events {
                1
            } else {
                0
            };

            // Build content with column names
            let mut lines = Vec::new();
            let max_width = table_area.width.saturating_sub(3) as usize;

            for col in &app.visible_event_columns {
                let value = match col {
                    EventColumn::Timestamp => format_timestamp(&event.timestamp),
                    EventColumn::Message => event.message.replace('\t', "    "),
                    EventColumn::IngestionTime => "-".to_string(),
                    EventColumn::EventId => "-".to_string(),
                    EventColumn::LogStreamName => "-".to_string(),
                };
                let col_name = format!("{}: ", col.name());
                let full_line = format!("{}{}", col_name, value);

                // Wrap long lines, marking first line
                if full_line.len() <= max_width {
                    lines.push((full_line, true)); // true = first line with column name
                } else {
                    // First chunk includes column name
                    let first_chunk_len = max_width.min(full_line.len());
                    lines.push((full_line[..first_chunk_len].to_string(), true));

                    // Remaining chunks are continuation
                    let mut remaining = &full_line[first_chunk_len..];
                    while !remaining.is_empty() {
                        let take = max_width.min(remaining.len());
                        lines.push((remaining[..take].to_string(), false)); // false = continuation
                        remaining = &remaining[take..];
                    }
                }
            }

            // Render each line as overlay
            // Clear entire expanded area once
            let start_y = table_area.y + 2 + banner_offset as u16 + row_y as u16 + 1;
            let max_y = table_area.y + table_area.height - 1;

            // Only render if start_y is within bounds
            if start_y < max_y {
                let available_height = (max_y - start_y) as usize;
                let visible_lines = lines.len().min(available_height);

                if visible_lines > 0 {
                    let clear_area = Rect {
                        x: table_area.x + 1,
                        y: start_y,
                        width: table_area.width.saturating_sub(3),
                        height: visible_lines as u16,
                    };
                    frame.render_widget(Clear, clear_area);
                }

                for (line_idx, (line, is_first)) in lines.iter().enumerate() {
                    let y = start_y + line_idx as u16;
                    if y >= max_y {
                        break;
                    }

                    let line_area = Rect {
                        x: table_area.x + 1,
                        y,
                        width: table_area.width.saturating_sub(3), // Leave room for scrollbar
                        height: 1,
                    };

                    // Add expansion indicator on the left
                    let is_last_line = line_idx == lines.len() - 1;
                    let indicator = if is_last_line {
                        "╰ "
                    } else if *is_first {
                        "├ "
                    } else {
                        "│ "
                    };

                    // Bold column name only on first line of each field
                    let spans = if *is_first {
                        if let Some(colon_pos) = line.find(": ") {
                            let col_name = &line[..colon_pos + 2];
                            let rest = &line[colon_pos + 2..];
                            vec![
                                Span::raw(indicator),
                                Span::styled(
                                    col_name.to_string(),
                                    Style::default().add_modifier(Modifier::BOLD),
                                ),
                                Span::raw(rest.to_string()),
                            ]
                        } else {
                            vec![Span::raw(indicator), Span::raw(line.clone())]
                        }
                    } else {
                        // Continuation line - no bold
                        vec![Span::raw(indicator), Span::raw(line.clone())]
                    };

                    let paragraph = Paragraph::new(Line::from(spans));
                    frame.render_widget(paragraph, line_area);
                }
            }
        }
    }

    // Render scrollbar
    let event_count = app.log_groups_state.log_events.len();
    if event_count > 0 {
        render_vertical_scrollbar(
            frame,
            table_area.inner(Margin {
                vertical: 1,
                horizontal: 0,
            }),
            event_count,
            app.log_groups_state.event_scroll_offset,
        );
    }
}

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

    #[test]
    fn test_input_focus_enum_cycling() {
        use InputFocus;
        assert_eq!(
            InputFocus::Filter.next(&FILTER_CONTROLS),
            InputFocus::Checkbox("ExactMatch")
        );
        assert_eq!(
            InputFocus::Checkbox("ExactMatch").next(&FILTER_CONTROLS),
            InputFocus::Checkbox("ShowExpired")
        );
        assert_eq!(
            InputFocus::Checkbox("ShowExpired").next(&FILTER_CONTROLS),
            InputFocus::Pagination
        );
        assert_eq!(
            InputFocus::Pagination.next(&FILTER_CONTROLS),
            InputFocus::Filter
        );

        assert_eq!(
            InputFocus::Filter.prev(&FILTER_CONTROLS),
            InputFocus::Pagination
        );
        assert_eq!(
            InputFocus::Pagination.prev(&FILTER_CONTROLS),
            InputFocus::Checkbox("ShowExpired")
        );
        assert_eq!(
            InputFocus::Checkbox("ShowExpired").prev(&FILTER_CONTROLS),
            InputFocus::Checkbox("ExactMatch")
        );
        assert_eq!(
            InputFocus::Checkbox("ExactMatch").prev(&FILTER_CONTROLS),
            InputFocus::Filter
        );
    }
}