/// Spiral layout for media galleries

use egui::{pos2, vec2, Color32, Rect, Sense, TextureId, Vec2};

#[derive(Clone, Copy, Debug)]
pub struct ImageItem {
    pub texture: TextureId,
    pub ar: f32, // width / height (must be > 0)
}

#[derive(Clone, Debug)]
struct Placed {
    texture: TextureId,
    rect: Rect,
}

#[derive(Clone, Copy, Debug)]
pub struct LayoutParams {
    pub gutter: f32,
    pub h_min: f32,
    pub h_max: f32,
    pub w_min: f32,
    pub w_max: f32,
    pub seed_center: bool,
}

pub fn layout_spiral(images: &[ImageItem], params: LayoutParams) -> (Vec<Placed>, Vec2) {
    if images.is_empty() {
        return (Vec::new(), vec2(0.0, 0.0));
    }

    let eps = f32::EPSILON;
    let g = params.gutter.max(0.0);
    let h_min = params.h_min.max(1.0);
    let h_max = params.h_max.max(h_min);
    let w_min = params.w_min.max(1.0);
    let w_max = params.w_max.max(w_min);

    let mut placed = Vec::with_capacity(images.len());

    // Build around origin; normalize at the end.
    let mut x_min = 0.0f32;
    let mut x_max = 0.0f32;
    let mut y_min = 0.0f32;
    let mut y_max = 0.0f32;

    // dir: 0 right-col, 1 top-row, 2 left-col, 3 bottom-row
    let mut dir = 0usize;
    let mut i = 0usize;

    // Optional seed: center a single image
    if params.seed_center && i < images.len() {
        let ar = images[i].ar.max(eps);
        let h = ((h_min + h_max) * 0.5).clamp(h_min, h_max);
        let w = ar * h;

        let rect = Rect::from_center_size(pos2(0.0, 0.0), vec2(w, h));
        placed.push(Placed { texture: images[i].texture, rect });

        x_min = rect.min.x;
        x_max = rect.max.x;
        y_min = rect.min.y;
        y_max = rect.max.y;

        i += 1;
        dir = 1; // start by adding a row above
    } else {
        // ensure non-empty bbox for the first strip
        x_min = 0.0; x_max = 1.0; y_min = 0.0; y_max = 1.0;
    }

    // --- helpers -------------------------------------------------------------

    // Choose how many items fit and the strip size S (W for column, H for row).
    fn choose_k<F: Fn(&ImageItem) -> f32>(
        images: &[ImageItem],
        L: f32,
        g: f32,
        s_min: f32,
        s_max: f32,
        weight: F,
    ) -> (usize, f32) {
        // prefix sums of weights (sum over first k items)
        let mut pref = Vec::with_capacity(images.len() + 1);
        pref.push(0.0);
        for im in images {
            pref.push(pref.last().copied().unwrap_or(0.0) + weight(im));
        }

        let k_max = images.len().max(1);
        let mut chosen_k = 1usize;
        let mut chosen_s = f32::NAN;

        for k in 1..=k_max {
            let L_eff = (L - g * (k as f32 - 1.0)).max(1.0);
            let sum_w = pref[k].max(f32::EPSILON);
            let s = (L_eff / sum_w).max(1.0);

            if s > s_max && k < k_max {
                continue; // too big; add one more to thin the strip
            }
            if s < s_min {
                // prefer one fewer if possible
                if k > 1 {
                    let k2 = k - 1;
                    let L_eff2 = (L - g * (k2 as f32 - 1.0)).max(1.0);
                    let sum_w2 = pref[k2].max(f32::EPSILON);
                    chosen_k = k2;
                    chosen_s = (L_eff2 / sum_w2).max(1.0);
                } else {
                    chosen_k = 1;
                    chosen_s = s_min;
                }
                return (chosen_k, chosen_s);
            }
            return (k, s); // within bounds
        }

        // Fell through: use k_max and clamp
        let L_eff = (L - g * (k_max as f32 - 1.0)).max(1.0);
        let sum_w = pref[k_max].max(f32::EPSILON);
        let s = (L_eff / sum_w).clamp(s_min, s_max);
        (k_max, s)
    }

    // Place a column (top→bottom). Returns the new right/left edge.
    fn place_column(
        placed: &mut Vec<Placed>,
        strip: &[ImageItem],
        W: f32,
        x: f32,
        y_top: f32,
        g: f32,
    ) -> f32 {
        let mut y = y_top;
        for (idx, im) in strip.iter().enumerate() {
            let h = (W / im.ar.max(f32::EPSILON)).max(1.0);
            let rect = Rect::from_min_size(pos2(x, y), vec2(W, h));
            placed.push(Placed { texture: im.texture, rect });
            y += h;
            if idx + 1 != strip.len() { y += g; }
        }
        x + W
    }

    // Place a row (left→right). Returns the new top/bottom edge.
    fn place_row(
        placed: &mut Vec<Placed>,
        strip: &[ImageItem],
        H: f32,
        x_left: f32,
        y: f32,
        g: f32,
    ) -> f32 {
        let mut x = x_left;
        for (idx, im) in strip.iter().enumerate() {
            let w = (im.ar.max(f32::EPSILON) * H).max(1.0);
            let rect = Rect::from_min_size(pos2(x, y), vec2(w, H));
            placed.push(Placed { texture: im.texture, rect });
            x += w;
            if idx + 1 != strip.len() { x += g; }
        }
        y + H
    }

    // --- main loop -----------------------------------------------------------

    while i < images.len() {
        let remaining = &images[i..];

        if dir % 2 == 0 {
            // COLUMN (dir 0: right, 2: left)
            let L = (y_max - y_min).max(1.0);
            let (k, W) = choose_k(
                remaining,
                L, g, w_min, w_max,
                |im| 1.0 / im.ar.max(f32::EPSILON),
            );

            let x = if dir == 0 { x_max + g } else { x_min - g - W };
            let new_edge = place_column(&mut placed, &remaining[..k], W, x, y_min, g);
            if dir == 0 { x_max = new_edge; } else { x_min = x; }
            i += k;
        } else {
            // ROW (dir 1: top, 3: bottom)
            let L = (x_max - x_min).max(1.0);
            let (k, H) = choose_k(
                remaining,
                L, g, h_min, h_max,
                |im| im.ar.max(f32::EPSILON),
            );

            let y = if dir == 1 { y_max + g } else { y_min - g - H };
            let new_edge = place_row(&mut placed, &remaining[..k], H, x_min, y, g);
            if dir == 1 { y_max = new_edge; } else { y_min = y; }
            i += k;
        }

        dir = (dir + 1) % 4;
    }

    // Normalize so bbox top-left is (0,0)
    let shift = vec2(-x_min, -y_min);
    for p in &mut placed {
        p.rect = p.rect.translate(shift);
    }
    let total_size = vec2(x_max - x_min, y_max - y_min);
    (placed, total_size)
}

pub fn spiral_gallery(ui: &mut egui::Ui, images: &[ImageItem], params: LayoutParams) {
    use egui::{ScrollArea, Stroke};

    let (placed, size) = layout_spiral(images, params);

    ScrollArea::both().auto_shrink([false, false]).show(ui, |ui| {
        let (rect, _resp) = ui.allocate_exact_size(size, Sense::hover());
        let painter = ui.painter_at(rect);
        painter.rect_stroke(
            Rect::from_min_size(rect.min, size),
            0.0,
            Stroke::new(1.0, Color32::DARK_GRAY),
        );

        let uv = Rect::from_min_max(pos2(0.0, 0.0), pos2(1.0, 1.0));
        for p in &placed {
            let r = Rect::from_min_max(rect.min + p.rect.min.to_vec2(),
                                       rect.min + p.rect.max.to_vec2());
            painter.image(p.texture, r, uv, Color32::WHITE);
        }
    });
}