// widgets.rs — Shared TUI helpers and reusable components

use ratatui::{
    style::{Color, Modifier, Style},
    text::Line,
    widgets::{Block, Borders},
    crossterm::event::KeyCode,
};
use crate::agent::context::ContextSection;

// ---------------------------------------------------------------------------
// Helpers
// ---------------------------------------------------------------------------

/// Standard pane block — cyan border, right-aligned title.
pub fn pane_block(title: &str) -> Block<'_> {
    Block::default()
        .title_top(Line::from(format!(" {} ", title)).right_aligned())
        .borders(Borders::ALL)
        .border_style(Style::default().fg(Color::Cyan))
}

/// Focused pane block — brighter border to indicate focus.
pub fn pane_block_focused(title: &str, focused: bool) -> Block<'_> {
    let color = if focused { Color::White } else { Color::Cyan };
    Block::default()
        .title_top(Line::from(format!(" {} ", title)).right_aligned())
        .borders(Borders::ALL)
        .border_style(Style::default().fg(color))
}

/// Format a duration in seconds as a compact human-readable string.
pub fn format_age(secs: f64) -> String {
    if secs < 60.0 { format!("{:.0}s", secs) }
    else if secs < 3600.0 { format!("{:.0}m", secs / 60.0) }
    else if secs < 86400.0 { format!("{:.1}h", secs / 3600.0) }
    else { format!("{:.0}d", secs / 86400.0) }
}

/// Format a unix epoch timestamp as age from now.
pub fn format_ts_age(ts: i64) -> String {
    let now = std::time::SystemTime::now()
        .duration_since(std::time::UNIX_EPOCH)
        .unwrap_or_default()
        .as_secs() as i64;
    format_age((now - ts).max(0) as f64)
}

// ---------------------------------------------------------------------------
// SectionTree — expand/collapse tree renderer for ContextSection
// ---------------------------------------------------------------------------

pub struct SectionTree {
    pub selected: Option<usize>,
    pub expanded: std::collections::HashSet<usize>,
    pub scroll: u16,
}

impl SectionTree {
    pub fn new() -> Self {
        Self { selected: None, expanded: std::collections::HashSet::new(), scroll: 0 }
    }

    pub fn item_count(&self, sections: &[ContextSection]) -> usize {
        fn count(section: &ContextSection, expanded: &std::collections::HashSet<usize>, idx: &mut usize) -> usize {
            let my_idx = *idx;
            *idx += 1;
            let mut total = 1;
            if expanded.contains(&my_idx) {
                for child in &section.children {
                    total += count(child, expanded, idx);
                }
            }
            total
        }
        let mut idx = 0;
        sections.iter().map(|s| count(s, &self.expanded, &mut idx)).sum()
    }

    pub fn handle_nav(&mut self, code: KeyCode, sections: &[ContextSection]) {
        let item_count = self.item_count(sections);
        match code {
            KeyCode::Up => {
                self.selected = Some(self.selected.unwrap_or(0).saturating_sub(1));
                self.scroll_to_selected();
            }
            KeyCode::Down => {
                let max = item_count.saturating_sub(1);
                self.selected = Some(self.selected.map_or(0, |s| (s + 1).min(max)));
                self.scroll_to_selected();
            }
            KeyCode::Right | KeyCode::Enter => {
                if let Some(sel) = self.selected {
                    self.expanded.insert(sel);
                }
            }
            KeyCode::Left => {
                if let Some(sel) = self.selected {
                    self.expanded.remove(&sel);
                }
            }
            KeyCode::PageUp => { self.scroll = self.scroll.saturating_sub(20); }
            KeyCode::PageDown => { self.scroll += 20; }
            _ => {}
        }
    }

    fn scroll_to_selected(&mut self) {
        if let Some(sel) = self.selected {
            let sel_line = sel as u16;
            if sel_line < self.scroll + 2 {
                self.scroll = sel_line.saturating_sub(2);
            } else if sel_line > self.scroll + 30 {
                self.scroll = sel_line.saturating_sub(15);
            }
        }
    }

    pub fn render_sections(&self, sections: &[ContextSection], lines: &mut Vec<Line>) {
        let mut idx = 0;
        for section in sections {
            self.render_one(section, 0, lines, &mut idx);
        }
    }

    fn render_one(
        &self,
        section: &ContextSection,
        depth: usize,
        lines: &mut Vec<Line>,
        idx: &mut usize,
    ) {
        let my_idx = *idx;
        let selected = self.selected == Some(my_idx);
        let expanded = self.expanded.contains(&my_idx);
        let has_children = !section.children.is_empty();
        let has_content = !section.content.is_empty();
        let expandable = has_children || has_content;

        let indent = "  ".repeat(depth + 1);
        let marker = if !expandable { " " } else if expanded { "▼" } else { "▶" };
        let label = format!("{}{} {:30} {:>6} tokens", indent, marker, section.name, section.tokens);
        let style = if selected {
            Style::default().fg(Color::Yellow).add_modifier(Modifier::BOLD)
        } else {
            Style::default()
        };
        lines.push(Line::styled(label, style));
        *idx += 1;

        if expanded {
            if has_children {
                for child in &section.children {
                    self.render_one(child, depth + 1, lines, idx);
                }
            } else if has_content {
                let content_indent = format!("{}    │ ", "  ".repeat(depth + 1));
                let content_lines: Vec<&str> = section.content.lines().collect();
                let show = content_lines.len().min(50);
                for line in &content_lines[..show] {
                    lines.push(Line::styled(
                        format!("{}{}", content_indent, line),
                        Style::default().fg(Color::DarkGray),
                    ));
                }
                if content_lines.len() > 50 {
                    lines.push(Line::styled(
                        format!("{}... ({} more lines)", content_indent, content_lines.len() - 50),
                        Style::default().fg(Color::DarkGray),
                    ));
                }
            }
        }
    }
}