use std::collections::VecDeque;

use super::*;
use crate::{
    animals::{Animal, AnimalKind},
    colonist::follow_path,
    food::Hunger,
    items::STACK_LIMIT,
    sim::{SimPos, sim_pos},
    world::Terrain,
    zones::NEW_STOCKPILE_SIZE,
};

const TICK: Duration = Duration::from_nanos(1_000_000_000 / 60);

fn test_app(map: WorldMap) -> App {
    let mut app = App::new();
    app.insert_resource(map)
        .insert_resource(SimRng::new(1))
        .init_resource::<Time>()
        .init_resource::<Reservations>()
        .init_resource::<ColonyGoals>()
        .init_resource::<ItemAssets>()
        .init_resource::<StructureAssets>()
        .init_resource::<Blueprints>()
        .init_resource::<LightMap>()
        .init_resource::<SimTick>()
        .init_resource::<Zones>()
        .add_message::<Order>()
        .add_message::<TileChanged>()
        .add_systems(
            Update,
            (
                handle_orders,
                choose_jobs,
                run_jobs,
                follow_path,
                crate::needs::update_rest,
            )
                .chain(),
        );
    app
}

fn spawn_colonist(app: &mut App, tile: UVec2) -> Entity {
    app.world_mut()
        .spawn((
            Colonist {
                name: "Test".into(),
            },
            TilePos(tile),
            sim_pos(WorldMap::tile_center(tile)),
        ))
        .id()
}

fn run_ticks(app: &mut App, ticks: u32) {
    for _ in 0..ticks {
        app.world_mut().resource_mut::<Time>().advance_by(TICK);
        app.update();
    }
}

fn map_with_trees(trees: &[UVec2]) -> WorldMap {
    let mut map = WorldMap::filled(UVec2::new(20, 20), Terrain::Grass);
    for &t in trees {
        map.set_plant(t, Some(Plant::Tree));
    }
    map
}

fn wood_on_map(app: &mut App) -> u32 {
    let world = app.world_mut();
    let items: Vec<Item> = world.query::<&Item>().iter(world).copied().collect();
    stock(items.iter(), ItemKind::Wood)
}

fn items_at(app: &mut App) -> Vec<(UVec2, u32)> {
    let world = app.world_mut();
    let mut items: Vec<(UVec2, u32)> = world
        .query::<(&Item, &TilePos)>()
        .iter(world)
        .map(|(item, pos)| (pos.0, item.count))
        .collect();
    items.sort_by_key(|(p, _)| (p.y, p.x));
    items
}

fn put_wood(app: &mut App, tile: UVec2, count: u32) {
    app.world_mut()
        .spawn((Item::new(ItemKind::Wood, count), TilePos(tile)));
}

fn set_goals(app: &mut App, goals: &[(ItemKind, u32)]) {
    *app.world_mut().resource_mut::<ColonyGoals>() = ColonyGoals::fixed(goals);
}

fn stockpile_size(app: &App) -> usize {
    let map = app.world().resource::<WorldMap>();
    let zones = app.world().resource::<Zones>();
    map.positions().filter(|&p| zones.is_stockpile(p)).count()
}

fn stored(app: &mut App) -> u32 {
    let zones = app.world().resource::<Zones>().clone();
    items_at(app)
        .iter()
        .filter(|(p, _)| zones.is_stockpile(*p))
        .map(|(_, c)| c)
        .sum()
}

fn put_beds(app: &mut App, count: u32) {
    for x in 0..count {
        app.world_mut().spawn((
            Structure {
                kind: StructureKind::Bed,
            },
            TilePos(UVec2::new(19 - x, 19)),
        ));
    }
}

fn hauling_app(stockpile: (IVec2, IVec2)) -> App {
    let mut app = test_app(map_with_trees(&[]));
    put_beds(&mut app, 2);
    set_goals(&mut app, &[]);
    let map = app.world().resource::<WorldMap>().clone();
    app.world_mut()
        .resource_mut::<Zones>()
        .add_stockpile(&map, stockpile.0, stockpile.1);
    app
}

fn carrying(app: &App, colonist: Entity) -> Option<Item> {
    app.world().get::<Carrying>(colonist).unwrap().0
}

fn job(app: &App, colonist: Entity) -> Option<Job> {
    app.world().get::<CurrentJob>(colonist).unwrap().0
}

#[test]
fn idle_colonists_cut_trees_when_the_colony_needs_wood() {
    let tree = UVec2::new(8, 5);
    let mut app = test_app(map_with_trees(&[tree]));
    spawn_colonist(&mut app, UVec2::new(2, 5));
    run_ticks(&mut app, 60 * 15);
    assert_eq!(
        app.world().resource::<WorldMap>().plant(tree.as_ivec2()),
        None
    );
    assert_eq!(wood_on_map(&mut app), 10);
    assert!(app.world().resource::<Reservations>().0.is_empty());
}

#[test]
fn colonists_leave_trees_alone_when_there_is_enough_wood() {
    let tree = UVec2::new(8, 5);
    let mut app = test_app(map_with_trees(&[tree]));
    set_goals(&mut app, &[]);
    spawn_colonist(&mut app, UVec2::new(2, 5));
    run_ticks(&mut app, 60 * 15);
    assert_eq!(
        app.world().resource::<WorldMap>().plant(tree.as_ivec2()),
        Some(Plant::Tree)
    );
}

#[test]
fn colonists_never_pick_the_same_tree() {
    let trees = [UVec2::new(10, 10), UVec2::new(10, 11)];
    let mut app = test_app(map_with_trees(&trees));
    let a = spawn_colonist(&mut app, UVec2::new(5, 10));
    let b = spawn_colonist(&mut app, UVec2::new(5, 11));
    run_ticks(&mut app, 61);
    let target = |c| match job(&app, c) {
        Some(Job {
            task: Task::Work { site, .. },
            ..
        }) => site,
        other => panic!("expected chop job, got {other:?}"),
    };
    assert_ne!(target(a), target(b));
}

#[test]
fn ordered_chop_ignores_the_wood_goal() {
    let tree = UVec2::new(8, 5);
    let mut app = test_app(map_with_trees(&[tree]));
    set_goals(&mut app, &[]);
    let colonist = spawn_colonist(&mut app, UVec2::new(2, 5));
    app.world_mut().write_message(Order {
        colonist,
        tile: tree,
    });
    run_ticks(&mut app, 60 * 15);
    assert_eq!(
        app.world().resource::<WorldMap>().plant(tree.as_ivec2()),
        None
    );
}

#[test]
fn ordering_a_move_cancels_the_current_job_and_frees_its_tree() {
    let tree = UVec2::new(15, 5);
    let mut app = test_app(map_with_trees(&[tree]));
    let colonist = spawn_colonist(&mut app, UVec2::new(2, 5));
    run_ticks(&mut app, 61);
    assert!(matches!(
        job(&app, colonist),
        Some(Job {
            task: Task::Work { .. },
            ..
        })
    ));
    app.world_mut().write_message(Order {
        colonist,
        tile: UVec2::new(2, 15),
    });
    run_ticks(&mut app, 1);
    assert_eq!(
        job(&app, colonist).map(|j| j.task),
        Some(Task::MoveTo(UVec2::new(2, 15)))
    );
    assert!(
        app.world()
            .resource::<Reservations>()
            .is_free(Target::Site(tree))
    );
}

#[test]
fn idle_colonists_haul_loose_items_into_the_stockpile() {
    let mut app = hauling_app((IVec2::new(15, 15), IVec2::new(17, 15)));
    put_wood(&mut app, UVec2::new(5, 5), 20);
    spawn_colonist(&mut app, UVec2::new(2, 5));
    run_ticks(&mut app, 60 * 15);
    assert_eq!(items_at(&mut app), vec![(UVec2::new(15, 15), 20)]);
}

#[test]
fn large_stacks_take_several_trips_and_spill_into_more_stockpile_tiles() {
    let mut app = hauling_app((IVec2::new(15, 15), IVec2::new(17, 15)));
    put_wood(&mut app, UVec2::new(5, 5), STACK_LIMIT + 10);
    spawn_colonist(&mut app, UVec2::new(2, 5));
    run_ticks(&mut app, 60 * 40);
    let stacks = items_at(&mut app);
    assert_eq!(stored(&mut app), STACK_LIMIT + 10);
    assert!(stacks.len() >= 2);
    assert!(stacks.iter().all(|(_, count)| *count <= STACK_LIMIT));
}

#[test]
fn items_already_in_a_stockpile_stay_put() {
    let mut app = hauling_app((IVec2::new(5, 5), IVec2::new(16, 16)));
    put_wood(&mut app, UVec2::new(5, 5), 20);
    let colonist = spawn_colonist(&mut app, UVec2::new(2, 5));
    run_ticks(&mut app, 60 * 5);
    assert_eq!(items_at(&mut app), vec![(UVec2::new(5, 5), 20)]);
    assert_eq!(carrying(&app, colonist), None);
}

#[test]
fn colonists_found_a_stockpile_when_items_need_storing() {
    let mut app = test_app(map_with_trees(&[]));
    put_beds(&mut app, 1);
    set_goals(&mut app, &[]);
    put_wood(&mut app, UVec2::new(5, 5), 20);
    spawn_colonist(&mut app, UVec2::new(2, 5));
    run_ticks(&mut app, 60 * 15);
    assert_eq!(
        stockpile_size(&app),
        (NEW_STOCKPILE_SIZE * NEW_STOCKPILE_SIZE) as usize
    );
    assert_eq!(stored(&mut app), 20);
}

#[test]
fn no_stockpile_is_founded_while_there_is_nothing_to_store() {
    let mut app = test_app(map_with_trees(&[]));
    set_goals(&mut app, &[]);
    spawn_colonist(&mut app, UVec2::new(2, 5));
    run_ticks(&mut app, 60 * 5);
    assert_eq!(stockpile_size(&app), 0);
}

#[test]
fn two_colonists_never_haul_the_same_stack() {
    let mut app = hauling_app((IVec2::new(15, 15), IVec2::new(16, 16)));
    put_wood(&mut app, UVec2::new(5, 5), 10);
    put_wood(&mut app, UVec2::new(5, 6), 10);
    let a = spawn_colonist(&mut app, UVec2::new(2, 5));
    let b = spawn_colonist(&mut app, UVec2::new(2, 6));
    run_ticks(&mut app, 61);
    let pickup = |c| match job(&app, c).map(|j| j.task) {
        Some(Task::Haul { pickup, .. }) => pickup,
        other => panic!("expected haul, got {other:?}"),
    };
    assert_ne!(pickup(a), pickup(b));
}

// Orders interrupt whatever a colonist is doing, but whatever it is carrying stays in its
// hands; once it is idle again it finishes delivering it instead of dropping it anywhere.
#[test]
fn interrupted_haulers_deliver_their_load_later() {
    let mut app = hauling_app((IVec2::new(15, 15), IVec2::new(17, 15)));
    put_wood(&mut app, UVec2::new(4, 5), 20);
    let colonist = spawn_colonist(&mut app, UVec2::new(2, 5));
    let mut ticks = 0;
    while carrying(&app, colonist).is_none() && ticks < 60 * 10 {
        run_ticks(&mut app, 1);
        ticks += 1;
    }
    app.world_mut().write_message(Order {
        colonist,
        tile: UVec2::new(2, 2),
    });
    run_ticks(&mut app, 60 * 3);
    assert!(carrying(&app, colonist).is_some());
    run_ticks(&mut app, 60 * 20);
    assert_eq!(carrying(&app, colonist), None);
    assert_eq!(stored(&mut app), 20);
}

#[test]
fn right_clicking_loose_items_orders_a_haul() {
    let mut app = hauling_app((IVec2::new(15, 15), IVec2::new(15, 15)));
    set_goals(&mut app, &[(ItemKind::Wood, 1000)]);
    put_wood(&mut app, UVec2::new(5, 5), 20);
    let colonist = spawn_colonist(&mut app, UVec2::new(2, 5));
    app.world_mut().write_message(Order {
        colonist,
        tile: UVec2::new(5, 5),
    });
    run_ticks(&mut app, 1);
    assert!(matches!(
        job(&app, colonist),
        Some(Job {
            task: Task::Haul { .. },
            ordered: true
        })
    ));
}

fn mining_map() -> WorldMap {
    let mut map = WorldMap::filled(UVec2::new(20, 20), Terrain::Grass);
    for y in 0..20 {
        map.set(UVec2::new(10, y), Terrain::Stone);
    }
    map.set(UVec2::new(10, 5), Terrain::IronOre);
    map
}

fn items_of(app: &mut App, kind: ItemKind) -> u32 {
    let world = app.world_mut();
    let items: Vec<Item> = world.query::<&Item>().iter(world).copied().collect();
    stock(items.iter(), kind)
}

#[test]
fn colonists_mine_rock_the_colony_needs_and_leave_gravel() {
    let mut app = test_app(mining_map());
    set_goals(&mut app, &[(ItemKind::Stone, 10)]);
    spawn_colonist(&mut app, UVec2::new(8, 12));
    run_ticks(&mut app, 60 * 12);
    assert_eq!(items_of(&mut app, ItemKind::Stone), 10);
    assert_eq!(items_of(&mut app, ItemKind::Iron), 0);
    let map = app.world().resource::<WorldMap>();
    let gravel = map
        .positions()
        .filter(|p| map.get(p.as_ivec2()) == Some(Terrain::Gravel))
        .count();
    assert_eq!(gravel, 1);
}

#[test]
fn colonists_walk_past_rock_they_do_not_need() {
    let mut app = test_app(mining_map());
    set_goals(&mut app, &[(ItemKind::Iron, 10)]);
    spawn_colonist(&mut app, UVec2::new(8, 15));
    run_ticks(&mut app, 60 * 15);
    assert_eq!(items_of(&mut app, ItemKind::Iron), 10);
    assert_eq!(items_of(&mut app, ItemKind::Stone), 0);
    assert_eq!(
        app.world().resource::<WorldMap>().get(IVec2::new(10, 5)),
        Some(Terrain::Gravel)
    );
}

#[test]
fn right_clicking_rock_orders_mining_regardless_of_goals() {
    let mut app = test_app(mining_map());
    set_goals(&mut app, &[]);
    let colonist = spawn_colonist(&mut app, UVec2::new(8, 12));
    app.world_mut().write_message(Order {
        colonist,
        tile: UVec2::new(10, 12),
    });
    run_ticks(&mut app, 60 * 10);
    assert_eq!(
        app.world().resource::<WorldMap>().get(IVec2::new(10, 12)),
        Some(Terrain::Gravel)
    );
}

#[test]
fn colonists_expand_a_stockpile_that_is_nearly_full() {
    let mut app = hauling_app((IVec2::new(5, 5), IVec2::new(6, 5)));
    let colonist = spawn_colonist(&mut app, UVec2::new(2, 5));
    run_ticks(&mut app, 61);
    assert!(matches!(
        job(&app, colonist).map(|j| j.task),
        Some(Task::ExpandStockpile { .. })
    ));
    run_ticks(&mut app, 60 * 5);
    assert_eq!(stockpile_size(&app), 2 + EXPANSION_TILES);
}

#[test]
fn roomy_stockpiles_are_left_alone() {
    let mut app = hauling_app((IVec2::new(5, 5), IVec2::new(8, 5)));
    spawn_colonist(&mut app, UVec2::new(2, 5));
    run_ticks(&mut app, 60 * 5);
    assert_eq!(stockpile_size(&app), 4);
}

fn set_hour(app: &mut App, hour: u64) {
    let ticks = (hour + 24 - 6) % 24 * crate::sim::TICKS_PER_HOUR;
    *app.world_mut().resource_mut::<SimTick>() = SimTick(ticks);
}

fn structures(app: &mut App) -> Vec<(UVec2, StructureKind)> {
    let world = app.world_mut();
    world
        .query::<(&TilePos, &Structure)>()
        .iter(world)
        .map(|(pos, s)| (pos.0, s.kind))
        .collect()
}

fn put_campfire(app: &mut App, tile: UVec2) {
    app.world_mut().spawn((
        Structure {
            kind: StructureKind::Campfire,
        },
        Fuel(StructureKind::Campfire.fuel_ticks().unwrap()),
        TilePos(tile),
    ));
}

#[test]
fn colonists_light_a_campfire_near_the_stockpile_when_night_falls() {
    let mut app = hauling_app((IVec2::new(10, 10), IVec2::new(12, 12)));
    put_wood(&mut app, UVec2::new(10, 10), 20);
    set_hour(&mut app, 18);
    spawn_colonist(&mut app, UVec2::new(2, 5));
    run_ticks(&mut app, 60 * 20);
    let built = structures(&mut app);
    let campfire = built
        .iter()
        .find(|(_, kind)| *kind == StructureKind::Campfire)
        .expect("a campfire");
    assert!(campfire.0.as_vec2().distance(Vec2::new(11.0, 11.0)) <= HOME_RADIUS);
    assert_eq!(wood_on_map(&mut app), 10);
}

#[test]
fn no_fires_are_built_during_the_day() {
    let mut app = hauling_app((IVec2::new(10, 10), IVec2::new(12, 12)));
    put_wood(&mut app, UVec2::new(10, 10), 20);
    set_hour(&mut app, 10);
    spawn_colonist(&mut app, UVec2::new(2, 5));
    run_ticks(&mut app, 60 * 10);
    assert!(
        structures(&mut app)
            .iter()
            .all(|(_, kind)| kind.light().is_none())
    );
}

#[test]
fn without_wood_nothing_can_be_built() {
    let mut app = hauling_app((IVec2::new(10, 10), IVec2::new(12, 12)));
    set_hour(&mut app, 22);
    spawn_colonist(&mut app, UVec2::new(2, 5));
    run_ticks(&mut app, 60 * 10);
    assert!(
        structures(&mut app)
            .iter()
            .all(|(_, kind)| kind.light().is_none())
    );
}

#[test]
fn torches_light_stockpile_tiles_beyond_the_campfire() {
    let mut app = hauling_app((IVec2::new(2, 10), IVec2::new(17, 10)));
    put_wood(&mut app, UVec2::new(9, 10), 20);
    put_campfire(&mut app, UVec2::new(9, 12));
    set_hour(&mut app, 22);
    spawn_colonist(&mut app, UVec2::new(9, 8));
    run_ticks(&mut app, 60 * 15);
    assert!(
        structures(&mut app)
            .iter()
            .any(|(_, kind)| *kind == StructureKind::Torch)
    );
}

// Light is what makes fires worth building: work in darkness goes at half speed.
#[test]
fn work_is_slower_in_the_dark() {
    let tree = UVec2::new(8, 5);
    let finish_ticks = |daylight: f32| {
        let mut app = test_app(map_with_trees(&[tree]));
        let size = app.world().resource::<WorldMap>().size;
        app.insert_resource(LightMap::compute(size, daylight, []));
        spawn_colonist(&mut app, UVec2::new(7, 5));
        let mut ticks = 0;
        while app
            .world()
            .resource::<WorldMap>()
            .plant(tree.as_ivec2())
            .is_some()
        {
            run_ticks(&mut app, 1);
            ticks += 1;
        }
        ticks
    };
    let (lit, dark) = (finish_ticks(1.0), finish_ticks(0.0));
    assert!(
        dark > lit + WorkKind::Chop.work() / 2 - 10,
        "lit {lit}, dark {dark}"
    );
}

const NAP_TEST_REST: f32 = 0.25;

fn set_rest(app: &mut App, colonist: Entity, rest: f32) {
    app.world_mut().get_mut::<Rest>(colonist).unwrap().0 = rest;
}

fn rest(app: &App, colonist: Entity) -> f32 {
    app.world().get::<Rest>(colonist).unwrap().0
}

fn task(app: &App, colonist: Entity) -> Option<Task> {
    job(app, colonist).map(|j| j.task)
}

#[test]
fn tired_colonists_nap_and_get_up_when_rested() {
    let mut app = test_app(map_with_trees(&[]));
    set_goals(&mut app, &[]);
    set_hour(&mut app, 10);
    let colonist = spawn_colonist(&mut app, UVec2::new(5, 5));
    set_rest(&mut app, colonist, NAP_TEST_REST);
    run_ticks(&mut app, 61);
    assert!(matches!(task(&app, colonist), Some(Task::Sleep { .. })));
    let mut ticks = 0;
    while matches!(task(&app, colonist), Some(Task::Sleep { .. })) && ticks < 60 * 60 * 10 {
        run_ticks(&mut app, 60);
        ticks += 60;
    }
    assert!(!matches!(task(&app, colonist), Some(Task::Sleep { .. })));
    assert!(rest(&app, colonist) > 0.95);
}

#[test]
fn colonists_go_to_bed_at_night_and_sleep_until_morning() {
    let mut app = test_app(map_with_trees(&[]));
    set_goals(&mut app, &[]);
    set_hour(&mut app, 22);
    let colonist = spawn_colonist(&mut app, UVec2::new(5, 5));
    set_rest(&mut app, colonist, 0.8);
    run_ticks(&mut app, 61);
    assert!(matches!(task(&app, colonist), Some(Task::Sleep { .. })));
    run_ticks(&mut app, 3 * crate::sim::TICKS_PER_HOUR as u32);
    assert_eq!(rest(&app, colonist), 1.0);
    assert!(matches!(task(&app, colonist), Some(Task::Sleep { .. })));
}

#[test]
fn rested_colonists_stay_up_during_the_day() {
    let mut app = test_app(map_with_trees(&[]));
    set_goals(&mut app, &[]);
    set_hour(&mut app, 12);
    let colonist = spawn_colonist(&mut app, UVec2::new(5, 5));
    set_rest(&mut app, colonist, 0.8);
    run_ticks(&mut app, 60 * 5);
    assert!(!matches!(task(&app, colonist), Some(Task::Sleep { .. })));
}

#[test]
fn exhausted_colonists_drop_their_work_to_sleep() {
    let tree = UVec2::new(15, 5);
    let mut app = test_app(map_with_trees(&[tree]));
    let colonist = spawn_colonist(&mut app, UVec2::new(2, 5));
    run_ticks(&mut app, 61);
    assert!(matches!(task(&app, colonist), Some(Task::Work { .. })));
    set_rest(&mut app, colonist, EXHAUSTED_REST / 2.0);
    run_ticks(&mut app, 30);
    assert!(matches!(task(&app, colonist), Some(Task::Sleep { .. })));
    assert!(
        app.world()
            .resource::<Reservations>()
            .is_free(Target::Site(tree))
    );
}

#[test]
fn exhaustion_does_not_override_orders() {
    let tree = UVec2::new(15, 5);
    let mut app = test_app(map_with_trees(&[tree]));
    let colonist = spawn_colonist(&mut app, UVec2::new(2, 5));
    app.world_mut().write_message(Order {
        colonist,
        tile: tree,
    });
    run_ticks(&mut app, 2);
    set_rest(&mut app, colonist, EXHAUSTED_REST / 2.0);
    run_ticks(&mut app, 30);
    assert!(matches!(
        job(&app, colonist),
        Some(Job {
            task: Task::Work { .. },
            ordered: true
        })
    ));
}

fn beds(app: &mut App) -> usize {
    structures(app)
        .iter()
        .filter(|(_, kind)| *kind == StructureKind::Bed)
        .count()
}

#[test]
fn colonists_build_one_bed_each() {
    let mut app = test_app(map_with_trees(&[]));
    set_goals(&mut app, &[]);
    let map = app.world().resource::<WorldMap>().clone();
    app.world_mut()
        .resource_mut::<Zones>()
        .add_stockpile(&map, IVec2::new(2, 2), IVec2::new(5, 5));
    put_wood(&mut app, UVec2::new(2, 2), 50);
    put_wood(&mut app, UVec2::new(3, 2), 50);
    spawn_colonist(&mut app, UVec2::new(10, 10));
    spawn_colonist(&mut app, UVec2::new(11, 10));
    run_ticks(&mut app, 60 * 40);
    assert_eq!(beds(&mut app), 2);
    assert_eq!(wood_on_map(&mut app), 100 - 2 * StructureKind::Bed.cost().1);
}

// A shelter needs a wall ring with walking space around the beds; beds hugging the stockpile
// would leave stored items where the walls must go and the room could never be planned.
#[test]
fn beds_keep_clear_of_the_stockpile() {
    let mut app = test_app(map_with_trees(&[]));
    set_goals(&mut app, &[]);
    let map = app.world().resource::<WorldMap>().clone();
    app.world_mut().resource_mut::<Zones>().add_stockpile(
        &map,
        IVec2::new(8, 8),
        IVec2::new(11, 11),
    );
    put_wood(&mut app, UVec2::new(8, 8), 50);
    spawn_colonist(&mut app, UVec2::new(10, 4));
    run_ticks(&mut app, 60 * 20);
    let built = structures(&mut app);
    let bed = built
        .iter()
        .find(|(_, kind)| *kind == StructureKind::Bed)
        .expect("a bed");
    let zones = app.world().resource::<Zones>();
    assert!(zones.stockpile_tiles().all(|s| {
        (s.as_ivec2() - bed.0.as_ivec2()).abs().max_element() >= BED_STOCKPILE_CLEARANCE
    }));
}

#[test]
fn colonists_sleep_in_their_beds() {
    let mut app = test_app(map_with_trees(&[]));
    set_goals(&mut app, &[]);
    put_beds(&mut app, 1);
    set_hour(&mut app, 22);
    let colonist = spawn_colonist(&mut app, UVec2::new(5, 5));
    set_rest(&mut app, colonist, 0.5);
    run_ticks(&mut app, 60 * 10);
    assert_eq!(
        app.world().get::<TilePos>(colonist).unwrap().0,
        UVec2::new(19, 19)
    );
    assert!(matches!(task(&app, colonist), Some(Task::Sleep { .. })));
}

fn put_items(app: &mut App, tile: UVec2, kind: ItemKind, count: u32) {
    app.world_mut()
        .spawn((Item::new(kind, count), TilePos(tile)));
}

#[test]
fn blueprints_are_built_with_the_right_material() {
    let mut app = test_app(map_with_trees(&[]));
    set_goals(&mut app, &[]);
    put_beds(&mut app, 1);
    put_items(&mut app, UVec2::new(2, 2), ItemKind::Stone, 10);
    let wall = UVec2::new(8, 8);
    app.world_mut()
        .resource_mut::<Blueprints>()
        .0
        .insert(wall, BuildKind::Structure(StructureKind::Wall));
    spawn_colonist(&mut app, UVec2::new(5, 5));
    run_ticks(&mut app, 60 * 10);
    assert!(app.world().resource::<WorldMap>().is_wall(wall.as_ivec2()));
    assert!(app.world().resource::<Blueprints>().0.is_empty());
    assert_eq!(items_of(&mut app, ItemKind::Stone), 8);
}

#[test]
fn colonists_build_a_roofed_shelter_around_their_beds() {
    let mut app = test_app(map_with_trees(&[]));
    app.add_systems(Update, crate::building::plan_shelter.before(choose_jobs));
    set_goals(&mut app, &[]);
    for x in [10, 11] {
        app.world_mut().spawn((
            Structure {
                kind: StructureKind::Bed,
            },
            TilePos(UVec2::new(x, 10)),
        ));
    }
    put_items(&mut app, UVec2::new(2, 2), ItemKind::Stone, 50);
    put_items(&mut app, UVec2::new(3, 2), ItemKind::Wood, 50);
    spawn_colonist(&mut app, UVec2::new(4, 4));
    spawn_colonist(&mut app, UVec2::new(5, 4));
    run_ticks(&mut app, 60 * 150);
    let map = app.world().resource::<WorldMap>();
    assert!(map.is_roofed(IVec2::new(10, 10)) && map.is_roofed(IVec2::new(11, 10)));
    let walls = map
        .positions()
        .filter(|p| map.is_wall(p.as_ivec2()))
        .count();
    assert_eq!(walls, 17);
    assert!(
        structures(&mut app)
            .iter()
            .any(|(_, kind)| *kind == StructureKind::Door)
    );
}

#[test]
fn colonists_chop_from_a_neighbouring_tile() {
    let tree = UVec2::new(8, 5);
    let mut app = test_app(map_with_trees(&[tree]));
    let colonist = spawn_colonist(&mut app, UVec2::new(2, 5));
    run_ticks(&mut app, 60 * 5);
    let tile = app.world().get::<TilePos>(colonist).unwrap().0;
    assert!(is_adjacent(tile.as_ivec2(), tree.as_ivec2()));
    assert_eq!(
        app.world().get::<SimPos>(colonist).unwrap().0,
        WorldMap::tile_center(tile)
    );
}

fn set_fed(app: &mut App, colonist: Entity, fed: f32) {
    app.world_mut().get_mut::<Hunger>(colonist).unwrap().0 = fed;
}

fn fed(app: &App, colonist: Entity) -> f32 {
    app.world().get::<Hunger>(colonist).unwrap().0
}

#[test]
fn hungry_colonists_eat_until_full() {
    let mut app = test_app(map_with_trees(&[]));
    set_goals(&mut app, &[]);
    put_items(&mut app, UVec2::new(8, 5), ItemKind::Berries, 20);
    let colonist = spawn_colonist(&mut app, UVec2::new(2, 5));
    set_fed(&mut app, colonist, 0.3);
    run_ticks(&mut app, 60 * 6);
    assert!(fed(&app, colonist) > 0.95);
    assert_eq!(items_of(&mut app, ItemKind::Berries), 13);
}

#[test]
fn colonists_are_not_peckish_when_fed() {
    let mut app = test_app(map_with_trees(&[]));
    set_goals(&mut app, &[]);
    put_items(&mut app, UVec2::new(8, 5), ItemKind::Berries, 20);
    let colonist = spawn_colonist(&mut app, UVec2::new(2, 5));
    set_fed(&mut app, colonist, 0.8);
    run_ticks(&mut app, 60 * 6);
    assert_eq!(items_of(&mut app, ItemKind::Berries), 20);
}

#[test]
fn starving_colonists_drop_their_work_to_eat() {
    let tree = UVec2::new(15, 5);
    let mut app = test_app(map_with_trees(&[tree]));
    put_items(&mut app, UVec2::new(2, 8), ItemKind::Meat, 20);
    let colonist = spawn_colonist(&mut app, UVec2::new(2, 5));
    run_ticks(&mut app, 61);
    assert!(task(&app, colonist).is_some_and(|t| !matches!(t, Task::Eat { .. })));
    set_fed(&mut app, colonist, STARVING / 2.0);
    run_ticks(&mut app, 30);
    assert!(matches!(task(&app, colonist), Some(Task::Eat { .. })));
}

#[test]
fn colonists_forage_ripe_berries_when_the_colony_wants_them() {
    let mut map = map_with_trees(&[]);
    let ripe = UVec2::new(8, 5);
    let unripe = UVec2::new(4, 5);
    for (bush, growth) in [(ripe, 1.0), (unripe, 0.5)] {
        map.set_plant(bush, Some(Plant::BerryBush));
        map.set_growth(bush, growth);
    }
    let mut app = test_app(map);
    set_goals(&mut app, &[(ItemKind::Berries, 30)]);
    spawn_colonist(&mut app, UVec2::new(2, 5));
    run_ticks(&mut app, 60 * 10);
    assert_eq!(items_of(&mut app, ItemKind::Berries), 8);
    let map = app.world().resource::<WorldMap>();
    assert_eq!(map.plant(ripe.as_ivec2()), Some(Plant::BerryBush));
    assert_eq!(map.growth(ripe.as_ivec2()), 0.0);
    assert_eq!(map.growth(unripe.as_ivec2()), 0.5);
}

fn put_animal(app: &mut App, kind: AnimalKind, tile: UVec2) -> Entity {
    app.world_mut()
        .spawn((
            Animal { kind },
            TilePos(tile),
            sim_pos(WorldMap::tile_center(tile)),
        ))
        .id()
}

#[test]
fn colonists_hunt_when_the_colony_wants_meat() {
    let mut app = test_app(map_with_trees(&[]));
    app.add_systems(Update, crate::animals::wander.before(choose_jobs));
    set_goals(&mut app, &[(ItemKind::Meat, 20)]);
    let deer = put_animal(&mut app, AnimalKind::Deer, UVec2::new(15, 15));
    spawn_colonist(&mut app, UVec2::new(2, 2));
    run_ticks(&mut app, 60 * 15);
    assert!(app.world().get_entity(deer).is_err());
    assert_eq!(items_of(&mut app, ItemKind::Meat), AnimalKind::Deer.meat());
}

#[test]
fn animals_are_left_alone_when_there_is_enough_meat() {
    let mut app = test_app(map_with_trees(&[]));
    set_goals(&mut app, &[]);
    let rabbit = put_animal(&mut app, AnimalKind::Rabbit, UVec2::new(10, 10));
    spawn_colonist(&mut app, UVec2::new(2, 2));
    run_ticks(&mut app, 60 * 10);
    assert!(app.world().get_entity(rabbit).is_ok());
}

#[test]
fn right_clicking_an_animal_orders_a_hunt() {
    let mut app = test_app(map_with_trees(&[]));
    set_goals(&mut app, &[]);
    let rabbit = put_animal(&mut app, AnimalKind::Rabbit, UVec2::new(10, 10));
    let colonist = spawn_colonist(&mut app, UVec2::new(2, 2));
    app.world_mut().write_message(Order {
        colonist,
        tile: UVec2::new(10, 10),
    });
    run_ticks(&mut app, 60 * 10);
    assert!(app.world().get_entity(rabbit).is_err());
    assert_eq!(
        items_of(&mut app, ItemKind::Meat),
        AnimalKind::Rabbit.meat()
    );
}

fn farm_app(tiles: &[UVec2]) -> App {
    let mut map = map_with_trees(&[]);
    for &t in tiles {
        map.set(t, Terrain::Soil);
    }
    let mut app = test_app(map);
    set_goals(&mut app, &[]);
    put_beds(&mut app, 1);
    let map = app.world().resource::<WorldMap>().clone();
    app.world_mut()
        .resource_mut::<Zones>()
        .add_farm_tiles(&map, tiles.iter().copied());
    app
}

#[test]
fn colonists_sow_empty_farm_tiles() {
    let farm = [UVec2::new(8, 8), UVec2::new(9, 8)];
    let mut app = farm_app(&farm);
    spawn_colonist(&mut app, UVec2::new(2, 2));
    run_ticks(&mut app, 60 * 10);
    let map = app.world().resource::<WorldMap>();
    assert!(
        farm.iter()
            .all(|t| map.plant(t.as_ivec2()) == Some(Plant::Crop))
    );
}

#[test]
fn ripe_crops_are_harvested_into_vegetables_and_resown() {
    let farm = [UVec2::new(8, 8)];
    let mut app = farm_app(&farm);
    set_goals(&mut app, &[(ItemKind::Vegetables, 30)]);
    {
        let mut map = app.world_mut().resource_mut::<WorldMap>();
        map.set_plant(farm[0], Some(Plant::Crop));
        map.set_growth(farm[0], 1.0);
    }
    spawn_colonist(&mut app, UVec2::new(2, 2));
    run_ticks(&mut app, 60 * 15);
    assert_eq!(items_of(&mut app, ItemKind::Vegetables), 10);
    let map = app.world().resource::<WorldMap>();
    assert_eq!(map.plant(farm[0].as_ivec2()), Some(Plant::Crop));
    assert!(map.growth(farm[0].as_ivec2()) < 0.1);
}

#[test]
fn colonists_cook_raw_food_into_meals_at_a_campfire() {
    let mut app = test_app(map_with_trees(&[]));
    set_goals(&mut app, &[(ItemKind::Meal, 2)]);
    put_beds(&mut app, 1);
    put_campfire(&mut app, UVec2::new(10, 10));
    put_items(&mut app, UVec2::new(5, 5), ItemKind::Meat, 12);
    spawn_colonist(&mut app, UVec2::new(2, 2));
    run_ticks(&mut app, 60 * 20);
    assert_eq!(items_of(&mut app, ItemKind::Meal), 2);
    assert_eq!(items_of(&mut app, ItemKind::Meat), 0);
}

#[test]
fn colonists_light_a_fire_to_cook_on() {
    let mut app = test_app(map_with_trees(&[]));
    set_goals(&mut app, &[(ItemKind::Meal, 1)]);
    put_beds(&mut app, 1);
    put_items(&mut app, UVec2::new(5, 5), ItemKind::Berries, 6);
    put_items(&mut app, UVec2::new(6, 5), ItemKind::Wood, 10);
    spawn_colonist(&mut app, UVec2::new(2, 2));
    run_ticks(&mut app, 60 * 25);
    assert!(
        structures(&mut app)
            .iter()
            .any(|(_, kind)| *kind == StructureKind::Campfire)
    );
    assert_eq!(items_of(&mut app, ItemKind::Meal), 1);
}

#[test]
fn no_cooking_without_demand_for_meals() {
    let mut app = test_app(map_with_trees(&[]));
    set_goals(&mut app, &[]);
    put_beds(&mut app, 1);
    put_campfire(&mut app, UVec2::new(10, 10));
    put_items(&mut app, UVec2::new(5, 5), ItemKind::Meat, 12);
    spawn_colonist(&mut app, UVec2::new(2, 2));
    run_ticks(&mut app, 60 * 10);
    assert_eq!(items_of(&mut app, ItemKind::Meal), 0);
}

// Chopping and hauling leave material in many small piles; a builder gathers from several
// piles instead of waiting for one big enough to cover the whole cost.
#[test]
fn builders_gather_material_from_several_piles() {
    let mut app = test_app(map_with_trees(&[]));
    set_goals(&mut app, &[]);
    put_wood(&mut app, UVec2::new(4, 4), 10);
    put_wood(&mut app, UVec2::new(15, 4), 10);
    spawn_colonist(&mut app, UVec2::new(2, 2));
    run_ticks(&mut app, 60 * 30);
    assert_eq!(beds(&mut app), 1);
    assert_eq!(wood_on_map(&mut app), 20 - StructureKind::Bed.cost().1);
}

#[test]
fn colonists_pave_planned_paths_with_stone() {
    let mut app = test_app(map_with_trees(&[]));
    set_goals(&mut app, &[]);
    put_beds(&mut app, 1);
    let tile = UVec2::new(8, 8);
    app.world_mut()
        .resource_mut::<WorldMap>()
        .set(tile, Terrain::Path);
    app.world_mut()
        .resource_mut::<Blueprints>()
        .0
        .insert(tile, BuildKind::Pave);
    put_items(&mut app, UVec2::new(2, 2), ItemKind::Stone, 5);
    spawn_colonist(&mut app, UVec2::new(4, 4));
    run_ticks(&mut app, 60 * 10);
    assert_eq!(
        app.world().resource::<WorldMap>().get(tile.as_ivec2()),
        Some(Terrain::Paved)
    );
    assert_eq!(items_of(&mut app, ItemKind::Stone), 4);
}

// The wall-builder must not trap a colonist who is just stepping onto the tile: that colonist's
// TilePos is still the previous tile, so only checking TilePos would let the wall close on them.
#[test]
fn walls_wait_for_colonists_stepping_onto_the_tile() {
    let mut app = test_app(map_with_trees(&[]));
    set_goals(&mut app, &[]);
    put_beds(&mut app, 2);
    put_items(&mut app, UVec2::new(2, 2), ItemKind::Stone, 10);
    let wall = UVec2::new(8, 8);
    app.world_mut()
        .resource_mut::<Blueprints>()
        .0
        .insert(wall, BuildKind::Structure(StructureKind::Wall));
    let colonists = [
        spawn_colonist(&mut app, UVec2::new(4, 4)),
        spawn_colonist(&mut app, UVec2::new(8, 10)),
    ];
    let mut sent = false;
    for _ in 0..60 * 20 {
        let nearly_built = |c| {
            matches!(
                task(&app, c),
                Some(Task::Build { progress, kind, .. }) if progress + 4 >= kind.work()
            )
        };
        if !sent && let Some(&builder) = colonists.iter().find(|&&c| nearly_built(c)) {
            let walker = *colonists.iter().find(|&&c| c != builder).unwrap();
            let from = app.world().get::<TilePos>(walker).unwrap().0;
            let route: VecDeque<UVec2> = find_path(app.world().resource::<WorldMap>(), from, wall)
                .unwrap()
                .into();
            app.world_mut().get_mut::<Path>(walker).unwrap().0 = route;
            sent = true;
        }
        run_ticks(&mut app, 1);
        let map = app.world().resource::<WorldMap>();
        for &c in &colonists {
            let tile = app.world().get::<TilePos>(c).unwrap().0;
            assert!(!map.is_wall(tile.as_ivec2()), "colonist trapped in a wall");
        }
    }
    assert!(sent);
    assert!(app.world().resource::<WorldMap>().is_wall(wall.as_ivec2()));
}