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

use bevy::prelude::*;

use crate::{
    building::{Blueprints, BuildKind, MAX_ROOM_TILES},
    colonist::Colonist,
    sim::{SimSystems, SimTick},
    structures::{Structure, StructureKind},
    world::{Terrain, TilePos, WorldMap},
    worldgen::WorldGenerated,
};

pub struct RoomsPlugin;

impl Plugin for RoomsPlugin {
    fn build(&self, app: &mut App) {
        app.init_resource::<Rooms>()
            .add_systems(Update, clear_rooms.run_if(on_message::<WorldGenerated>))
            .add_systems(
                FixedUpdate,
                (update_rooms, (roof_rooms, remove_bad_doors))
                    .chain()
                    .in_set(SimSystems::Decide),
            );
    }
}

pub const MIN_ROOM_TILES: usize = 4;
const ROOM_CHECK_TICKS: u64 = 60;
const ROOM_PLAN_TICKS: u64 = 300;
const CROWDED_TILES_PER_BED: usize = 3;
const SIDES: [IVec2; 4] = [IVec2::X, IVec2::NEG_X, IVec2::Y, IVec2::NEG_Y];

#[derive(Debug, Clone, PartialEq)]
pub struct Room {
    pub tiles: Vec<UVec2>,
    pub doors: Vec<UVec2>,
    pub quality: f32,
}

impl Room {
    pub fn bounds(&self) -> (UVec2, UVec2) {
        let lo = self.tiles.iter().fold(UVec2::MAX, |a, t| a.min(*t));
        let hi = self.tiles.iter().fold(UVec2::ZERO, |a, t| a.max(*t));
        (lo, hi)
    }

    pub fn is_rectangle(&self) -> bool {
        let (lo, hi) = self.bounds();
        (hi - lo + UVec2::ONE).element_product() as usize == self.tiles.len()
    }
}

#[derive(Resource, Default, Debug)]
pub struct Rooms {
    pub rooms: Vec<Room>,
    by_tile: HashMap<UVec2, usize>,
    shape: Option<(u64, Vec<UVec2>)>,
}

impl Rooms {
    pub fn at(&self, tile: UVec2) -> Option<&Room> {
        self.by_tile.get(&tile).map(|&i| &self.rooms[i])
    }

    pub fn contains(&self, tile: UVec2) -> bool {
        self.by_tile.contains_key(&tile)
    }

    pub fn detect(map: &WorldMap, doors: &HashSet<UVec2>) -> Self {
        let detected = detect_rooms(map, doors);
        Self {
            by_tile: detected
                .iter()
                .enumerate()
                .flat_map(|(i, (tiles, _))| tiles.iter().map(move |t| (*t, i)))
                .collect(),
            rooms: detected
                .into_iter()
                .map(|(tiles, doors)| Room {
                    tiles,
                    doors,
                    quality: 0.0,
                })
                .collect(),
            shape: None,
        }
    }
}

fn clear_rooms(mut rooms: ResMut<Rooms>) {
    *rooms = Rooms::default();
}

pub fn blocks_room(map: &WorldMap, doors: &HashSet<UVec2>, tile: IVec2) -> bool {
    !map.in_bounds(tile)
        || map.is_wall(tile)
        || doors.contains(&tile.as_uvec2())
        || map.get(tile).is_none_or(|t| t.move_cost().is_none())
}

pub fn detect_rooms(map: &WorldMap, doors: &HashSet<UVec2>) -> Vec<(Vec<UVec2>, Vec<UVec2>)> {
    let width = map.size.x;
    let index = |p: UVec2| (p.y * width + p.x) as usize;
    let mut seen = vec![false; map.size.element_product() as usize];
    let mut rooms = Vec::new();
    for start in map.positions() {
        if seen[index(start)] || blocks_room(map, doors, start.as_ivec2()) {
            continue;
        }
        seen[index(start)] = true;
        let mut region = vec![start];
        let mut room_doors = HashSet::new();
        let mut outdoors = false;
        let mut queue = VecDeque::from([start]);
        while let Some(tile) = queue.pop_front() {
            for side in SIDES {
                let next = tile.as_ivec2() + side;
                if !map.in_bounds(next) {
                    outdoors = true;
                    continue;
                }
                let next_u = next.as_uvec2();
                if doors.contains(&next_u) {
                    room_doors.insert(next_u);
                }
                if blocks_room(map, doors, next) || seen[index(next_u)] {
                    continue;
                }
                seen[index(next_u)] = true;
                region.push(next_u);
                queue.push_back(next_u);
            }
        }
        let size = region.len();
        if !outdoors && size >= MIN_ROOM_TILES && size <= MAX_ROOM_TILES && !room_doors.is_empty() {
            region.sort_by_key(|t| (t.y, t.x));
            let mut room_doors: Vec<UVec2> = room_doors.into_iter().collect();
            room_doors.sort_by_key(|t| (t.y, t.x));
            rooms.push((region, room_doors));
        }
    }
    rooms
}

#[derive(Debug, Default, Clone, Copy)]
pub struct Furnishing {
    pub beds: usize,
    pub statue: bool,
    pub hearth: bool,
}

pub fn room_quality(map: &WorldMap, tiles: &[UVec2], furnishing: Furnishing) -> f32 {
    let n = tiles.len().max(1) as f32;
    let share =
        |test: &dyn Fn(UVec2) -> bool| tiles.iter().filter(|t| test(**t)).count() as f32 / n;
    let floor = share(&|t| map.get(t.as_ivec2()) == Some(Terrain::WoodFloor));
    let roofed = share(&|t| map.is_roofed(t.as_ivec2()));
    let space = (n / 16.0).min(1.0);
    let crowded = furnishing.beds * CROWDED_TILES_PER_BED > tiles.len();
    let quality = 0.1
        + 0.2 * space
        + 0.25 * floor
        + 0.15 * roofed
        + if furnishing.statue { 0.2 } else { 0.0 }
        + if furnishing.hearth { 0.1 } else { 0.0 }
        - if crowded { 0.2 } else { 0.0 };
    quality.clamp(0.0, 1.0)
}

#[allow(clippy::type_complexity)]
fn update_rooms(
    tick: Res<SimTick>,
    map: Res<WorldMap>,
    structures: Query<(&TilePos, &Structure), Without<Colonist>>,
    mut rooms: ResMut<Rooms>,
) {
    if !tick.0.is_multiple_of(ROOM_CHECK_TICKS) {
        return;
    }
    let mut doors: Vec<UVec2> = structures
        .iter()
        .filter(|(_, s)| s.kind == StructureKind::Door)
        .map(|(pos, _)| pos.0)
        .collect();
    doors.sort_by_key(|t| (t.y, t.x));
    let shape = (map.shape_version(), doors.clone());
    if rooms.shape.as_ref() != Some(&shape) {
        let door_set: HashSet<UVec2> = doors.into_iter().collect();
        *rooms = Rooms::detect(&map, &door_set);
        rooms.shape = Some(shape);
    } else if !tick.0.is_multiple_of(ROOM_PLAN_TICKS) {
        return;
    }
    let mut furnishing = vec![Furnishing::default(); rooms.rooms.len()];
    for (pos, structure) in &structures {
        let Some(&i) = rooms.by_tile.get(&pos.0) else {
            continue;
        };
        match structure.kind {
            StructureKind::Bed => furnishing[i].beds += 1,
            StructureKind::Statue => furnishing[i].statue = true,
            StructureKind::Hearth => furnishing[i].hearth = true,
            _ => {}
        }
    }
    for (room, furnishing) in rooms.rooms.iter_mut().zip(furnishing) {
        room.quality = room_quality(&map, &room.tiles, furnishing);
    }
}

fn roof_rooms(
    tick: Res<SimTick>,
    map: Res<WorldMap>,
    rooms: Res<Rooms>,
    structures: Query<(&TilePos, &Structure), Without<Colonist>>,
    mut blueprints: ResMut<Blueprints>,
) {
    if !tick.0.is_multiple_of(ROOM_PLAN_TICKS) {
        return;
    }
    let lived_in: HashSet<*const Room> = structures
        .iter()
        .filter(|(_, s)| matches!(s.kind, StructureKind::Bed | StructureKind::Hearth))
        .filter_map(|(pos, _)| rooms.at(pos.0))
        .map(|room| room as *const Room)
        .collect();
    for room in &rooms.rooms {
        if !lived_in.contains(&(room as *const Room)) {
            continue;
        }
        for &tile in &room.tiles {
            if !map.is_roofed(tile.as_ivec2()) && blueprints.get(tile).is_none() {
                blueprints.0.insert(tile, BuildKind::Roof);
            }
        }
    }
}

pub fn bad_door(map: &WorldMap, door: UVec2) -> bool {
    let blocked = SIDES
        .iter()
        .filter(|side| {
            let next = door.as_ivec2() + **side;
            !map.in_bounds(next) || map.move_cost(next).is_none()
        })
        .count();
    blocked >= 3
}

fn remove_bad_doors(
    tick: Res<SimTick>,
    map: Res<WorldMap>,
    structures: Query<(&TilePos, &Structure), Without<Colonist>>,
    mut blueprints: ResMut<Blueprints>,
) {
    if !tick.0.is_multiple_of(ROOM_PLAN_TICKS) {
        return;
    }
    for (pos, structure) in &structures {
        if structure.kind == StructureKind::Door
            && bad_door(&map, pos.0)
            && blueprints.get(pos.0).is_none()
        {
            blueprints.0.insert(pos.0, BuildKind::Deconstruct);
        }
    }
}

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

    fn walled(map: &mut WorldMap, lo: UVec2, hi: UVec2) {
        for y in lo.y..=hi.y {
            for x in lo.x..=hi.x {
                if x == lo.x || x == hi.x || y == lo.y || y == hi.y {
                    map.set_wall(UVec2::new(x, y), true);
                }
            }
        }
    }

    // Rooms come from the map, not from plans: any enclosed space with a door that is big enough
    // and small enough to roof counts, however and in whatever order it was built, and two rooms
    // can share a wall.
    #[test]
    fn rooms_are_enclosed_spaces_with_a_door() {
        let mut map = WorldMap::filled(UVec2::splat(30), Terrain::Grass);
        walled(&mut map, UVec2::new(2, 2), UVec2::new(6, 5));
        walled(&mut map, UVec2::new(6, 2), UVec2::new(10, 5));
        walled(&mut map, UVec2::new(15, 15), UVec2::new(18, 18));
        let doors = [UVec2::new(4, 2), UVec2::new(8, 2)];
        for door in doors {
            map.set_wall(door, false);
        }
        let rooms = detect_rooms(&map, &doors.into_iter().collect());
        assert_eq!(rooms.len(), 2);
        assert!(
            rooms
                .iter()
                .all(|(tiles, doors)| tiles.len() == 6 && doors.len() == 1)
        );
    }

    #[test]
    fn quality_rewards_floors_furniture_and_space() {
        let mut map = WorldMap::filled(UVec2::splat(10), Terrain::Grass);
        let tiles: Vec<UVec2> = (1..5)
            .flat_map(|y| (1..5).map(move |x| UVec2::new(x, y)))
            .collect();
        let bare = room_quality(&map, &tiles, Furnishing::default());
        for &t in &tiles {
            map.set(t, Terrain::WoodFloor);
            map.set_roof(t, true);
        }
        let furnished = Furnishing {
            beds: 2,
            statue: true,
            hearth: true,
        };
        let nice = room_quality(&map, &tiles, furnished);
        assert!(nice > bare + 0.5, "{bare} {nice}");
        let packed = Furnishing {
            beds: 6,
            ..furnished
        };
        assert!(room_quality(&map, &tiles, packed) < nice);
    }

    // A door needs walls on two opposite sides and open ground on the others to be passable; one
    // boxed in by walls on three sides leads nowhere and gets taken down.
    #[test]
    fn doors_walled_in_on_three_sides_are_bad() {
        let mut map = WorldMap::filled(UVec2::splat(10), Terrain::Grass);
        map.set_wall(UVec2::new(4, 5), true);
        map.set_wall(UVec2::new(6, 5), true);
        assert!(!bad_door(&map, UVec2::new(5, 5)));
        map.set_wall(UVec2::new(5, 6), true);
        assert!(bad_door(&map, UVec2::new(5, 5)));
    }

    // A room built by hand, wall by wall, gets a roof once it has a bed in it; a door boxed in
    // on three sides gets taken down.
    #[test]
    fn lived_in_rooms_are_roofed_and_bad_doors_removed() {
        let mut map = WorldMap::filled(UVec2::splat(20), Terrain::Grass);
        walled(&mut map, UVec2::new(2, 2), UVec2::new(6, 5));
        let door = UVec2::new(4, 2);
        map.set_wall(door, false);
        let boxed = UVec2::new(12, 12);
        for side in [IVec2::X, IVec2::NEG_X, IVec2::Y] {
            map.set_wall((boxed.as_ivec2() + side).as_uvec2(), true);
        }
        let mut app = App::new();
        app.insert_resource(map)
            .init_resource::<SimTick>()
            .init_resource::<Rooms>()
            .init_resource::<Blueprints>()
            .add_systems(Update, (update_rooms, roof_rooms, remove_bad_doors).chain());
        let structure = |kind| Structure { kind };
        let world = app.world_mut();
        world.spawn((structure(StructureKind::Door), TilePos(door)));
        world.spawn((structure(StructureKind::Door), TilePos(boxed)));
        world.spawn((structure(StructureKind::Bed), TilePos(UVec2::new(3, 3))));
        app.update();
        let blueprints = app.world().resource::<Blueprints>();
        let roofs = blueprints
            .0
            .values()
            .filter(|k| **k == BuildKind::Roof)
            .count();
        assert_eq!(roofs, 6);
        assert_eq!(blueprints.get(boxed), Some(BuildKind::Deconstruct));
        assert_eq!(blueprints.get(door), None);
        let rooms = app.world().resource::<Rooms>();
        assert!(rooms.at(UVec2::new(3, 3)).is_some_and(|r| r.quality > 0.0));
    }
}