use std::{
    collections::{HashMap, HashSet},
    ops::Range,
    time::Duration,
};

use bevy::prelude::*;

use crate::{
    colonist::{Colonist, Path, repath},
    items::{
        CARRY_CAPACITY, Carrying, Item, ItemAssets, ItemKind, ItemQuery, drop_items, room_for,
        stock, take_items,
    },
    pathfinding::{find_path, find_path_adjacent, is_adjacent, nearest_tile},
    rng::SimRng,
    sim::SimSystems,
    world::{Plant, Terrain, TileChanged, TilePos, WorldMap},
    worldgen::WorldGenerated,
    zones::{Zones, plan_expansion},
};

pub struct JobsPlugin;

impl Plugin for JobsPlugin {
    fn build(&self, app: &mut App) {
        app.insert_resource(SimRng::new(0x5EED))
            .init_resource::<Reservations>()
            .init_resource::<ColonyGoals>()
            .add_message::<Order>()
            .add_message::<TileChanged>()
            .add_systems(
                Update,
                (
                    clear_reservations.run_if(on_message::<WorldGenerated>),
                    handle_orders,
                ),
            )
            .add_systems(FixedUpdate, choose_jobs.in_set(SimSystems::Decide))
            .add_systems(FixedUpdate, run_jobs.in_set(SimSystems::Act));
    }
}

pub const EXPAND_TICKS: u32 = 120;
pub const EXPANSION_TILES: usize = 8;
pub const MIN_EMPTY_STOCKPILE_TILES: usize = 3;
const SEARCH_TILES: usize = 15000;
const WANDER_RADIUS: i32 = 8;
const IDLE_SECS: Range<f32> = 1.0..4.0;
const IDLE_AFTER_ORDER_SECS: f32 = 10.0;
const WORK_PAUSE_SECS: Range<f32> = 0.2..0.8;
const NEIGHBORS: [IVec2; 8] = [
    IVec2::new(1, 0),
    IVec2::new(-1, 0),
    IVec2::new(0, 1),
    IVec2::new(0, -1),
    IVec2::new(1, 1),
    IVec2::new(1, -1),
    IVec2::new(-1, 1),
    IVec2::new(-1, -1),
];

#[derive(Component, Default, Debug, Clone, PartialEq)]
pub struct CurrentJob(pub Option<Job>);

#[derive(Debug, Clone, Copy, PartialEq)]
pub struct Job {
    pub task: Task,
    pub ordered: bool,
}

#[derive(Debug, Clone, Copy, PartialEq)]
pub enum Task {
    MoveTo(UVec2),
    Work {
        site: UVec2,
        kind: WorkKind,
        progress: u32,
    },
    Haul {
        pickup: Option<UVec2>,
        to: UVec2,
    },
    ExpandStockpile {
        site: UVec2,
        progress: u32,
    },
}

#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum WorkKind {
    Chop,
    Mine,
}

impl WorkKind {
    pub fn ticks(self) -> u32 {
        match self {
            WorkKind::Chop => 240,
            WorkKind::Mine => 360,
        }
    }

    fn complete(self, map: &mut WorldMap, site: UVec2) {
        match self {
            WorkKind::Chop => map.set_plant(site, None),
            WorkKind::Mine => map.set(site, Terrain::Gravel),
        }
    }
}

pub struct SiteWork {
    pub kind: WorkKind,
    pub item: ItemKind,
    pub count: u32,
}

pub fn site_work(map: &WorldMap, site: UVec2) -> Option<SiteWork> {
    let p = site.as_ivec2();
    if map.plant(p) == Some(Plant::Tree) {
        return Some(SiteWork {
            kind: WorkKind::Chop,
            item: ItemKind::Wood,
            count: 10,
        });
    }
    let (item, count) = match map.get(p)? {
        Terrain::Stone => (ItemKind::Stone, 10),
        Terrain::IronOre => (ItemKind::Iron, 10),
        Terrain::GoldOre => (ItemKind::Gold, 5),
        _ => return None,
    };
    Some(SiteWork {
        kind: WorkKind::Mine,
        item,
        count,
    })
}

#[derive(Component, Debug)]
pub struct IdleTimer(Timer);

impl Default for IdleTimer {
    fn default() -> Self {
        Self(Timer::from_seconds(IDLE_SECS.start, TimerMode::Once))
    }
}

impl IdleTimer {
    fn restart(&mut self, secs: f32) {
        self.0.set_duration(Duration::from_secs_f32(secs));
        self.0.reset();
    }
}

#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub enum Target {
    Site(UVec2),
    Pickup(UVec2),
    Storage(UVec2),
    StockpileExpansion,
}

#[derive(Resource, Default, Debug)]
pub struct Reservations(HashMap<Target, Entity>);

impl Reservations {
    pub fn reserve(&mut self, target: Target, by: Entity) {
        self.0.insert(target, by);
    }

    pub fn holder(&self, target: Target) -> Option<Entity> {
        self.0.get(&target).copied()
    }

    pub fn is_free(&self, target: Target) -> bool {
        self.holder(target).is_none()
    }

    pub fn release(&mut self, target: Target) {
        self.0.remove(&target);
    }

    pub fn release_all(&mut self, by: Entity) {
        self.0.retain(|_, holder| *holder != by);
    }
}

#[derive(Resource, Debug, Clone)]
pub struct ColonyGoals(pub HashMap<ItemKind, u32>);

impl Default for ColonyGoals {
    fn default() -> Self {
        Self(HashMap::from([
            (ItemKind::Wood, 50),
            (ItemKind::Stone, 40),
            (ItemKind::Iron, 20),
            (ItemKind::Gold, 10),
        ]))
    }
}

impl ColonyGoals {
    pub fn goal(&self, kind: ItemKind) -> u32 {
        self.0.get(&kind).copied().unwrap_or(0)
    }

    pub fn wanted(&self, kind: ItemKind, in_stock: u32, on_the_way: u32) -> bool {
        in_stock + on_the_way < self.goal(kind)
    }
}

#[derive(Message, Debug, Clone, Copy)]
pub struct Order {
    pub colonist: Entity,
    pub tile: UVec2,
}

fn clear_reservations(mut reservations: ResMut<Reservations>) {
    reservations.0.clear();
}

fn handle_orders(
    mut orders: MessageReader<Order>,
    map: Res<WorldMap>,
    zones: Res<Zones>,
    items: Query<(&Item, &TilePos)>,
    mut reservations: ResMut<Reservations>,
    mut colonists: Query<(&TilePos, &mut Path, &mut CurrentJob)>,
) {
    for order in orders.read() {
        let Ok((tile, mut path, mut job)) = colonists.get_mut(order.colonist) else {
            continue;
        };
        let loose_item = items
            .iter()
            .find(|(_, pos)| pos.0 == order.tile && !zones.is_stockpile(pos.0));
        let task = if let Some(work) = site_work(&map, order.tile) {
            Some(Task::Work {
                site: order.tile,
                kind: work.kind,
                progress: 0,
            })
        } else if let Some((item, _)) = loose_item {
            find_storage(&map, &zones, &reservations, &items, order.tile, item.kind).map(|to| {
                Task::Haul {
                    pickup: Some(order.tile),
                    to,
                }
            })
        } else {
            None
        };
        if let Some(task) = task {
            reservations.release_all(order.colonist);
            reserve_task(&mut reservations, task, order.colonist);
            path.0.truncate(1);
            job.0 = Some(Job {
                task,
                ordered: true,
            });
        } else if let Some(new_path) = repath(&map, tile.0, &path.0, order.tile) {
            reservations.release_all(order.colonist);
            path.0 = new_path;
            job.0 = Some(Job {
                task: Task::MoveTo(order.tile),
                ordered: true,
            });
        }
    }
}

fn reserve_task(reservations: &mut Reservations, task: Task, by: Entity) {
    match task {
        Task::MoveTo(_) => {}
        Task::Work { site, .. } => reservations.reserve(Target::Site(site), by),
        Task::Haul { pickup, to } => {
            if let Some(pickup) = pickup {
                reservations.reserve(Target::Pickup(pickup), by);
            }
            reservations.reserve(Target::Storage(to), by);
        }
        Task::ExpandStockpile { .. } => reservations.reserve(Target::StockpileExpansion, by),
    }
}

pub fn find_work(
    map: &WorldMap,
    reservations: &Reservations,
    from: UVec2,
    wanted: impl Fn(ItemKind) -> bool,
) -> Option<Task> {
    let mut found = None;
    nearest_tile(map, from, SEARCH_TILES, |stand| {
        found = NEIGHBORS.iter().find_map(|&d| {
            let site = stand.as_ivec2() + d;
            if site.x < 0 || site.y < 0 {
                return None;
            }
            let site = site.as_uvec2();
            let work = site_work(map, site)?;
            (wanted(work.item) && reservations.is_free(Target::Site(site))).then_some(Task::Work {
                site,
                kind: work.kind,
                progress: 0,
            })
        });
        found.is_some()
    })?;
    found
}

pub fn find_storage<'a>(
    map: &WorldMap,
    zones: &Zones,
    reservations: &Reservations,
    items: impl IntoIterator<Item = (&'a Item, &'a TilePos)> + Clone,
    from: UVec2,
    kind: ItemKind,
) -> Option<UVec2> {
    nearest_tile(map, from, SEARCH_TILES, |p| {
        zones.is_stockpile(p)
            && reservations.is_free(Target::Storage(p))
            && room_for(items.clone().into_iter(), p, kind) > 0
    })
}

pub fn find_haul(
    map: &WorldMap,
    zones: &Zones,
    reservations: &Reservations,
    items: &[(Item, TilePos)],
    from: UVec2,
) -> Option<Task> {
    let loose: HashSet<UVec2> = items
        .iter()
        .map(|(_, pos)| pos.0)
        .filter(|&p| !zones.is_stockpile(p) && reservations.is_free(Target::Pickup(p)))
        .collect();
    if loose.is_empty() {
        return None;
    }
    let pickup = nearest_tile(map, from, SEARCH_TILES, |p| loose.contains(&p))?;
    let (item, _) = items.iter().find(|(_, pos)| pos.0 == pickup)?;
    let refs = items.iter().map(|(i, p)| (i, p));
    let to = find_storage(map, zones, reservations, refs, pickup, item.kind)?;
    Some(Task::Haul {
        pickup: Some(pickup),
        to,
    })
}

pub fn stockpile_too_full(zones: &Zones, items: &[(Item, TilePos)]) -> bool {
    let occupied: HashSet<UVec2> = items.iter().map(|(_, pos)| pos.0).collect();
    zones.has_stockpile() && zones.empty_stockpile_tiles(&occupied) < MIN_EMPTY_STOCKPILE_TILES
}

pub fn find_expansion(
    map: &WorldMap,
    zones: &Zones,
    reservations: &Reservations,
    items: &[(Item, TilePos)],
) -> Option<Task> {
    if !reservations.is_free(Target::StockpileExpansion) || !stockpile_too_full(zones, items) {
        return None;
    }
    let site = *plan_expansion(map, zones, EXPANSION_TILES).first()?;
    Some(Task::ExpandStockpile { site, progress: 0 })
}

fn on_the_way(map: &WorldMap, jobs: impl Iterator<Item = Option<Job>>) -> HashMap<ItemKind, u32> {
    let mut totals = HashMap::new();
    for job in jobs.flatten() {
        if let Task::Work { site, .. } = job.task
            && let Some(work) = site_work(map, site)
        {
            *totals.entry(work.item).or_insert(0) += work.count;
        }
    }
    totals
}

#[allow(clippy::too_many_arguments)]
fn choose_jobs(
    mut commands: Commands,
    time: Res<Time>,
    map: Res<WorldMap>,
    zones: Res<Zones>,
    goals: Res<ColonyGoals>,
    item_assets: Res<ItemAssets>,
    mut rng: ResMut<SimRng>,
    mut reservations: ResMut<Reservations>,
    mut items: ItemQuery,
    mut colonists: Query<
        (
            Entity,
            &TilePos,
            &mut Path,
            &mut CurrentJob,
            &mut IdleTimer,
            &mut Carrying,
        ),
        With<Colonist>,
    >,
) {
    let carried: Vec<Item> = colonists.iter().filter_map(|c| c.5.0).collect();
    let stocks: HashMap<ItemKind, u32> = ItemKind::ALL
        .iter()
        .map(|&kind| {
            let all = items.iter().map(|(_, item, _)| item).chain(carried.iter());
            (kind, stock(all, kind))
        })
        .collect();
    let mut pending = on_the_way(&map, colonists.iter().map(|c| c.3.0));
    for (entity, tile, mut path, mut job, mut idle, mut carrying) in &mut colonists {
        if job.0.is_some() || !path.0.is_empty() || !idle.0.tick(time.delta()).is_finished() {
            continue;
        }
        let snapshot: Vec<(Item, TilePos)> =
            items.iter().map(|(_, item, pos)| (*item, *pos)).collect();
        let refs = snapshot.iter().map(|(i, p)| (i, p));
        let wanted = |kind: ItemKind| {
            goals.wanted(
                kind,
                stocks[&kind],
                pending.get(&kind).copied().unwrap_or(0),
            )
        };
        let task = if let Some(load) = carrying.0 {
            let storage = find_storage(&map, &zones, &reservations, refs, tile.0, load.kind);
            if storage.is_none() {
                drop_items(
                    &mut commands,
                    &mut items,
                    &item_assets,
                    tile.0,
                    load.kind,
                    load.count,
                );
                carrying.0 = None;
            }
            storage.map(|to| Task::Haul { pickup: None, to })
        } else {
            find_expansion(&map, &zones, &reservations, &snapshot)
                .or_else(|| find_work(&map, &reservations, tile.0, wanted))
                .or_else(|| find_haul(&map, &zones, &reservations, &snapshot, tile.0))
        };
        if let Some(task) = task {
            if let Task::Work { site, .. } = task
                && let Some(work) = site_work(&map, site)
            {
                *pending.entry(work.item).or_insert(0) += work.count;
            }
            reserve_task(&mut reservations, task, entity);
            job.0 = Some(Job {
                task,
                ordered: false,
            });
            continue;
        }
        let goal = tile.0.as_ivec2()
            + IVec2::new(
                rng.range_i32(-WANDER_RADIUS..WANDER_RADIUS + 1),
                rng.range_i32(-WANDER_RADIUS..WANDER_RADIUS + 1),
            );
        if map.in_bounds(goal)
            && let Some(wander_path) = find_path(&map, tile.0, goal.as_uvec2())
        {
            path.0 = wander_path.into();
            idle.restart(rng.range_f32(IDLE_SECS));
        }
    }
}

enum Step {
    Continue,
    Done,
}

fn walk_to(map: &WorldMap, from: UVec2, to: UVec2, path: &mut Path) -> Step {
    match find_path(map, from, to) {
        Some(p) if !p.is_empty() => {
            path.0 = p.into();
            Step::Continue
        }
        _ => Step::Done,
    }
}

#[allow(clippy::too_many_arguments)]
fn run_jobs(
    mut commands: Commands,
    mut map: ResMut<WorldMap>,
    mut zones: ResMut<Zones>,
    mut reservations: ResMut<Reservations>,
    mut rng: ResMut<SimRng>,
    item_assets: Res<ItemAssets>,
    mut items: ItemQuery,
    mut changed: MessageWriter<TileChanged>,
    mut colonists: Query<(
        Entity,
        &TilePos,
        &mut Path,
        &mut CurrentJob,
        &mut IdleTimer,
        &mut Carrying,
    )>,
) {
    for (entity, tile, mut path, mut current, mut idle, mut carrying) in &mut colonists {
        let Some(mut job) = current.0 else {
            continue;
        };
        if !path.0.is_empty() {
            continue;
        }
        let step = match &mut job.task {
            Task::MoveTo(_) => Step::Done,
            Task::Work {
                site,
                kind,
                progress,
            } => {
                let (site, kind) = (*site, *kind);
                let work = site_work(&map, site).filter(|w| w.kind == kind);
                let ours = reservations.holder(Target::Site(site)) == Some(entity);
                match work {
                    Some(work) if ours => {
                        if !is_adjacent(tile.0.as_ivec2(), site.as_ivec2()) {
                            match find_path_adjacent(&map, tile.0, site) {
                                Some(p) if !p.is_empty() => {
                                    path.0 = p.into();
                                    Step::Continue
                                }
                                _ => Step::Done,
                            }
                        } else {
                            *progress += 1;
                            if *progress < kind.ticks() {
                                Step::Continue
                            } else {
                                kind.complete(&mut map, site);
                                changed.write(TileChanged(site));
                                drop_items(
                                    &mut commands,
                                    &mut items,
                                    &item_assets,
                                    site,
                                    work.item,
                                    work.count,
                                );
                                Step::Done
                            }
                        }
                    }
                    _ => Step::Done,
                }
            }
            Task::ExpandStockpile { site, progress } => {
                if tile.0 != *site {
                    walk_to(&map, tile.0, *site, &mut path)
                } else {
                    *progress += 1;
                    if *progress >= EXPAND_TICKS {
                        let tiles = plan_expansion(&map, &zones, EXPANSION_TILES);
                        zones.add_tiles(&map, tiles);
                        Step::Done
                    } else {
                        Step::Continue
                    }
                }
            }
            Task::Haul { pickup, to } => {
                let to = *to;
                let destination_valid = zones.is_stockpile(to)
                    && reservations.holder(Target::Storage(to)) == Some(entity);
                if !destination_valid {
                    Step::Done
                } else if let Some(from) = *pickup {
                    if reservations.holder(Target::Pickup(from)) != Some(entity) {
                        Step::Done
                    } else if tile.0 != from {
                        walk_to(&map, tile.0, from, &mut path)
                    } else {
                        let kind = items
                            .iter()
                            .find(|(_, _, pos)| pos.0 == from)
                            .map(|(_, item, _)| item.kind);
                        let room = kind.map_or(0, |kind| {
                            room_for(items.iter().map(|(_, i, p)| (i, p)), to, kind)
                        });
                        match take_items(&mut commands, &mut items, from, CARRY_CAPACITY.min(room))
                            .filter(|load| load.count > 0)
                        {
                            Some(load) => {
                                carrying.0 = Some(load);
                                reservations.release(Target::Pickup(from));
                                *pickup = None;
                                Step::Continue
                            }
                            None => Step::Done,
                        }
                    }
                } else if let Some(load) = carrying.0 {
                    if tile.0 != to {
                        walk_to(&map, tile.0, to, &mut path)
                    } else {
                        let room = room_for(items.iter().map(|(_, i, p)| (i, p)), to, load.kind);
                        let dropped = load.count.min(room);
                        if dropped > 0 {
                            drop_items(
                                &mut commands,
                                &mut items,
                                &item_assets,
                                to,
                                load.kind,
                                dropped,
                            );
                        }
                        carrying.0 = (load.count > dropped).then_some(Item {
                            count: load.count - dropped,
                            ..load
                        });
                        Step::Done
                    }
                } else {
                    Step::Done
                }
            }
        };
        match step {
            Step::Continue => current.0 = Some(job),
            Step::Done => {
                reservations.release_all(entity);
                current.0 = None;
                let ordered_move = matches!(
                    job,
                    Job {
                        task: Task::MoveTo(_),
                        ordered: true
                    }
                );
                idle.restart(if ordered_move {
                    IDLE_AFTER_ORDER_SECS
                } else {
                    rng.range_f32(WORK_PAUSE_SECS)
                });
            }
        }
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use crate::{
        colonist::follow_path,
        items::STACK_LIMIT,
        sim::{SimPos, sim_pos},
        world::Terrain,
    };

    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::<Zones>()
            .add_message::<Order>()
            .add_message::<TileChanged>()
            .add_systems(
                Update,
                (handle_orders, choose_jobs, run_jobs, follow_path).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 {
                kind: ItemKind::Wood,
                count,
            },
            TilePos(tile),
        ));
    }

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

    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 hauling_app(stockpile: (IVec2, IVec2)) -> App {
        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, 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));
    }

    // Each tree or rock being worked will add its yield; counting that as material on the way
    // keeps the whole colony from felling a forest when only a little more wood is needed.
    #[test]
    fn work_in_progress_counts_towards_goals() {
        let goals = ColonyGoals(HashMap::from([(ItemKind::Wood, 25)]));
        assert!(goals.wanted(ItemKind::Wood, 10, 10));
        assert!(!goals.wanted(ItemKind::Wood, 10, 20));
        assert!(!goals.wanted(ItemKind::Wood, 30, 0));
        assert!(!goals.wanted(ItemKind::Gold, 0, 0));
    }

    #[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 without_a_stockpile_nothing_is_hauled() {
        let mut app = test_app(map_with_trees(&[]));
        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 * 5);
        assert_eq!(items_at(&mut app), vec![(UVec2::new(5, 5), 20)]);
    }

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

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