use eframe::egui;
use crate::book::Book;
use crate::theme::{self, Theme};

pub fn recalculate_pages(book: &mut Book, font_size: f32, panel_width: f32, panel_height: f32) {
    let char_width = font_size * 0.6;
    let line_height = font_size * 1.5;
    let chars_per_line = if char_width > 0.0 {
        (panel_width / char_width).max(1.0) as usize
    } else {
        1
    };
    let lines_per_page = if line_height > 0.0 {
        (panel_height / line_height).max(1.0) as usize
    } else {
        1
    };
    let chars_per_page = chars_per_line * lines_per_page;
    for section in &mut book.sections {
        section.pages = calculate_pages(&section.content, chars_per_page);
    }
}

pub struct ReaderAction {
    pub go_back: bool,
    pub toggle_theme: bool,
    pub toggle_bookmark: bool,
    pub page_next: bool,
    pub page_prev: bool,
}

pub fn reading_view(
    ui: &mut egui::Ui,
    book: &mut Book,
    current_section: &mut usize,
    current_page: &mut usize,
    sidebar_open: &mut bool,
    font_size: &mut f32,
    theme: &Theme,
    _file_path: &str,
) -> ReaderAction {
    let mut action = ReaderAction {
        go_back: false,
        toggle_theme: false,
        toggle_bookmark: false,
        page_next: false,
        page_prev: false,
    };

    let panel_size = ui.available_size();
    recalculate_pages(book, *font_size, panel_size.x, panel_size.y);

    let colors = theme::reader_colors(theme);

    // --- Sidebar (TOC) ---
    if *sidebar_open {
        egui::SidePanel::left("toc_sidebar")
            .resizable(true)
            .default_width(200.0)
            .show_inside(ui, |ui| {
                ui.heading("目录");
                ui.separator();
                render_toc(ui, &book.toc, current_section, current_page);
            });
    }

    // --- Top toolbar ---
    egui::TopBottomPanel::top("reader_toolbar")
        .show_inside(ui, |ui| {
            ui.horizontal(|ui| {
                if ui.button("← 返回").on_hover_text("返回书架").clicked() {
                    action.go_back = true;
                }
                ui.separator();
                ui.label(&book.title);
                ui.with_layout(egui::Layout::right_to_left(egui::Align::Center), |ui| {
                    let (theme_icon, theme_hint) = match theme {
                        Theme::Dark => ("🌞", "切换到浅色主题"),
                        Theme::Light => ("🌙", "切换到夜间主题"),
                        Theme::Sepia => ("📜", "切换到棕褐色主题"),
                    };
                    if ui.button(theme_icon).on_hover_text(theme_hint).clicked() {
                        action.toggle_theme = true;
                    }
                    if ui.button("🔖").on_hover_text("添加/移除书签").clicked() {
                        action.toggle_bookmark = true;
                    }
                    if ui.button("A⁻").on_hover_text("缩小字体").clicked() {
                        *font_size = (*font_size - 2.0).max(10.0);
                    }
                    if ui.button("A⁺").on_hover_text("放大字体").clicked() {
                        *font_size = (*font_size + 2.0).min(48.0);
                    }
                    if ui.button("☰").on_hover_text("打开/关闭目录").clicked() {
                        *sidebar_open = !*sidebar_open;
                    }
                });
            });
        });

    // --- Bottom progress bar ---
    let total_pages = if *current_section < book.sections.len() {
        let p = &book.sections[*current_section].pages;
        if p.len() > 1 { p.len() - 1 } else { 0 }
    } else { 0 };

    egui::TopBottomPanel::bottom("reader_progress")
        .show_inside(ui, |ui| {
            ui.horizontal(|ui| {
                let section_title = book.sections.get(*current_section)
                    .map(|s| s.title.as_str())
                    .unwrap_or("");
                ui.label(section_title);
                ui.with_layout(egui::Layout::right_to_left(egui::Align::Center), |ui| {
                    // Page turn buttons (right side of bottom bar)
                    let prev_enabled = *current_page > 0 || *current_section > 0;
                    let next_enabled = (*current_page + 1 < book.sections[*current_section]
                        .pages.len().saturating_sub(1))
                        || (*current_section + 1 < book.sections.len());

                    let next_btn = egui::Button::new(
                        egui::RichText::new("下一页 ▶").size(13.0)
                    ).min_size(egui::vec2(100.0, 28.0));

                    let prev_btn = egui::Button::new(
                        egui::RichText::new("◀ 上一页").size(13.0)
                    ).min_size(egui::vec2(100.0, 28.0));

                    if !next_enabled {
                        ui.add_enabled(false, next_btn);
                    } else if ui.add(next_btn).on_hover_text("下一页 (→键)").clicked() {
                        action.page_next = true;
                    }

                    ui.add_space(8.0);

                    if !prev_enabled {
                        ui.add_enabled(false, prev_btn);
                    } else if ui.add(prev_btn).on_hover_text("上一页 (←键)").clicked() {
                        action.page_prev = true;
                    }

                    ui.separator();

                    let label = if total_pages > 0 {
                        format!("{}/{}", *current_page + 1, total_pages)
                    } else {
                        "1/1".to_string()
                    };
                    ui.label(label);
                    let mut progress = if total_pages > 0 {
                        *current_page as f32 / total_pages as f32
                    } else { 0.0 };
                    if ui.add(egui::Slider::new(&mut progress, 0.0..=1.0).text("")).changed() && total_pages > 0 {
                        *current_page = (progress * total_pages as f32).round() as usize;
                    }
                });
            });
        });

    // --- Center text area ---
    egui::CentralPanel::default().show_inside(ui, |ui| {
        let (rect, response) = ui.allocate_at_least(ui.available_size(), egui::Sense::click());

        if let Some(section) = book.sections.get(*current_section) {
            if *current_page < section.pages.len().saturating_sub(1) {
                let start = section.pages[*current_page];
                let end = section.pages[*current_page + 1];
                let text: String = section.content.chars().skip(start).take(end - start).collect();
                ui.put(rect, |ui: &mut egui::Ui| {
                    ui.add(
                        egui::Label::new(
                            egui::RichText::new(&text)
                                .size(*font_size)
                                .color(colors.text)
                        ).wrap()
                    )
                });
            }
        }

        // Click navigation
        if response.clicked() {
            if let Some(click_pos) = response.interact_pointer_pos() {
                let x_ratio = (click_pos.x - rect.min.x) / rect.width();
                if x_ratio < 0.3 {
                    action.page_prev = true;
                } else if x_ratio > 0.7 {
                    action.page_next = true;
                }
            }
        }

        // Keyboard navigation
        if ui.input(|i| i.key_pressed(egui::Key::ArrowRight)) {
            action.page_next = true;
        }
        if ui.input(|i| i.key_pressed(egui::Key::ArrowLeft)) {
            action.page_prev = true;
        }
    });

    action
}

fn render_toc(
    ui: &mut egui::Ui,
    entries: &[crate::book::TocEntry],
    current_section: &mut usize,
    current_page: &mut usize,
) {
    for entry in entries {
        let is_current = entry.section == *current_section;
        let label_text = if is_current {
            egui::RichText::new(&entry.label).color(egui::Color32::YELLOW).strong()
        } else {
            egui::RichText::new(&entry.label)
        };
        let response = ui.add(
            egui::Button::new(label_text)
                .frame(false)
                .wrap()
        );
        if response.clicked() {
            *current_section = entry.section;
            *current_page = 0;
        }
        response.on_hover_text(format!("跳转到: {}", entry.label));
        if !entry.children.is_empty() {
            ui.indent(&entry.label, |ui| {
                render_toc(ui, &entry.children, current_section, current_page);
            });
        }
    }
}

pub fn calculate_pages(text: &str, chars_per_page: usize) -> Vec<usize> {
    let mut pages = Vec::new();
    pages.push(0);

    if text.is_empty() || chars_per_page == 0 {
        return pages;
    }

    let total_chars = text.chars().count();
    if total_chars <= chars_per_page {
        pages.push(total_chars);
        return pages;
    }

    let mut pos = 0;
    while pos < total_chars {
        pos = (pos + chars_per_page).min(total_chars);
        pages.push(pos);
    }

    pages
}

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

    #[test]
    fn test_pagination_empty() {
        let pages = calculate_pages("", 100);
        assert_eq!(pages, vec![0]);
    }

    #[test]
    fn test_pagination_shorter_than_page() {
        let pages = calculate_pages("Hello World", 100);
        assert_eq!(pages, vec![0, 11]);
    }

    #[test]
    fn test_pagination_exact_fit() {
        let pages = calculate_pages("ABCD", 4);
        assert_eq!(pages, vec![0, 4]);
    }

    #[test]
    fn test_pagination_multiple_pages() {
        let text = "A".repeat(100);
        let pages = calculate_pages(&text, 30);
        assert_eq!(pages, vec![0, 30, 60, 90, 100]);
    }

    #[test]
    fn test_pagination_single_char() {
        let pages = calculate_pages("A", 1);
        assert_eq!(pages, vec![0, 1]);
    }

    #[test]
    fn test_pagination_zero_chars_per_page() {
        let pages = calculate_pages("test", 0);
        assert_eq!(pages, vec![0]);
    }
}