use crate::api::Status;
use crate::ui::app::{App, TimelineType};
use crate::ui::content::ContentParser;
use crate::utils::format_time;
use crate::ui::image::ImageViewer;
use ratatui::{
    layout::{Constraint, Direction, Layout, Rect},
    style::{Color, Modifier, Style},
    text::{Line, Span, Text},
    widgets::{Block, Borders, List, ListItem, ListState, Paragraph, Wrap},
    Frame,
};

pub fn render_timeline(f: &mut Frame, app: &App, area: Rect) {
    let constraints: &[Constraint] = if app.error_message.is_some() {
        &[Constraint::Length(3), Constraint::Min(0), Constraint::Length(3)]
    } else {
        &[Constraint::Length(3), Constraint::Min(0)]
    };
    
    let chunks = Layout::default()
        .direction(Direction::Vertical)
        .constraints(constraints)
        .split(area);

    render_header(f, app, chunks[0]);
    render_status_list(f, app, chunks[1]);
    
    if let Some(error) = &app.error_message {
        let error_widget = Paragraph::new(error.clone())
            .block(Block::default().borders(Borders::ALL).title("Debug/Error"))
            .style(Style::default().fg(Color::Red))
            .wrap(Wrap { trim: true });
        f.render_widget(error_widget, chunks[2]);
    }
}

fn render_header(f: &mut Frame, app: &App, area: Rect) {
    let timeline_name = match app.timeline_type {
        TimelineType::Home => "Home",
        TimelineType::Local => "Local",
        TimelineType::Federated => "Federated",
    };

    let header_text = if app.loading {
        format!("{} Timeline (Loading...)", timeline_name)
    } else {
        format!("{} Timeline", timeline_name)
    };

    let header = Paragraph::new(header_text)
        .block(Block::default().borders(Borders::ALL).title("Mastui"))
        .style(Style::default().fg(Color::Cyan));

    f.render_widget(header, area);
}

fn render_status_list(f: &mut Frame, app: &App, area: Rect) {
    let statuses = &app.statuses;

    if statuses.is_empty() && !app.loading {
        let empty_msg = if let Some(error) = &app.error_message {
            format!("Error: {}", error)
        } else {
            "No statuses to display".to_string()
        };

        let paragraph = Paragraph::new(empty_msg)
            .block(Block::default().borders(Borders::ALL))
            .wrap(Wrap { trim: true })
            .style(Style::default().fg(Color::Yellow));

        f.render_widget(paragraph, area);
        return;
    }

    let items: Vec<ListItem> = statuses
        .iter()
        .enumerate()
        .map(|(i, status)| format_status(status, i == app.selected_status_index))
        .collect();

    let mut list_state = ListState::default();
    list_state.select(Some(app.selected_status_index));

    let list = List::new(items)
        .block(Block::default().borders(Borders::ALL))
        .highlight_style(Style::default().bg(Color::DarkGray).add_modifier(Modifier::BOLD))
        .highlight_symbol("▶ ");

    f.render_stateful_widget(list, area, &mut list_state);
}

fn format_status(status: &Status, is_selected: bool) -> ListItem {
    let display_status = if let Some(reblog) = &status.reblog {
        reblog.as_ref()
    } else {
        status
    };

    let mut lines = Vec::new();

    if status.reblog.is_some() {
        lines.push(Line::from(vec![
            Span::styled("🔄 ", Style::default().fg(Color::Green)),
            Span::styled(
                format!("{} reblogged", status.account.display_name),
                Style::default().fg(Color::Green),
            ),
        ]));
    }

    let username_style = if is_selected {
        Style::default().fg(Color::Cyan).add_modifier(Modifier::BOLD)
    } else {
        Style::default().fg(Color::Cyan)
    };

    lines.push(Line::from(vec![
        Span::styled(
            format!("@{}", display_status.account.acct),
            username_style,
        ),
        Span::raw(" • "),
        Span::styled(
            format_time(&display_status.created_at),
            Style::default().fg(Color::Gray),
        ),
    ]));

    // Parse content with improved HTML handling
    let parser = ContentParser::new();
    let content_lines = parser.parse_content_simple(&display_status.content);
    
    // Show first 3 lines of content
    for line in content_lines.iter().take(3) {
        lines.push(line.clone());
    }

    if content_lines.len() > 3 {
        lines.push(Line::from(Span::styled("...", Style::default().fg(Color::Gray))));
    }

    // Show media attachments with better formatting
    if !display_status.media_attachments.is_empty() {
        let media_info = ImageViewer::show_media_attachments(&display_status.media_attachments);
        for media_line in media_info.lines() {
            if !media_line.trim().is_empty() {
                lines.push(Line::from(Span::styled(
                    media_line.to_string(),
                    Style::default().fg(Color::Magenta),
                )));
            }
        }
    }

    let mut stats = Vec::new();
    
    if display_status.replies_count > 0 {
        stats.push(format!("💬 {}", display_status.replies_count));
    }
    
    if display_status.reblogs_count > 0 {
        stats.push(format!("🔄 {}", display_status.reblogs_count));
    }
    
    if display_status.favourites_count > 0 {
        stats.push(format!("⭐ {}", display_status.favourites_count));
    }

    if !stats.is_empty() {
        lines.push(Line::from(Span::styled(
            stats.join(" • "),
            Style::default().fg(Color::Gray),
        )));
    }

    lines.push(Line::from(Span::raw("")));

    ListItem::new(Text::from(lines))
}

fn strip_html(html: &str) -> String {
    html.replace("<br>", "\n")
        .replace("<br/>", "\n")
        .replace("<br />", "\n")
        .replace("</p>", "\n")
        .chars()
        .filter(|&c| c != '<' && c != '>')
        .collect::<String>()
        .replace("&lt;", "<")
        .replace("&gt;", ">")
        .replace("&amp;", "&")
        .replace("&quot;", "\"")
        .replace("&#39;", "'")
}