use std::collections::VecDeque;

use bevy::prelude::*;

use crate::{
    climate::Warmth,
    food::Hunger,
    items::{Carrying, ItemAssets},
    jobs::{CurrentJob, IdleTimer, WorkPriorities},
    needs::{Rest, sleep_marker},
    pathfinding::find_path,
    population::Starvation,
    sim::{SimPos, SimSystems, sim_pos},
    skills::{Skills, WorkCarry},
    social::Personality,
    threats::Health,
    world::{TILE_SIZE, TilePos, WorldMap},
    worldgen::{WorldGenerated, spawn_tiles},
};

pub struct ColonistPlugin;

impl Plugin for ColonistPlugin {
    fn build(&self, app: &mut App) {
        app.add_systems(Startup, create_colonist_assets)
            .add_systems(Update, spawn_colonists.run_if(on_message::<WorldGenerated>))
            .add_systems(FixedUpdate, follow_path.in_set(SimSystems::Move));
    }
}

const TILES_PER_SECOND: f32 = 4.0;

pub const NAMES: [&str; 26] = [
    "Ada", "Bram", "Cleo", "Dana", "Emil", "Fenna", "Gijs", "Hanna", "Ivo", "Juul", "Kees",
    "Lotte", "Milan", "Noor", "Otto", "Pien", "Quinn", "Roos", "Sem", "Tess", "Ugo", "Vera",
    "Wout", "Xem", "Yara", "Zeno",
];

pub fn colonist_name(index: usize) -> String {
    let base = NAMES[index % NAMES.len()];
    match index / NAMES.len() {
        0 => base.to_string(),
        n => format!("{base} {}", n + 1),
    }
}

pub fn free_name_index<'a>(taken: impl Iterator<Item = &'a str> + Clone) -> usize {
    (0..)
        .find(|&i| !taken.clone().any(|name| name == colonist_name(i)))
        .unwrap_or(0)
}

const COLORS: [Color; 8] = [
    Color::srgb(0.9, 0.3, 0.3),
    Color::srgb(0.3, 0.5, 0.95),
    Color::srgb(0.95, 0.75, 0.3),
    Color::srgb(0.6, 0.35, 0.85),
    Color::srgb(0.3, 0.8, 0.75),
    Color::srgb(0.95, 0.5, 0.75),
    Color::srgb(0.55, 0.8, 0.3),
    Color::srgb(0.95, 0.95, 0.95),
];

const STARTING_COLONISTS: usize = 3;

#[derive(Resource, Default)]
pub struct ColonistAssets {
    mesh: Handle<Mesh>,
}

fn create_colonist_assets(mut commands: Commands, mut meshes: ResMut<Assets<Mesh>>) {
    commands.insert_resource(ColonistAssets {
        mesh: meshes.add(Circle::new(TILE_SIZE * 0.35)),
    });
}

pub fn spawn_colonist(
    commands: &mut Commands,
    assets: &ColonistAssets,
    item_assets: &ItemAssets,
    materials: &mut Assets<ColorMaterial>,
    index: usize,
    tile: UVec2,
) -> Entity {
    let name = colonist_name(index);
    commands
        .spawn((
            Name::new(name.clone()),
            Colonist { name },
            TilePos(tile),
            Mesh2d(assets.mesh.clone()),
            MeshMaterial2d(materials.add(COLORS[index % COLORS.len()])),
            sim_pos(WorldMap::tile_center(tile)),
            Transform::from_translation(WorldMap::tile_center(tile).extend(1.0)),
            children![item_assets.carried_visual(), sleep_marker()],
        ))
        .id()
}

#[derive(Component, Debug)]
#[require(
    Transform,
    SimPos,
    TilePos,
    Path,
    CurrentJob,
    IdleTimer,
    Carrying,
    Rest,
    Hunger,
    Starvation,
    WorkPriorities,
    Warmth,
    Skills,
    WorkCarry,
    Health,
    Personality
)]
pub struct Colonist {
    pub name: String,
}

#[derive(Component, Default, Debug)]
pub struct Path(pub VecDeque<UVec2>);

fn spawn_colonists(
    mut commands: Commands,
    map: Res<WorldMap>,
    existing: Query<Entity, With<Colonist>>,
    assets: Res<ColonistAssets>,
    item_assets: Res<ItemAssets>,
    mut materials: ResMut<Assets<ColorMaterial>>,
) {
    for entity in &existing {
        commands.entity(entity).despawn();
    }
    let tiles = spawn_tiles(&map, STARTING_COLONISTS);
    for (index, tile) in tiles.into_iter().enumerate() {
        spawn_colonist(
            &mut commands,
            &assets,
            &item_assets,
            &mut materials,
            index,
            tile,
        );
    }
}

pub fn repath(
    map: &WorldMap,
    tile: UVec2,
    current: &VecDeque<UVec2>,
    goal: UVec2,
) -> Option<VecDeque<UVec2>> {
    match current.front() {
        Some(&next) => {
            let mut path: VecDeque<_> = find_path(map, next, goal)?.into();
            path.push_front(next);
            Some(path)
        }
        None => find_path(map, tile, goal).map(VecDeque::from),
    }
}

#[derive(Component, Debug, Clone, Copy, PartialEq)]
pub struct MoveSpeed(pub f32);

pub fn follow_path(
    time: Res<Time>,
    mut map: ResMut<WorldMap>,
    mut movers: Query<(
        &mut TilePos,
        &mut Path,
        &mut SimPos,
        Option<&MoveSpeed>,
        Has<Colonist>,
    )>,
) {
    for (mut tile, mut path, mut pos, speed, is_colonist) in &mut movers {
        let Some(&next) = path.0.front() else {
            continue;
        };
        if map.move_cost(next.as_ivec2()).is_none() {
            path.0.clear();
            continue;
        }
        let cost = map
            .step_cost(tile.0.as_ivec2(), next.as_ivec2())
            .unwrap_or(100) as f32
            / 100.0;
        let tiles_per_second = speed.map_or(TILES_PER_SECOND, |s| s.0);
        let max_distance = tiles_per_second * TILE_SIZE / cost * time.delta_secs();
        let target = WorldMap::tile_center(next);
        let arrived;
        (pos.0, arrived) = step_towards(pos.0, target, max_distance);
        if arrived {
            tile.0 = next;
            path.0.pop_front();
            if is_colonist {
                let wear = map.wear(next.as_ivec2());
                map.set_wear(next, wear + 1.0);
            }
        }
    }
}

pub fn step_towards(pos: Vec2, target: Vec2, max_distance: f32) -> (Vec2, bool) {
    let delta = target - pos;
    if delta.length() <= max_distance {
        (target, true)
    } else {
        (pos + delta.normalize() * max_distance, false)
    }
}

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

    // The colony has no size cap, so once the name list runs out names repeat with a number.
    #[test]
    fn names_stay_unique_past_the_name_list() {
        assert_eq!(colonist_name(0), "Ada");
        assert_eq!(colonist_name(NAMES.len()), "Ada 2");
        let taken = ["Ada".to_string(), "Bram".to_string()];
        assert_eq!(free_name_index(taken.iter().map(String::as_str)), 2);
        let all: Vec<String> = (0..NAMES.len()).map(colonist_name).collect();
        assert_eq!(free_name_index(all.iter().map(String::as_str)), NAMES.len());
    }
    use crate::world::Terrain;
    use std::time::Duration;

    #[test]
    fn step_towards_stops_exactly_on_target() {
        assert_eq!(
            step_towards(Vec2::ZERO, Vec2::new(3.0, 4.0), 10.0),
            (Vec2::new(3.0, 4.0), true)
        );
        let (pos, arrived) = step_towards(Vec2::ZERO, Vec2::new(3.0, 4.0), 2.5);
        assert!(!arrived);
        assert!(pos.abs_diff_eq(Vec2::new(1.5, 2.0), 1e-5));
    }

    // A colonist halfway between two tiles keeps heading to the tile it is entering; repathing
    // from its last reached tile would make it turn around mid-step or walk diagonally past walls.
    #[test]
    fn repath_while_moving_keeps_the_tile_being_entered() {
        let map = WorldMap::filled(UVec2::new(10, 10), Terrain::Grass);
        let current = VecDeque::from([UVec2::new(3, 2), UVec2::new(4, 2)]);
        let path = repath(&map, UVec2::new(2, 2), &current, UVec2::new(3, 5)).unwrap();
        assert_eq!(path.front(), Some(&UVec2::new(3, 2)));
        assert_eq!(path.back(), Some(&UVec2::new(3, 5)));
    }

    #[test]
    fn repath_when_idle_starts_from_current_tile() {
        let map = WorldMap::filled(UVec2::new(10, 10), Terrain::Grass);
        let path = repath(&map, UVec2::new(2, 2), &VecDeque::new(), UVec2::new(4, 2)).unwrap();
        assert_eq!(path, VecDeque::from([UVec2::new(3, 2), UVec2::new(4, 2)]));
    }

    #[test]
    fn movers_stop_instead_of_walking_into_a_new_wall() {
        let mut map = WorldMap::filled(UVec2::new(10, 10), Terrain::Grass);
        map.set_wall(UVec2::new(3, 1), true);
        let mut app = App::new();
        app.insert_resource(map)
            .init_resource::<Time>()
            .add_systems(Update, follow_path);
        let mover = app
            .world_mut()
            .spawn((
                TilePos(UVec2::new(1, 1)),
                Path(VecDeque::from([
                    UVec2::new(2, 1),
                    UVec2::new(3, 1),
                    UVec2::new(4, 1),
                ])),
                sim_pos(WorldMap::tile_center(UVec2::new(1, 1))),
            ))
            .id();
        for _ in 0..40 {
            app.world_mut()
                .resource_mut::<Time>()
                .advance_by(Duration::from_millis(50));
            app.update();
        }
        assert_eq!(
            app.world().get::<TilePos>(mover),
            Some(&TilePos(UVec2::new(2, 1)))
        );
        assert!(app.world().get::<Path>(mover).unwrap().0.is_empty());
    }

    #[test]
    fn colonists_wear_down_the_ground_they_walk_on() {
        let mut app = App::new();
        app.insert_resource(WorldMap::filled(UVec2::new(10, 10), Terrain::Grass))
            .init_resource::<Time>()
            .add_systems(Update, follow_path);
        app.world_mut().spawn((
            Colonist {
                name: "Test".into(),
            },
            TilePos(UVec2::new(1, 1)),
            Path(VecDeque::from([UVec2::new(2, 1)])),
            sim_pos(WorldMap::tile_center(UVec2::new(1, 1))),
        ));
        app.world_mut().spawn((
            TilePos(UVec2::new(1, 3)),
            Path(VecDeque::from([UVec2::new(2, 3)])),
            sim_pos(WorldMap::tile_center(UVec2::new(1, 3))),
        ));
        for _ in 0..20 {
            app.world_mut()
                .resource_mut::<Time>()
                .advance_by(Duration::from_millis(50));
            app.update();
        }
        let map = app.world().resource::<WorldMap>();
        assert_eq!(map.wear(IVec2::new(2, 1)), 1.0);
        assert_eq!(map.wear(IVec2::new(2, 3)), 0.0);
    }

    #[test]
    fn colonists_walk_their_path_and_update_tile_pos() {
        let mut app = App::new();
        app.insert_resource(WorldMap::filled(UVec2::new(10, 10), Terrain::Grass))
            .init_resource::<Time>()
            .add_systems(Update, follow_path);
        let colonist = app
            .world_mut()
            .spawn((
                Colonist {
                    name: "Test".into(),
                },
                TilePos(UVec2::new(1, 1)),
                Path(VecDeque::from([UVec2::new(2, 1), UVec2::new(3, 1)])),
                sim_pos(WorldMap::tile_center(UVec2::new(1, 1))),
            ))
            .id();
        for _ in 0..100 {
            app.world_mut()
                .resource_mut::<Time>()
                .advance_by(Duration::from_millis(50));
            app.update();
        }
        let world = app.world();
        assert_eq!(
            world.get::<TilePos>(colonist),
            Some(&TilePos(UVec2::new(3, 1)))
        );
        assert!(world.get::<Path>(colonist).unwrap().0.is_empty());
        assert_eq!(
            world.get::<SimPos>(colonist),
            Some(&SimPos(WorldMap::tile_center(UVec2::new(3, 1))))
        );
    }
}