use std::collections::{HashSet, VecDeque};

use crate::seed;

#[derive(Debug, Clone)]
pub struct Room {
    pub x: usize,
    pub y: usize,
    pub width: usize,
    pub height: usize,
}

impl Room {
    // Return the center cell of the room.
    pub fn center_cell(&self) -> (usize, usize) {
        (self.x + (self.width / 2), self.y + (self.height / 2))
    }
}

#[derive(Debug, Clone)]
pub struct Corridor {
    #[allow(dead_code)]
    pub id: u64,
    pub start_room_id: usize,
    pub end_room_id: usize,
    pub path: Vec<(usize, usize)>,
    pub width: usize,
}

#[derive(Debug, Clone)]
pub struct Door {
    pub from: (usize, usize),
    pub to: (usize, usize),
    pub width: usize,
    pub span_width: bool,
    pub locked: bool,
    pub archway: bool,
}

#[derive(Debug, Clone, Copy)]
pub struct DoorSettings {
    pub frequency_percent: usize,
    pub room_hallway_percent: usize,
    pub locked_percent: usize,
    pub allow_middle_corridor_doors: bool,
}

#[derive(Debug, Clone)]
pub struct DungeonLayout {
    pub rooms: Vec<Room>,
    pub corridors: Vec<Corridor>,
    pub doors: Vec<Door>,
    pub packed_rooms: bool,
}

impl Default for DungeonLayout {
    fn default() -> Self {
        Self {
            rooms: Vec::new(),
            corridors: Vec::new(),
            doors: Vec::new(),
            packed_rooms: false,
        }
    }
}

// Collect all room cells except those belonging to excluded room ids.
pub fn blocked_room_cells(rooms: &[Room], excluded_room_ids: &[usize]) -> HashSet<(usize, usize)> {
    let excluded: HashSet<usize> = excluded_room_ids.iter().copied().collect();
    let mut blocked = HashSet::new();

    for (room_idx, room) in rooms.iter().enumerate() {
        if excluded.contains(&room_idx) {
            continue;
        }

        for x in room.x..(room.x + room.width) {
            for y in room.y..(room.y + room.height) {
                blocked.insert((x, y));
            }
        }
    }

    blocked
}

// Build a layout based on settings and a derived deterministic seed.
pub fn generate_layout(
    cols: usize,
    rows: usize,
    target_room_count: usize,
    seed: u64,
    min_room_size: usize,
    max_room_size: usize,
    square_rooms_only: bool,
    min_corridor_width: usize,
    max_corridor_width: usize,
    corridor_randomness_percent: usize,
    dead_end_room_percent: usize,
    pack_rooms_without_corridors: bool,
    door_settings: DoorSettings,
) -> DungeonLayout {
    let layout_salt = ((cols as u64) << 48)
        ^ ((rows as u64) << 32)
        ^ ((target_room_count as u64) << 16)
        ^ (min_room_size as u64)
        ^ ((max_room_size as u64) << 8)
        ^ ((min_corridor_width as u64) << 24)
        ^ ((max_corridor_width as u64) << 28)
        ^ ((corridor_randomness_percent as u64) << 56)
        ^ ((dead_end_room_percent as u64) << 40);
    let base_seed = seed::derive_seed(seed, layout_salt);
    let mut room_rng = SimpleRng::new(seed::derive_seed(base_seed, 1));
    let mut graph_rng = SimpleRng::new(seed::derive_seed(base_seed, 2));
    let mut path_rng = SimpleRng::new(seed::derive_seed(base_seed, 3));
    let mut corridor_rng = SimpleRng::new(seed::derive_seed(base_seed, 4));

    let mut rooms = Vec::new();
    let mut corridors = Vec::new();

    if cols < 2 || rows < 2 || target_room_count == 0 {
        return DungeonLayout {
            rooms,
            corridors,
            doors: Vec::new(),
            packed_rooms: pack_rooms_without_corridors,
        };
    }

    let mut min_size = min_room_size.max(2);
    let mut max_size = max_room_size.max(min_size);

    if square_rooms_only {
        let hard_max = cols.min(rows);
        min_size = min_size.min(hard_max);
        max_size = max_size.min(hard_max);
    } else {
        min_size = min_size.min(cols.min(rows));
        max_size = max_size.min(cols.max(rows));
    }

    if min_size == 0 || max_size < min_size {
        return DungeonLayout {
            rooms,
            corridors,
            doors: Vec::new(),
            packed_rooms: pack_rooms_without_corridors,
        };
    }

    let room_sizes = generate_room_sizes(
        target_room_count,
        cols,
        rows,
        min_size,
        max_size,
        square_rooms_only,
        &mut room_rng,
    );
    let room_count = room_sizes.len();
    let centers = random_centers(room_count, cols, rows, &mut graph_rng);
    let randomness = (corridor_randomness_percent.min(100) as f32) / 100.0;
    let target_dead_end_rooms = ((room_count * dead_end_room_percent.min(50)) + 50) / 100;
    let room_edges =
        build_room_connection_edges(&centers, randomness, target_dead_end_rooms, &mut graph_rng);

    if pack_rooms_without_corridors {
        rooms = place_packed_rooms(&room_sizes, &room_edges, cols, rows, &mut room_rng);
        let mut layout = DungeonLayout {
            rooms,
            corridors,
            doors: Vec::new(),
            packed_rooms: true,
        };
        apply_doors(&mut layout, seed, door_settings, cols, rows);
        return layout;
    }

    let max_attempts = target_room_count.saturating_mul(40).max(50);

    for _ in 0..max_attempts {
        if rooms.len() >= target_room_count {
            break;
        }

        let (width, height) = if square_rooms_only {
            let side = room_rng.range_inclusive(min_size, max_size.min(cols.min(rows)));
            (side, side)
        } else {
            let width_max = max_size.min(cols);
            let height_max = max_size.min(rows);
            if min_size > width_max || min_size > height_max {
                continue;
            }
            (
                room_rng.range_inclusive(min_size, width_max),
                room_rng.range_inclusive(min_size, height_max),
            )
        };

        if width > cols || height > rows {
            continue;
        }

        let x = room_rng.range_inclusive(0, cols - width);
        let y = room_rng.range_inclusive(0, rows - height);
        let candidate = Room {
            x,
            y,
            width,
            height,
        };

        if rooms
            .iter()
            .all(|existing| !overlaps_with_padding(&candidate, existing, 1))
        {
            rooms.push(candidate);
        }
    }

    if rooms.len() < 2 {
        return DungeonLayout {
            rooms,
            corridors,
            doors: Vec::new(),
            packed_rooms: false,
        };
    }

    let mut min_width = min_corridor_width.max(1);
    let max_grid_width = cols.max(1).min(rows.max(1));
    let max_width = max_corridor_width.max(min_width).min(max_grid_width);
    min_width = min_width.min(max_width);
    let centers: Vec<(usize, usize)> = rooms.iter().map(Room::center_cell).collect();
    let target_dead_end_rooms = ((rooms.len() * dead_end_room_percent.min(50)) + 50) / 100;
    let room_edges =
        build_room_connection_edges(&centers, randomness, target_dead_end_rooms, &mut graph_rng);

    let mut next_corridor_id = 1u64;
    for (start_room_id, end_room_id) in room_edges {
        let start = centers[start_room_id];
        let end = centers[end_room_id];
        let blocked = blocked_room_cells(&rooms, &[start_room_id, end_room_id]);

        let path = if randomness <= 0.001 {
            shortest_path_cells(start, end, cols, rows, &blocked)
        } else {
            Some(noisy_path(
                start,
                end,
                cols,
                rows,
                randomness,
                &blocked,
                &mut path_rng,
            ))
        }
        .or_else(|| shortest_path_cells(start, end, cols, rows, &blocked));

        if let Some(path) = path
            && path.len() >= 2
        {
            corridors.push(Corridor {
                id: next_corridor_id,
                start_room_id,
                end_room_id,
                path,
                width: corridor_rng.range_inclusive(min_width, max_width),
            });
            next_corridor_id = next_corridor_id.wrapping_add(1);
        }
    }

    let mut layout = DungeonLayout {
        rooms,
        corridors,
        doors: Vec::new(),
        packed_rooms: false,
    };
    apply_doors(&mut layout, seed, door_settings, cols, rows);
    layout
}

// Populate layout doors based on corridor edges and door settings.
pub fn apply_doors(
    layout: &mut DungeonLayout,
    seed: u64,
    settings: DoorSettings,
    cols: usize,
    rows: usize,
) {
    layout.doors.clear();

    if layout.packed_rooms {
        apply_packed_room_doors(layout, seed, settings);
        return;
    }

    let mut rng = SimpleRng::new(seed::derive_seed(seed, 0xD005_5EED_u64));
    let base = (settings.frequency_percent.min(100) as f32) / 100.0;
    let room_hall = (settings.room_hallway_percent.min(100) as f32) / 100.0;
    let locked = (settings.locked_percent.min(100) as f32) / 100.0;

    let corridor_cells = corridor_cells(layout, cols, rows);
    let mut seen_edges = HashSet::new();
    let door_chance = base * room_hall;
    for corridor in &layout.corridors {
        if corridor.path.len() < 2 {
            continue;
        }

        let start_room = &layout.rooms[corridor.start_room_id];
        let end_room = &layout.rooms[corridor.end_room_id];

        if let Some(edge) = room_exit_edge(&corridor.path, start_room, true) {
            if seen_edges.insert(edge) {
                let place_door = door_chance > 0.0 && rng.next_f32() <= door_chance;
                layout.doors.push(Door {
                    from: edge.0,
                    to: edge.1,
                    width: corridor.width.max(1),
                    span_width: true,
                    locked: place_door && rng.next_f32() <= locked,
                    archway: !place_door,
                });
            }
        }

        if let Some(edge) = room_exit_edge(&corridor.path, end_room, false) {
            if seen_edges.insert(edge) {
                let place_door = door_chance > 0.0 && rng.next_f32() <= door_chance;
                layout.doors.push(Door {
                    from: edge.0,
                    to: edge.1,
                    width: corridor.width.max(1),
                    span_width: true,
                    locked: place_door && rng.next_f32() <= locked,
                    archway: !place_door,
                });
            }
        }

        for (room_idx, room) in layout.rooms.iter().enumerate() {
            if room_idx == corridor.start_room_id || room_idx == corridor.end_room_id {
                continue;
            }

            for edge in room_collision_edges(&corridor.path, room) {
                if seen_edges.insert(edge) {
                    let place_door = door_chance > 0.0 && rng.next_f32() <= door_chance;
                    layout.doors.push(Door {
                        from: edge.0,
                        to: edge.1,
                        width: corridor.width.max(1),
                        span_width: true,
                        locked: place_door && rng.next_f32() <= locked,
                        archway: !place_door,
                    });
                }
            }
        }
    }

    if settings.allow_middle_corridor_doors {
        for &(x, y) in &corridor_cells {
            let right = (x + 1, y);
            let bottom = (x, y + 1);
            if x + 1 < cols && corridor_cells.contains(&right) {
                let edge = normalized_cell_edge((x, y), right);
                if seen_edges.insert(edge) && base > 0.0 && rng.next_f32() <= base {
                    layout.doors.push(Door {
                        from: edge.0,
                        to: edge.1,
                        width: 1,
                        span_width: false,
                        locked: rng.next_f32() <= locked,
                        archway: false,
                    });
                }
            }
            if y + 1 < rows && corridor_cells.contains(&bottom) {
                let edge = normalized_cell_edge((x, y), bottom);
                if seen_edges.insert(edge) && base > 0.0 && rng.next_f32() <= base {
                    layout.doors.push(Door {
                        from: edge.0,
                        to: edge.1,
                        width: 1,
                        span_width: false,
                        locked: rng.next_f32() <= locked,
                        archway: false,
                    });
                }
            }
        }
    }
}

fn apply_packed_room_doors(layout: &mut DungeonLayout, seed: u64, settings: DoorSettings) {
    let mut rng = SimpleRng::new(seed::derive_seed(seed, 0xD005_5EED_u64));
    let door_chance = ((settings.frequency_percent.min(100) as f32) / 100.0)
        * ((settings.room_hallway_percent.min(100) as f32) / 100.0);
    let locked = (settings.locked_percent.min(100) as f32) / 100.0;

    for (a_idx, b_idx, shared_edges) in shared_room_boundaries(&layout.rooms) {
        let edge_idx = if shared_edges.len() <= 1 {
            0
        } else {
            rng.range_inclusive(0, shared_edges.len() - 1)
        };
        let edge = shared_edges[edge_idx];
        let place_door = door_chance > 0.0 && rng.next_f32() <= door_chance;

        let width = shared_opening_width(
            &layout.rooms[a_idx],
            &layout.rooms[b_idx],
            shared_edges.len(),
            1,
        );
        layout.doors.push(Door {
            from: edge.0,
            to: edge.1,
            width,
            span_width: width > 1,
            locked: place_door && rng.next_f32() <= locked,
            archway: !place_door,
        });
    }
}

// Find the edge where a corridor path exits a room.
fn room_exit_edge(
    path: &[(usize, usize)],
    room: &Room,
    from_start: bool,
) -> Option<((usize, usize), (usize, usize))> {
    let in_room = |cell: (usize, usize)| {
        cell.0 >= room.x
            && cell.0 < room.x + room.width
            && cell.1 >= room.y
            && cell.1 < room.y + room.height
    };

    if from_start {
        for pair in path.windows(2) {
            if in_room(pair[0]) && !in_room(pair[1]) {
                return Some(normalized_cell_edge(pair[0], pair[1]));
            }
        }
    } else {
        for pair in path.windows(2).rev() {
            if in_room(pair[1]) && !in_room(pair[0]) {
                return Some(normalized_cell_edge(pair[0], pair[1]));
            }
        }
    }

    None
}

// Find every edge where a corridor path crosses into or out of a room.
fn room_collision_edges(
    path: &[(usize, usize)],
    room: &Room,
) -> Vec<((usize, usize), (usize, usize))> {
    let in_room = |cell: (usize, usize)| {
        cell.0 >= room.x
            && cell.0 < room.x + room.width
            && cell.1 >= room.y
            && cell.1 < room.y + room.height
    };

    let mut edges = Vec::new();
    let mut seen = HashSet::new();
    for pair in path.windows(2) {
        let a_in_room = in_room(pair[0]);
        let b_in_room = in_room(pair[1]);
        if a_in_room == b_in_room {
            continue;
        }

        let edge = normalized_cell_edge(pair[0], pair[1]);
        if seen.insert(edge) {
            edges.push(edge);
        }
    }

    edges
}

fn shared_room_boundaries(
    rooms: &[Room],
) -> Vec<(usize, usize, Vec<((usize, usize), (usize, usize))>)> {
    let mut boundaries = Vec::new();
    for a_idx in 0..rooms.len() {
        for b_idx in (a_idx + 1)..rooms.len() {
            let shared_edges = shared_boundary_edges(&rooms[a_idx], &rooms[b_idx]);
            if !shared_edges.is_empty() {
                boundaries.push((a_idx, b_idx, shared_edges));
            }
        }
    }
    boundaries
}

fn shared_boundary_edges(a: &Room, b: &Room) -> Vec<((usize, usize), (usize, usize))> {
    let mut edges = Vec::new();

    if a.x + a.width == b.x || b.x + b.width == a.x {
        let left = if a.x < b.x { a } else { b };
        let right = if a.x < b.x { b } else { a };
        let y0 = left.y.max(right.y);
        let y1 = (left.y + left.height).min(right.y + right.height);
        for y in y0..y1 {
            edges.push(normalized_cell_edge(
                (left.x + left.width - 1, y),
                (right.x, y),
            ));
        }
    }

    if a.y + a.height == b.y || b.y + b.height == a.y {
        let top = if a.y < b.y { a } else { b };
        let bottom = if a.y < b.y { b } else { a };
        let x0 = top.x.max(bottom.x);
        let x1 = (top.x + top.width).min(bottom.x + bottom.width);
        for x in x0..x1 {
            edges.push(normalized_cell_edge(
                (x, top.y + top.height - 1),
                (x, bottom.y),
            ));
        }
    }

    edges
}

// Compute corridor cells while excluding room cells.
pub fn corridor_cells(layout: &DungeonLayout, cols: usize, rows: usize) -> HashSet<(usize, usize)> {
    let mut cells = HashSet::new();
    if cols == 0 || rows == 0 {
        return cells;
    }

    let mut room_cells = HashSet::new();
    for room in &layout.rooms {
        for x in room.x..(room.x + room.width) {
            for y in room.y..(room.y + room.height) {
                room_cells.insert((x, y));
            }
        }
    }

    for corridor in &layout.corridors {
        let width = corridor.width.max(1);
        let min_offset = -((width as isize - 1) / 2);
        let max_offset = width as isize / 2;
        if corridor.path.len() == 1 {
            let (x, y) = corridor.path[0];
            for dy in min_offset..=max_offset {
                let ny = y as isize + dy;
                if ny < 0 || ny >= rows as isize {
                    continue;
                }
                let cell = (x, ny as usize);
                if !room_cells.contains(&cell) {
                    cells.insert(cell);
                }
            }
            continue;
        }

        for pair in corridor.path.windows(2) {
            let a = pair[0];
            let b = pair[1];
            if a == b {
                continue;
            }

            if a.0 != b.0 {
                let x0 = a.0.min(b.0);
                let x1 = a.0.max(b.0);
                let y = a.1 as isize;
                for x in x0..=x1 {
                    for dy in min_offset..=max_offset {
                        let ny = y + dy;
                        if ny < 0 || ny >= rows as isize {
                            continue;
                        }
                        let cell = (x, ny as usize);
                        if !room_cells.contains(&cell) {
                            cells.insert(cell);
                        }
                    }
                }
            } else {
                let y0 = a.1.min(b.1);
                let y1 = a.1.max(b.1);
                let x = a.0 as isize;
                for y in y0..=y1 {
                    for dx in min_offset..=max_offset {
                        let nx = x + dx;
                        if nx < 0 || nx >= cols as isize {
                            continue;
                        }
                        let cell = (nx as usize, y);
                        if !room_cells.contains(&cell) {
                            cells.insert(cell);
                        }
                    }
                }
            }
        }

        for turn in corridor.path.windows(3) {
            let prev = turn[0];
            let corner = turn[1];
            let next = turn[2];
            let incoming = (
                corner.0 as isize - prev.0 as isize,
                corner.1 as isize - prev.1 as isize,
            );
            let outgoing = (
                next.0 as isize - corner.0 as isize,
                next.1 as isize - corner.1 as isize,
            );
            if incoming == outgoing {
                continue;
            }

            for dx in min_offset..=max_offset {
                let nx = corner.0 as isize + dx;
                if nx < 0 || nx >= cols as isize {
                    continue;
                }
                for dy in min_offset..=max_offset {
                    let ny = corner.1 as isize + dy;
                    if ny < 0 || ny >= rows as isize {
                        continue;
                    }

                    let cell = (nx as usize, ny as usize);
                    if !room_cells.contains(&cell) {
                        cells.insert(cell);
                    }
                }
            }
        }
    }

    cells
}

fn generate_room_sizes(
    target_room_count: usize,
    cols: usize,
    rows: usize,
    min_size: usize,
    max_size: usize,
    square_rooms_only: bool,
    rng: &mut SimpleRng,
) -> Vec<(usize, usize)> {
    let mut sizes = Vec::new();
    let max_attempts = target_room_count.saturating_mul(40).max(50);

    for _ in 0..max_attempts {
        if sizes.len() >= target_room_count {
            break;
        }

        let (width, height) = if square_rooms_only {
            let side = rng.range_inclusive(min_size, max_size.min(cols.min(rows)));
            (side, side)
        } else {
            let width_max = max_size.min(cols);
            let height_max = max_size.min(rows);
            if min_size > width_max || min_size > height_max {
                continue;
            }
            (
                rng.range_inclusive(min_size, width_max),
                rng.range_inclusive(min_size, height_max),
            )
        };

        if width <= cols && height <= rows {
            sizes.push((width, height));
        }
    }

    sizes
}

fn random_centers(
    count: usize,
    cols: usize,
    rows: usize,
    rng: &mut SimpleRng,
) -> Vec<(usize, usize)> {
    let mut centers = Vec::with_capacity(count);
    for _ in 0..count {
        centers.push((
            rng.range_inclusive(0, cols.saturating_sub(1)),
            rng.range_inclusive(0, rows.saturating_sub(1)),
        ));
    }
    centers
}

fn place_packed_rooms(
    room_sizes: &[(usize, usize)],
    room_edges: &[(usize, usize)],
    cols: usize,
    rows: usize,
    rng: &mut SimpleRng,
) -> Vec<Room> {
    if room_sizes.is_empty() || cols == 0 || rows == 0 {
        return Vec::new();
    }

    let mut placed: Vec<Option<Room>> = vec![None; room_sizes.len()];
    let (first_w, first_h) = room_sizes[0];
    if first_w > cols || first_h > rows {
        return Vec::new();
    }

    placed[0] = Some(Room {
        x: (cols.saturating_sub(first_w)) / 2,
        y: (rows.saturating_sub(first_h)) / 2,
        width: first_w,
        height: first_h,
    });

    let mut order = placement_order(room_sizes.len(), room_edges);
    if !order.contains(&0) {
        order.insert(0, 0);
    }

    for room_idx in order.into_iter().skip(1) {
        let Some(room) =
            try_place_packed_room(room_idx, room_sizes, room_edges, &placed, cols, rows, rng)
        else {
            continue;
        };
        placed[room_idx] = Some(room);
    }

    for room_idx in 0..room_sizes.len() {
        if placed[room_idx].is_some() {
            continue;
        }
        if let Some(room) =
            try_place_packed_room(room_idx, room_sizes, room_edges, &placed, cols, rows, rng)
        {
            placed[room_idx] = Some(room);
        }
    }

    placed.into_iter().flatten().collect()
}

fn placement_order(room_count: usize, room_edges: &[(usize, usize)]) -> Vec<usize> {
    if room_count == 0 {
        return Vec::new();
    }

    let mut adjacency = vec![Vec::new(); room_count];
    for &(a, b) in room_edges {
        adjacency[a].push(b);
        adjacency[b].push(a);
    }

    let mut visited = vec![false; room_count];
    let mut queue = VecDeque::new();
    let mut order = Vec::with_capacity(room_count);
    queue.push_back(0);
    visited[0] = true;

    while let Some(idx) = queue.pop_front() {
        order.push(idx);
        for &next in &adjacency[idx] {
            if !visited[next] {
                visited[next] = true;
                queue.push_back(next);
            }
        }
    }

    for idx in 0..room_count {
        if !visited[idx] {
            order.push(idx);
        }
    }

    order
}

fn try_place_packed_room(
    room_idx: usize,
    room_sizes: &[(usize, usize)],
    room_edges: &[(usize, usize)],
    placed: &[Option<Room>],
    cols: usize,
    rows: usize,
    rng: &mut SimpleRng,
) -> Option<Room> {
    let (width, height) = *room_sizes.get(room_idx)?;
    if width > cols || height > rows {
        return None;
    }

    let mut anchors: Vec<usize> = room_edges
        .iter()
        .filter_map(|&(a, b)| {
            if a == room_idx && placed.get(b)?.is_some() {
                Some(b)
            } else if b == room_idx && placed.get(a)?.is_some() {
                Some(a)
            } else {
                None
            }
        })
        .collect();

    if anchors.is_empty() {
        anchors = placed
            .iter()
            .enumerate()
            .filter_map(|(idx, room)| room.as_ref().map(|_| idx))
            .collect();
    }

    shuffle_indices(&mut anchors, rng);

    for anchor_idx in anchors {
        let Some(anchor) = placed.get(anchor_idx).and_then(|room| room.as_ref()) else {
            continue;
        };
        let mut candidates = packed_room_candidates(anchor, width, height, cols, rows);
        shuffle_rooms(&mut candidates, rng);

        for candidate in candidates {
            if placed
                .iter()
                .flatten()
                .all(|existing| !rooms_overlap(&candidate, existing))
                && placed
                    .iter()
                    .flatten()
                    .any(|existing| rooms_touch(&candidate, existing))
            {
                return Some(candidate);
            }
        }
    }

    None
}

fn packed_room_candidates(
    anchor: &Room,
    width: usize,
    height: usize,
    cols: usize,
    rows: usize,
) -> Vec<Room> {
    let mut candidates = Vec::new();

    let min_y = anchor.y.saturating_sub(height.saturating_sub(1));
    let max_y = (anchor.y + anchor.height).saturating_sub(1);
    for y in min_y..=max_y {
        candidates.push(Room {
            x: anchor.x.saturating_sub(width),
            y,
            width,
            height,
        });
        candidates.push(Room {
            x: anchor.x + anchor.width,
            y,
            width,
            height,
        });
    }

    let min_x = anchor.x.saturating_sub(width.saturating_sub(1));
    let max_x = (anchor.x + anchor.width).saturating_sub(1);
    for x in min_x..=max_x {
        candidates.push(Room {
            x,
            y: anchor.y.saturating_sub(height),
            width,
            height,
        });
        candidates.push(Room {
            x,
            y: anchor.y + anchor.height,
            width,
            height,
        });
    }

    candidates.retain(|room| room.x + room.width <= cols && room.y + room.height <= rows);
    candidates
}

fn shuffle_rooms(rooms: &mut [Room], rng: &mut SimpleRng) {
    if rooms.len() <= 1 {
        return;
    }
    for i in (1..rooms.len()).rev() {
        let j = rng.range_inclusive(0, i);
        rooms.swap(i, j);
    }
}

fn rooms_overlap(a: &Room, b: &Room) -> bool {
    let a_right = a.x + a.width;
    let a_bottom = a.y + a.height;
    let b_right = b.x + b.width;
    let b_bottom = b.y + b.height;

    a.x < b_right && a_right > b.x && a.y < b_bottom && a_bottom > b.y
}

fn rooms_touch(a: &Room, b: &Room) -> bool {
    !shared_boundary_edges(a, b).is_empty()
}

fn shared_opening_width(a: &Room, b: &Room, span: usize, default_width: usize) -> usize {
    let max_width = if a.x + a.width == b.x || b.x + b.width == a.x {
        a.height.min(b.height)
    } else {
        a.width.min(b.width)
    };
    default_width.max(1).min(span).min(max_width.max(1))
}

// Create a connected graph of room-to-room edges with optional dead ends.
fn build_room_connection_edges(
    centers: &[(usize, usize)],
    randomness: f32,
    target_dead_end_rooms: usize,
    rng: &mut SimpleRng,
) -> Vec<(usize, usize)> {
    if centers.len() < 2 {
        return Vec::new();
    }

    let room_count = centers.len();
    let max_dead_ends = room_count / 2;
    let desired_dead_ends = target_dead_end_rooms.min(max_dead_ends);
    let core_count = (room_count - desired_dead_ends).max(1);

    let mut room_indices: Vec<usize> = (0..room_count).collect();
    shuffle_indices(&mut room_indices, rng);

    let mut core_rooms = room_indices[..core_count].to_vec();
    let leaf_rooms = room_indices[core_count..].to_vec();
    core_rooms = ordered_core_rooms(&core_rooms, centers, randomness, rng);

    let mut edges = Vec::new();
    let mut edge_set = HashSet::new();

    if core_rooms.len() >= 2 {
        for pair in core_rooms.windows(2) {
            push_unique_room_edge(pair[0], pair[1], &mut edges, &mut edge_set);
        }

        if core_rooms.len() >= 3 {
            push_unique_room_edge(
                core_rooms[core_rooms.len() - 1],
                core_rooms[0],
                &mut edges,
                &mut edge_set,
            );
        }
    }

    for leaf in leaf_rooms {
        let mut best_anchor = core_rooms[0];
        let mut best_score = f32::INFINITY;

        for &core in &core_rooms {
            let dist = manhattan_distance(centers[leaf], centers[core]) as f32;
            let score = (dist * (1.0 - 0.8 * randomness)) + (rng.next_f32() * 30.0 * randomness);
            if score < best_score {
                best_score = score;
                best_anchor = core;
            }
        }

        push_unique_room_edge(leaf, best_anchor, &mut edges, &mut edge_set);
    }

    edges
}

// Order core rooms to create a reasonable loop backbone.
fn ordered_core_rooms(
    core_rooms: &[usize],
    centers: &[(usize, usize)],
    randomness: f32,
    rng: &mut SimpleRng,
) -> Vec<usize> {
    if core_rooms.len() <= 2 {
        return core_rooms.to_vec();
    }

    let mut remaining = core_rooms.to_vec();
    let start_idx = rng.range_inclusive(0, remaining.len() - 1);
    let mut ordered = vec![remaining.swap_remove(start_idx)];

    while !remaining.is_empty() {
        let last = *ordered.last().unwrap_or(&remaining[0]);
        let mut best_idx = 0usize;
        let mut best_score = f32::INFINITY;

        for (idx, candidate) in remaining.iter().enumerate() {
            let dist = manhattan_distance(centers[last], centers[*candidate]) as f32;
            let score = (dist * (1.0 - 0.85 * randomness)) + (rng.next_f32() * 20.0 * randomness);
            if score < best_score {
                best_score = score;
                best_idx = idx;
            }
        }

        ordered.push(remaining.swap_remove(best_idx));
    }

    ordered
}

// Insert a room edge only if it has not been added yet.
fn push_unique_room_edge(
    a: usize,
    b: usize,
    edges: &mut Vec<(usize, usize)>,
    edge_set: &mut HashSet<(usize, usize)>,
) {
    if a == b {
        return;
    }
    let normalized = if a < b { (a, b) } else { (b, a) };
    if edge_set.insert(normalized) {
        edges.push((a, b));
    }
}

// Shuffle indices in place using the provided RNG.
fn shuffle_indices(indices: &mut [usize], rng: &mut SimpleRng) {
    if indices.len() <= 1 {
        return;
    }
    for i in (1..indices.len()).rev() {
        let j = rng.range_inclusive(0, i);
        indices.swap(i, j);
    }
}

// Compute the shortest grid path between two cells using BFS.
pub fn shortest_path_cells(
    start: (usize, usize),
    end: (usize, usize),
    cols: usize,
    rows: usize,
    blocked: &HashSet<(usize, usize)>,
) -> Option<Vec<(usize, usize)>> {
    if start == end {
        return Some(vec![start]);
    }
    if blocked.contains(&start) || blocked.contains(&end) {
        return None;
    }

    let total = cols.saturating_mul(rows);
    if total == 0 {
        return None;
    }

    let index = |p: (usize, usize)| -> usize { p.1 * cols + p.0 };
    let coord = |idx: usize| -> (usize, usize) { (idx % cols, idx / cols) };

    let start_idx = index(start);
    let end_idx = index(end);

    let mut queue = VecDeque::new();
    let mut visited = vec![false; total];
    let mut parent: Vec<Option<usize>> = vec![None; total];

    visited[start_idx] = true;
    queue.push_back(start_idx);

    while let Some(current) = queue.pop_front() {
        if current == end_idx {
            break;
        }

        let (x, y) = coord(current);
        let neighbors = [
            x.checked_sub(1).map(|nx| (nx, y)),
            (x + 1 < cols).then_some((x + 1, y)),
            y.checked_sub(1).map(|ny| (x, ny)),
            (y + 1 < rows).then_some((x, y + 1)),
        ];

        for neighbor in neighbors.into_iter().flatten() {
            if blocked.contains(&neighbor) {
                continue;
            }
            let n_idx = index(neighbor);
            if !visited[n_idx] {
                visited[n_idx] = true;
                parent[n_idx] = Some(current);
                queue.push_back(n_idx);
            }
        }
    }

    if !visited[end_idx] {
        return None;
    }

    let mut path = Vec::new();
    let mut current = end_idx;
    path.push(coord(current));

    while let Some(prev) = parent[current] {
        current = prev;
        path.push(coord(current));
    }

    path.reverse();
    Some(path)
}

// Generate a noisy path biased toward the target cell.
fn noisy_path(
    start: (usize, usize),
    end: (usize, usize),
    cols: usize,
    rows: usize,
    randomness: f32,
    blocked: &HashSet<(usize, usize)>,
    rng: &mut SimpleRng,
) -> Vec<(usize, usize)> {
    if start == end {
        return vec![start];
    }

    let mut path = vec![start];
    let mut visited = HashSet::new();
    visited.insert(start);

    let mut current = start;
    let mut prev_dir = (0isize, 0isize);
    let max_steps = cols.saturating_mul(rows).max(32);

    for _ in 0..max_steps {
        if current == end {
            break;
        }

        let mut neighbors = Vec::with_capacity(4);
        let (x, y) = current;
        if x > 0 {
            neighbors.push((x - 1, y));
        }
        if x + 1 < cols {
            neighbors.push((x + 1, y));
        }
        if y > 0 {
            neighbors.push((x, y - 1));
        }
        if y + 1 < rows {
            neighbors.push((x, y + 1));
        }

        if neighbors.is_empty() {
            break;
        }

        let mut best = neighbors[0];
        let mut best_score = f32::INFINITY;

        for &candidate in &neighbors {
            if blocked.contains(&candidate) && candidate != end {
                continue;
            }

            let step_dir = (
                candidate.0 as isize - current.0 as isize,
                candidate.1 as isize - current.1 as isize,
            );

            let dist = manhattan_distance(candidate, end) as f32;
            let progress_weight = 1.0 - (0.85 * randomness);
            let revisit_penalty = if visited.contains(&candidate) {
                2.5 + (2.0 * randomness)
            } else {
                0.0
            };
            let turn_penalty = if prev_dir == (0, 0) || prev_dir == step_dir {
                0.0
            } else {
                0.6 - (0.35 * randomness)
            };
            let noise = rng.next_f32() * 8.0 * randomness;
            let score = (dist * progress_weight) + revisit_penalty + turn_penalty + noise;

            if score < best_score {
                best_score = score;
                best = candidate;
            }
        }

        prev_dir = (
            best.0 as isize - current.0 as isize,
            best.1 as isize - current.1 as isize,
        );
        current = best;
        path.push(current);
        visited.insert(current);
    }

    if current != end
        && let Some(tail) = shortest_path_cells(current, end, cols, rows, blocked)
    {
        for &cell in tail.iter().skip(1) {
            path.push(cell);
        }
    }

    path
}

// Test whether two rooms overlap with extra padding.
fn overlaps_with_padding(a: &Room, b: &Room, padding: usize) -> bool {
    let a_left = a.x.saturating_sub(padding);
    let a_top = a.y.saturating_sub(padding);
    let a_right = a.x + a.width + padding;
    let a_bottom = a.y + a.height + padding;

    let b_left = b.x;
    let b_top = b.y;
    let b_right = b.x + b.width;
    let b_bottom = b.y + b.height;

    a_left < b_right && a_right > b_left && a_top < b_bottom && a_bottom > b_top
}

// Compute Manhattan distance between two grid cells.
fn manhattan_distance(a: (usize, usize), b: (usize, usize)) -> usize {
    a.0.abs_diff(b.0) + a.1.abs_diff(b.1)
}

// Normalize a cell edge ordering.
fn normalized_cell_edge(a: (usize, usize), b: (usize, usize)) -> ((usize, usize), (usize, usize)) {
    if a <= b { (a, b) } else { (b, a) }
}

struct SimpleRng {
    state: u64,
}

impl SimpleRng {
    // Create a small deterministic RNG with a fallback seed.
    fn new(seed: u64) -> Self {
        let state = if seed == 0 {
            0xA5A5_A5A5_1234_5678
        } else {
            seed
        };
        Self { state }
    }

    // Return the next random u32.
    fn next_u32(&mut self) -> u32 {
        self.state ^= self.state >> 12;
        self.state ^= self.state << 25;
        self.state ^= self.state >> 27;
        (self.state.wrapping_mul(0x2545_F491_4F6C_DD1D) >> 32) as u32
    }

    // Return the next random f32 in [0,1].
    fn next_f32(&mut self) -> f32 {
        self.next_u32() as f32 / u32::MAX as f32
    }

    // Generate a random usize between min and max inclusive.
    fn range_inclusive(&mut self, min: usize, max: usize) -> usize {
        if min >= max {
            return min;
        }
        let width = max - min + 1;
        min + (self.next_u32() as usize % width)
    }
}