use crate::book::Book;
use crate::persistence;
use crate::style::StyleProfile;
use crate::theme::{self, BgType, Settings};
use eframe::egui;
use std::path::PathBuf;

pub struct App {
    pub state: AppState,
    settings: Settings,
    settings_dir: std::path::PathBuf,
    kraft_texture: Option<egui::TextureHandle>,
    manuscript_texture: Option<egui::TextureHandle>,
    composition_texture: Option<egui::TextureHandle>,
    custom_texture: Option<egui::TextureHandle>,
}

pub struct AppState {
    pub book: Option<Book>,
    pub current_section: usize,
    pub current_page: usize,
    pub sidebar_open: bool,
    pub file_path: Option<PathBuf>,
    pub error_message: Option<String>,
    pub pending_anchor: Option<theme::ReadingPosition>,
}

impl AppState {
    pub fn prev_page(&mut self) {
        if let Some(ref book) = self.book {
            if self.current_page > 0 {
                self.current_page -= 1;
            } else if self.current_section > 0 {
                self.current_section -= 1;
                self.current_page = book.sections[self.current_section]
                    .page_block_ranges.len().saturating_sub(1);
            }
        }
    }

    pub fn next_page(&mut self) {
        if let Some(ref book) = self.book {
            if self.current_page + 1 < book.sections[self.current_section]
                .page_block_ranges.len()
            {
                self.current_page += 1;
            } else if self.current_section + 1 < book.sections.len() {
                self.current_section += 1;
                self.current_page = 0;
            }
        }
    }
}

impl App {
    pub fn new(cc: &eframe::CreationContext<'_>) -> Self {
        let settings_dir = persistence::settings_dir();
        let settings = persistence::load_settings(&settings_dir).unwrap_or_default();
        cc.egui_ctx.set_style(theme::create_style(&settings.theme));
        crate::font::setup_fonts(&cc.egui_ctx, &settings.font_name);
        Self {
            state: AppState {
                book: None,
                current_section: 0,
                current_page: 0,
                sidebar_open: false,
                file_path: None,
                error_message: None,
                pending_anchor: None,
            },
            settings,
            settings_dir,
            kraft_texture: Some(crate::texture::generate_kraft_paper(&cc.egui_ctx)),
            manuscript_texture: Some(crate::texture::generate_manuscript(&cc.egui_ctx)),
            composition_texture: Some(crate::texture::generate_composition(&cc.egui_ctx)),
            custom_texture: None,
        }
    }

    pub fn open_file(&mut self, path: PathBuf) {
        match crate::book::load_epub(&path) {
            Ok(book) => {
                let path_str = path.to_string_lossy().to_string();
                let pos = self.settings.reading_positions.get(&path_str).cloned();
                let mut recent = Vec::new();
                recent.push(path_str.clone());
                for f in &self.settings.recent_files {
                    if *f != path_str {
                        recent.push(f.clone());
                        if recent.len() >= 10 {
                            break;
                        }
                    }
                }
                self.settings.recent_files = recent;
                self.state.book = Some(book);
                self.state.current_section = pos.as_ref().map(|p| p.section).unwrap_or(0);
                self.state.current_page = pos.as_ref().map(|p| p.page).unwrap_or(0);
                self.state.pending_anchor = pos;
                self.state.sidebar_open = false;
                self.state.file_path = Some(path);
                self.state.error_message = None;
                self.save_settings();
            }
            Err(e) => {
                self.state.error_message = Some(e);
            }
        }
    }

    fn save_settings(&self) {
        let _ = persistence::save_settings(&self.settings_dir, &self.settings);
    }

    fn active_profile(&self) -> &StyleProfile {
        let idx = self.settings.profiles.iter().position(|p| p.name == self.settings.active_profile);
        let idx = idx.unwrap_or(0);
        &self.settings.profiles[idx]
    }

    fn save_reading_position(&mut self) {
        if let Some(ref path) = self.state.file_path {
            let path_str = path.to_string_lossy().to_string();
            let (block_index, text_snippet) = if let Some(ref book) = self.state.book {
                let section = &book.sections[self.state.current_section];
                if let Some(&(start, _end)) = section.page_block_ranges.get(self.state.current_page) {
                    let first_block = start;
                    let snippet = section.blocks.get(first_block)
                        .map(|b| b.text.chars().take(30).collect())
                        .unwrap_or_default();
                    (Some(first_block), Some(snippet))
                } else {
                    (None, None)
                }
            } else {
                (None, None)
            };
            self.settings.reading_positions.insert(
                path_str,
                theme::ReadingPosition {
                    section: self.state.current_section,
                    page: self.state.current_page,
                    block_index,
                    text_snippet,
                },
            );
        }
    }

    fn welcome_view(&mut self, ctx: &egui::Context) {
        egui::CentralPanel::default().show(ctx, |ui| {
            ui.vertical_centered(|ui| {
                ui.add_space(150.0);
                ui.heading("ePub Reader");
                ui.add_space(20.0);
                if ui
                    .add(egui::Button::new("📂  打开 ePub 文件").min_size(egui::vec2(200.0, 40.0)))
                    .clicked()
                {
                    if let Some(path) = rfd::FileDialog::new()
                        .add_filter("ePub", &["epub"])
                        .pick_file()
                    {
                        self.open_file(path);
                    }
                }
                ui.add_space(30.0);
                if !self.settings.recent_files.is_empty() {
                    ui.label("最近阅读:");
                    ui.separator();
                    let mut to_open: Option<PathBuf> = None;
                    let mut to_remove: Option<usize> = None;
                    for (i, path) in self.settings.recent_files.iter().enumerate() {
                        let name = std::path::Path::new(path)
                            .file_name()
                            .map(|n| n.to_string_lossy().to_string())
                            .unwrap_or_else(|| path.clone());
                        if ui.button(&name).clicked() {
                            let p = std::path::PathBuf::from(path);
                            if p.exists() {
                                to_open = Some(p);
                            } else {
                                to_remove = Some(i);
                            }
                        }
                    }
                    if let Some(path) = to_open {
                        self.open_file(path);
                    }
                    if let Some(i) = to_remove {
                        self.settings.recent_files.remove(i);
                        self.save_settings();
                    }
                }
                if let Some(ref msg) = self.state.error_message {
                    ui.add_space(20.0);
                    ui.colored_label(egui::Color32::RED, msg);
                }
            });
        });
    }
}

impl eframe::App for App {
     fn update(&mut self, ctx: &egui::Context, _frame: &mut eframe::Frame) {
         let bg_type = self.settings.bg_type.clone();
         let has_bg = bg_type.has_background();

         // 有背景时面板设为透明
         if has_bg {
             ctx.style_mut(|s| {
                 s.visuals.panel_fill = egui::Color32::TRANSPARENT;
                 s.visuals.window_fill = egui::Color32::TRANSPARENT;
             });
         }

         // 全窗口背景纹理
         let viewport_rect = ctx.input(|i| i.screen_rect());
         match bg_type {
             BgType::Kraft => {
                 if let Some(tex) = &self.kraft_texture {
                     crate::texture::draw_tiled_bg(
                         &ctx.layer_painter(egui::LayerId::background()),
                         viewport_rect,
                         tex,
                     );
                 }
             }
             BgType::Manuscript => {
                 if let Some(tex) = &self.manuscript_texture {
                     crate::texture::draw_tiled_bg(
                         &ctx.layer_painter(egui::LayerId::background()),
                         viewport_rect,
                         tex,
                     );
                 }
             }
             BgType::Composition => {
                 if let Some(tex) = &self.composition_texture {
                     crate::texture::draw_tiled_bg(
                         &ctx.layer_painter(egui::LayerId::background()),
                         viewport_rect,
                         tex,
                     );
                 }
             }
BgType::Custom(ref path) if !path.is_empty() => {
                  if self.custom_texture.is_none() {
                      match image::ImageReader::open(path) {
                          Ok(reader) => match reader.decode() {
                              Ok(img) => {
                                  let size = [img.width() as usize, img.height() as usize];
                                  let pixels: Vec<egui::Color32> = img
                                      .to_rgba8()
                                      .pixels()
                                      .map(|p| {
                                          egui::Color32::from_rgba_unmultiplied(p[0], p[1], p[2], p[3])
                                      })
                                      .collect();
                                  let image = egui::ColorImage { size, pixels };
                                  self.custom_texture = Some(
                                      ctx.load_texture("custom_bg", image, Default::default()),
                                  );
                              }
                              Err(_) => {}
                          },
                          Err(_) => {}
                      }
                  }
                 if let Some(tex) = &self.custom_texture {
                     let painter = &ctx.layer_painter(egui::LayerId::background());
                     painter.image(
                         tex.id(),
                         viewport_rect,
                         egui::Rect::from_min_max(egui::pos2(0.0, 0.0), egui::pos2(1.0, 1.0)),
                         egui::Color32::WHITE,
                     );
                 }
             }
             _ => {}
         }

         if self.state.book.is_none() {
             self.welcome_view(ctx);
             return;
         }

         let file_path = self.state.file_path
             .as_ref()
             .map(|p| p.to_string_lossy().to_string())
             .unwrap_or_default();

         let mut style = self.active_profile().clone();
         let theme_copy = self.settings.theme;
         let profile_names: Vec<String> = self.settings.profiles.iter().map(|p| p.name.clone()).collect();

         let bookmarks = self.settings.bookmarks.get(&file_path).cloned().unwrap_or_default();
         let mut jump_to_bookmark: Option<usize> = None;

          egui::CentralPanel::default().show(ctx, |ui| {
              let book = self.state.book.as_mut().unwrap();
              let current_font = self.settings.font_name.clone();
              let (action, jump) = crate::reader::reading_view(
                  ui,
                  book,
                  &mut self.state.current_section,
                  &mut self.state.current_page,
                  &mut self.state.sidebar_open,
                  &mut style,
                  &theme_copy,
                  bg_type.clone(),
                  &file_path,
                  &profile_names,
                  &bookmarks,
                  &current_font,
              );
             jump_to_bookmark = jump;

             if action.go_back {
                 self.save_reading_position();
                 self.state.book = None;
                 self.state.current_section = 0;
                 self.state.current_page = 0;
             }

             // Switch profile immediately
             if let Some(ref target) = action.switch_to_profile {
                 if let Some(profile) = self.settings.profiles.iter()
                     .find(|p| p.name == *target)
                 {
                     style.alignment = profile.alignment;
                     style.line_spacing = profile.line_spacing;
                     style.paragraph_spacing = profile.paragraph_spacing;
                     style.first_line_indent = profile.first_line_indent;
                     style.font_size = profile.font_size;
                     style.name = profile.name.clone();
                     self.settings.active_profile = profile.name.clone();
                 }
             }

              if let Some(ref new_font) = action.switch_font {
                  if new_font != &self.settings.font_name {
                      let actual = crate::font::setup_fonts(ui.ctx(), new_font);
                      self.settings.font_name = actual;
                  }
              }

              if let Some(new_bg) = action.switch_bg {
                 self.settings.bg_type = new_bg;
                 // 切换背景时，如果选自定义图片则弹出文件选择器
                 if let BgType::Custom(_) = &self.settings.bg_type {
                     if let Some(p) = rfd::FileDialog::new()
                         .add_filter("Images", &["png", "jpg", "jpeg", "bmp", "webp"])
                         .pick_file()
                     {
                         self.settings.bg_type = BgType::Custom(p.to_string_lossy().to_string());
                         self.custom_texture = None;
                     } else {
                         self.settings.bg_type = BgType::None;
                     }
                 }
                 // 切换背景时，如果从自定义图片切走，清除纹理缓存
                 if !self.settings.bg_type.has_background() || !matches!(self.settings.bg_type, BgType::Custom(_)) {
                     self.custom_texture = None;
                 }
             }

             if action.toggle_theme {
                self.settings.theme = match self.settings.theme {
                    theme::Theme::Light => theme::Theme::Dark,
                    theme::Theme::Dark => theme::Theme::Sepia,
                    theme::Theme::Sepia => theme::Theme::Light,
                };
                ctx.set_style(theme::create_style(&self.settings.theme));
            }

            if action.toggle_sidebar {
                self.state.sidebar_open = !self.state.sidebar_open;
            }

            if let Some(section) = action.jump_to_section {
                self.state.current_section = section;
                self.state.current_page = 0;
                self.state.pending_anchor = None;
                if let Some(ref anchor) = action.jump_to_anchor {
                    if let Some(ref book) = self.state.book {
                        if section < book.sections.len() {
                            if let Some(page) = crate::reader::find_page_for_anchor(&book.sections[section], anchor) {
                                self.state.current_page = page;
                            }
                        }
                    }
                }
            }

            if action.page_prev {
                 self.state.prev_page();
             }
             if action.page_next {
                 self.state.next_page();
             }

             if action.toggle_bookmark {
                 let file_path = file_path.clone();
                 let section = self.state.current_section;
                 let page = self.state.current_page;
                 let book = self.state.book.as_ref().unwrap();
                 let section_title = book.sections.get(section)
                     .map(|s| s.title.clone())
                     .unwrap_or_else(|| format!("第{}章", section + 1));

                 let bookmarks = self.settings.bookmarks.entry(file_path)
                     .or_insert_with(Vec::new);

                 let existing_idx = bookmarks.iter()
                     .position(|b: &theme::Bookmark| b.section == section && b.page == page);

                 if let Some(idx) = existing_idx {
                     bookmarks.remove(idx);
                 } else {
                     use std::time::{SystemTime, UNIX_EPOCH};
                     let timestamp = SystemTime::now()
                         .duration_since(UNIX_EPOCH)
                         .map(|d| d.as_secs() as i64)
                         .unwrap_or(0);
                     bookmarks.push(theme::Bookmark {
                         section,
                         page,
                         label: format!("{} - 第{}页", section_title, page + 1),
                         timestamp,
                     });
                 }
             }
         });

         if let Some(idx) = jump_to_bookmark {
             if let Some(bookmarks) = self.settings.bookmarks.get(&file_path) {
                 if let Some(bm) = bookmarks.get(idx) {
                     self.state.current_section = bm.section;
                     self.state.current_page = bm.page;
                 }
             }
         }

         if let Some(anchor) = self.state.pending_anchor.take() {
             if let Some(ref book) = self.state.book {
                 if anchor.section < book.sections.len() {
                     let section = &book.sections[anchor.section];
                     let restored = if let Some(block_idx) = anchor.block_index {
                         crate::reader::find_page_for_block(section, block_idx)
                     } else if let Some(ref snippet) = anchor.text_snippet {
                         crate::reader::find_page_by_snippet(section, snippet)
                     } else {
                         None
                     };
                     if let Some(page) = restored {
                         self.state.current_page = page;
                     }
                 }
             }
         }

         // Sync style changes back to active profile (outside closure)
         if let Some(p) = self.settings.profiles.iter_mut()
             .find(|p| p.name == self.settings.active_profile)
         {
             p.font_size = style.font_size;
             p.alignment = style.alignment;
             p.line_spacing = style.line_spacing;
             p.paragraph_spacing = style.paragraph_spacing;
             p.first_line_indent = style.first_line_indent;
         }
         self.settings.font_size = style.font_size;

         self.save_reading_position();
         self.save_settings();
     }
 }