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

use bevy::prelude::*;

use crate::{
    animals::{Animal, AnimalKind, MAX_TAME, Tame},
    building::{Blueprints, BuildKind},
    climate::{COLD_TEMP, WARM_TEMP, Warmth, outdoor_temperature, sowing_season, tile_temperature},
    colonist::{Colonist, Path, repath},
    designations::Designations,
    economy::{ColonyGoals, Stock, in_colony},
    family::{Child, Family, Home, Homes},
    food::{EAT_TICKS, Hunger, STARVING, find_food, portion, wants_food},
    items::{
        CARRY_CAPACITY, Carrying, Item, ItemAssets, ItemKind, ItemQuery, STACK_LIMIT, drop_items,
        room_for, take_items,
    },
    light::{
        LIGHT_LOOKAHEAD_TICKS, LIT_BRIGHTNESS, LightMap, brightness, dark_soon, light_from,
        line_of_sight,
    },
    mood::{Ate, Sick},
    needs::{EXHAUSTED_REST, Rest, SleepContext, done_sleeping, wants_sleep},
    pathfinding::{
        ColonyReach, WANDER_SEARCH, can_step, find_bridged_path, find_nearby_path, find_path,
        find_path_adjacent, find_path_adjacent_within, is_adjacent, nearest_of, nearest_tile,
        search_reach,
    },
    paths::busy_path,
    population::ColonyLog,
    raids::Raider,
    rng::SimRng,
    sim::{SimSystems, SimTick, hour_of_day},
    skills::{POOR_LEVEL, Skill, Skills, WorkCarry, speed},
    social::{FRIEND, Relations},
    structures::{Fuel, Structure, StructureAssets, StructureKind, spawn_structure},
    threats::{Health, INJURED, TEND_WORK, TENDED_TICKS, Tended, needs_tending, tend_quality},
    trading::{TRADE_WORK, Trader, find_trade},
    world::{Plant, Terrain, TileChanged, TilePos, WorldMap},
    worldgen::WorldGenerated,
    zones::{
        StoragePriority, Zones, can_zone, find_stockpile_site, new_stockpile_tiles, plan_expansion,
    },
};

pub struct JobsPlugin;

impl Plugin for JobsPlugin {
    fn build(&self, app: &mut App) {
        app.insert_resource(SimRng::new(0x5EED))
            .init_resource::<Reservations>()
            .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_WORK: u32 = 240;
pub const REFUEL_BELOW_SHARE: u32 = 3;
pub const CAMPFIRE_MIN_FUEL: u32 = 3 * crate::sim::TICKS_PER_HOUR as u32;
pub const HOME_RADIUS: f32 = 10.0;
pub const BED_STOCKPILE_CLEARANCE: i32 = 3;
const LIT_WORK_RATE: u32 = 2;
const DARK_WORK_RATE: u32 = 1;
pub const EXPANSION_TILES: usize = 8;
pub const MIN_EMPTY_STOCKPILE_TILES: usize = 3;
const SEARCH_TILES: usize = 15000;
const FORAGE_SEARCH_TILES: usize = 5000;
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(Clone, Copy, Debug, PartialEq, Eq, Hash, Serialize, Deserialize)]
pub enum WorkType {
    Food,
    Build,
    Gather,
    Haul,
    Tame,
    Craft,
    Doctor,
}

impl WorkType {
    pub const ALL: [WorkType; 7] = [
        WorkType::Food,
        WorkType::Build,
        WorkType::Gather,
        WorkType::Haul,
        WorkType::Tame,
        WorkType::Craft,
        WorkType::Doctor,
    ];

    pub fn label(self) -> &'static str {
        match self {
            WorkType::Food => "Food",
            WorkType::Build => "Build",
            WorkType::Gather => "Gather",
            WorkType::Haul => "Haul",
            WorkType::Tame => "Tame",
            WorkType::Craft => "Craft",
            WorkType::Doctor => "Doctor",
        }
    }
}

#[derive(Component, Default, Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
pub struct WorkPriorities {
    disabled: Vec<WorkType>,
}

impl WorkPriorities {
    pub fn allows(&self, work: WorkType) -> bool {
        !self.disabled.contains(&work)
    }

    pub fn toggle(&mut self, work: WorkType) {
        if self.allows(work) {
            self.disabled.push(work);
        } else {
            self.disabled.retain(|w| *w != work);
        }
    }
}

#[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,
    },
    Build {
        site: UVec2,
        kind: BuildKind,
        pickup: Option<UVec2>,
        progress: u32,
    },
    Sleep {
        spot: UVec2,
    },
    Eat {
        pickup: Option<UVec2>,
        progress: u32,
    },
    Hunt {
        animal: Entity,
        kind: AnimalKind,
        progress: u32,
    },
    Craft {
        recipe: Recipe,
        pickup: Option<UVec2>,
        station: UVec2,
        progress: u32,
    },
    Equip {
        pickup: UVec2,
    },
    Tend {
        patient: Entity,
        pickup: Option<UVec2>,
        progress: u32,
    },
    Fight {
        enemy: Entity,
        progress: u32,
    },
    Butcher {
        site: UVec2,
        progress: u32,
    },
    Tame {
        animal: Entity,
        kind: AnimalKind,
        progress: u32,
    },
    Trade {
        trader: Entity,
        pickup: Option<UVec2>,
        give: ItemKind,
        count: u32,
        want: ItemKind,
        receive: u32,
        progress: u32,
    },
}

#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum Recipe {
    Meal,
    Tools,
}

impl Recipe {
    pub fn stations(self) -> &'static [StructureKind] {
        match self {
            Recipe::Meal => &[StructureKind::Campfire, StructureKind::Hearth],
            Recipe::Tools => &[StructureKind::Workbench],
        }
    }

    pub fn accepts(self, kind: ItemKind) -> bool {
        match self {
            Recipe::Meal => kind.is_raw_food(),
            Recipe::Tools => kind == ItemKind::Iron,
        }
    }

    pub fn input(self) -> u32 {
        match self {
            Recipe::Meal => COOK_INPUT,
            Recipe::Tools => TOOL_IRON,
        }
    }

    pub fn work(self) -> u32 {
        match self {
            Recipe::Meal => COOK_WORK,
            Recipe::Tools => TOOL_WORK,
        }
    }

    pub fn output(self) -> ItemKind {
        match self {
            Recipe::Meal => ItemKind::Meal,
            Recipe::Tools => ItemKind::Tools,
        }
    }
}

pub const TOOL_IRON: u32 = 3;
pub const TOOL_WORK: u32 = 600;
pub const TOOL_LIFE_TICKS: u32 = 2 * 24 * crate::sim::TICKS_PER_HOUR as u32;

#[derive(Component, Debug, Default, Clone, Copy, PartialEq, Eq)]
pub struct Tool {
    pub wear: u32,
}

impl Task {
    pub fn progress(&self) -> Option<u32> {
        match *self {
            Task::Work { progress, .. }
            | Task::ExpandStockpile { progress, .. }
            | Task::Build { progress, .. }
            | Task::Hunt { progress, .. }
            | Task::Craft { progress, .. }
            | Task::Butcher { progress, .. }
            | Task::Tame { progress, .. }
            | Task::Tend { progress, .. }
            | Task::Fight { progress, .. }
            | Task::Trade { progress, .. }
            | Task::Eat { progress, .. } => Some(progress),
            _ => None,
        }
    }
}

pub fn tool_rate(rate: u32, tool: bool) -> u32 {
    if tool { (rate * 3).div_ceil(2) } else { rate }
}

pub fn work_rate(light: &LightMap, tile: UVec2) -> u32 {
    if light.is_lit(tile) {
        LIT_WORK_RATE
    } else {
        DARK_WORK_RATE
    }
}

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

impl WorkKind {
    pub fn work(self) -> u32 {
        match self {
            WorkKind::Chop => 480,
            WorkKind::Mine => 720,
            WorkKind::Harvest => 240,
            WorkKind::Sow => 160,
        }
    }

    fn complete(self, map: &mut WorldMap, site: UVec2) {
        match self {
            WorkKind::Chop => map.set_plant(site, None),
            WorkKind::Mine => map.set(site, Terrain::Gravel),
            WorkKind::Harvest => {
                if map.plant(site.as_ivec2()) == Some(Plant::Crop) {
                    map.set_plant(site, None);
                }
                map.set_growth(site, 0.0);
            }
            WorkKind::Sow => {
                map.set_plant(site, Some(Plant::Crop));
                map.set_growth(site, 0.0);
            }
        }
    }
}

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();
    let harvest = |item, count| SiteWork {
        kind: WorkKind::Harvest,
        item,
        count,
    };
    match map.plant(p) {
        Some(Plant::Tree) => {
            return Some(SiteWork {
                kind: WorkKind::Chop,
                item: ItemKind::Wood,
                count: 10,
            });
        }
        Some(Plant::BerryBush) if map.ripe_plant(p).is_some() => {
            return Some(harvest(ItemKind::Berries, 8));
        }
        Some(Plant::Crop) if map.ripe_plant(p).is_some() => {
            return Some(harvest(ItemKind::Vegetables, 10));
        }
        Some(Plant::Herb) if map.ripe_plant(p).is_some() => {
            return Some(harvest(ItemKind::Herbs, 3));
        }
        _ => {}
    }
    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,
    SleepSpot(UVec2),
    Animal(Entity),
    Station(UVec2),
    Patient(Entity),
}

#[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(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)>,
    animals: Query<(Entity, &TilePos, &Animal), Without<Colonist>>,
    mut reservations: ResMut<Reservations>,
    mut colonists: Query<(&TilePos, &mut Path, &mut CurrentJob), With<Colonist>>,
) {
    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 animal = animals.iter().find(|(_, pos, _)| pos.0 == order.tile);
        let task = if let Some((animal, _, a)) = animal {
            Some(Task::Hunt {
                animal,
                kind: a.kind,
                progress: 0,
            })
        } else 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 {
            let anywhere = ColonyReach::default();
            find_storage(
                &map,
                &zones,
                &reservations,
                &anywhere,
                &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::Fight { .. } => {}
        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),
        Task::Sleep { spot } => reservations.reserve(Target::SleepSpot(spot), by),
        Task::Eat { pickup, .. } => {
            if let Some(pickup) = pickup {
                reservations.reserve(Target::Pickup(pickup), by);
            }
        }
        Task::Hunt { animal, .. } | Task::Tame { animal, .. } => {
            reservations.reserve(Target::Animal(animal), by)
        }
        Task::Butcher { site, .. } => reservations.reserve(Target::Pickup(site), by),
        Task::Equip { pickup } => reservations.reserve(Target::Pickup(pickup), by),
        Task::Trade { pickup, .. } => {
            if let Some(pickup) = pickup {
                reservations.reserve(Target::Pickup(pickup), by);
            }
        }
        Task::Tend {
            patient, pickup, ..
        } => {
            reservations.reserve(Target::Patient(patient), by);
            if let Some(pickup) = pickup {
                reservations.reserve(Target::Pickup(pickup), by);
            }
        }
        Task::Craft {
            pickup, station, ..
        } => {
            reservations.reserve(Target::Station(station), by);
            if let Some(pickup) = pickup {
                reservations.reserve(Target::Pickup(pickup), by);
            }
        }
        Task::Build { site, pickup, .. } => {
            reservations.reserve(Target::Site(site), by);
            if let Some(pickup) = pickup {
                reservations.reserve(Target::Pickup(pickup), by);
            }
        }
    }
}

const GATHER_RETRY_TICKS: u64 = 300;
const HAUL_RETRY_TICKS: u64 = 120;
const FOOD_RETRY_TICKS: u64 = 60;

#[derive(Default, Clone, Copy)]
pub struct Memo {
    mask: u32,
    until: u64,
}

impl Memo {
    fn skips(self, mask: u32, tick: u64) -> bool {
        self.mask == mask && tick < self.until
    }
}

#[derive(Default)]
pub struct GatherMemo {
    gather: Memo,
    forage: Memo,
    haul: Memo,
    build: Memo,
    food: HashMap<Entity, u64>,
    warm: Option<(u64, HashSet<UVec2>)>,
}

pub fn find_work(
    map: &WorldMap,
    reservations: &Reservations,
    from: UVec2,
    wanted: impl Fn(UVec2, ItemKind) -> bool,
) -> Option<Task> {
    find_work_within(map, reservations, from, SEARCH_TILES, wanted)
}

pub fn find_work_within(
    map: &WorldMap,
    reservations: &Reservations,
    from: UVec2,
    max_tiles: usize,
    wanted: impl Fn(UVec2, ItemKind) -> bool,
) -> Option<Task> {
    let mut found = None;
    nearest_tile(map, from, max_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(site, work.item) && reservations.is_free(Target::Site(site))).then_some(
                Task::Work {
                    site,
                    kind: work.kind,
                    progress: 0,
                },
            )
        });
        found.is_some()
    })?;
    found
}

fn stacks_by_tile<'a>(
    items: impl IntoIterator<Item = (&'a Item, &'a TilePos)>,
) -> HashMap<UVec2, (ItemKind, u32)> {
    let mut stacks: HashMap<UVec2, (ItemKind, u32)> = HashMap::new();
    for (item, pos) in items {
        stacks.entry(pos.0).or_insert((item.kind, 0)).1 += item.count;
    }
    stacks
}

fn storage_candidates<'z>(
    zones: &'z Zones,
    reservations: &'z Reservations,
    stacks: &'z HashMap<UVec2, (ItemKind, u32)>,
    kind: ItemKind,
) -> impl Iterator<Item = UVec2> + 'z {
    zones.stockpile_tiles().filter(move |&t| {
        zones.accepts(t, kind)
            && reservations.is_free(Target::Storage(t))
            && match stacks.get(&t) {
                None => true,
                Some(&(other, count)) => other == kind && count < STACK_LIMIT,
            }
    })
}

pub fn find_storage<'a>(
    map: &WorldMap,
    zones: &Zones,
    reservations: &Reservations,
    reach: &ColonyReach,
    items: impl IntoIterator<Item = (&'a Item, &'a TilePos)> + Clone,
    from: UVec2,
    kind: ItemKind,
) -> Option<UVec2> {
    let stacks = stacks_by_tile(items);
    StoragePriority::DESCENDING
        .into_iter()
        .find_map(|priority| {
            let candidates: HashSet<UVec2> = storage_candidates(zones, reservations, &stacks, kind)
                .filter(|&t| zones.rule(t).priority == priority)
                .collect();
            reach.nearest(map, from, SEARCH_TILES, &candidates)
        })
}

pub fn find_haul(
    map: &WorldMap,
    zones: &Zones,
    reservations: &Reservations,
    reach: &ColonyReach,
    homes: &Homes,
    items: &[(Item, TilePos)],
    from: UVec2,
) -> Option<Task> {
    let stacks = stacks_by_tile(items.iter().map(|(i, p)| (i, p)));
    let mut best: HashMap<ItemKind, StoragePriority> = HashMap::new();
    let misplaced = |item: &Item, tile: UVec2, best: &mut HashMap<ItemKind, StoragePriority>| {
        if !zones.accepts(tile, item.kind) {
            return true;
        }
        let top = *best.entry(item.kind).or_insert_with(|| {
            storage_candidates(zones, reservations, &stacks, item.kind)
                .map(|t| zones.rule(t).priority)
                .max()
                .unwrap_or(StoragePriority::Low)
        });
        zones.rule(tile).priority < top
    };
    let mut room: HashMap<ItemKind, bool> = HashMap::new();
    let loose: HashSet<UVec2> = items
        .iter()
        .filter(|(item, pos)| {
            reservations.is_free(Target::Pickup(pos.0))
                && reach.allows(pos.0)
                && !(item.kind == ItemKind::Meal && homes.is_home(pos.0))
                && misplaced(item, pos.0, &mut best)
                && *room.entry(item.kind).or_insert_with(|| {
                    storage_candidates(zones, reservations, &stacks, item.kind)
                        .next()
                        .is_some()
                })
        })
        .map(|(_, pos)| pos.0)
        .collect();
    if loose.is_empty() {
        return None;
    }
    let pickup = reach.nearest(map, from, SEARCH_TILES, &loose)?;
    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, reach, refs, pickup, item.kind)?;
    Some(Task::Haul {
        pickup: Some(pickup),
        to,
    })
}

pub fn sowable(map: &WorldMap, zones: &Zones, site: UVec2) -> bool {
    zones.is_farm(site) && map.plant(site.as_ivec2()).is_none()
}

pub fn find_sowing(
    map: &WorldMap,
    zones: &Zones,
    reservations: &Reservations,
    from: UVec2,
) -> Option<Task> {
    let open: HashSet<UVec2> = zones
        .farm_tiles()
        .filter(|&p| sowable(map, zones, p) && reservations.is_free(Target::Site(p)))
        .collect();
    let site = nearest_of(map, from, SEARCH_TILES, &open)?;
    Some(Task::Work {
        site,
        kind: WorkKind::Sow,
        progress: 0,
    })
}

pub const HUNT_RADIUS: f32 = 60.0;
pub const HUNT_RANGE: f32 = 6.0;

pub type Wildlife = (Entity, UVec2, AnimalKind, bool);

fn nearest_reachable(
    map: &WorldMap,
    reservations: &Reservations,
    animals: &[Wildlife],
    from: UVec2,
    pick: impl Fn(&Wildlife) -> bool,
) -> Option<Wildlife> {
    let mut candidates: Vec<&Wildlife> = animals
        .iter()
        .filter(|a| {
            pick(a)
                && reservations.is_free(Target::Animal(a.0))
                && a.1.as_vec2().distance(from.as_vec2()) <= HUNT_RADIUS
        })
        .collect();
    candidates.sort_by(|a, b| {
        a.1.as_vec2()
            .distance_squared(from.as_vec2())
            .total_cmp(&b.1.as_vec2().distance_squared(from.as_vec2()))
    });
    candidates
        .into_iter()
        .find(|a| find_path_adjacent(map, from, a.1).is_some())
        .copied()
}

pub fn find_hunt(
    map: &WorldMap,
    reservations: &Reservations,
    animals: &[Wildlife],
    from: UVec2,
) -> Option<Task> {
    let herd = |kind: AnimalKind| animals.iter().filter(|a| a.3 && a.2 == kind).count();
    let spare_tame = |a: &Wildlife| a.3 && herd(a.2) > 2;
    let (animal, _, kind, _) = nearest_reachable(map, reservations, animals, from, spare_tame)
        .or_else(|| nearest_reachable(map, reservations, animals, from, |a| !a.3))?;
    Some(Task::Hunt {
        animal,
        kind,
        progress: 0,
    })
}

pub fn find_taming(
    map: &WorldMap,
    reservations: &Reservations,
    animals: &[Wildlife],
    from: UVec2,
) -> Option<Task> {
    if animals.iter().filter(|a| a.3).count() >= MAX_TAME {
        return None;
    }
    let tameable = |a: &Wildlife| !a.3 && !a.2.is_predator();
    let (animal, _, kind, _) = nearest_reachable(map, reservations, animals, from, tameable)?;
    Some(Task::Tame {
        animal,
        kind,
        progress: 0,
    })
}

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)],
    blueprints: &Blueprints,
) -> Option<Task> {
    if !reservations.is_free(Target::StockpileExpansion) {
        return None;
    }
    let site = if zones.has_stockpile() {
        if !stockpile_too_full(zones, items) {
            return None;
        }
        *plan_expansion(map, zones, &blueprints.tiles(), EXPANSION_TILES).first()?
    } else {
        find_stockpile_site(map, central_item_tile(items)?)?
    };
    Some(Task::ExpandStockpile { site, progress: 0 })
}

fn central_item_tile(items: &[(Item, TilePos)]) -> Option<UVec2> {
    let tiles: Vec<Vec2> = items.iter().map(|(_, pos)| pos.0.as_vec2()).collect();
    let centroid = tiles.iter().sum::<Vec2>() / tiles.len().max(1) as f32;
    items.iter().map(|(_, pos)| pos.0).min_by(|a, b| {
        a.as_vec2()
            .distance_squared(centroid)
            .total_cmp(&b.as_vec2().distance_squared(centroid))
    })
}

pub struct BuildContext<'a> {
    pub map: &'a WorldMap,
    pub zones: &'a Zones,
    pub reservations: &'a Reservations,
    pub items: &'a [(Item, TilePos)],
    pub structures: &'a [(UVec2, StructureKind, u32)],
    pub planned: &'a [(UVec2, StructureKind)],
    pub blueprints: &'a Blueprints,
    pub occupied: &'a HashSet<UVec2>,
    pub reach: &'a ColonyReach,
}

impl BuildContext<'_> {
    fn buildable(&self, tile: UVec2) -> bool {
        can_zone(self.map, tile.as_ivec2())
            && !busy_path(self.map, tile.as_ivec2())
            && !self.zones.is_stockpile(tile)
            && !self.zones.is_farm(tile)
            && self.map.plant(tile.as_ivec2()).is_none()
            && !self.occupied.contains(&tile)
            && self.blueprints.get(tile).is_none()
            && self.reservations.is_free(Target::Site(tile))
    }

    fn lights(&self) -> impl Iterator<Item = (UVec2, StructureKind)> + Clone + '_ {
        self.structures
            .iter()
            .map(|&(pos, kind, _)| (pos, kind))
            .chain(self.planned.iter().copied())
    }

    fn campfire_needed(&self, home: UVec2) -> bool {
        let burning = self.structures.iter().any(|&(pos, kind, fuel)| {
            kind == StructureKind::Campfire
                && fuel >= CAMPFIRE_MIN_FUEL
                && pos.as_vec2().distance(home.as_vec2()) <= HOME_RADIUS
        });
        let planned = self
            .planned
            .iter()
            .any(|(_, kind)| *kind == StructureKind::Campfire);
        !burning && !planned
    }

    fn darkest_stockpile_tile(&self, home: UVec2) -> Option<UVec2> {
        self.zones
            .stockpile_tiles()
            .filter(|&t| brightness(light_from(t, self.lights())) < LIT_BRIGHTNESS)
            .min_by(|a, b| {
                a.as_vec2()
                    .distance_squared(home.as_vec2())
                    .total_cmp(&b.as_vec2().distance_squared(home.as_vec2()))
                    .then((a.y, a.x).cmp(&(b.y, b.x)))
            })
    }

    fn site_near(&self, target: UVec2, max_distance: f32) -> Option<UVec2> {
        self.site_near_where(target, max_distance, |_| true)
    }

    fn site_near_where(
        &self,
        target: UVec2,
        max_distance: f32,
        extra: impl Fn(UVec2) -> bool,
    ) -> Option<UVec2> {
        nearest_tile(self.map, target, SEARCH_TILES, |p| {
            self.buildable(p) && extra(p)
        })
        .filter(|site| site.as_vec2().distance(target.as_vec2()) <= max_distance)
    }

    fn clear_of_stockpile(&self, tile: UVec2) -> bool {
        self.zones
            .stockpile_tiles()
            .chain(self.zones.farm_tiles())
            .all(|s| {
                (s.as_ivec2() - tile.as_ivec2()).abs().max_element() >= BED_STOCKPILE_CLEARANCE
            })
    }

    fn count(&self, kind: StructureKind) -> usize {
        let built = self.structures.iter().filter(|s| s.1 == kind).count();
        built + self.planned.iter().filter(|p| p.1 == kind).count()
    }

    fn bed_anchor(&self, home: UVec2) -> UVec2 {
        let positions = |kind: StructureKind| {
            let built = self.structures.iter().map(|s| (s.0, s.1));
            built
                .chain(self.planned.iter().copied())
                .filter(move |s| s.1 == kind)
                .map(|s| s.0)
        };
        let nearest = |kind: StructureKind| {
            positions(kind).min_by(|a, b| {
                a.as_vec2()
                    .distance_squared(home.as_vec2())
                    .total_cmp(&b.as_vec2().distance_squared(home.as_vec2()))
            })
        };
        nearest(StructureKind::Bed)
            .or_else(|| nearest(StructureKind::Campfire))
            .unwrap_or(home)
    }

    fn material_source(&self, from: UVec2, (kind, amount): (ItemKind, u32)) -> Option<UVec2> {
        let stacks: Vec<(u32, UVec2)> = self
            .items
            .iter()
            .filter(|(item, pos)| {
                item.kind == kind && self.reservations.is_free(Target::Pickup(pos.0))
            })
            .map(|(item, pos)| (item.count, pos.0))
            .collect();
        if stacks.iter().map(|(count, _)| count).sum::<u32>() < amount {
            return None;
        }
        let tiles: HashSet<UVec2> = stacks.into_iter().map(|(_, tile)| tile).collect();
        self.reach.nearest(self.map, from, SEARCH_TILES, &tiles)
    }

    fn build_task(&self, from: UVec2, site: UVec2, kind: BuildKind) -> Option<Task> {
        let pickup = match kind.cost() {
            (_, 0) => None,
            cost => Some(self.material_source(from, cost)?),
        };
        Some(Task::Build {
            site,
            kind,
            pickup,
            progress: 0,
        })
    }
}

pub const COOK_INPUT: u32 = 6;
pub const COOK_WORK: u32 = 300;
pub const COOK_MIN_FUEL: u32 = crate::sim::TICKS_PER_HOUR as u32;

pub fn find_campfire(ctx: &BuildContext, from: UVec2) -> Option<Task> {
    let home = ctx.zones.home(from);
    if !ctx.campfire_needed(home) {
        return None;
    }
    let site = ctx.site_near(home, HOME_RADIUS)?;
    ctx.build_task(from, site, BuildKind::Structure(StructureKind::Campfire))
}

pub fn food_to_fetch(reservations: &Reservations, food_tiles: &HashSet<UVec2>) -> bool {
    food_tiles
        .iter()
        .any(|&p| reservations.is_free(Target::Pickup(p)))
}

pub fn input_source(ctx: &BuildContext, from: UVec2, recipe: Recipe) -> Option<UVec2> {
    let sources: HashSet<UVec2> = ctx
        .items
        .iter()
        .filter(|(item, pos)| {
            recipe.accepts(item.kind)
                && item.count >= recipe.input()
                && ctx.reservations.is_free(Target::Pickup(pos.0))
        })
        .map(|(_, pos)| pos.0)
        .collect();
    ctx.reach.nearest(ctx.map, from, SEARCH_TILES, &sources)
}

pub const BUTCHER_WORK: u32 = 240;

pub fn find_butchering(
    map: &WorldMap,
    reservations: &Reservations,
    items: &[(Item, TilePos)],
    from: UVec2,
) -> Option<Task> {
    let carcasses: HashSet<UVec2> = items
        .iter()
        .filter(|(item, pos)| {
            item.kind == ItemKind::Carcass && reservations.is_free(Target::Pickup(pos.0))
        })
        .map(|(_, pos)| pos.0)
        .collect();
    let site = nearest_of(map, from, SEARCH_TILES, &carcasses)?;
    Some(Task::Butcher { site, progress: 0 })
}

pub fn find_workbench(ctx: &BuildContext, from: UVec2) -> Option<Task> {
    if ctx.count(StructureKind::Workbench) > 0 {
        return None;
    }
    let home = ctx.zones.home(from);
    let site = ctx.site_near(home, HOME_RADIUS * 1.5)?;
    ctx.build_task(from, site, BuildKind::Structure(StructureKind::Workbench))
}

pub fn tool_source(
    map: &WorldMap,
    reservations: &Reservations,
    items: &[(Item, TilePos)],
    from: UVec2,
) -> Option<UVec2> {
    let tools: HashSet<UVec2> = items
        .iter()
        .filter(|(item, pos)| {
            item.kind == ItemKind::Tools && reservations.is_free(Target::Pickup(pos.0))
        })
        .map(|(_, pos)| pos.0)
        .collect();
    if tools.is_empty() {
        return None;
    }
    nearest_of(map, from, SEARCH_TILES, &tools)
}

pub fn find_crafting(
    ctx: &BuildContext,
    from: UVec2,
    recipe: Recipe,
    home: Option<&Home>,
) -> Option<Task> {
    let usable = |pos: UVec2, kind: StructureKind| {
        kind != StructureKind::Hearth || home.is_some_and(|h| h.contains(pos))
    };
    let station = ctx
        .structures
        .iter()
        .filter(|&&(pos, kind, fuel)| {
            recipe.stations().contains(&kind)
                && usable(pos, kind)
                && fuel >= COOK_MIN_FUEL
                && ctx.reservations.is_free(Target::Station(pos))
        })
        .min_by_key(|&&(pos, kind, _)| {
            let d = pos.as_ivec2() - from.as_ivec2();
            (
                kind != StructureKind::Hearth,
                d.length_squared(),
                pos.y,
                pos.x,
            )
        })
        .map(|&(pos, ..)| pos)?;
    let pickup = input_source(ctx, from, recipe)?;
    Some(Task::Craft {
        recipe,
        pickup: Some(pickup),
        station,
        progress: 0,
    })
}

pub fn find_lighting(ctx: &BuildContext, from: UVec2, dark: bool) -> Option<Task> {
    let home = ctx.zones.home(from);
    let (kind, site) = if ctx.campfire_needed(home) {
        (StructureKind::Campfire, ctx.site_near(home, HOME_RADIUS)?)
    } else if !dark {
        return None;
    } else {
        let dark = ctx.darkest_stockpile_tile(home)?;
        let reach = StructureKind::Torch.radius() * 0.6;
        (StructureKind::Torch, ctx.site_near(dark, reach)?)
    };
    ctx.build_task(from, site, BuildKind::Structure(kind))
}

pub const SHOT_WORK: u32 = 90;
pub const SHOT_DAMAGE: f32 = 0.2;
const FIGHT_SEARCH: usize = 4000;
const FIGHT_STEPS: usize = 4;
pub const DANGER_RANGE: i32 = 6;
const VISIT_CHANCE: f32 = 0.4;
const VISIT_RANGE: i32 = 30;
const VISIT_SEARCH: usize = 3000;
pub const DEFEND_RANGE: i32 = 15;
const FLEE_STEPS: f32 = 10.0;

fn chebyshev(a: UVec2, b: UVec2) -> i32 {
    (a.as_ivec2() - b.as_ivec2()).abs().max_element()
}

pub fn flee_from(map: &WorldMap, from: UVec2, threat: UVec2) -> Option<Vec<UVec2>> {
    let away = (from.as_ivec2() - threat.as_ivec2())
        .as_vec2()
        .normalize_or(Vec2::X);
    let goal = (from.as_ivec2() + (away * FLEE_STEPS).round().as_ivec2())
        .clamp(IVec2::ZERO, map.size.as_ivec2() - 1);
    let open = nearest_tile(map, goal.as_uvec2(), 200, |p| {
        map.move_cost(p.as_ivec2()).is_some()
    })?;
    find_path(map, from, open).filter(|route| !route.is_empty())
}

pub fn find_tending(
    map: &WorldMap,
    patients: &[(Entity, UVec2)],
    reservations: &Reservations,
    reach: &ColonyReach,
    items: &[(Item, TilePos)],
    doctor: Entity,
    from: UVec2,
) -> Option<Task> {
    let &(patient, _) = patients
        .iter()
        .filter(|&&(patient, at)| {
            patient != doctor
                && reach.allows_near(at)
                && reservations.is_free(Target::Patient(patient))
        })
        .min_by_key(|(_, at)| {
            let d = at.as_ivec2() - from.as_ivec2();
            (d.length_squared(), at.y, at.x)
        })?;
    let herbs: HashSet<UVec2> = items
        .iter()
        .filter(|(item, pos)| {
            item.kind == ItemKind::Herbs && reservations.is_free(Target::Pickup(pos.0))
        })
        .map(|(_, pos)| pos.0)
        .collect();
    let pickup = (!herbs.is_empty())
        .then(|| reach.nearest(map, from, SEARCH_TILES, &herbs))
        .flatten();
    Some(Task::Tend {
        patient,
        pickup,
        progress: 0,
    })
}

pub fn chilly_soon(tick: SimTick) -> bool {
    let later = SimTick(tick.0 + LIGHT_LOOKAHEAD_TICKS);
    outdoor_temperature(tick) < COLD_TEMP || outdoor_temperature(later) < COLD_TEMP
}

pub fn warm_tiles(
    map: &WorldMap,
    structures: &[(UVec2, StructureKind, u32)],
    outdoor: f32,
) -> HashSet<UVec2> {
    let fires: Vec<(UVec2, StructureKind)> = structures
        .iter()
        .filter(|(_, kind, _)| kind.heat() > 0.0)
        .map(|&(pos, kind, _)| (pos, kind))
        .collect();
    let taken: HashSet<UVec2> = structures.iter().map(|(pos, ..)| *pos).collect();
    let warm: HashSet<UVec2> = fires
        .iter()
        .flat_map(|&(pos, kind)| {
            let r = kind.radius().ceil() as i32;
            (-r..=r).flat_map(move |dy| (-r..=r).map(move |dx| pos.as_ivec2() + IVec2::new(dx, dy)))
        })
        .filter(|&p| map.in_bounds(p) && map.move_cost(p).is_some())
        .map(|p| p.as_uvec2())
        .filter(|p| !taken.contains(p))
        .filter(|&p| {
            let near = fires
                .iter()
                .copied()
                .filter(|(pos, kind)| pos.as_vec2().distance(p.as_vec2()) < kind.radius());
            tile_temperature(map, outdoor, p, near) >= WARM_TEMP
        })
        .collect();
    warm
}

pub fn find_refuel(ctx: &BuildContext, from: UVec2) -> Option<Task> {
    let home = ctx.zones.home(from);
    let (site, kind, _) = ctx
        .structures
        .iter()
        .filter(|&&(pos, kind, fuel)| {
            kind.fuel_ticks()
                .is_some_and(|full| fuel < full / REFUEL_BELOW_SHARE)
                && (kind == StructureKind::Hearth
                    || pos.as_vec2().distance(home.as_vec2()) <= HOME_RADIUS * 2.0)
                && ctx.reservations.is_free(Target::Site(pos))
        })
        .min_by_key(|(.., fuel)| *fuel)?;
    ctx.build_task(from, *site, BuildKind::Refuel(*kind))
}

pub fn find_bed_site(ctx: &BuildContext, colonists: usize, from: UVec2) -> Option<Task> {
    if ctx.count(StructureKind::Bed) >= colonists {
        return None;
    }
    let anchor = ctx.bed_anchor(ctx.zones.home(from));
    let site = ctx.site_near_where(anchor, HOME_RADIUS * 1.5, |p| ctx.clear_of_stockpile(p))?;
    ctx.build_task(from, site, BuildKind::Structure(StructureKind::Bed))
}

pub fn find_blueprint_work(ctx: &BuildContext, from: UVec2) -> Option<Task> {
    let mut stock: HashMap<ItemKind, u32> = HashMap::new();
    for (item, pos) in ctx.items {
        if ctx.reservations.is_free(Target::Pickup(pos.0)) {
            *stock.entry(item.kind).or_insert(0) += item.count;
        }
    }
    let mut stands: HashSet<UVec2> = HashSet::new();
    for (&site, &kind) in &ctx.blueprints.0 {
        let (material, amount) = kind.cost();
        let affordable = amount == 0 || stock.get(&material).copied().unwrap_or(0) >= amount;
        let affordable = affordable && ctx.reach.allows_near(site);
        if !affordable || !ctx.reservations.is_free(Target::Site(site)) {
            continue;
        }
        for d in std::iter::once(IVec2::ZERO).chain(NEIGHBORS) {
            let stand = site.as_ivec2() + d;
            if (d == IVec2::ZERO || ctx.map.move_cost(site.as_ivec2()).is_none())
                && ctx.map.move_cost(stand).is_some()
            {
                stands.insert(stand.as_uvec2());
            }
        }
    }
    let reach = search_reach(SEARCH_TILES) as i32;
    let in_reach = |p: &UVec2| (p.as_ivec2() - from.as_ivec2()).abs().max_element() <= reach;
    if !stands.iter().any(in_reach) {
        return None;
    }
    let mut sources: HashMap<(ItemKind, u32), Option<UVec2>> = HashMap::new();
    let mut found = None;
    nearest_tile(ctx.map, from, SEARCH_TILES, |p| {
        if !stands.contains(&p) {
            return false;
        }
        found = std::iter::once(IVec2::ZERO)
            .chain(NEIGHBORS)
            .filter_map(|d| {
                let site = p.as_ivec2() + d;
                (site.min_element() >= 0).then(|| site.as_uvec2())
            })
            .filter(|&site| site == p || ctx.map.move_cost(site.as_ivec2()).is_none())
            .find_map(|site| {
                let kind = ctx.blueprints.get(site)?;
                if !ctx.reservations.is_free(Target::Site(site)) {
                    return None;
                }
                let pickup = match kind.cost() {
                    (_, 0) => None,
                    cost => Some(
                        (*sources
                            .entry(cost)
                            .or_insert_with(|| ctx.material_source(from, cost)))?,
                    ),
                };
                Some(Task::Build {
                    site,
                    kind,
                    pickup,
                    progress: 0,
                })
            });
        found.is_some()
    })?;
    found
}

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>,
    tick: Res<SimTick>,
    blueprints: Res<Blueprints>,
    mut rng: ResMut<SimRng>,
    mut reservations: ResMut<Reservations>,
    mut items: ItemQuery,
    structures: Query<(&TilePos, &Structure, Option<&Fuel>), Without<Colonist>>,
    animals: Query<(Entity, &TilePos, &Animal, Has<Tame>), Without<Colonist>>,
    mut colonists: Query<
        (
            Entity,
            &TilePos,
            &mut Path,
            &mut CurrentJob,
            &mut IdleTimer,
            &mut Carrying,
            &Rest,
            &Hunger,
            Option<&Family>,
            Has<Child>,
            &WorkPriorities,
            &Warmth,
            Has<Tool>,
            &Skills,
            &Health,
        ),
        With<Colonist>,
    >,
    plans: (
        Res<Homes>,
        Res<Designations>,
        Res<ColonyReach>,
        Query<(Entity, &TilePos, &Health, Option<&Tended>), With<Colonist>>,
        Query<(Entity, &TilePos), With<Raider>>,
        Res<Relations>,
        Query<(Entity, &Trader)>,
    ),
    mut gather_memo: Local<GatherMemo>,
) {
    let (homes, designations, reach, patient_query, raider_query, relations, trader_query) = plans;
    let trader = trader_query.iter().find(|(_, t)| t.open());
    let whereabouts: HashMap<Entity, UVec2> = patient_query
        .iter()
        .map(|(e, pos, ..)| (e, pos.0))
        .collect();
    let raiders: HashSet<Entity> = raider_query.iter().map(|(e, _)| e).collect();
    let patients: Vec<(Entity, UVec2)> = patient_query
        .iter()
        .filter(|(_, _, health, tended)| needs_tending(health.0, *tended, tick.0))
        .map(|(entity, pos, ..)| (entity, pos.0))
        .collect();
    if zones.is_changed() {
        gather_memo.haul = Memo::default();
    }
    if blueprints.is_changed() {
        gather_memo.build = Memo::default();
    }
    gather_memo.food.retain(|_, until| tick.0 < *until);
    let wolves: Vec<(Entity, UVec2)> = animals
        .iter()
        .filter(|(_, _, animal, _)| animal.kind.is_predator())
        .map(|(entity, pos, ..)| (entity, pos.0))
        .chain(raider_query.iter().map(|(entity, pos)| (entity, pos.0)))
        .collect();
    let nearest_wolf = |tile: UVec2, range: i32| {
        wolves
            .iter()
            .map(|&(entity, pos)| (entity, pos, chebyshev(pos, tile)))
            .filter(|&(.., d)| d <= range)
            .min_by_key(|&(_, pos, d)| (d, pos.y, pos.x))
    };
    let mut anyone_ready = false;
    for (_, tile, path, job, mut idle, _, rest, hunger, ..) in &mut colonists {
        let idle_now = job.0.is_none() && path.0.is_empty();
        if idle_now {
            idle.0.tick(time.delta());
        }
        anyone_ready |= (idle_now && idle.0.is_finished())
            || rest.0 < EXHAUSTED_REST
            || hunger.0 < STARVING
            || nearest_wolf(tile.0, DANGER_RANGE).is_some();
    }
    if !anyone_ready {
        return;
    }
    let wildlife: Vec<Wildlife> = animals
        .iter()
        .map(|(e, pos, a, tame)| (e, pos.0, a.kind, tame))
        .collect();
    let adults = colonists.iter().filter(|c| !c.9).count();
    let structures_list: Vec<(UVec2, StructureKind, u32)> = structures
        .iter()
        .map(|(pos, s, fuel)| (pos.0, s.kind, fuel.map_or(u32::MAX, |f| f.0)))
        .collect();
    let mut planned: Vec<(UVec2, StructureKind)> = colonists
        .iter()
        .filter_map(|c| match c.3.0?.task {
            Task::Build {
                site,
                kind: BuildKind::Structure(kind),
                ..
            } => Some((site, kind)),
            _ => None,
        })
        .collect();
    let dark = dark_soon(*tick);
    let chilly = chilly_soon(*tick);
    let outdoor = outdoor_temperature(*tick);
    let sowing = sowing_season(*tick);
    let carried: Vec<Item> = colonists.iter().filter_map(|c| c.5.0).collect();
    let home = zones.home(map.size / 2);
    let mut stocks: HashMap<ItemKind, u32> = ItemKind::ALL.iter().map(|&k| (k, 0)).collect();
    let in_store = items
        .iter()
        .filter(|(_, _, pos)| in_colony(home, pos.0))
        .map(|(_, item, _)| item)
        .chain(carried.iter());
    for item in in_store {
        *stocks.entry(item.kind).or_insert(0) += item.count;
    }
    let mut pending = on_the_way(&map, colonists.iter().map(|c| c.3.0));
    for job in colonists.iter().filter_map(|c| c.3.0) {
        match job.task {
            Task::Hunt { kind, .. } => *pending.entry(ItemKind::Meat).or_insert(0) += kind.meat(),
            Task::Craft { recipe, .. } => *pending.entry(recipe.output()).or_insert(0) += 1,
            Task::Trade { want, receive, .. } => *pending.entry(want).or_insert(0) += receive,
            _ => {}
        }
    }
    let mut selling = [0u32; ItemKind::ALL.len()];
    for job in colonists.iter().filter_map(|c| c.3.0) {
        if let Task::Trade { give, count, .. } = job.task {
            selling[give.index()] += count;
        }
    }
    let mut food_tiles: Option<HashSet<UVec2>> = None;
    let hour = hour_of_day(*tick);
    let mut occupied: Option<HashSet<UVec2>> = None;
    for (
        entity,
        tile,
        mut path,
        mut job,
        mut idle,
        mut carrying,
        rest,
        hunger,
        family,
        child,
        priorities,
        warmth,
        has_tool,
        skills,
        health,
    ) in &mut colonists
    {
        let exhausted = rest.0 < EXHAUSTED_REST;
        let skip_food = gather_memo
            .food
            .get(&entity)
            .is_some_and(|&until| tick.0 < until);
        let starving = hunger.0 < STARVING && !skip_food && {
            let tiles = food_tiles.get_or_insert_with(|| {
                items
                    .iter()
                    .filter(|(_, item, _)| item.kind.is_food())
                    .map(|(_, _, pos)| pos.0)
                    .collect()
            });
            food_to_fetch(&reservations, tiles)
        };
        let danger = nearest_wolf(tile.0, DANGER_RANGE);
        let urgent = exhausted || starving || danger.is_some();
        let fighting_wolf = |task: Task| {
            matches!(task, Task::Hunt { kind, .. } if kind.is_predator())
                || matches!(task, Task::MoveTo(_) | Task::Fight { .. })
        };
        let interrupt = |j: Job| {
            !j.ordered
                && if danger.is_some() {
                    !fighting_wolf(j.task)
                } else {
                    !matches!(j.task, Task::Sleep { .. } | Task::Eat { .. })
                }
        };
        if urgent && job.0.is_some_and(interrupt) {
            reservations.release_all(entity);
            job.0 = None;
            path.0.truncate(1);
        }
        let rested = idle.0.is_finished();
        if job.0.is_some() || !path.0.is_empty() || !(rested || urgent) {
            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_kinds = ItemKind::ALL.map(|kind| goals.wanted(kind, &stocks, &pending));
        let wanted = |kind: ItemKind| wanted_kinds[kind.index()];
        let sleep = SleepContext {
            map: &map,
            zones: &zones,
            reservations: &reservations,
            items: &snapshot,
            structures: &structures_list,
            blueprints: &blueprints,
            homes: &homes,
            family: family.copied(),
            child,
        };
        let food = (wants_food(hunger.0) && !skip_food)
            .then(|| find_food(&map, &reservations, &reach, &snapshot, tile.0))
            .flatten();
        if wants_food(hunger.0) && !skip_food && food.is_none() {
            gather_memo.food.insert(entity, tick.0 + FOOD_RETRY_TICKS);
        }
        let fighter = !child && health.0 >= INJURED && priorities.allows(WorkType::Food);
        let free_to_fight = fighter && !exhausted && !wants_food(hunger.0);
        let defend =
            danger
                .or_else(|| nearest_wolf(home, DEFEND_RANGE))
                .filter(|&(wolf, pos, _)| {
                    free_to_fight
                        && reach.allows_near(pos)
                        && (raiders.contains(&wolf) || reservations.is_free(Target::Animal(wolf)))
                });
        let flee = danger
            .filter(|_| !fighter)
            .and_then(|(_, wolf, _)| flee_from(&map, tile.0, wolf));
        let task = if let Some(route) = flee {
            let goal = route.last().copied().unwrap_or(tile.0);
            path.0 = route.into();
            Some(Task::MoveTo(goal))
        } else if let Some((enemy, ..)) = defend.filter(|(e, ..)| raiders.contains(e)) {
            Some(Task::Fight { enemy, progress: 0 })
        } else if let Some((wolf, ..)) = defend {
            Some(Task::Hunt {
                animal: wolf,
                kind: AnimalKind::Wolf,
                progress: 0,
            })
        } else if exhausted {
            Some(Task::Sleep {
                spot: sleep.spot(tile.0),
            })
        } else if let Some(pickup) = food {
            if let Some(load) = carrying.0.take() {
                drop_items(&mut commands, &mut items, &item_assets, tile.0, load);
            }
            Some(Task::Eat {
                pickup: Some(pickup),
                progress: 0,
            })
        } else if wants_sleep(rest.0, hour) || health.0 < INJURED {
            Some(Task::Sleep {
                spot: sleep.spot(tile.0),
            })
        } else if let Some(spot) = warmth
            .cold()
            .then(|| {
                let hour = tick.0 / crate::sim::TICKS_PER_HOUR;
                if gather_memo.warm.as_ref().is_none_or(|(at, _)| *at != hour) {
                    gather_memo.warm = Some((hour, warm_tiles(&map, &structures_list, outdoor)));
                }
                let warm = &gather_memo.warm.as_ref().expect("computed above").1;
                reach.nearest(&map, tile.0, SEARCH_TILES, warm)
            })
            .flatten()
            .filter(|&spot| spot != tile.0)
        {
            find_path(&map, tile.0, spot).map(|route| {
                path.0 = route.into();
                Task::MoveTo(spot)
            })
        } else if child {
            None
        } else if let Some(load) = carrying.0 {
            let storage =
                find_storage(&map, &zones, &reservations, &reach, refs, tile.0, load.kind);
            if storage.is_none() {
                drop_items(&mut commands, &mut items, &item_assets, tile.0, load);
                carrying.0 = None;
            }
            storage.map(|to| Task::Haul { pickup: None, to })
        } else if let Some(pickup) = (!has_tool)
            .then(|| tool_source(&map, &reservations, &snapshot, tile.0))
            .flatten()
        {
            Some(Task::Equip { pickup })
        } else {
            let occupied = occupied.get_or_insert_with(|| {
                structures_list
                    .iter()
                    .map(|(pos, ..)| *pos)
                    .chain(items.iter().map(|(_, _, pos)| pos.0))
                    .collect()
            });
            occupied.extend(planned.iter().map(|(pos, _)| *pos));
            let build = BuildContext {
                reach: &reach,
                map: &map,
                zones: &zones,
                reservations: &reservations,
                items: &snapshot,
                structures: &structures_list,
                planned: &planned,
                blueprints: &blueprints,
                occupied,
            };
            let has_input = |recipe| input_source(&build, tile.0, recipe).is_some();
            let own_home = homes.of(family.copied());
            let cooking = || {
                if !wanted(ItemKind::Meal) {
                    return None;
                }
                find_crafting(&build, tile.0, Recipe::Meal, own_home).or_else(|| {
                    (build.campfire_needed(zones.home(tile.0)) && has_input(Recipe::Meal))
                        .then(|| find_campfire(&build, tile.0))
                        .flatten()
                })
            };
            let toolmaking = || {
                if !wanted(ItemKind::Tools) {
                    return None;
                }
                find_crafting(&build, tile.0, Recipe::Tools, None).or_else(|| {
                    (build.count(StructureKind::Workbench) == 0 && has_input(Recipe::Tools))
                        .then(|| find_workbench(&build, tile.0))
                        .flatten()
                })
            };
            let designated = || {
                (!designations.0.is_empty())
                    .then(|| {
                        find_work(&map, &reservations, tile.0, |site, _| {
                            designations.0.contains(&site)
                        })
                    })
                    .flatten()
            };
            let gather_mask = ItemKind::ALL
                .iter()
                .filter(|&&k| wanted(k))
                .fold(0u32, |mask, k| mask | 1 << k.index());
            let food_mask = gather_mask
                & ItemKind::ALL
                    .iter()
                    .filter(|k| k.is_food())
                    .fold(0u32, |mask, k| mask | 1 << k.index());
            let skip_gather = gather_memo.gather.skips(gather_mask, tick.0);
            let skip_forage = gather_memo.forage.skips(food_mask, tick.0);
            let skip_haul = gather_memo.haul.skips(0, tick.0);
            let skip_build = gather_memo.build.skips(0, tick.0);
            let build_failed = std::cell::Cell::new(false);
            let gather_failed = std::cell::Cell::new(false);
            let forage_failed = std::cell::Cell::new(false);
            let haul_failed = std::cell::Cell::new(false);
            let candidates: [(WorkType, Option<Skill>, &dyn Fn() -> Option<Task>); 18] = [
                (WorkType::Haul, None, &|| {
                    find_expansion(&map, &zones, &reservations, &snapshot, &blueprints)
                }),
                (WorkType::Build, None, &|| find_refuel(&build, tile.0)),
                (WorkType::Doctor, Some(Skill::Medicine), &|| {
                    find_tending(
                        &map,
                        &patients,
                        &reservations,
                        &reach,
                        &snapshot,
                        entity,
                        tile.0,
                    )
                }),
                (WorkType::Build, None, &|| {
                    (dark || chilly)
                        .then(|| find_lighting(&build, tile.0, dark))
                        .flatten()
                }),
                (WorkType::Food, Some(Skill::Cooking), &cooking),
                (WorkType::Food, None, &|| {
                    find_butchering(&map, &reservations, &snapshot, tile.0)
                }),
                (WorkType::Food, None, &|| {
                    if food_mask == 0 || skip_forage {
                        return None;
                    }
                    let food = |_, k: ItemKind| k.is_food() && wanted(k);
                    let work =
                        find_work_within(&map, &reservations, tile.0, FORAGE_SEARCH_TILES, food);
                    forage_failed.set(work.is_none());
                    work
                }),
                (WorkType::Gather, None, &designated),
                (WorkType::Food, None, &|| {
                    (sowing && wanted(ItemKind::Vegetables))
                        .then(|| find_sowing(&map, &zones, &reservations, tile.0))
                        .flatten()
                }),
                (WorkType::Build, Some(Skill::Construction), &|| {
                    find_bed_site(&build, adults, tile.0)
                }),
                (WorkType::Craft, Some(Skill::Crafting), &toolmaking),
                (WorkType::Build, Some(Skill::Construction), &|| {
                    if skip_build {
                        return None;
                    }
                    let work = find_blueprint_work(&build, tile.0);
                    build_failed.set(work.is_none());
                    work
                }),
                (WorkType::Gather, None, &|| {
                    if gather_mask == 0 || skip_gather {
                        return None;
                    }
                    let work = find_work(&map, &reservations, tile.0, |_, k| wanted(k));
                    gather_failed.set(work.is_none());
                    work
                }),
                (WorkType::Food, Some(Skill::Hunting), &|| {
                    wanted(ItemKind::Meat)
                        .then(|| find_hunt(&map, &reservations, &wildlife, tile.0))
                        .flatten()
                }),
                (WorkType::Food, Some(Skill::Farming), &|| {
                    sowing
                        .then(|| find_sowing(&map, &zones, &reservations, tile.0))
                        .flatten()
                }),
                (WorkType::Tame, Some(Skill::Taming), &|| {
                    (!wanted(ItemKind::Meat))
                        .then(|| find_taming(&map, &reservations, &wildlife, tile.0))
                        .flatten()
                }),
                (WorkType::Haul, None, &|| {
                    let trader = trader?;
                    let have = |stock: Stock| {
                        let mut total = 0;
                        for kind in stock.members() {
                            total += stocks[&kind] + pending.get(&kind).copied().unwrap_or(0);
                            total = total.saturating_sub(selling[kind.index()]);
                        }
                        total
                    };
                    let goal = |stock: Stock| goals.goal(stock);
                    find_trade(
                        &map,
                        &reservations,
                        &reach,
                        &snapshot,
                        home,
                        tile.0,
                        trader,
                        &have,
                        &goal,
                    )
                }),
                (WorkType::Haul, None, &|| {
                    if skip_haul {
                        return None;
                    }
                    let haul = find_haul(
                        &map,
                        &zones,
                        &reservations,
                        &reach,
                        &homes,
                        &snapshot,
                        tile.0,
                    );
                    haul_failed.set(haul.is_none());
                    haul
                }),
            ];
            let poor = |skill: &Option<Skill>| skill.is_some_and(|s| skills.level(s) < POOR_LEVEL);
            let allowed = candidates
                .iter()
                .filter(|(work, ..)| priorities.allows(*work));
            let task = allowed
                .clone()
                .filter(|(_, skill, _)| !poor(skill))
                .chain(allowed.filter(|(_, skill, _)| poor(skill)))
                .find_map(|(.., find)| find());
            let retry = |mask, ticks| Memo {
                mask,
                until: tick.0 + ticks,
            };
            if gather_failed.get() {
                gather_memo.gather = retry(gather_mask, GATHER_RETRY_TICKS);
            }
            if forage_failed.get() {
                gather_memo.forage = retry(food_mask, GATHER_RETRY_TICKS);
            }
            if haul_failed.get() {
                gather_memo.haul = retry(0, HAUL_RETRY_TICKS);
            }
            if build_failed.get() {
                gather_memo.build = retry(0, HAUL_RETRY_TICKS);
            }
            task
        };
        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;
            }
            match task {
                Task::Hunt { kind, .. } => {
                    *pending.entry(ItemKind::Meat).or_insert(0) += kind.meat()
                }
                Task::Craft { recipe, .. } => *pending.entry(recipe.output()).or_insert(0) += 1,
                _ => {}
            }
            if let Task::Build {
                site,
                kind: BuildKind::Structure(kind),
                ..
            } = task
            {
                planned.push((site, kind));
            }
            reserve_task(&mut reservations, task, entity);
            job.0 = Some(Job {
                task,
                ordered: false,
            });
            continue;
        }
        let friend = (rng.range_f32(0.0..1.0) < VISIT_CHANCE)
            .then(|| {
                relations
                    .of(entity)
                    .filter(|(_, opinion)| *opinion >= FRIEND)
                    .filter_map(|(friend, _)| whereabouts.get(&friend).copied())
                    .filter(|at| chebyshev(*at, tile.0) <= VISIT_RANGE)
                    .min_by_key(|at| (chebyshev(*at, tile.0), at.y, at.x))
            })
            .flatten();
        let offset = IVec2::new(rng.range_i32(-1..2), rng.range_i32(-1..2));
        let (goal, search) = match friend {
            Some(at) => (at.as_ivec2() + offset, VISIT_SEARCH),
            None => (
                tile.0.as_ivec2()
                    + IVec2::new(
                        rng.range_i32(-WANDER_RADIUS..WANDER_RADIUS + 1),
                        rng.range_i32(-WANDER_RADIUS..WANDER_RADIUS + 1),
                    ),
                WANDER_SEARCH,
            ),
        };
        if map.in_bounds(goal)
            && let Some(wander_path) = find_nearby_path(&map, tile.0, goal.as_uvec2(), search)
        {
            path.0 = wander_path.into();
        }
        idle.restart(rng.range_f32(IDLE_SECS));
    }
}

enum Step {
    Continue,
    Done,
}

pub const DETOUR_MIN_TILES: usize = 24;
const DETOUR_SEARCH: usize = 4000;

pub fn note_detour(map: &mut WorldMap, from: UVec2, to: UVec2, route: Option<&[UVec2]>) {
    let straight = (to.as_ivec2() - from.as_ivec2()).abs().max_element() as usize;
    if route.is_some_and(|r| r.len() < DETOUR_MIN_TILES || r.len() * 2 < straight * 3) {
        return;
    }
    let Some(bridged) = find_bridged_path(map, from, to, DETOUR_SEARCH) else {
        return;
    };
    let shorter = route.is_none_or(|r| bridged.len() * 3 / 2 < r.len());
    if !shorter {
        return;
    }
    for tile in bridged {
        let p = tile.as_ivec2();
        if map.get(p).is_some_and(|t| t.is_water()) {
            map.set_wear(tile, map.wear(p) + 1.0);
        }
    }
}

fn walk_to(map: &mut WorldMap, from: UVec2, to: UVec2, path: &mut Path) -> Step {
    let route = find_path(map, from, to);
    note_detour(map, from, to, route.as_deref());
    match route {
        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>,
    structure_assets: Res<StructureAssets>,
    light: Res<LightMap>,
    tick: Res<SimTick>,
    mut blueprints: ResMut<Blueprints>,
    mut goals: ResMut<ColonyGoals>,
    mut items: ItemQuery,
    mut structures: Query<(Entity, &TilePos, &Structure, Option<&mut Fuel>), Without<Colonist>>,
    creatures: (
        Query<(&TilePos, &Path), (With<Animal>, Without<Colonist>)>,
        Query<(&TilePos, &mut Health), (With<Raider>, Without<Colonist>)>,
        Query<(&TilePos, &mut Trader), Without<Colonist>>,
    ),
    messages: (
        MessageWriter<TileChanged>,
        MessageWriter<Ate>,
        ResMut<ColonyLog>,
    ),
    mut colonists: Query<
        (
            Entity,
            &TilePos,
            &mut Path,
            &mut CurrentJob,
            &mut IdleTimer,
            &mut Carrying,
            &Rest,
            &mut Hunger,
            Has<Sick>,
            Option<&mut Tool>,
            (&mut Skills, &mut WorkCarry, &Health),
        ),
        With<Colonist>,
    >,
) {
    let (mut changed, mut ate, mut log) = messages;
    let (animals, mut raiders, mut traders) = creatures;
    let hour = hour_of_day(*tick);
    let tending = colonists
        .iter()
        .any(|c| c.3.0.is_some_and(|j| matches!(j.task, Task::Tend { .. })));
    let positions: HashMap<Entity, UVec2> = colonists
        .iter()
        .filter(|_| tending)
        .map(|c| (c.0, c.1.0))
        .collect();
    let walling = colonists.iter().any(|c| {
        c.3.0
            .is_some_and(|j| matches!(j.task, Task::Build { kind, .. } if kind.blocks_tile()))
    });
    let occupied: Vec<UVec2> = colonists
        .iter()
        .filter(|_| walling)
        .flat_map(|c| [Some(c.1.0), c.2.0.front().copied()])
        .chain(
            animals
                .iter()
                .filter(|_| walling)
                .flat_map(|(t, p)| [Some(t.0), p.0.front().copied()]),
        )
        .flatten()
        .collect();
    for (
        entity,
        tile,
        mut path,
        mut current,
        mut idle,
        mut carrying,
        rest,
        mut hunger,
        sick,
        mut tool,
        (mut skills, mut carry, health),
    ) in &mut colonists
    {
        let Some(mut job) = current.0 else {
            continue;
        };
        let rate = match work_rate(&light, tile.0) {
            rate if sick => rate.div_ceil(2),
            rate => rate,
        };
        let rate = tool_rate(rate, tool.is_some());
        if !path.0.is_empty() {
            continue;
        }
        let skill = Skill::of(&job.task);
        let rate = carry.apply(rate, skill.map_or(1.0, |s| speed(skills.level(s))));
        let progress_before = job.task.progress();
        if let Some(tool) = tool.as_mut()
            && !matches!(
                job.task,
                Task::MoveTo(_) | Task::Sleep { .. } | Task::Eat { .. } | Task::Equip { .. }
            )
        {
            tool.wear += 1;
            if tool.wear >= TOOL_LIFE_TICKS {
                commands.entity(entity).remove::<Tool>();
            }
        }
        let step = match &mut job.task {
            Task::MoveTo(_) => Step::Done,
            Task::Tend {
                patient,
                pickup,
                progress,
            } => {
                let patient = *patient;
                let ours = reservations.holder(Target::Patient(patient)) == Some(entity);
                match positions.get(&patient) {
                    _ if !ours => Step::Done,
                    None => Step::Done,
                    Some(_) if pickup.is_some() => {
                        let from = pickup.expect("checked above");
                        if tile.0 != from {
                            walk_to(&mut map, tile.0, from, &mut path)
                        } else {
                            reservations.release(Target::Pickup(from));
                            carrying.0 = take_items(&mut commands, &mut items, from, 1)
                                .filter(|load| load.kind == ItemKind::Herbs && load.count > 0);
                            *pickup = None;
                            Step::Continue
                        }
                    }
                    Some(&at) if at != tile.0 && !is_adjacent(tile.0.as_ivec2(), at.as_ivec2()) => {
                        match find_path_adjacent(&map, tile.0, at) {
                            Some(p) if !p.is_empty() => {
                                path.0 = p.into();
                                Step::Continue
                            }
                            _ => Step::Done,
                        }
                    }
                    Some(_) => {
                        *progress += rate;
                        if *progress < TEND_WORK {
                            Step::Continue
                        } else {
                            let herb = carrying.0.is_some_and(|l| l.kind == ItemKind::Herbs);
                            if herb {
                                goals.record_use(ItemKind::Herbs, 1);
                                carrying.0 = None;
                            }
                            let speed = speed(skills.level(Skill::Medicine));
                            commands.entity(patient).insert(Tended {
                                until: tick.0 + TENDED_TICKS,
                                quality: tend_quality(speed, herb),
                            });
                            Step::Done
                        }
                    }
                }
            }
            Task::Trade {
                trader,
                pickup,
                give,
                count,
                want,
                progress,
                ..
            } => match traders.get_mut(*trader) {
                Ok((_, t)) if !t.open() => Step::Done,
                Ok(_) if pickup.is_some() => {
                    let from = pickup.expect("checked above");
                    if reservations.holder(Target::Pickup(from)) != Some(entity) {
                        Step::Done
                    } else if tile.0 != from {
                        walk_to(&mut map, tile.0, from, &mut path)
                    } else {
                        reservations.release(Target::Pickup(from));
                        *pickup = None;
                        let load = take_items(&mut commands, &mut items, from, *count);
                        carrying.0 = load.filter(|l| l.kind == *give && l.count > 0);
                        if carrying.0.is_some() {
                            Step::Continue
                        } else {
                            Step::Done
                        }
                    }
                }
                Ok((at, _))
                    if at.0 != tile.0 && !is_adjacent(tile.0.as_ivec2(), at.0.as_ivec2()) =>
                {
                    match find_path_adjacent(&map, tile.0, at.0) {
                        Some(p) if !p.is_empty() => {
                            path.0 = p.into();
                            Step::Continue
                        }
                        _ => Step::Done,
                    }
                }
                Ok((_, mut t)) => {
                    *progress += rate;
                    if *progress < TRADE_WORK {
                        Step::Continue
                    } else {
                        if let Some(offer) = carrying.0.filter(|l| l.kind == *give)
                            && let Some(got) = t.trade(offer, *want)
                        {
                            carrying.0 = Some(got);
                            log.push(
                                *tick,
                                format!(
                                    "Traded {} {:?} for {} {:?}",
                                    offer.count, offer.kind, got.count, got.kind
                                ),
                            );
                        }
                        Step::Done
                    }
                }
                Err(_) => Step::Done,
            },
            Task::Fight { enemy, progress } => match raiders.get_mut(*enemy) {
                Ok((at, mut enemy_health)) if enemy_health.0 > 0.0 => {
                    let at = at.0;
                    let in_range = tile.0.as_vec2().distance(at.as_vec2()) <= HUNT_RANGE
                        && line_of_sight(&map, tile.0, at);
                    if in_range {
                        *progress += rate;
                        if *progress >= SHOT_WORK {
                            *progress = 0;
                            enemy_health.0 -= SHOT_DAMAGE;
                        }
                        Step::Continue
                    } else {
                        match find_path_adjacent_within(&map, tile.0, at, FIGHT_SEARCH) {
                            Some(p) if !p.is_empty() => {
                                path.0 = p.into();
                                path.0.truncate(FIGHT_STEPS);
                                Step::Continue
                            }
                            _ => Step::Done,
                        }
                    }
                }
                _ => Step::Done,
            },
            Task::Equip { pickup } => {
                let from = *pickup;
                if reservations.holder(Target::Pickup(from)) != Some(entity) {
                    Step::Done
                } else if tile.0 != from {
                    walk_to(&mut map, tile.0, from, &mut path)
                } else {
                    reservations.release(Target::Pickup(from));
                    let stack = items
                        .iter()
                        .any(|(_, item, pos)| pos.0 == from && item.kind == ItemKind::Tools);
                    if stack && take_items(&mut commands, &mut items, from, 1).is_some() {
                        goals.record_use(ItemKind::Tools, 1);
                        commands.entity(entity).insert(Tool::default());
                    }
                    Step::Done
                }
            }
            Task::Craft {
                recipe,
                pickup,
                station,
                progress,
            } => {
                let (recipe, station) = (*recipe, *station);
                let input = recipe.input();
                let fire = structures
                    .iter()
                    .any(|(_, pos, s, _)| pos.0 == station && recipe.stations().contains(&s.kind));
                let ours = reservations.holder(Target::Station(station)) == Some(entity);
                if !fire || !ours {
                    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(&mut map, tile.0, from, &mut path)
                    } else {
                        let load = take_items(&mut commands, &mut items, from, input)
                            .filter(|load| recipe.accepts(load.kind) && load.count > 0);
                        carrying.0 = load;
                        reservations.release(Target::Pickup(from));
                        match load {
                            Some(load) if load.count >= input => {
                                *pickup = None;
                                Step::Continue
                            }
                            _ => Step::Done,
                        }
                    }
                } else if !carrying
                    .0
                    .is_some_and(|load| recipe.accepts(load.kind) && load.count >= input)
                {
                    Step::Done
                } else if !is_adjacent(tile.0.as_ivec2(), station.as_ivec2()) {
                    match find_path_adjacent(&map, tile.0, station) {
                        Some(p) if !p.is_empty() => {
                            path.0 = p.into();
                            Step::Continue
                        }
                        _ => Step::Done,
                    }
                } else {
                    *progress += rate;
                    if *progress < recipe.work() {
                        Step::Continue
                    } else {
                        if let Some(load) = carrying.0 {
                            goals.record_use(load.kind, input);
                        }
                        carrying.0 = carrying.0.and_then(|load| {
                            (load.count > input).then_some(Item {
                                count: load.count - input,
                                ..load
                            })
                        });
                        drop_items(
                            &mut commands,
                            &mut items,
                            &item_assets,
                            tile.0,
                            Item::new(recipe.output(), 1),
                        );
                        Step::Done
                    }
                }
            }
            Task::Hunt {
                animal,
                kind,
                progress,
            } => match animals.get(*animal) {
                Ok((prey, _)) if reservations.holder(Target::Animal(*animal)) == Some(entity) => {
                    let prey = prey.0;
                    let in_range = tile.0.as_vec2().distance(prey.as_vec2()) <= HUNT_RANGE
                        && line_of_sight(&map, tile.0, prey);
                    let stale = path.0.back().is_none_or(|end| {
                        end.as_vec2().distance(prey.as_vec2()) > HUNT_RANGE / 2.0
                    });
                    if !in_range && !stale {
                        Step::Continue
                    } else if !in_range {
                        match find_path_adjacent(&map, tile.0, prey) {
                            Some(p) if !p.is_empty() => {
                                path.0 = p.into();
                                Step::Continue
                            }
                            _ => Step::Done,
                        }
                    } else {
                        path.0.truncate(1);
                        *progress += rate;
                        if *progress < kind.hunt_work() {
                            Step::Continue
                        } else {
                            commands.entity(*animal).despawn();
                            drop_items(
                                &mut commands,
                                &mut items,
                                &item_assets,
                                prey,
                                Item::new(ItemKind::Carcass, kind.meat()),
                            );
                            Step::Done
                        }
                    }
                }
                _ => Step::Done,
            },
            Task::Tame {
                animal,
                kind,
                progress,
            } => match animals.get(*animal) {
                Ok((prey, _)) if reservations.holder(Target::Animal(*animal)) == Some(entity) => {
                    let prey = prey.0;
                    if prey != tile.0 && !is_adjacent(tile.0.as_ivec2(), prey.as_ivec2()) {
                        if path.0.is_empty() {
                            match find_path_adjacent(&map, tile.0, prey) {
                                Some(p) if !p.is_empty() => {
                                    path.0 = p.into();
                                    Step::Continue
                                }
                                _ => Step::Done,
                            }
                        } else {
                            Step::Continue
                        }
                    } else {
                        *progress += rate;
                        if *progress < kind.tame_work() {
                            Step::Continue
                        } else {
                            commands.entity(*animal).insert(Tame);
                            Step::Done
                        }
                    }
                }
                _ => Step::Done,
            },
            Task::Butcher { site, progress } => {
                let site = *site;
                if reservations.holder(Target::Pickup(site)) != Some(entity) {
                    Step::Done
                } else if tile.0 != site {
                    walk_to(&mut map, tile.0, site, &mut path)
                } else {
                    *progress += rate;
                    if *progress < BUTCHER_WORK {
                        Step::Continue
                    } else {
                        let is_carcass = items
                            .iter()
                            .any(|(_, item, pos)| pos.0 == site && item.kind == ItemKind::Carcass);
                        if is_carcass
                            && let Some(carcass) =
                                take_items(&mut commands, &mut items, site, u32::MAX)
                        {
                            let meat = Item {
                                kind: ItemKind::Meat,
                                ..carcass
                            };
                            drop_items(&mut commands, &mut items, &item_assets, site, meat);
                        }
                        Step::Done
                    }
                }
            }
            Task::Eat { pickup, progress } => {
                if let Some(from) = *pickup {
                    if reservations.holder(Target::Pickup(from)) != Some(entity) {
                        Step::Done
                    } else if tile.0 != from {
                        walk_to(&mut map, tile.0, from, &mut path)
                    } else {
                        let kind = items
                            .iter()
                            .find(|(_, item, pos)| pos.0 == from && item.kind.is_food())
                            .map(|(_, item, _)| item.kind);
                        let meal = kind.and_then(|kind| {
                            take_items(&mut commands, &mut items, from, portion(kind, hunger.0))
                        });
                        reservations.release(Target::Pickup(from));
                        match meal.filter(|m| m.kind.is_food()) {
                            Some(meal) => {
                                carrying.0 = Some(meal);
                                *pickup = None;
                                Step::Continue
                            }
                            None => Step::Done,
                        }
                    }
                } else if let Some(meal) = carrying.0.filter(|m| m.kind.is_food()) {
                    *progress += 1;
                    if *progress < EAT_TICKS {
                        Step::Continue
                    } else {
                        hunger.0 = (hunger.0 + meal.count as f32 * meal.kind.nutrition()).min(1.0);
                        goals.record_use(meal.kind, meal.count);
                        ate.write(Ate {
                            colonist: entity,
                            kind: meal.kind,
                        });
                        carrying.0 = None;
                        Step::Done
                    }
                } else {
                    Step::Done
                }
            }
            Task::Sleep { spot } => {
                if reservations.holder(Target::SleepSpot(*spot)) != Some(entity) {
                    Step::Done
                } else if tile.0 != *spot {
                    let step = walk_to(&mut map, tile.0, *spot, &mut path);
                    if matches!(step, Step::Done) {
                        reservations.release(Target::SleepSpot(*spot));
                        *spot = tile.0;
                        reservations.reserve(Target::SleepSpot(*spot), entity);
                    }
                    Step::Continue
                } else if done_sleeping(rest.0, hour) && health.0 >= INJURED {
                    Step::Done
                } else {
                    Step::Continue
                }
            }
            Task::Work {
                site,
                kind,
                progress,
            } => {
                let (site, kind) = (*site, *kind);
                let work = site_work(&map, site).filter(|w| w.kind == kind);
                let valid =
                    work.is_some() || (kind == WorkKind::Sow && sowable(&map, &zones, site));
                let ours = reservations.holder(Target::Site(site)) == Some(entity);
                if !valid || !ours {
                    Step::Done
                } else 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 += rate;
                    if *progress < kind.work() {
                        Step::Continue
                    } else {
                        kind.complete(&mut map, site);
                        changed.write(TileChanged(site));
                        let step = site.as_ivec2() - tile.0.as_ivec2();
                        let drop_at = if can_step(&map, tile.0.as_ivec2(), step) {
                            site
                        } else {
                            tile.0
                        };
                        if let Some(work) = work {
                            drop_items(
                                &mut commands,
                                &mut items,
                                &item_assets,
                                drop_at,
                                Item::new(work.item, work.count),
                            );
                        }
                        Step::Done
                    }
                }
            }
            Task::ExpandStockpile { site, progress } => {
                if tile.0 != *site {
                    walk_to(&mut map, tile.0, *site, &mut path)
                } else {
                    *progress += rate;
                    if *progress >= EXPAND_WORK {
                        if zones.has_stockpile() {
                            let excluded = blueprints.tiles();
                            let tiles = plan_expansion(&map, &zones, &excluded, EXPANSION_TILES);
                            zones.add_tiles(&map, tiles);
                        } else {
                            zones.add_tiles(&map, new_stockpile_tiles(*site));
                        }
                        Step::Done
                    } else {
                        Step::Continue
                    }
                }
            }
            Task::Build {
                site,
                kind,
                pickup,
                progress,
            } => {
                let (site, kind) = (*site, *kind);
                let ours = reservations.holder(Target::Site(site)) == Some(entity);
                let planned = match kind {
                    BuildKind::Structure(
                        StructureKind::Campfire
                        | StructureKind::Torch
                        | StructureKind::Bed
                        | StructureKind::Workbench,
                    )
                    | BuildKind::Refuel(_) => true,
                    _ => blueprints.get(site) == Some(kind),
                };
                let structure_there = structures.iter().any(|(_, pos, ..)| pos.0 == site);
                let blocked = map.plant(site.as_ivec2()).is_some()
                    || match kind {
                        BuildKind::Roof | BuildKind::Floor | BuildKind::Bridge => false,
                        BuildKind::Refuel(fire) => !structures
                            .iter()
                            .any(|(_, pos, s, _)| pos.0 == site && s.kind == fire),
                        BuildKind::Deconstruct => {
                            !structure_there && !map.is_roofed(site.as_ivec2())
                        }
                        _ => structure_there,
                    };
                let (material, cost) = kind.cost();
                if !ours || blocked || !planned {
                    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(&mut map, tile.0, from, &mut path)
                    } else if carrying.0.is_some_and(|load| load.kind != material) {
                        Step::Done
                    } else {
                        let have = carrying.0.map_or(0, |load| load.count);
                        let taken = take_items(&mut commands, &mut items, from, cost - have)
                            .filter(|load| load.kind == material)
                            .map_or(0, |load| load.count);
                        reservations.release(Target::Pickup(from));
                        let total = have + taken;
                        carrying.0 = (total > 0).then_some(Item::new(material, total));
                        let next = nearest_tile(&map, tile.0, SEARCH_TILES, |p| {
                            reservations.is_free(Target::Pickup(p))
                                && items.iter().any(|(_, item, pos)| {
                                    pos.0 == p && item.kind == material && item.count > 0
                                })
                        });
                        match next {
                            _ if total >= cost => {
                                *pickup = None;
                                Step::Continue
                            }
                            Some(next) => {
                                reservations.reserve(Target::Pickup(next), entity);
                                *pickup = Some(next);
                                Step::Continue
                            }
                            None => Step::Done,
                        }
                    }
                } else if cost > 0
                    && !carrying
                        .0
                        .is_some_and(|load| load.kind == material && load.count >= cost)
                {
                    Step::Done
                } else 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 = (*progress + rate).min(kind.work());
                    let someone_in_the_way = kind.blocks_tile() && occupied.contains(&site);
                    if *progress < kind.work() || someone_in_the_way {
                        Step::Continue
                    } else {
                        goals.record_use(material, cost);
                        carrying.0 = carrying.0.and_then(|load| {
                            (load.count > cost).then_some(Item {
                                count: load.count - cost,
                                ..load
                            })
                        });
                        match kind {
                            BuildKind::Structure(structure) => {
                                spawn_structure(&mut commands, &structure_assets, site, structure);
                                if kind.blocks_tile() {
                                    map.set_wall(site, true);
                                    changed.write(TileChanged(site));
                                }
                            }
                            BuildKind::Roof => {
                                map.set_roof(site, true);
                                changed.write(TileChanged(site));
                            }
                            BuildKind::Pave => {
                                map.set(site, Terrain::Paved);
                                changed.write(TileChanged(site));
                            }
                            BuildKind::Floor => {
                                map.set(site, Terrain::WoodFloor);
                                changed.write(TileChanged(site));
                            }
                            BuildKind::Bridge => {
                                map.set(site, Terrain::Bridge);
                                map.set_wear(site, 0.0);
                                changed.write(TileChanged(site));
                            }
                            BuildKind::Deconstruct => {
                                for (entity, pos, structure, _) in &structures {
                                    if pos.0 != site {
                                        continue;
                                    }
                                    commands.entity(entity).despawn();
                                    let (refund, amount) = structure.kind.cost();
                                    if amount / 2 > 0 {
                                        drop_items(
                                            &mut commands,
                                            &mut items,
                                            &item_assets,
                                            site,
                                            Item::new(refund, amount / 2),
                                        );
                                    }
                                }
                                if map.is_wall(site.as_ivec2()) || map.is_roofed(site.as_ivec2()) {
                                    map.set_wall(site, false);
                                    map.set_roof(site, false);
                                    changed.write(TileChanged(site));
                                }
                            }
                            BuildKind::Refuel(fire) => {
                                for (_, pos, _, fuel) in &mut structures {
                                    if pos.0 == site
                                        && let Some(mut fuel) = fuel
                                    {
                                        fuel.0 = fire.fuel_ticks().unwrap_or(fuel.0);
                                    }
                                }
                            }
                        }
                        blueprints.0.remove(&site);
                        Step::Done
                    }
                }
            }
            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(&mut 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(&mut 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.with_count(dropped),
                            );
                        }
                        carrying.0 = (load.count > dropped).then_some(Item {
                            count: load.count - dropped,
                            ..load
                        });
                        Step::Done
                    }
                } else {
                    Step::Done
                }
            }
        };
        if let Some(skill) = skill
            && job.task.progress() > progress_before
        {
            skills.practice(skill, 1.0);
        }
        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;