//! Kurulum sırasında gösterilen slayt gösterisi.
//!
//! Her slayt: başlık, açıklama metni ve isteğe bağlı bir simge karakteri.
//! Slaytlar otomatik olarak 6 saniyede bir değişir.
//! Slaytlar harici `slides/slides_{lang}.toml` dosyasından yüklenir.

use eframe::egui;
use std::time::{Duration, Instant};
use std::borrow::Cow;

const SLIDE_INTERVAL: Duration = Duration::from_secs(6);

pub struct Slide {
    pub icon:        String,
    pub title:       Cow<'static, str>,
    pub description: Cow<'static, str>,
}

// ─── Slayt gösterisi widget'ı ───────────────────────────────────────────

pub struct Slideshow {
    slides:       Vec<Slide>,
    current:      usize,
    last_advance: Instant,
}

impl Slideshow {
    pub fn new(desktop: &str, lang: &str) -> Self {
        let slides = Self::load_slides(desktop, lang);
        Self {
            slides,
            current: 0,
            last_advance: Instant::now(),
        }
    }

    fn load_slides(desktop: &str, lang: &str) -> Vec<Slide> {
        let filenames = [
            format!("slides_{}.toml", lang),
            "slides.toml".to_string(),
        ];
        let exe_dir = std::env::current_exe()
            .ok()
            .and_then(|p| p.parent().map(|d| d.to_path_buf()))
            .unwrap_or_default();
        let search_dirs = [
            std::env::current_dir().unwrap_or_default(),
            exe_dir,
            std::path::PathBuf::from("/usr/share/yali"),
            std::path::PathBuf::from("/etc/yali"),
        ];
        for dir in &search_dirs {
            for fname in &filenames {
                let path = dir.join("slides").join(fname);
                let content = match std::fs::read_to_string(&path) {
                    Ok(c) => c,
                    Err(_) => continue,
                };
                match toml::from_str::<crate::branding::SlidesConfig>(&content) {
                    Ok(cfg) => {
                        let slides: Vec<Slide> = cfg.items
                            .into_iter()
                            .filter(|item| item.desktop.is_empty() || item.desktop.to_lowercase() == desktop.to_lowercase())
                            .map(|item| Slide {
                                icon: item.icon,
                                title: Cow::Owned(item.title),
                                description: Cow::Owned(item.description),
                            })
                            .collect();
                    eprintln!("[slides] {} -> {} slayt yüklendi", path.display(), slides.len());
                    return slides;
                }
                Err(e) => {
                    eprintln!("[slides] {} ayrıştırılamadı: {}", path.display(), e);
                    }
                }
            }
        }
        eprintln!("[slides] hiçbir slayt dosyası yüklenemedi");
        Vec::new()
    }

    /// Her frame'de çağrılır. Otomatik ilerlemeyi ve çizimi yönetir.
    pub fn show(&mut self, ui: &mut egui::Ui) {
        if self.slides.is_empty() {
            ui.label(egui::RichText::new("Slayt yüklenemedi").size(14.0));
            return;
        }

        // Otomatik ilerleme
        if self.last_advance.elapsed() >= SLIDE_INTERVAL {
            self.current = (self.current + 1) % self.slides.len();
            self.last_advance = Instant::now();
            ui.ctx().request_repaint_after(SLIDE_INTERVAL);
        } else {
            // Bir sonraki değişime kadar geri sayım için tekrar çiz
            let remaining = SLIDE_INTERVAL
                .checked_sub(self.last_advance.elapsed())
                .unwrap_or_default();
            ui.ctx().request_repaint_after(remaining);
        }

        let slide = &self.slides[self.current];

        // İkon: doğrudan dosya yolundan file:// URI'sine çevir
        let resolved_uri = if !slide.icon.is_empty() {
            Some(crate::branding::path_to_file_uri(&slide.icon))
        } else {
            None
        };

        // Kart, kendisine ayrılan dikey alanı doldursun.
        let fill_h = ui.available_height().max(180.0);
        egui::Frame::none()
            .fill(crate::ui::theme::c_bg_widget())
            .rounding(egui::Rounding::same(10.0))
            .inner_margin(egui::Margin::same(24.0))
            .show(ui, |ui| {
                ui.set_min_height(fill_h);
                ui.vertical_centered(|ui| {
                    // Simge veya Görsel
                    if let Some(uri) = resolved_uri {
                        ui.add(
                            egui::Image::from_uri(uri)
                                .max_height(64.0)
                                .rounding(egui::Rounding::same(8.0)),
                        );
                    } else {
                        ui.label(
                            egui::RichText::new("\u{1f5bc}\u{fe0f}")
                                .size(48.0),
                        );
                    }
                    ui.add_space(10.0);

                    // Başlık
                    ui.label(
                        egui::RichText::new(slide.title.clone())
                            .size(17.0)
                            .strong()
                            .color(crate::ui::theme::c_text()),
                    );
                    ui.add_space(8.0);

                    // Açıklama
                    ui.label(
                        egui::RichText::new(slide.description.clone())
                            .size(13.0)
                            .color(crate::ui::theme::c_text_dim()),
                    );

                    });
            });
    }

    pub fn slide_count(&self) -> usize {
        self.slides.len()
    }
}
