use std::{collections::VecDeque, time::Duration};

use bevy::prelude::*;

use crate::{
    pathfinding::find_path,
    rng::SimRng,
    sim::{SimPos, sim_pos},
    world::{TILE_SIZE, WorldMap},
    worldgen::{WorldGenerated, spawn_tiles},
};

pub struct ColonistPlugin;

impl Plugin for ColonistPlugin {
    fn build(&self, app: &mut App) {
        app.insert_resource(SimRng::new(0x5EED))
            .add_message::<MoveOrder>()
            .add_systems(Update, spawn_colonists.run_if(on_message::<WorldGenerated>))
            .add_systems(Update, handle_move_orders)
            .add_systems(FixedUpdate, (wander, follow_path).chain());
    }
}

const TILES_PER_SECOND: f32 = 4.0;
const WANDER_RADIUS: i32 = 8;
const WANDER_PAUSE_SECS: std::ops::Range<f32> = 1.0..4.0;

const STARTING_COLONISTS: [(&str, Color); 3] = [
    ("Ada", Color::srgb(0.9, 0.3, 0.3)),
    ("Bram", Color::srgb(0.3, 0.5, 0.95)),
    ("Cleo", Color::srgb(0.95, 0.75, 0.3)),
];

#[derive(Component, Debug)]
#[require(Transform, SimPos, TilePos, Path, Wander)]
pub struct Colonist {
    pub name: String,
}

#[derive(Component, Default, Debug, Clone, Copy, PartialEq)]
pub struct TilePos(pub UVec2);

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

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

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

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

fn spawn_colonists(
    mut commands: Commands,
    map: Res<WorldMap>,
    existing: Query<Entity, With<Colonist>>,
    mut meshes: ResMut<Assets<Mesh>>,
    mut materials: ResMut<Assets<ColorMaterial>>,
) {
    for entity in &existing {
        commands.entity(entity).despawn();
    }
    let mesh = meshes.add(Circle::new(TILE_SIZE * 0.35));
    let tiles = spawn_tiles(&map, STARTING_COLONISTS.len());
    for ((name, color), tile) in STARTING_COLONISTS.into_iter().zip(tiles) {
        commands.spawn((
            Name::new(name),
            Colonist { name: name.into() },
            TilePos(tile),
            Mesh2d(mesh.clone()),
            MeshMaterial2d(materials.add(color)),
            sim_pos(WorldMap::tile_center(tile)),
            Transform::from_translation(WorldMap::tile_center(tile).extend(1.0)),
        ));
    }
}

fn handle_move_orders(
    mut orders: MessageReader<MoveOrder>,
    map: Res<WorldMap>,
    mut colonists: Query<(&TilePos, &mut Path)>,
) {
    for order in orders.read() {
        let Ok((tile, mut path)) = colonists.get_mut(order.colonist) else {
            continue;
        };
        if let Some(new_path) = repath(&map, tile.0, &path.0, order.goal) {
            path.0 = new_path;
        }
    }
}

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),
    }
}

fn wander(
    time: Res<Time>,
    map: Res<WorldMap>,
    mut rng: ResMut<SimRng>,
    mut colonists: Query<(&TilePos, &mut Path, &mut Wander)>,
) {
    for (tile, mut path, mut wander) in &mut colonists {
        if !path.0.is_empty() || !wander.0.tick(time.delta()).is_finished() {
            continue;
        }
        let offset = IVec2::new(
            rng.range_i32(-WANDER_RADIUS..WANDER_RADIUS + 1),
            rng.range_i32(-WANDER_RADIUS..WANDER_RADIUS + 1),
        );
        let goal = tile.0.as_ivec2() + offset;
        if !map.in_bounds(goal) {
            continue;
        }
        if let Some(new_path) = find_path(&map, tile.0, goal.as_uvec2()) {
            path.0 = new_path.into();
            let pause = rng.range_f32(WANDER_PAUSE_SECS);
            wander.0.set_duration(Duration::from_secs_f32(pause));
            wander.0.reset();
        }
    }
}

fn follow_path(
    time: Res<Time>,
    map: Res<WorldMap>,
    mut colonists: Query<(&mut TilePos, &mut Path, &mut SimPos)>,
) {
    for (mut tile, mut path, mut pos) in &mut colonists {
        let Some(&next) = path.0.front() else {
            continue;
        };
        let cost = map
            .step_cost(tile.0.as_ivec2(), next.as_ivec2())
            .unwrap_or(100) as f32
            / 100.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();
        }
    }
}

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::*;
    use crate::world::Terrain;

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