use std::collections::VecDeque;

use super::*;
use crate::{
    animals::{Animal, AnimalKind},
    colonist::follow_path,
    economy::{COLONY_RADIUS, Stock},
    food::Hunger,
    items::{STACK_LIMIT, stock},
    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::<crate::family::Homes>()
        .init_resource::<crate::pathfinding::ColonyReach>()
        .init_resource::<crate::rooms::Rooms>()
        .init_resource::<crate::social::Relations>()
        .init_resource::<crate::population::ColonyLog>()
        .add_message::<crate::mood::Ate>()
        .init_resource::<crate::designations::Designations>()
        .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 map = app.world().resource::<WorldMap>().clone();
        app.insert_resource(LightMap::compute(&map, 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 { .. })));
}

// Starvation only interrupts work when there is food to fetch. Without that check a starving
// colonist dropped their job every tick, searched the whole map for food and picked the same
// job again, never finishing anything and stalling the simulation.
#[test]
fn starving_colonists_without_food_keep_working() {
    let tree = UVec2::new(6, 5);
    let mut app = test_app(map_with_trees(&[tree]));
    set_goals(&mut app, &[(ItemKind::Wood, 50)]);
    let colonist = spawn_colonist(&mut app, UVec2::new(2, 5));
    set_fed(&mut app, colonist, STARVING / 2.0);
    run_ticks(&mut app, 60 + 60 * 4 + WorkKind::Chop.work());
    assert!(items_of(&mut app, ItemKind::Wood) > 0);
}

#[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 + BUTCHER_WORK);
    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))
    );
}

// Sowing used to be the last resort, so a colony with any material or construction demand
// never planted its farm and starved once wild food ran out.
#[test]
fn hungry_colonies_sow_before_gathering_materials() {
    let farm = [UVec2::new(8, 8)];
    let mut app = farm_app(&farm);
    app.world_mut()
        .resource_mut::<WorldMap>()
        .set_plant(UVec2::new(3, 2), Some(Plant::Tree));
    set_goals(
        &mut app,
        &[(ItemKind::Vegetables, 30), (ItemKind::Wood, 30)],
    );
    let colonist = spawn_colonist(&mut app, UVec2::new(2, 2));
    run_ticks(&mut app, 61);
    assert!(matches!(
        task(&app, colonist),
        Some(Task::Work {
            kind: WorkKind::Sow,
            ..
        })
    ));
}

#[test]
fn hungry_colonies_harvest_before_gathering_materials() {
    let farm = [UVec2::new(8, 8)];
    let mut app = farm_app(&farm);
    {
        let mut map = app.world_mut().resource_mut::<WorldMap>();
        map.set_plant(UVec2::new(3, 2), Some(Plant::Tree));
        map.set_plant(farm[0], Some(Plant::Crop));
        map.set_growth(farm[0], 1.0);
    }
    set_goals(
        &mut app,
        &[(ItemKind::Vegetables, 30), (ItemKind::Wood, 30)],
    );
    let colonist = spawn_colonist(&mut app, UVec2::new(2, 2));
    run_ticks(&mut app, 61);
    assert!(matches!(
        task(&app, colonist),
        Some(Task::Work {
            kind: WorkKind::Harvest,
            ..
        })
    ));
}

#[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);
}

// Food the colony cannot reach must not count towards its stock: a stray stack far from home
// once satisfied the raw food target, so nobody harvested ripe crops while everyone starved.
#[test]
fn stock_out_of_the_colonys_reach_does_not_stop_harvesting() {
    let farm = UVec2::new(8, 8);
    let mut map = WorldMap::filled(UVec2::splat(150), Terrain::Grass);
    map.set(farm, Terrain::Soil);
    map.set_plant(farm, Some(Plant::Crop));
    map.set_growth(farm, 1.0);
    let mut app = test_app(map.clone());
    set_goals(&mut app, &[(ItemKind::Vegetables, 10)]);
    put_beds(&mut app, 1);
    let mut zones = app.world_mut().resource_mut::<Zones>();
    zones.add_farm_tiles(&map, [farm]);
    zones.add_tiles(&map, [UVec2::new(4, 4)]);
    let far = UVec2::new(4, 4) + UVec2::splat(COLONY_RADIUS as u32 + 1);
    put_items(&mut app, far, ItemKind::Meat, 20);
    spawn_colonist(&mut app, UVec2::new(2, 2));
    run_ticks(&mut app, 60 * 15);
    assert!(items_of(&mut app, ItemKind::Vegetables) > 0);
}

#[test]
fn colonist_searches_cover_the_colony_radius() {
    let map = WorldMap::filled(UVec2::splat(200), Terrain::Grass);
    let home = UVec2::splat(100);
    let corner = home + UVec2::splat(COLONY_RADIUS as u32);
    assert_eq!(
        nearest_tile(&map, home, SEARCH_TILES, |p| p == corner),
        Some(corner)
    );
}

#[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()));
}

#[test]
fn children_play_instead_of_working() {
    let mut app = test_app(map_with_trees(&[UVec2::new(4, 2)]));
    set_goals(&mut app, &[(ItemKind::Wood, 50)]);
    let child = spawn_colonist(&mut app, UVec2::new(2, 2));
    app.world_mut()
        .entity_mut(child)
        .insert(crate::family::Child { born: 0 });
    run_ticks(&mut app, 60 * 10);
    assert!(!matches!(task(&app, child), Some(Task::Work { .. })));
    assert_eq!(items_of(&mut app, ItemKind::Wood), 0);
}

#[test]
fn colonists_refuel_a_dying_campfire_instead_of_building_a_new_one() {
    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));
    let full = StructureKind::Campfire.fuel_ticks().unwrap();
    {
        let world = app.world_mut();
        let mut fuel = world.query::<&mut Fuel>();
        fuel.single_mut(world).unwrap().0 = full / 10;
    }
    put_items(&mut app, UVec2::new(5, 5), ItemKind::Wood, 20);
    spawn_colonist(&mut app, UVec2::new(2, 2));
    run_ticks(&mut app, 60 * 15);
    let world = app.world_mut();
    let fuel: Vec<u32> = world.query::<&Fuel>().iter(world).map(|f| f.0).collect();
    assert_eq!(fuel.len(), 1);
    assert!(fuel[0] > full / 2, "{fuel:?}");
}

#[test]
fn designated_trees_are_cut_even_when_wood_is_not_wanted() {
    let marked = UVec2::new(12, 5);
    let mut app = test_app(map_with_trees(&[UVec2::new(4, 5), marked]));
    set_goals(&mut app, &[]);
    app.world_mut()
        .resource_mut::<crate::designations::Designations>()
        .0
        .insert(marked);
    spawn_colonist(&mut app, UVec2::new(2, 5));
    run_ticks(&mut app, 61 + 60 * 3 + WorkKind::Chop.work());
    let map = app.world().resource::<WorldMap>();
    assert!(map.plant(marked.as_ivec2()).is_none());
    assert_eq!(map.plant(IVec2::new(4, 5)), Some(Plant::Tree));
}

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

#[test]
fn carcasses_are_butchered_into_meat() {
    let mut app = test_app(map_with_trees(&[]));
    set_goals(&mut app, &[]);
    put_items(&mut app, UVec2::new(8, 5), ItemKind::Carcass, 8);
    spawn_colonist(&mut app, UVec2::new(2, 5));
    run_ticks(&mut app, 61 + 60 * 3 + BUTCHER_WORK);
    assert_eq!(items_of(&mut app, ItemKind::Carcass), 0);
    assert_eq!(items_of(&mut app, ItemKind::Meat), 8);
}

#[test]
fn hunters_shoot_from_a_distance() {
    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));
    let hunter = spawn_colonist(&mut app, UVec2::new(2, 2));
    let mut shots_from = Vec::new();
    let mut last_progress = 0;
    for _ in 0..60 * 15 {
        run_ticks(&mut app, 1);
        let Some(prey) = app.world().get::<TilePos>(deer) else {
            break;
        };
        let at = app.world().get::<TilePos>(hunter).unwrap();
        if let Some(Task::Hunt { progress, .. }) = task(&app, hunter) {
            if progress > last_progress {
                shots_from.push(prey.0.as_vec2().distance(at.0.as_vec2()));
            }
            last_progress = progress;
        }
    }
    assert!(app.world().get_entity(deer).is_err());
    assert!(shots_from.iter().any(|&d| d > 2.0), "{shots_from:?}");
    assert!(
        shots_from.iter().all(|&d| d <= HUNT_RANGE + 1.5),
        "{shots_from:?}"
    );
}

#[test]
fn colonists_tame_wild_animals_when_food_is_plentiful() {
    let mut app = test_app(map_with_trees(&[]));
    app.add_systems(Update, crate::animals::wander.before(choose_jobs));
    set_goals(&mut app, &[]);
    put_beds(&mut app, 1);
    let rabbit = put_animal(&mut app, AnimalKind::Rabbit, UVec2::new(12, 12));
    spawn_colonist(&mut app, UVec2::new(2, 2));
    run_ticks(&mut app, 60 * 6 + AnimalKind::Rabbit.tame_work());
    assert!(app.world().get::<crate::animals::Tame>(rabbit).is_some());
}

// Tame herds are a renewable meat supply, so hunters take spare tame animals (beyond a breeding
// pair) before chasing wild ones.
#[test]
fn hunters_slaughter_spare_tame_animals_first() {
    let wild = (
        Entity::from_raw_u32(1).unwrap(),
        UVec2::new(5, 5),
        AnimalKind::Deer,
        false,
    );
    let tame = |i: u32, x: u32| {
        (
            Entity::from_raw_u32(10 + i).unwrap(),
            UVec2::new(x, 15),
            AnimalKind::Deer,
            true,
        )
    };
    let map = map_with_trees(&[]);
    let reservations = Reservations::default();
    let pick = |animals: &[Wildlife]| match find_hunt(&map, &reservations, animals, UVec2::ONE) {
        Some(Task::Hunt { animal, .. }) => animal,
        _ => panic!("no hunt"),
    };
    assert_eq!(pick(&[wild, tame(0, 10), tame(1, 11)]), wild.0);
    let herd = [wild, tame(0, 10), tame(1, 11), tame(2, 12)];
    assert_eq!(pick(&herd), tame(0, 10).0);
}

#[test]
fn colonists_skip_work_types_they_are_not_assigned() {
    let mut app = test_app(map_with_trees(&[UVec2::new(4, 2)]));
    set_goals(&mut app, &[(ItemKind::Wood, 50)]);
    let colonist = spawn_colonist(&mut app, UVec2::new(2, 2));
    app.world_mut()
        .get_mut::<WorkPriorities>(colonist)
        .unwrap()
        .toggle(WorkType::Gather);
    run_ticks(&mut app, 60 * 10);
    assert_eq!(items_of(&mut app, ItemKind::Wood), 0);
    app.world_mut()
        .get_mut::<WorkPriorities>(colonist)
        .unwrap()
        .toggle(WorkType::Gather);
    run_ticks(&mut app, 60 * 15);
    assert!(items_of(&mut app, ItemKind::Wood) > 0);
}

#[test]
fn hauled_items_go_to_the_highest_priority_stockpile_that_accepts_them() {
    let mut app = test_app(map_with_trees(&[]));
    set_goals(&mut app, &[]);
    put_beds(&mut app, 1);
    let map = app.world().resource::<WorldMap>().clone();
    {
        let mut zones = app.world_mut().resource_mut::<Zones>();
        zones.add_stockpile(&map, IVec2::new(3, 3), IVec2::new(4, 4));
        zones.add_stockpile(&map, IVec2::new(15, 15), IVec2::new(16, 16));
        zones.add_stockpile(&map, IVec2::new(15, 3), IVec2::new(16, 4));
        zones.update_region_rule(UVec2::new(15, 15), |rule| {
            rule.priority = crate::zones::StoragePriority::High
        });
        zones.update_region_rule(UVec2::new(3, 3), |rule| rule.toggle(Stock::Stone));
    }
    put_items(&mut app, UVec2::new(3, 3), ItemKind::Stone, 5);
    put_items(&mut app, UVec2::new(6, 6), ItemKind::Wood, 5);
    spawn_colonist(&mut app, UVec2::new(5, 5));
    run_ticks(&mut app, 60 * 30);
    let world = app.world_mut();
    let placed: Vec<(ItemKind, UVec2)> = world
        .query::<(&Item, &TilePos)>()
        .iter(world)
        .map(|(i, p)| (i.kind, p.0))
        .collect();
    let in_high = |t: UVec2| t.x >= 15 && t.y >= 15;
    assert!(placed.iter().all(|(_, t)| in_high(*t)), "{placed:?}");
}

#[test]
fn stored_items_move_up_to_a_higher_priority_stockpile() {
    let mut app = test_app(map_with_trees(&[]));
    set_goals(&mut app, &[]);
    put_beds(&mut app, 1);
    let map = app.world().resource::<WorldMap>().clone();
    {
        let mut zones = app.world_mut().resource_mut::<Zones>();
        zones.add_stockpile(&map, IVec2::new(3, 3), IVec2::new(4, 4));
        zones.add_stockpile(&map, IVec2::new(14, 14), IVec2::new(15, 15));
    }
    put_items(&mut app, UVec2::new(3, 3), ItemKind::Wood, 5);
    spawn_colonist(&mut app, UVec2::new(5, 5));
    run_ticks(&mut app, 60 * 5);
    let wood_at = |app: &mut App| {
        let world = app.world_mut();
        world
            .query::<(&Item, &TilePos)>()
            .iter(world)
            .map(|(_, p)| p.0)
            .collect::<Vec<_>>()
    };
    assert_eq!(wood_at(&mut app), vec![UVec2::new(3, 3)]);
    app.world_mut()
        .resource_mut::<Zones>()
        .update_region_rule(UVec2::new(14, 14), |rule| {
            rule.priority = crate::zones::StoragePriority::High
        });
    run_ticks(&mut app, 60 * 20);
    assert!(wood_at(&mut app).iter().all(|t| t.x >= 14 && t.y >= 14));
}

// Cold colonists stop to warm up by a fire before taking new work; they would otherwise lose
// mood, rest and food to the cold for as long as winter lasts.
#[test]
fn cold_colonists_warm_up_by_a_fire() {
    let mut app = test_app(WorldMap::filled(UVec2::splat(30), Terrain::Grass));
    let winter = 9 * 24 * crate::sim::TICKS_PER_HOUR;
    app.insert_resource(SimTick(winter));
    app.world_mut().spawn((
        Structure {
            kind: StructureKind::Campfire,
        },
        TilePos(UVec2::new(20, 20)),
    ));
    let colonist = spawn_colonist(&mut app, UVec2::new(2, 2));
    app.world_mut()
        .entity_mut(colonist)
        .insert(crate::climate::Warmth(-5.0));
    for _ in 0..300 {
        run_ticks(&mut app, 1);
        if job(&app, colonist).is_some() {
            break;
        }
    }
    let Some(Job {
        task: Task::MoveTo(spot),
        ..
    }) = job(&app, colonist)
    else {
        panic!("expected a move to the fire, got {:?}", job(&app, colonist));
    };
    assert!(spot.as_vec2().distance(Vec2::splat(20.0)) <= 3.0);
}

// Tools are made from iron at a workbench when the colony wants more, and colonists without
// tools pick one up; working with tools is half again as fast.
#[test]
fn colonists_make_tools_at_a_workbench_and_equip_them() {
    let mut app = test_app(WorldMap::filled(UVec2::splat(30), Terrain::Grass));
    set_goals(&mut app, &[(ItemKind::Tools, 1)]);
    app.world_mut().spawn((
        Structure {
            kind: StructureKind::Workbench,
        },
        TilePos(UVec2::new(15, 15)),
    ));
    app.world_mut().spawn((
        Item::new(ItemKind::Iron, TOOL_IRON),
        TilePos(UVec2::new(5, 5)),
    ));
    let colonist = spawn_colonist(&mut app, UVec2::new(2, 2));
    run_ticks(&mut app, 3000);
    assert_eq!(items_of(&mut app, ItemKind::Iron), 0);
    assert!(app.world().get::<Tool>(colonist).is_some());
    assert_eq!(tool_rate(2, true), 3);
    assert_eq!(tool_rate(1, true), 2);
}

#[test]
fn a_workbench_is_built_when_tools_are_wanted() {
    let mut app = test_app(WorldMap::filled(UVec2::splat(30), Terrain::Grass));
    set_goals(&mut app, &[(ItemKind::Tools, 1)]);
    put_wood(&mut app, UVec2::new(5, 5), 50);
    put_beds(&mut app, 1);
    app.world_mut().spawn((
        Item::new(ItemKind::Iron, TOOL_IRON),
        TilePos(UVec2::new(6, 5)),
    ));
    spawn_colonist(&mut app, UVec2::new(2, 2));
    run_ticks(&mut app, 4000);
    let world = app.world_mut();
    let benches = world
        .query::<&Structure>()
        .iter(world)
        .filter(|s| s.kind == StructureKind::Workbench)
        .count();
    assert_eq!(benches, 1);
}

// A colonist's skill sets how fast they work, and working practises it.
#[test]
fn skilled_colonists_work_faster_and_practice_improves_them() {
    let ticks_to_chop = |level: u32| {
        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));
        app.world_mut()
            .entity_mut(colonist)
            .insert(crate::skills::Skills::uniform(level));
        let mut ticks = 0;
        while wood_on_map(&mut app) == 0 && ticks < 60 * 60 {
            run_ticks(&mut app, 10);
            ticks += 10;
        }
        let skills = app.world().get::<crate::skills::Skills>(colonist).unwrap();
        assert_ne!(skills, &crate::skills::Skills::uniform(level));
        ticks
    };
    assert!(ticks_to_chop(15) * 3 / 2 < ticks_to_chop(1));
}

// Colonists leave work they are poor at to others: it comes after everything else they could do.
#[test]
fn colonists_try_work_they_are_poor_at_last() {
    let first_job = |construction: u32| {
        let mut app = test_app(map_with_trees(&[UVec2::new(8, 5)]));
        set_goals(&mut app, &[(ItemKind::Wood, 100)]);
        put_wood(&mut app, UVec2::new(4, 4), 20);
        put_beds(&mut app, 1);
        app.world_mut()
            .resource_mut::<Blueprints>()
            .0
            .insert(UVec2::new(3, 8), BuildKind::Floor);
        let colonist = spawn_colonist(&mut app, UVec2::new(2, 5));
        let mut skills = crate::skills::Skills::uniform(5);
        let level = crate::skills::xp_for(construction) - crate::skills::xp_for(5);
        skills.practice(crate::skills::Skill::Construction, level);
        app.world_mut().entity_mut(colonist).insert(skills);
        for _ in 0..300 {
            run_ticks(&mut app, 1);
            if let Some(job) = job(&app, colonist)
                && !matches!(job.task, Task::ExpandStockpile { .. } | Task::Haul { .. })
            {
                return job.task;
            }
        }
        panic!("no job");
    };
    assert!(matches!(first_job(8), Task::Build { .. }));
    assert!(matches!(
        first_job(1),
        Task::Work {
            kind: WorkKind::Chop,
            ..
        }
    ));
}

// A wolf near the colony is everyone's business: healthy adults drop their work to go after it,
// while children (and the badly hurt) run the other way.
#[test]
fn adults_fight_wolves_and_children_flee() {
    let mut app = test_app(WorldMap::filled(UVec2::splat(40), Terrain::Grass));
    let wolf = app
        .world_mut()
        .spawn((
            Animal {
                kind: AnimalKind::Wolf,
            },
            TilePos(UVec2::new(20, 20)),
        ))
        .id();
    let adult = spawn_colonist(&mut app, UVec2::new(15, 20));
    let child = spawn_colonist(&mut app, UVec2::new(22, 20));
    app.world_mut()
        .entity_mut(child)
        .insert(crate::family::Child { born: 0 });
    run_ticks(&mut app, 1);
    assert!(matches!(
        job(&app, adult).map(|j| j.task),
        Some(Task::Hunt { animal, .. }) if animal == wolf
    ));
    let route = &app.world().get::<Path>(child).unwrap().0;
    assert!(route.back().is_some_and(|end| end.x > 26));
}

// Families cook at the hearth in their own home (another family's hearth is off limits, even if
// it is closer), and the meals they make stay in the home instead of being hauled away.
#[test]
fn families_cook_at_their_own_hearth_and_keep_the_meals() {
    let mut app = test_app(WorldMap::filled(UVec2::splat(30), Terrain::Grass));
    set_goals(&mut app, &[(ItemKind::Meal, 5)]);
    let own = crate::family::Home::at(UVec2::new(15, 3));
    let other = crate::family::Home::at(UVec2::new(3, 3));
    app.world_mut()
        .resource_mut::<crate::family::Homes>()
        .by_family
        .extend([(1, own), (2, other)]);
    for home in [own, other] {
        app.world_mut().spawn((
            Structure {
                kind: StructureKind::Hearth,
            },
            TilePos(home.hearth_tile()),
        ));
    }
    app.world_mut()
        .spawn((Item::new(ItemKind::Berries, 20), TilePos(UVec2::new(9, 9))));
    let cook = spawn_colonist(&mut app, UVec2::new(9, 6));
    app.world_mut()
        .entity_mut(cook)
        .insert(crate::family::Family(1));
    let mut first = None;
    for _ in 0..600 {
        run_ticks(&mut app, 1);
        if let Some(job) = job(&app, cook)
            && !matches!(job.task, Task::ExpandStockpile { .. } | Task::Haul { .. })
        {
            first = Some(job.task);
            break;
        }
    }
    assert!(
        matches!(first, Some(Task::Craft { station, .. }) if station == own.hearth_tile()),
        "{first:?}"
    );
    let meal_home = UVec2::new(16, 4);
    app.world_mut()
        .spawn((Item::new(ItemKind::Meal, 1), TilePos(meal_home)));
    let snapshot: Vec<(Item, TilePos)> = vec![(Item::new(ItemKind::Meal, 1), TilePos(meal_home))];
    let world = app.world();
    let haul = find_haul(
        world.resource::<WorldMap>(),
        world.resource::<Zones>(),
        world.resource::<Reservations>(),
        &crate::pathfinding::ColonyReach::default(),
        world.resource::<crate::family::Homes>(),
        &snapshot,
        UVec2::new(9, 6),
    );
    assert_eq!(haul, None);
}

// Wounded colonists rest in bed while a doctor fetches a herb and tends them; tending speeds up
// healing for a day, more with a herb and a skilled doctor.
#[test]
fn doctors_tend_the_wounded_with_herbs() {
    let mut app = test_app(WorldMap::filled(UVec2::splat(30), Terrain::Grass));
    put_beds(&mut app, 2);
    app.world_mut()
        .spawn((Item::new(ItemKind::Herbs, 3), TilePos(UVec2::new(8, 8))));
    let patient = spawn_colonist(&mut app, UVec2::new(15, 15));
    app.world_mut()
        .entity_mut(patient)
        .insert(crate::threats::Health(0.3));
    let doctor = spawn_colonist(&mut app, UVec2::new(5, 5));
    run_ticks(&mut app, 60 * 30);
    let tended = app.world().get::<crate::threats::Tended>(patient);
    assert!(tended.is_some_and(|t| t.quality >= 1.0), "{tended:?}");
    assert_eq!(items_of(&mut app, ItemKind::Herbs), 2);
    assert!(app.world().get::<crate::threats::Tended>(doctor).is_none());
    assert!(matches!(
        job(&app, patient).map(|j| j.task),
        Some(Task::Sleep { .. })
    ));
}

// Bridges over deep water are built from the shore outwards: each finished span is the footing
// for the next, until the far bank can be reached.
#[test]
fn colonists_bridge_deep_water_from_the_shore() {
    let mut map = WorldMap::filled(UVec2::new(30, 20), Terrain::Grass);
    for y in 0..20 {
        for x in 12..16 {
            map.set(UVec2::new(x, y), Terrain::DeepWater);
        }
    }
    let mut app = test_app(map);
    put_beds(&mut app, 1);
    put_items(&mut app, UVec2::new(5, 5), ItemKind::Wood, 20);
    let mut blueprints = app.world_mut().resource_mut::<Blueprints>();
    for x in 12..16 {
        blueprints.0.insert(UVec2::new(x, 8), BuildKind::Bridge);
    }
    spawn_colonist(&mut app, UVec2::new(6, 8));
    run_ticks(&mut app, 60 * 60);
    let map = app.world().resource::<WorldMap>();
    for x in 12..16 {
        assert_eq!(map.get(IVec2::new(x, 8)), Some(Terrain::Bridge));
    }
    assert!(find_path(map, UVec2::new(6, 8), UVec2::new(20, 8)).is_some());
}

// Raiders are fought like wolves near the colony: healthy adults shoot at them from range until
// they go down (and drop what they stole), skill making each shot count for more.
#[test]
fn colonists_fight_raiders() {
    let mut app = test_app(WorldMap::filled(UVec2::splat(40), Terrain::Grass));
    let raider = app
        .world_mut()
        .spawn((crate::raids::Raider::default(), TilePos(UVec2::new(20, 20))))
        .id();
    let fighter = spawn_colonist(&mut app, UVec2::new(16, 20));
    run_ticks(&mut app, 1);
    assert!(matches!(
        job(&app, fighter).map(|j| j.task),
        Some(Task::Fight { enemy, .. }) if enemy == raider
    ));
    run_ticks(&mut app, 60 * 20);
    let health = app.world().get::<crate::threats::Health>(raider).unwrap();
    assert!(health.0 <= 0.0, "{health:?}");
}

// Colonists keep trading surplus while it lasts, but never sell below the surplus floor
// (goal + SURPLUS_MARGIN here), so trading can't strip the colony of what it needs.
#[test]
fn colonists_trade_surplus_for_wanted_goods() {
    let mut app = hauling_app((IVec2::new(15, 15), IVec2::new(17, 15)));
    set_goals(&mut app, &[(ItemKind::Wood, 10), (ItemKind::Iron, 10)]);
    put_wood(&mut app, UVec2::new(15, 15), 50);
    let trader = app
        .world_mut()
        .spawn((
            Trader {
                stock: vec![Item::new(ItemKind::Iron, 30)],
                arrived: Some(0),
                ..default()
            },
            TilePos(UVec2::new(10, 10)),
        ))
        .id();
    spawn_colonist(&mut app, UVec2::new(2, 5));
    run_ticks(&mut app, 60 * 30);
    assert_eq!(items_of(&mut app, ItemKind::Iron), 6);
    assert_eq!(items_of(&mut app, ItemKind::Wood), 20);
    assert_eq!(app.world().get::<Trader>(trader).unwrap().deals, 2);
}