use ratatui::layout::{Alignment, Constraint, Direction, Layout, Rect};
use ratatui::style::{Color, Modifier, Style};
use ratatui::text::{Line, Span};
use ratatui::widgets::{Block, Borders, Clear, List, ListItem, ListState, Paragraph, Wrap};
use ratatui::Frame;
use textwrap::{wrap, Options};
use tui_textarea::TextArea;
use unicode_width::UnicodeWidthStr;

use crate::chat_app::ChatApp;
use owlen_core::types::Role;
use owlen_core::ui::{FocusedPanel, InputMode};

pub fn render_chat(frame: &mut Frame<'_>, app: &mut ChatApp) {
    // Update thinking content from last message
    app.update_thinking_from_last_message();

    // Calculate dynamic input height based on textarea content
    let available_width = frame.area().width;
    let input_height = if matches!(app.mode(), InputMode::Editing) {
        let visual_lines = calculate_wrapped_line_count(
            app.textarea().lines().iter().map(|s| s.as_str()),
            available_width,
        );
        (visual_lines as u16).min(10) + 2 // +2 for borders
    } else {
        let buffer_text = app.input_buffer().text();
        let lines: Vec<&str> = if buffer_text.is_empty() {
            vec![""]
        } else {
            buffer_text.lines().collect()
        };
        let visual_lines = calculate_wrapped_line_count(lines, available_width);
        (visual_lines as u16).min(10) + 2 // +2 for borders
    };

    // Calculate thinking section height
    let thinking_height = if let Some(thinking) = app.current_thinking() {
        let content_width = available_width.saturating_sub(4);
        let visual_lines = calculate_wrapped_line_count(thinking.lines(), content_width);
        (visual_lines as u16).min(6) + 2 // +2 for borders, max 6 lines
    } else {
        0
    };

    let mut constraints = vec![
        Constraint::Length(4), // Header
        Constraint::Min(8),    // Messages
    ];

    if thinking_height > 0 {
        constraints.push(Constraint::Length(thinking_height)); // Thinking
    }

    constraints.push(Constraint::Length(input_height)); // Input
    constraints.push(Constraint::Length(3)); // Status

    let layout = Layout::default()
        .direction(Direction::Vertical)
        .constraints(constraints)
        .split(frame.area());

    let mut idx = 0;
    render_header(frame, layout[idx], app);
    idx += 1;

    render_messages(frame, layout[idx], app);
    idx += 1;

    if thinking_height > 0 {
        render_thinking(frame, layout[idx], app);
        idx += 1;
    }

    render_input(frame, layout[idx], app);
    idx += 1;

    render_status(frame, layout[idx], app);

    match app.mode() {
        InputMode::ProviderSelection => render_provider_selector(frame, app),
        InputMode::ModelSelection => render_model_selector(frame, app),
        InputMode::Help => render_help(frame),
        _ => {}
    }
}

fn render_editable_textarea(
    frame: &mut Frame<'_>,
    area: Rect,
    textarea: &mut TextArea<'static>,
    mut wrap_lines: bool,
) {
    let block = textarea.block().cloned();
    let inner = block.as_ref().map(|b| b.inner(area)).unwrap_or(area);
    let base_style = textarea.style();
    let cursor_line_style = textarea.cursor_line_style();
    let selection_style = textarea.selection_style();
    let selection_range = textarea.selection_range();
    let cursor = textarea.cursor();
    let mask_char = textarea.mask_char();
    let is_empty = textarea.is_empty();
    let placeholder_text = textarea.placeholder_text().to_string();
    let placeholder_style = textarea.placeholder_style();
    let lines_slice = textarea.lines();

    // Disable wrapping when there's an active selection to preserve highlighting
    if selection_range.is_some() {
        wrap_lines = false;
    }

    let mut render_lines: Vec<Line> = Vec::new();

    if is_empty {
        if !placeholder_text.is_empty() {
            let style = placeholder_style.unwrap_or_else(|| Style::default().fg(Color::DarkGray));
            render_lines.push(Line::from(vec![Span::styled(placeholder_text, style)]));
        } else {
            render_lines.push(Line::default());
        }
    } else {
        for (row_idx, raw_line) in lines_slice.iter().enumerate() {
            let display_line = mask_char
                .map(|mask| mask_line(raw_line, mask))
                .unwrap_or_else(|| raw_line.clone());

            let spans = build_line_spans(&display_line, row_idx, selection_range, selection_style);

            let mut line = Line::from(spans);
            if row_idx == cursor.0 {
                line = line.patch_style(cursor_line_style);
            }
            render_lines.push(line);
        }
    }

    if render_lines.is_empty() {
        render_lines.push(Line::default());
    }

    // If wrapping is enabled, we need to manually wrap the lines
    // This ensures consistency with cursor calculation
    if wrap_lines {
        let content_width = inner.width as usize;
        let mut wrapped_lines: Vec<Line> = Vec::new();

        for (row_idx, line) in render_lines.iter().enumerate() {
            let line_text = line.to_string();
            let segments = wrap_line_segments(&line_text, content_width);

            for (seg_idx, segment) in segments.into_iter().enumerate() {
                // For the line with the cursor, preserve the cursor line style
                if row_idx == cursor.0 && seg_idx == 0 {
                    wrapped_lines.push(Line::from(segment).patch_style(cursor_line_style));
                } else {
                    wrapped_lines.push(Line::from(segment));
                }
            }
        }

        render_lines = wrapped_lines;
    }

    let mut paragraph = Paragraph::new(render_lines).style(base_style);

    let metrics = compute_cursor_metrics(lines_slice, cursor, mask_char, inner, wrap_lines);

    if let Some(ref metrics) = metrics {
        if metrics.scroll_top > 0 {
            paragraph = paragraph.scroll((metrics.scroll_top, 0));
        }
    }

    if let Some(block) = block {
        paragraph = paragraph.block(block);
    }

    frame.render_widget(paragraph, area);

    if let Some(metrics) = metrics {
        frame.set_cursor_position((metrics.cursor_x, metrics.cursor_y));
    }
}

fn mask_line(line: &str, mask: char) -> String {
    line.chars().map(|_| mask).collect()
}

fn build_line_spans(
    display_line: &str,
    row_idx: usize,
    selection: Option<((usize, usize), (usize, usize))>,
    selection_style: Style,
) -> Vec<Span<'static>> {
    if let Some(((start_row, start_col), (end_row, end_col))) = selection {
        if row_idx < start_row || row_idx > end_row {
            return vec![Span::raw(display_line.to_string())];
        }

        let char_count = display_line.chars().count();
        let start = if row_idx == start_row {
            start_col.min(char_count)
        } else {
            0
        };
        let end = if row_idx == end_row {
            end_col.min(char_count)
        } else {
            char_count
        };

        if start >= end {
            return vec![Span::raw(display_line.to_string())];
        }

        let start_byte = char_to_byte_idx(display_line, start);
        let end_byte = char_to_byte_idx(display_line, end);

        let mut spans = Vec::new();
        if start_byte > 0 {
            spans.push(Span::raw(display_line[..start_byte].to_string()));
        }
        spans.push(Span::styled(
            display_line[start_byte..end_byte].to_string(),
            selection_style,
        ));
        if end_byte < display_line.len() {
            spans.push(Span::raw(display_line[end_byte..].to_string()));
        }
        if spans.is_empty() {
            spans.push(Span::raw(String::new()));
        }
        spans
    } else {
        vec![Span::raw(display_line.to_string())]
    }
}

fn char_to_byte_idx(s: &str, char_idx: usize) -> usize {
    if char_idx == 0 {
        return 0;
    }

    let mut iter = s.char_indices();
    for (i, (byte_idx, _)) in iter.by_ref().enumerate() {
        if i == char_idx {
            return byte_idx;
        }
    }
    s.len()
}

struct CursorMetrics {
    cursor_x: u16,
    cursor_y: u16,
    scroll_top: u16,
}

fn compute_cursor_metrics(
    lines: &[String],
    cursor: (usize, usize),
    mask_char: Option<char>,
    inner: Rect,
    wrap_lines: bool,
) -> Option<CursorMetrics> {
    if inner.width == 0 || inner.height == 0 {
        return None;
    }

    let content_width = inner.width as usize;
    let visible_height = inner.height as usize;
    if content_width == 0 || visible_height == 0 {
        return None;
    }

    let cursor_row = cursor.0.min(lines.len().saturating_sub(1));
    let cursor_col = cursor.1;

    let mut total_visual_rows = 0usize;
    let mut cursor_visual_row = 0usize;
    let mut cursor_col_width = 0usize;
    let mut cursor_found = false;

    for (row_idx, line) in lines.iter().enumerate() {
        let display_owned = mask_char.map(|mask| mask_line(line, mask));
        let display_line = display_owned.as_deref().unwrap_or(line.as_str());

        let mut segments = if wrap_lines {
            wrap_line_segments(display_line, content_width)
        } else {
            vec![display_line.to_string()]
        };

        if segments.is_empty() {
            segments.push(String::new());
        }

        if row_idx == cursor_row && !cursor_found {
            let mut remaining = cursor_col;
            for (segment_idx, segment) in segments.iter().enumerate() {
                let segment_len = segment.chars().count();
                let is_last_segment = segment_idx + 1 == segments.len();

                if remaining > segment_len {
                    remaining -= segment_len;
                    continue;
                }

                if remaining == segment_len && !is_last_segment {
                    cursor_visual_row = total_visual_rows + segment_idx + 1;
                    cursor_col_width = 0;
                    cursor_found = true;
                    break;
                }

                let prefix: String = segment.chars().take(remaining).collect();
                cursor_visual_row = total_visual_rows + segment_idx;
                cursor_col_width = UnicodeWidthStr::width(prefix.as_str());
                cursor_found = true;
                break;
            }

            if !cursor_found {
                if let Some(last_segment) = segments.last() {
                    cursor_visual_row = total_visual_rows + segments.len().saturating_sub(1);
                    cursor_col_width = UnicodeWidthStr::width(last_segment.as_str());
                    cursor_found = true;
                }
            }
        }

        total_visual_rows += segments.len();
    }

    if !cursor_found {
        cursor_visual_row = total_visual_rows.saturating_sub(1);
        cursor_col_width = 0;
    }

    let mut scroll_top = 0usize;
    if cursor_visual_row + 1 > visible_height {
        scroll_top = cursor_visual_row + 1 - visible_height;
    }

    let max_scroll = total_visual_rows.saturating_sub(visible_height);
    if scroll_top > max_scroll {
        scroll_top = max_scroll;
    }

    let cursor_visible_row = cursor_visual_row.saturating_sub(scroll_top);
    let cursor_y = inner.y + cursor_visible_row.min(visible_height.saturating_sub(1)) as u16;
    let cursor_x = inner.x + cursor_col_width.min(content_width.saturating_sub(1)) as u16;

    Some(CursorMetrics {
        cursor_x,
        cursor_y,
        scroll_top: scroll_top as u16,
    })
}

fn wrap_line_segments(line: &str, width: usize) -> Vec<String> {
    if width == 0 {
        return vec![String::new()];
    }

    if line.is_empty() {
        return vec![String::new()];
    }

    // Manual wrapping that preserves all characters including spaces
    let mut result = Vec::new();
    let mut current = String::new();
    let mut current_width = 0usize;

    for ch in line.chars() {
        let ch_width = UnicodeWidthStr::width(ch.to_string().as_str());

        // If adding this character would exceed width, wrap to next line
        if current_width + ch_width > width {
            if !current.is_empty() {
                result.push(current);
                current = String::new();
                current_width = 0;
            }
            // If even a single character is too wide, add it anyway to avoid infinite loop
            if ch_width > width {
                current.push(ch);
                result.push(current);
                current = String::new();
                current_width = 0;
                continue;
            }
        }

        current.push(ch);
        current_width += ch_width;
    }

    if !current.is_empty() {
        result.push(current);
    }

    if result.is_empty() {
        result.push(String::new());
    }

    result
}

fn render_header(frame: &mut Frame<'_>, area: Rect, app: &ChatApp) {
    let title_span = Span::styled(
        " 🦉 OWLEN - AI Assistant ",
        Style::default()
            .fg(Color::LightMagenta)
            .add_modifier(Modifier::BOLD),
    );
    let model_span = Span::styled(
        format!("Model: {}", app.selected_model()),
        Style::default().fg(Color::LightBlue),
    );

    let header_block = Block::default()
        .borders(Borders::ALL)
        .border_style(Style::default().fg(Color::Rgb(95, 20, 135)))
        .title(Line::from(vec![title_span]));

    let inner_area = header_block.inner(area);

    let header_text = vec![Line::from(""), Line::from(format!(" {model_span} "))];

    let paragraph = Paragraph::new(header_text).alignment(Alignment::Left);

    frame.render_widget(header_block, area);
    frame.render_widget(paragraph, inner_area);
}

fn apply_visual_selection(
    lines: Vec<Line>,
    selection: Option<((usize, usize), (usize, usize))>,
) -> Vec<Line> {
    if let Some(((start_row, start_col), (end_row, end_col))) = selection {
        // Normalize selection (ensure start is before end)
        let ((start_r, start_c), (end_r, end_c)) =
            if start_row < end_row || (start_row == end_row && start_col <= end_col) {
                ((start_row, start_col), (end_row, end_col))
            } else {
                ((end_row, end_col), (start_row, start_col))
            };

        lines
            .into_iter()
            .enumerate()
            .map(|(idx, line)| {
                if idx < start_r || idx > end_r {
                    // Line not in selection
                    return line;
                }

                // Convert line to plain text for character indexing
                let line_text = line.to_string();
                let char_count = line_text.chars().count();

                if idx == start_r && idx == end_r {
                    // Selection within single line
                    let sel_start = start_c.min(char_count);
                    let sel_end = end_c.min(char_count);

                    if sel_start >= sel_end {
                        return line;
                    }

                    let start_byte = char_to_byte_index(&line_text, sel_start);
                    let end_byte = char_to_byte_index(&line_text, sel_end);

                    let mut spans = Vec::new();
                    if start_byte > 0 {
                        spans.push(Span::raw(line_text[..start_byte].to_string()));
                    }
                    spans.push(Span::styled(
                        line_text[start_byte..end_byte].to_string(),
                        Style::default().bg(Color::LightBlue).fg(Color::Black),
                    ));
                    if end_byte < line_text.len() {
                        spans.push(Span::raw(line_text[end_byte..].to_string()));
                    }
                    Line::from(spans)
                } else if idx == start_r {
                    // First line of multi-line selection
                    let sel_start = start_c.min(char_count);
                    let start_byte = char_to_byte_index(&line_text, sel_start);

                    let mut spans = Vec::new();
                    if start_byte > 0 {
                        spans.push(Span::raw(line_text[..start_byte].to_string()));
                    }
                    spans.push(Span::styled(
                        line_text[start_byte..].to_string(),
                        Style::default().bg(Color::LightBlue).fg(Color::Black),
                    ));
                    Line::from(spans)
                } else if idx == end_r {
                    // Last line of multi-line selection
                    let sel_end = end_c.min(char_count);
                    let end_byte = char_to_byte_index(&line_text, sel_end);

                    let mut spans = Vec::new();
                    spans.push(Span::styled(
                        line_text[..end_byte].to_string(),
                        Style::default().bg(Color::LightBlue).fg(Color::Black),
                    ));
                    if end_byte < line_text.len() {
                        spans.push(Span::raw(line_text[end_byte..].to_string()));
                    }
                    Line::from(spans)
                } else {
                    // Middle line - fully selected
                    let styled_spans: Vec<Span> = line
                        .spans
                        .into_iter()
                        .map(|span| {
                            Span::styled(
                                span.content,
                                span.style.bg(Color::LightBlue).fg(Color::Black),
                            )
                        })
                        .collect();
                    Line::from(styled_spans)
                }
            })
            .collect()
    } else {
        lines
    }
}

fn char_to_byte_index(s: &str, char_idx: usize) -> usize {
    if char_idx == 0 {
        return 0;
    }

    let mut iter = s.char_indices();
    for (i, (byte_idx, _)) in iter.by_ref().enumerate() {
        if i == char_idx {
            return byte_idx;
        }
    }
    s.len()
}

fn render_messages(frame: &mut Frame<'_>, area: Rect, app: &mut ChatApp) {
    // Calculate viewport dimensions for autoscroll calculations
    let viewport_height = area.height.saturating_sub(2) as usize; // subtract borders
    let content_width = area.width.saturating_sub(4).max(20);
    app.set_viewport_dimensions(viewport_height, usize::from(content_width));

    let conversation = app.conversation();
    let mut formatter = app.formatter().clone();

    // Reserve space for borders and the message indent so text fits within the block
    formatter.set_wrap_width(usize::from(content_width));

    // Build the lines for messages
    let mut lines: Vec<Line> = Vec::new();
    for (message_index, message) in conversation.messages.iter().enumerate() {
        let role = &message.role;
        let (emoji, name) = match role {
            Role::User => ("👤 ", "You: "),
            Role::Assistant => ("🤖 ", "Assistant: "),
            Role::System => ("⚙️ ", "System: "),
        };

        // Extract content without thinking tags for assistant messages
        let content_to_display = if matches!(role, Role::Assistant) {
            let (content_without_think, _) = formatter.extract_thinking(&message.content);
            content_without_think
        } else {
            message.content.clone()
        };

        let formatted: Vec<String> = content_to_display
            .trim()
            .lines()
            .map(|s| s.to_string())
            .collect();
        let is_streaming = message
            .metadata
            .get("streaming")
            .and_then(|v| v.as_bool())
            .unwrap_or(false);

        let show_role_labels = formatter.show_role_labels();

        if show_role_labels {
            // Role name line
            let mut role_line_spans = vec![
                Span::raw(emoji),
                Span::styled(name, role_color(role).add_modifier(Modifier::BOLD)),
            ];

            // Add loading indicator if applicable
            if matches!(role, Role::Assistant)
                && app.get_loading_indicator() != ""
                && message_index == conversation.messages.len() - 1
                && is_streaming
            {
                role_line_spans.push(Span::styled(
                    format!(" {}", app.get_loading_indicator()),
                    Style::default().fg(Color::Yellow),
                ));
            }

            lines.push(Line::from(role_line_spans));

            // Join all formatted lines into single content string
            let content = formatted.join("\n");

            // Wrap content with available width minus indent (2 spaces)
            let indent = "  ";
            let available_width = (content_width as usize).saturating_sub(2);
            let chunks = if available_width > 0 {
                wrap(&content, available_width)
            } else {
                vec![]
            };

            let chunks_len = chunks.len();
            for (i, seg) in chunks.into_iter().enumerate() {
                let mut spans = vec![Span::raw(format!("{indent}{}", seg))];
                if i == chunks_len - 1 && is_streaming {
                    spans.push(Span::styled(" ▌", Style::default().fg(Color::Magenta)));
                }
                lines.push(Line::from(spans));
            }
        } else {
            // No role labels - just show content
            let content = formatted.join("\n");
            let chunks = wrap(&content, content_width as usize);
            let chunks_len = chunks.len();
            for (i, seg) in chunks.into_iter().enumerate() {
                let mut spans = vec![Span::raw(seg.into_owned())];
                if i == chunks_len - 1 && is_streaming {
                    spans.push(Span::styled(" ▌", Style::default().fg(Color::Magenta)));
                }
                lines.push(Line::from(spans));
            }
        }

        // Add an empty line after each message, except the last one
        if message_index < conversation.messages.len() - 1 {
            lines.push(Line::from(""));
        }
    }

    // Add loading indicator ONLY if we're loading and there are no messages at all,
    // or if the last message is from the user (no Assistant response started yet)
    let last_message_is_user = conversation
        .messages
        .last()
        .map(|msg| matches!(msg.role, Role::User))
        .unwrap_or(true);

    if app.get_loading_indicator() != "" && last_message_is_user {
        let loading_spans = vec![
            Span::raw("🤖 "),
            Span::styled(
                "Assistant:",
                Style::default()
                    .fg(Color::LightMagenta)
                    .add_modifier(Modifier::BOLD),
            ),
            Span::styled(
                format!(" {}", app.get_loading_indicator()),
                Style::default().fg(Color::Yellow),
            ),
        ];
        lines.push(Line::from(loading_spans));
    }

    if lines.is_empty() {
        lines.push(Line::from("No messages yet. Press 'i' to start typing."));
    }

    // Apply visual selection highlighting if in visual mode and Chat panel is focused
    if matches!(app.mode(), InputMode::Visual) && matches!(app.focused_panel(), FocusedPanel::Chat)
    {
        if let Some(selection) = app.visual_selection() {
            lines = apply_visual_selection(lines, Some(selection));
        }
    }

    // Update AutoScroll state with accurate content length
    let auto_scroll = app.auto_scroll_mut();
    auto_scroll.content_len = lines.len();
    auto_scroll.on_viewport(viewport_height);

    let scroll_position = app.scroll().min(u16::MAX as usize) as u16;

    // Highlight border if this panel is focused
    let border_color = if matches!(app.focused_panel(), FocusedPanel::Chat) {
        Color::LightMagenta
    } else {
        Color::Rgb(95, 20, 135)
    };

    let paragraph = Paragraph::new(lines)
        .block(
            Block::default()
                .borders(Borders::ALL)
                .border_style(Style::default().fg(border_color)),
        )
        .scroll((scroll_position, 0));

    frame.render_widget(paragraph, area);

    // Render cursor if Chat panel is focused and in Normal mode
    if matches!(app.focused_panel(), FocusedPanel::Chat) && matches!(app.mode(), InputMode::Normal)
    {
        let cursor = app.chat_cursor();
        let cursor_row = cursor.0;
        let cursor_col = cursor.1;

        // Calculate visible cursor position (accounting for scroll)
        if cursor_row >= scroll_position as usize
            && cursor_row < (scroll_position as usize + viewport_height)
        {
            let visible_row = cursor_row - scroll_position as usize;
            let cursor_y = area.y + 1 + visible_row as u16; // +1 for border

            // Get the rendered line and calculate display width
            let rendered_lines = app.get_rendered_lines();
            if let Some(line_text) = rendered_lines.get(cursor_row) {
                let chars: Vec<char> = line_text.chars().collect();
                let text_before_cursor: String = chars.iter().take(cursor_col).collect();
                let display_width = UnicodeWidthStr::width(text_before_cursor.as_str());

                let cursor_x = area.x + 1 + display_width as u16; // +1 for border only

                frame.set_cursor_position((cursor_x, cursor_y));
            }
        }
    }
}

fn render_thinking(frame: &mut Frame<'_>, area: Rect, app: &mut ChatApp) {
    if let Some(thinking) = app.current_thinking().cloned() {
        let viewport_height = area.height.saturating_sub(2) as usize; // subtract borders
        let content_width = area.width.saturating_sub(4);

        app.set_thinking_viewport_height(viewport_height);

        let chunks = wrap(&thinking, content_width as usize);

        let mut lines: Vec<Line> = chunks
            .into_iter()
            .map(|seg| {
                Line::from(Span::styled(
                    seg.into_owned(),
                    Style::default()
                        .fg(Color::DarkGray)
                        .add_modifier(Modifier::ITALIC),
                ))
            })
            .collect();

        // Apply visual selection highlighting if in visual mode and Thinking panel is focused
        if matches!(app.mode(), InputMode::Visual)
            && matches!(app.focused_panel(), FocusedPanel::Thinking)
        {
            if let Some(selection) = app.visual_selection() {
                lines = apply_visual_selection(lines, Some(selection));
            }
        }

        // Update AutoScroll state with accurate content length
        let thinking_scroll = app.thinking_scroll_mut();
        thinking_scroll.content_len = lines.len();
        thinking_scroll.on_viewport(viewport_height);

        let scroll_position = app.thinking_scroll_position().min(u16::MAX as usize) as u16;

        // Highlight border if this panel is focused
        let border_color = if matches!(app.focused_panel(), FocusedPanel::Thinking) {
            Color::LightMagenta
        } else {
            Color::DarkGray
        };

        let paragraph = Paragraph::new(lines)
            .block(
                Block::default()
                    .title(Span::styled(
                        " 💭 Thinking ",
                        Style::default()
                            .fg(Color::DarkGray)
                            .add_modifier(Modifier::ITALIC),
                    ))
                    .borders(Borders::ALL)
                    .border_style(Style::default().fg(border_color)),
            )
            .scroll((scroll_position, 0))
            .wrap(Wrap { trim: false });

        frame.render_widget(paragraph, area);

        // Render cursor if Thinking panel is focused and in Normal mode
        if matches!(app.focused_panel(), FocusedPanel::Thinking)
            && matches!(app.mode(), InputMode::Normal)
        {
            let cursor = app.thinking_cursor();
            let cursor_row = cursor.0;
            let cursor_col = cursor.1;

            // Calculate visible cursor position (accounting for scroll)
            if cursor_row >= scroll_position as usize
                && cursor_row < (scroll_position as usize + viewport_height)
            {
                let visible_row = cursor_row - scroll_position as usize;
                let cursor_y = area.y + 1 + visible_row as u16; // +1 for border

                // Calculate actual display width by measuring characters up to cursor
                let line_text = thinking.lines().nth(cursor_row).unwrap_or("");
                let chars: Vec<char> = line_text.chars().collect();
                let text_before_cursor: String = chars.iter().take(cursor_col).collect();
                let display_width = UnicodeWidthStr::width(text_before_cursor.as_str());

                let cursor_x = area.x + 1 + display_width as u16; // +1 for border only

                frame.set_cursor_position((cursor_x, cursor_y));
            }
        }
    }
}

fn render_input(frame: &mut Frame<'_>, area: Rect, app: &mut ChatApp) {
    let title = match app.mode() {
        InputMode::Editing => " Input (Enter=send · Ctrl+J=newline · Esc=exit input mode) ",
        InputMode::Visual => " Visual Mode (y=yank · d=cut · Esc=cancel) ",
        InputMode::Command => " Command Mode (Enter=execute · Esc=cancel) ",
        _ => " Input (Press 'i' to start typing) ",
    };

    // Highlight border if this panel is focused
    let border_color = if matches!(app.focused_panel(), FocusedPanel::Input) {
        Color::LightMagenta
    } else {
        Color::Rgb(95, 20, 135)
    };

    let input_block = Block::default()
        .title(Span::styled(
            title,
            Style::default()
                .fg(Color::LightMagenta)
                .add_modifier(Modifier::BOLD),
        ))
        .borders(Borders::ALL)
        .border_style(Style::default().fg(border_color));

    if matches!(app.mode(), InputMode::Editing) {
        // Use the textarea directly to preserve selection state
        let textarea = app.textarea_mut();
        textarea.set_block(input_block.clone());
        textarea.set_hard_tab_indent(false);
        render_editable_textarea(frame, area, textarea, true);
    } else if matches!(app.mode(), InputMode::Visual) {
        // In visual mode, render textarea in read-only mode with selection
        let textarea = app.textarea_mut();
        textarea.set_block(input_block.clone());
        textarea.set_hard_tab_indent(false);
        render_editable_textarea(frame, area, textarea, true);
    } else if matches!(app.mode(), InputMode::Command) {
        // In command mode, show the command buffer with : prefix
        let command_text = format!(":{}", app.command_buffer());
        let lines = vec![Line::from(Span::styled(
            command_text,
            Style::default()
                .fg(Color::Yellow)
                .add_modifier(Modifier::BOLD),
        ))];

        let paragraph = Paragraph::new(lines)
            .block(input_block)
            .wrap(Wrap { trim: false });

        frame.render_widget(paragraph, area);
    } else {
        // In non-editing mode, show the current input buffer content as read-only
        let input_text = app.input_buffer().text();
        let lines: Vec<Line> = if input_text.is_empty() {
            vec![Line::from("Press 'i' to start typing")]
        } else {
            input_text.lines().map(Line::from).collect()
        };

        let paragraph = Paragraph::new(lines)
            .block(input_block)
            .wrap(Wrap { trim: false });

        frame.render_widget(paragraph, area);
    }
}

fn calculate_wrapped_line_count<'a, I>(lines: I, available_width: u16) -> usize
where
    I: IntoIterator<Item = &'a str>,
{
    let content_width = available_width.saturating_sub(2); // subtract block borders
    if content_width == 0 {
        let mut count = 0;
        for _ in lines.into_iter() {
            count += 1;
        }
        return count.max(1);
    }

    let options = Options::new(content_width as usize).break_words(false);

    let mut total = 0usize;
    let mut seen = false;
    for line in lines.into_iter() {
        seen = true;
        if line.is_empty() {
            total += 1;
            continue;
        }
        let wrapped = wrap(line, &options);
        total += wrapped.len().max(1);
    }

    if !seen {
        1
    } else {
        total.max(1)
    }
}

fn render_status(frame: &mut Frame<'_>, area: Rect, app: &ChatApp) {
    let (mode_text, mode_bg_color) = match app.mode() {
        InputMode::Normal => (" NORMAL", Color::LightBlue),
        InputMode::Editing => (" INPUT", Color::LightGreen),
        InputMode::ModelSelection => (" MODEL", Color::LightYellow),
        InputMode::ProviderSelection => (" PROVIDER", Color::LightCyan),
        InputMode::Help => (" HELP", Color::LightMagenta),
        InputMode::Visual => (" VISUAL", Color::Magenta),
        InputMode::Command => (" COMMAND", Color::Yellow),
    };

    let status_message = if app.streaming_count() > 0 {
        format!("Streaming... ({})", app.streaming_count())
    } else if let Some(error) = app.error_message() {
        format!("Error: {}", error)
    } else {
        "Ready".to_string()
    };

    let help_text = "i:Input :m:Model :n:New :c:Clear :h:Help q:Quit";

    let left_spans = vec![
        Span::styled(
            format!(" {} ", mode_text),
            Style::default()
                .fg(Color::Black)
                .bg(mode_bg_color)
                .add_modifier(Modifier::BOLD),
        ),
        Span::raw(format!(" | {} ", status_message)),
    ];

    let right_spans = vec![
        Span::raw(" Help: "),
        Span::styled(help_text, Style::default().fg(Color::LightBlue)),
    ];

    let layout = Layout::default()
        .direction(Direction::Horizontal)
        .constraints([Constraint::Percentage(50), Constraint::Percentage(50)])
        .split(area);

    let left_paragraph = Paragraph::new(Line::from(left_spans))
        .alignment(Alignment::Left)
        .block(
            Block::default()
                .borders(Borders::ALL)
                .border_style(Style::default().fg(Color::Rgb(95, 20, 135))),
        );

    let right_paragraph = Paragraph::new(Line::from(right_spans))
        .alignment(Alignment::Right)
        .block(
            Block::default()
                .borders(Borders::ALL)
                .border_style(Style::default().fg(Color::Rgb(95, 20, 135))),
        );

    frame.render_widget(left_paragraph, layout[0]);
    frame.render_widget(right_paragraph, layout[1]);
}

fn render_provider_selector(frame: &mut Frame<'_>, app: &ChatApp) {
    let area = centered_rect(60, 60, frame.area());
    frame.render_widget(Clear, area);

    let items: Vec<ListItem> = app
        .available_providers
        .iter()
        .map(|provider| {
            ListItem::new(Span::styled(
                provider.to_string(),
                Style::default()
                    .fg(Color::LightBlue)
                    .add_modifier(Modifier::BOLD),
            ))
        })
        .collect();

    let list = List::new(items)
        .block(
            Block::default()
                .title(Span::styled(
                    "Select Provider",
                    Style::default()
                        .fg(Color::LightMagenta)
                        .add_modifier(Modifier::BOLD),
                ))
                .borders(Borders::ALL)
                .border_style(Style::default().fg(Color::Rgb(95, 20, 135))),
        )
        .highlight_style(
            Style::default()
                .fg(Color::Magenta)
                .add_modifier(Modifier::BOLD),
        )
        .highlight_symbol("▶ ");

    let mut state = ListState::default();
    state.select(Some(app.selected_provider_index));
    frame.render_stateful_widget(list, area, &mut state);
}

fn render_model_selector(frame: &mut Frame<'_>, app: &ChatApp) {
    let area = centered_rect(60, 60, frame.area());
    frame.render_widget(Clear, area);

    let items: Vec<ListItem> = app
        .models()
        .iter()
        .map(|model| {
            let label = if model.name.is_empty() {
                model.id.clone()
            } else {
                format!("{} — {}", model.id, model.name)
            };
            ListItem::new(Span::styled(
                label,
                Style::default()
                    .fg(Color::LightBlue)
                    .add_modifier(Modifier::BOLD),
            ))
        })
        .collect();

    let list = List::new(items)
        .block(
            Block::default()
                .title(Span::styled(
                    format!("Select Model ({})", app.selected_provider),
                    Style::default()
                        .fg(Color::LightMagenta)
                        .add_modifier(Modifier::BOLD),
                ))
                .borders(Borders::ALL)
                .border_style(Style::default().fg(Color::Rgb(95, 20, 135))),
        )
        .highlight_style(
            Style::default()
                .fg(Color::Magenta)
                .add_modifier(Modifier::BOLD),
        )
        .highlight_symbol("▶ ");

    let mut state = ListState::default();
    state.select(app.selected_model_index());
    frame.render_stateful_widget(list, area, &mut state);
}

fn render_help(frame: &mut Frame<'_>) {
    let area = centered_rect(70, 60, frame.area());
    frame.render_widget(Clear, area);

    let help_text = vec![
        Line::from("MODES:"),
        Line::from("  Normal      → default mode for navigation"),
        Line::from("  Insert      → editing input text"),
        Line::from("  Visual      → selecting text"),
        Line::from("  Command     → executing commands (: prefix)"),
        Line::from(""),
        Line::from("PANEL NAVIGATION:"),
        Line::from("  Tab         → cycle panels forward"),
        Line::from("  Shift+Tab   → cycle panels backward"),
        Line::from("  (Panels: Chat, Thinking, Input)"),
        Line::from(""),
        Line::from("CURSOR MOVEMENT (Normal mode, Chat/Thinking panels):"),
        Line::from("  h/←  l/→    → move left/right by character"),
        Line::from("  j/↓  k/↑    → move down/up by line"),
        Line::from("  w           → forward to next word start"),
        Line::from("  e           → forward to word end"),
        Line::from("  b           → backward to previous word"),
        Line::from("  0 / Home    → start of line"),
        Line::from("  ^           → first non-blank character"),
        Line::from("  $ / End     → end of line"),
        Line::from("  gg          → jump to top"),
        Line::from("  G           → jump to bottom"),
        Line::from("  Ctrl+d/u    → scroll half page down/up"),
        Line::from("  Ctrl+f/b    → scroll full page down/up"),
        Line::from("  PageUp/Down → scroll full page"),
        Line::from(""),
        Line::from("EDITING (Normal mode):"),
        Line::from("  i / Enter   → enter insert mode at cursor"),
        Line::from("  a           → append after cursor"),
        Line::from("  A           → append at end of line"),
        Line::from("  I           → insert at start of line"),
        Line::from("  o           → insert line below and enter insert mode"),
        Line::from("  O           → insert line above and enter insert mode"),
        Line::from("  dd          → clear input buffer"),
        Line::from("  p           → paste from clipboard to input"),
        Line::from("  Esc         → return to normal mode"),
        Line::from(""),
        Line::from("INSERT MODE:"),
        Line::from("  Enter       → send message"),
        Line::from("  Ctrl+J      → insert newline"),
        Line::from("  Ctrl+↑/↓    → navigate input history"),
        Line::from("  Ctrl+A      → start of line"),
        Line::from("  Ctrl+E      → end of line"),
        Line::from("  Ctrl+W      → word forward"),
        Line::from("  Ctrl+B      → word backward"),
        Line::from("  Esc         → return to normal mode"),
        Line::from(""),
        Line::from("VISUAL MODE (all panels):"),
        Line::from("  v           → enter visual mode at cursor"),
        Line::from("  h/j/k/l     → extend selection left/down/up/right"),
        Line::from("  w / e / b   → extend by word (start/end/back)"),
        Line::from("  0 / ^ / $   → extend to line start/first char/end"),
        Line::from("  y           → yank (copy) selection"),
        Line::from("  d           → yank selection (delete in Input)"),
        Line::from("  v / Esc     → exit visual mode"),
        Line::from(""),
        Line::from("COMMANDS (press : then type):"),
        Line::from("  :h, :help   → show this help"),
        Line::from("  :m, :model  → select model"),
        Line::from("  :n, :new    → start new conversation"),
        Line::from("  :c, :clear  → clear current conversation"),
        Line::from("  :q, :quit   → quit application"),
        Line::from(""),
        Line::from("QUICK KEYS:"),
        Line::from("  q           → quit (from normal mode)"),
        Line::from("  Ctrl+C      → quit"),
        Line::from(""),
        Line::from("Press Esc or Enter to close this help."),
    ];

    let paragraph = Paragraph::new(help_text).block(
        Block::default()
            .title(Span::styled(
                "Help",
                Style::default()
                    .fg(Color::LightMagenta)
                    .add_modifier(Modifier::BOLD),
            ))
            .borders(Borders::ALL)
            .border_style(Style::default().fg(Color::Rgb(95, 20, 135))),
    );

    frame.render_widget(paragraph, area);
}

fn centered_rect(percent_x: u16, percent_y: u16, area: Rect) -> Rect {
    let vertical = Layout::default()
        .direction(Direction::Vertical)
        .constraints(
            [
                Constraint::Percentage((100 - percent_y) / 2),
                Constraint::Percentage(percent_y),
                Constraint::Percentage((100 - percent_y) / 2),
            ]
            .as_ref(),
        )
        .split(area);

    Layout::default()
        .direction(Direction::Horizontal)
        .constraints(
            [
                Constraint::Percentage((100 - percent_x) / 2),
                Constraint::Percentage(percent_x),
                Constraint::Percentage((100 - percent_x) / 2),
            ]
            .as_ref(),
        )
        .split(vertical[1])[1]
}

fn role_color(role: &Role) -> Style {
    match role {
        Role::User => Style::default().fg(Color::LightBlue),
        Role::Assistant => Style::default().fg(Color::LightMagenta),
        Role::System => Style::default().fg(Color::Cyan),
    }
}