use crate::protocol::*;
use crate::server::entity_map::*;
use crate::server::network::*;
use crate::shared::ability::*;
use crate::shared::activation::*;
use crate::shared::area_of_effect::*;
use crate::shared::buffs::*;
use crate::shared::champion::*;
use crate::shared::cooldown::*;
use crate::shared::faction::*;
use crate::shared::health::*;
use crate::shared::health_event::*;
use crate::shared::immovable::*;
use crate::shared::imperative::*;
use crate::shared::minion::*;
use crate::shared::nexus::*;
use crate::shared::player::*;
use crate::shared::projectile::*;
use crate::shared::shape::*;
use crate::shared::stats::*;
use crate::shared::tower::*;
use bevy::prelude::*;
use bevy::utils::*;
use lightyear::prelude::*;
use lightyear::server::events::MessageEvent;
use rand::Rng;

pub mod entity_map;
mod network;

pub fn main(transport: TransportConfig) {
    App::new()
        .add_plugins(MinimalPlugins)
        .add_plugins(ServerPlugin { transport })
        .run();
}

struct ServerPlugin {
    pub transport: TransportConfig,
}

const HEALTH_REGEN_RATE: f32 = 5.;

#[derive(Resource)]
struct HealthRegenTimer(pub Timer);

impl Default for HealthRegenTimer {
    fn default() -> Self {
        HealthRegenTimer(Timer::from_seconds(HEALTH_REGEN_RATE, TimerMode::Repeating))
    }
}

impl Plugin for ServerPlugin {
    fn build(&self, app: &mut App) {
        app.insert_resource(EntityMap::default())
            .insert_resource(HealthRegenTimer::default())
            .add_plugins(NetworkPlugin {
                transport: self.transport.clone(),
            })
            .add_systems(Startup, setup)
            .add_systems(Update, (connects, disconnects))
            .add_systems(Update, receive_message)
            .add_systems(FixedUpdate, timers_tick)
            .add_systems(FixedUpdate, effective_stats.after(buffs_despawn))
            .add_systems(FixedUpdate, health_regen.after(timers_tick))
            .add_systems(
                FixedUpdate,
                (
                    (imperative_attack_approach, imperative_attack_attack)
                        .chain()
                        .after(activation),
                    activation.after(cooldown_decrement),
                    imperative_walk_to,
                )
                    .after(player_input),
            )
            .add_systems(
                FixedUpdate,
                (
                    projectile_despawn,
                    projectile_move.after(imperative_walk_to),
                )
                    .chain(),
            )
            .add_systems(
                FixedUpdate,
                (
                    area_of_effect_despawn,
                    area_of_effect_tick.after(imperative_walk_to),
                    area_of_effect_activate,
                )
                    .chain(),
            )
            .add_systems(FixedUpdate, cooldown_decrement)
            .add_systems(FixedUpdate, (buffs_despawn, buffs_tick).chain())
            .add_systems(FixedUpdate, player_input)
            .add_systems(
                FixedUpdate,
                (tower_ai, (minion_ai_attack, minion_ai_walk).chain())
                    .before(imperative_attack_approach),
            )
            .add_systems(FixedUpdate, minion_despawn)
            .add_systems(FixedUpdate, (nexus_tick, nexus_spawn_minions));
    }
}

fn setup(mut commands: Commands, mut entity_map: ResMut<EntityMap>) {
    {
        let client_id = 1;
        let entity = commands.spawn(TowerBundle::new(
            client_id,
            Vec2::new(0., 100.),
            Faction::Blue,
        ));
        entity_map.0.insert(client_id, entity.id());
    }
    {
        let client_id = 2;
        let entity = commands.spawn(TowerBundle::new(
            client_id,
            Vec2::new(0., -100.),
            Faction::Red,
        ));
        entity_map.0.insert(client_id, entity.id());
    }
    for client_id in 3..=8 {
        let entity = commands.spawn(MinionBundle::new(
            client_id,
            Vec2::new((client_id - 2) as f32 * 25., 0.),
            Faction::Blue,
        ));
        entity_map.0.insert(client_id, entity.id());
    }
    for client_id in 9..=14 {
        let entity = commands.spawn(MinionBundle::new(
            client_id,
            Vec2::new((client_id - 8) as f32 * -25., 0.),
            Faction::Red,
        ));
        entity_map.0.insert(client_id, entity.id());
    }
    {
        let client_id = 15;
        let entity = commands.spawn(NexusBundle::new(
            client_id,
            Vec2::new(100., 100.0),
            Faction::Blue,
        ));
        entity_map.0.insert(client_id, entity.id());
    }
    {
        let client_id = 16;
        let entity = commands.spawn(NexusBundle::new(
            client_id,
            Vec2::new(-100., -100.0),
            Faction::Red,
        ));
        entity_map.0.insert(client_id, entity.id());
    }
}

fn connects(
    mut commands: Commands,
    mut connects: EventReader<server::ConnectEvent>,
    mut entity_map: ResMut<EntityMap>,
) {
    let mut rng = rand::thread_rng();
    for connection in connects.read() {
        let client_id = connection.context();
        let position = Vec2::new(
            50. * rng.gen_range(-2..=2) as f32,
            50. * rng.gen_range(-2..=2) as f32,
        );
        let color = Color::hsl(360. * rng.gen_range(0..=15) as f32 / 16., 0.95, 0.7);
        let entity = commands.spawn(PlayerBundle::new(*client_id, position, color));
        entity_map.0.insert(*client_id, entity.id());
    }
}

fn receive_message(
    entity_map: Res<EntityMap>,
    mut commands: Commands,
    mut reader: EventReader<MessageEvent<SelectChampion>>,
) {
    for event in reader.read() {
        let client_id = event.context();
        let SelectChampion(champion) = event.message();
        let Some(entity) = entity_map.0.get(client_id) else {
            continue;
        };
        commands.entity(*entity).insert(*champion);
    }
}

fn disconnects(
    mut commands: Commands,
    mut disconnects: EventReader<server::DisconnectEvent>,
    mut entity_map: ResMut<EntityMap>,
) {
    for connection in disconnects.read() {
        let client_id = connection.context();
        if let Some(entity_id) = entity_map.0.remove(client_id) {
            commands.entity(entity_id).despawn();
        }
    }
}

fn player_input(
    entity_map: Res<EntityMap>,
    mut input_reader: EventReader<server::InputEvent<Inputs>>,
    mut imperatives: Query<&mut Imperative>,
    mut activations: Query<&mut Activation>,
) {
    for input in input_reader.read() {
        let client_id = input.context();
        if let Some(input) = input.input() {
            if let Some(entity_id) = entity_map.0.get(client_id) {
                match input {
                    Inputs::Imperative(new_imperative) => {
                        if let Ok(mut imperative) = imperatives.get_mut(*entity_id) {
                            *imperative = *new_imperative;
                        }
                    }
                    Inputs::Activation(new_activation) => {
                        if let Ok(mut activation) = activations.get_mut(*entity_id) {
                            *activation = *new_activation;
                        }
                    }
                    Inputs::None => {}
                }
            }
        }
    }
}

fn imperative_walk_to(
    mut players: Query<(Entity, &mut Imperative, &EffectiveStats)>,
    mut positions: Query<&mut PlayerPosition>,
    time: Res<Time>,
) {
    for (entity, mut imperative, effective_stats) in players.iter_mut() {
        match *imperative {
            Imperative::WalkTo(target_position) => {
                if let Ok(mut position) = positions.get_mut(entity) {
                    let (new_position, target_reached) = move_to_target(
                        position.0,
                        target_position,
                        effective_stats.0.movement_speed * time.delta().as_secs_f32(),
                    );
                    position.0 = new_position;
                    if target_reached {
                        *imperative = Imperative::Idle;
                    }
                } else {
                    *imperative = Imperative::Idle;
                }
            }
            _ => {}
        }
    }
}

fn move_to_target(position: Vec2, target_position: Vec2, max_distance: f32) -> (Vec2, bool) {
    let distance = (target_position - position).length();
    let direction = (target_position - position).normalize_or_zero();
    let new_position = position + f32::min(max_distance, distance) * direction;
    if position.distance(new_position) <= f32::EPSILON {
        (target_position, true)
    } else {
        (new_position, false)
    }
}

fn move_along_direction(position: Vec2, direction: Vec2, distance: f32) -> Vec2 {
    position + distance * direction
}

fn imperative_attack_approach(
    entity_map: Res<EntityMap>,
    mut players: Query<(&PlayerId, &mut Imperative, &EffectiveStats), Without<Immovable>>,
    mut positions: Query<&mut PlayerPosition>,
    shapes: Query<&Shape>,
    time: Res<Time>,
) {
    for (id, mut imperative, effective_stats) in players.iter_mut() {
        match *imperative {
            Imperative::AttackTarget(_, target_player) => {
                let Some(entity) = entity_map.0.get(&id.0) else {
                    *imperative = Imperative::Idle;
                    continue;
                };
                let Some(target_entity) = entity_map.0.get(&target_player.0) else {
                    *imperative = Imperative::Idle;
                    continue;
                };
                let Ok([mut position, target_position]) =
                    positions.get_many_mut([*entity, *target_entity])
                else {
                    *imperative = Imperative::Idle;
                    continue;
                };
                let Ok(target_shape) = shapes.get(*target_entity) else {
                    *imperative = Imperative::Idle;
                    continue;
                };
                let distance = target_position.0.distance(position.0);
                if distance > effective_stats.0.attack_range + target_shape.radius {
                    let (new_position, _) = move_to_target(
                        position.0,
                        target_position.0,
                        effective_stats.0.movement_speed * time.delta().as_secs_f32(),
                    );
                    position.0 = new_position;
                }
            }
            _ => {}
        }
    }
}

fn imperative_attack_attack(
    entity_map: Res<EntityMap>,
    mut commands: Commands,
    mut cooldowns: Query<&mut Cooldown>,
    mut players: Query<(&PlayerId, &mut Imperative, &EffectiveStats)>,
    mut positions: Query<&mut PlayerPosition>,
    shapes: Query<&Shape>,
    champions: Query<&Champion>,
) {
    for (id, mut imperative, effective_stats) in players.iter_mut() {
        let Some(entity) = entity_map.0.get(&id.0) else {
            *imperative = Imperative::Idle;
            continue;
        };
        let Ok(champion) = champions.get(*entity) else {
            *imperative = Imperative::Idle;
            continue;
        };
        match *imperative {
            Imperative::AttackTarget(ability_slot, target_player) => {
                let Ability::Targeted(ability) = champion.ability(ability_slot) else {
                    *imperative = Imperative::Idle;
                    continue;
                };
                let Some(target_entity) = entity_map.0.get(&target_player.0) else {
                    *imperative = Imperative::Idle;
                    continue;
                };
                let Ok([position, target_position]) =
                    positions.get_many_mut([*entity, *target_entity])
                else {
                    *imperative = Imperative::Idle;
                    continue;
                };
                let Ok(target_shape) = shapes.get(*target_entity) else {
                    *imperative = Imperative::Idle;
                    continue;
                };
                let distance = target_position.0.distance(position.0);
                if distance <= effective_stats.0.attack_range + target_shape.radius {
                    let Ok(mut cooldown) = cooldowns.get_mut(*entity) else {
                        *imperative = Imperative::Idle;
                        continue;
                    };
                    let base_cooldown = champion.base_cooldown();
                    if cooldown.0[ability_slot].is_zero() {
                        cooldown.0[ability_slot] = if ability_slot == AbilitySlot::A {
                            Duration::from_secs_f32(effective_stats.0.attack_speed)
                        } else {
                            base_cooldown.0[ability_slot]
                        };
                        commands.spawn(ProjectileBundle::new(ability.to_projectile(
                            *id,
                            position.0,
                            target_player,
                        )));
                        *imperative = Imperative::AttackTarget(AbilitySlot::A, target_player);
                    }
                }
            }
            Imperative::AttackDirection(ability_slot, direction) => {
                let Ability::Directional(ability) = champion.ability(ability_slot) else {
                    *imperative = Imperative::Idle;
                    continue;
                };
                let Ok(mut cooldown) = cooldowns.get_mut(*entity) else {
                    *imperative = Imperative::Idle;
                    continue;
                };
                let base_cooldown = champion.base_cooldown();
                if cooldown.0[ability_slot].is_zero() {
                    cooldown.0[ability_slot] = base_cooldown.0[ability_slot];
                    ability.activate()(&mut commands, *id, direction);
                }
                *imperative = Imperative::Idle;
            }
            _ => {}
        }
    }
}

fn activation(
    champions: Query<&Champion>,
    mut commands: Commands,
    entity_map: Res<EntityMap>,
    mut cooldowns: Query<&mut Cooldown>,
    mut players: Query<(&PlayerId, &mut Activation)>,
) {
    for (id, mut activation) in players.iter_mut() {
        let Some(entity) = entity_map.0.get(&id.0) else {
            *activation = Activation::None;
            continue;
        };
        let Ok(champion) = champions.get(*entity) else {
            *activation = Activation::None;
            continue;
        };
        let Activation::Activate(ability_slot) = *activation else {
            *activation = Activation::None;
            continue;
        };
        let Ability::Activated(ability) = champion.ability(ability_slot) else {
            *activation = Activation::None;
            continue;
        };
        let Ok(mut cooldown) = cooldowns.get_mut(*entity) else {
            *activation = Activation::None;
            continue;
        };
        let base_cooldown = champion.base_cooldown();
        if cooldown.0[ability_slot].is_zero() {
            cooldown.0[ability_slot] = base_cooldown.0[ability_slot];
            ability.activate()(&mut commands, *id);
            *activation = Activation::None;
        }
    }
}

const PROJECTILE_SPEED: f32 = 150.;

fn projectile_move(
    entity_map: Res<EntityMap>,
    player_positions: Query<&PlayerPosition>,
    mut projectiles: Query<&mut Projectile>,
    time: Res<Time>,
) {
    for mut projectile in projectiles.iter_mut() {
        let new_type = match projectile.type_.clone() {
            ProjectileType::Free(mut free_projectile) => {
                let new_position = move_along_direction(
                    free_projectile.position,
                    free_projectile.direction,
                    PROJECTILE_SPEED * time.delta().as_secs_f32(),
                );
                free_projectile.position = new_position;
                ProjectileType::Free(free_projectile)
            }
            ProjectileType::Instant(instant_projectile) => {
                ProjectileType::Instant(instant_projectile)
            }
            ProjectileType::Targeted(mut targeted_projectile) => {
                if let Some(target_entity) = entity_map.0.get(&targeted_projectile.target_player.0)
                {
                    if let Ok(target_position) = player_positions.get(*target_entity) {
                        let (new_position, _) = move_to_target(
                            targeted_projectile.position.clone(),
                            target_position.0,
                            PROJECTILE_SPEED * time.delta().as_secs_f32(),
                        );
                        targeted_projectile.position = new_position;
                    }
                }
                ProjectileType::Targeted(targeted_projectile)
            }
        };
        projectile.type_ = new_type;
    }
}

fn projectile_despawn(
    entity_map: Res<EntityMap>,
    mut commands: Commands,
    mut connection_manager: ResMut<ServerConnectionManager>,
    mut healths: Query<&mut Health>,
    player_positions: Query<&PlayerPosition>,
    projectiles: Query<(Entity, &mut Projectile)>,
    projectile_targets: Query<(&PlayerId, &PlayerPosition, &Shape)>,
) {
    for (entity, projectile) in projectiles.iter() {
        let (despawn, maybe_target_player): (bool, Option<PlayerId>) = (|| match &projectile.type_ {
            ProjectileType::Free(free_projectile) => {
                let mut maybe_target_player = None;
                let mut maybe_target_distance = None;
                for (player, position, player_shape) in projectile_targets.iter() {
                    if *player == projectile.source_player {
                        continue;
                    }
                    let distance = free_projectile.position.distance(position.0);
                    if distance > player_shape.radius {
                        continue;
                    }
                    match maybe_target_distance {
                        Some(old_distance) => {
                            if distance < old_distance {
                                maybe_target_player = Some(player);
                                maybe_target_distance = Some(distance);
                            }
                        }
                        None => {
                            maybe_target_player = Some(player);
                            maybe_target_distance = Some(distance);
                        }
                    }
                }
                if let Some(target_player) = maybe_target_player {
                    (true, Some(*target_player))
                } else {
                    (
                        free_projectile
                            .position
                            .distance(free_projectile.starting_position)
                            >= free_projectile.max_distance,
                        None,
                    )
                }
            }
            ProjectileType::Instant(instant_projectile) => {
                (true, Some(instant_projectile.target_player))
            }
            ProjectileType::Targeted(targeted_projectile) => {
                let Some(target_entity) = entity_map.0.get(&targeted_projectile.target_player.0)
                else {
                    return (true, None);
                };
                let Ok(target_position) = player_positions.get(*target_entity) else {
                    return (true, None);
                };
                (
                    targeted_projectile.position.distance(target_position.0) <= f32::EPSILON,
                    Some(targeted_projectile.target_player),
                )
            }
        })();
        if despawn {
            if let Some(target_player) = maybe_target_player {
                if let Some(target_entity) = entity_map.0.get(&target_player.0) {
                    if let Ok(mut health) = healths.get_mut(*target_entity) {
                        let damage = match projectile.type_ {
                            ProjectileType::Free(FreeProjectile {
                                position,
                                starting_position,
                                max_distance,
                                scale_damage: Some((min_multiplier, max_multiplier)),
                                ..
                            }) => {
                                let distance_traveled =
                                    position.distance(starting_position) / max_distance;
                                let multiplier =
                                    min_multiplier.lerp(max_multiplier, distance_traveled);
                                multiplier * projectile.damage
                            }
                            _ => projectile.damage,
                        };
                        health.apply_damage(damage);
                        let _ = connection_manager
                            .send_message_to_target::<Channel1, HealthChanged>(
                                HealthChanged(HealthEvent {
                                    target_player,
                                    health_gained: -damage,
                                }),
                                NetworkTarget::All,
                            );
                    }
                }
            }
            commands.entity(entity).despawn();
        }
    }
}

fn cooldown_decrement(mut cooldowns: Query<&mut Cooldown>, time: Res<Time>) {
    let dt = time.delta();
    for mut cooldown in cooldowns.iter_mut() {
        for ability_slot in AbilitySlot::all() {
            cooldown.0[ability_slot] = cooldown.0[ability_slot].saturating_sub(dt);
        }
    }
}

fn timers_tick(mut health_regen_timer: ResMut<HealthRegenTimer>, time: Res<Time>) {
    health_regen_timer.0.tick(time.delta());
}

const HEALTH_REGEN: f32 = 5.;
fn health_regen(
    health_regen_timer: Res<HealthRegenTimer>,
    mut connection_manager: ResMut<ServerConnectionManager>,
    mut healths: Query<(&PlayerId, &mut Health, &EffectiveStats)>,
) {
    if health_regen_timer.0.just_finished() {
        for (target_player, mut health, effective_stats) in healths.iter_mut() {
            health.heal(HEALTH_REGEN, effective_stats.0.max_health);
            let _ = connection_manager.send_message_to_target::<Channel1, HealthChanged>(
                HealthChanged(HealthEvent {
                    target_player: *target_player,
                    health_gained: HEALTH_REGEN,
                }),
                NetworkTarget::All,
            );
        }
    }
}

fn effective_stats(
    mut effective_statses: Query<(&Champion, &mut EffectiveStats, &Buffs, &mut Health)>,
) {
    for (champion, mut effective_stats, buffs, mut health) in effective_statses.iter_mut() {
        let mut stats = champion.base_stats().0;
        if buffs.slow.is_some() {
            stats.movement_speed *= 0.85;
        }
        if buffs.speed.is_some() {
            stats.movement_speed *= 1.25;
        }
        if buffs.haste.is_some() {
            stats.attack_speed *= 0.5;
        }
        effective_stats.0 = stats;
        health.health = health.health.min(effective_stats.0.max_health);
        if buffs.shield.is_none() {
            health.shield = 0.;
        }
    }
}

fn buffs_tick(mut buffses: Query<&mut Buffs>, time: Res<Time>) {
    let dt = time.delta().as_secs_f32();
    for mut buffs in buffses.iter_mut() {
        if let Some(ref mut duration) = &mut buffs.haste {
            *duration = (*duration - dt).max(0.);
        }
        if let Some(ref mut duration) = &mut buffs.shield {
            *duration = (*duration - dt).max(0.);
        }
        if let Some(ref mut duration) = &mut buffs.slow {
            *duration = (*duration - dt).max(0.);
        }
        if let Some(ref mut duration) = &mut buffs.speed {
            *duration = (*duration - dt).max(0.);
        }
    }
}

fn buffs_despawn(mut buffses: Query<&mut Buffs>) {
    for mut buffs in buffses.iter_mut() {
        if let Some(duration) = &buffs.haste {
            if *duration <= 0. {
                buffs.haste = None;
            }
        }
        if let Some(duration) = &buffs.shield {
            if *duration <= 0. {
                buffs.shield = None;
            }
        }
        if let Some(duration) = &buffs.slow {
            if *duration <= 0. {
                buffs.slow = None;
            }
        }
        if let Some(duration) = &buffs.speed {
            if *duration <= 0. {
                buffs.speed = None;
            }
        }
    }
}

fn area_of_effect_tick(mut area_of_effects: Query<&mut AreaOfEffect>, time: Res<Time>) {
    let dt = time.delta();
    for mut area_of_effect in area_of_effects.iter_mut() {
        if let Some(ref mut duration) = area_of_effect.duration {
            *duration = (*duration - dt.as_secs_f32()).max(0.);
        } else {
            area_of_effect.duration = Some(0.);
        }
    }
}

fn area_of_effect_despawn(area_of_effects: Query<(Entity, &AreaOfEffect)>, mut commands: Commands) {
    for (entity, area_of_effect) in area_of_effects.iter() {
        let Some(duration) = area_of_effect.duration else {
            continue;
        };
        if duration > 0. {
            continue;
        };
        commands.entity(entity).despawn();
    }
}

fn area_of_effect_activate(
    players: Query<(&PlayerId, &PlayerPosition, &Shape)>,
    area_of_effects: Query<&AreaOfEffect>,
    mut commands: Commands,
) {
    for area_of_effect in area_of_effects.iter() {
        for (player_id, player_position, player_shape) in players.iter() {
            if *player_id == area_of_effect.source_player {
                continue;
            }
            if area_of_effect.position.distance(player_position.0)
                < area_of_effect.radius + player_shape.radius
            {
                area_of_effect.activate()(&mut commands, area_of_effect.source_player, *player_id);
            }
        }
    }
}

fn tower_ai(
    mut towers: Query<(
        &mut Tower,
        &mut Imperative,
        &PlayerPosition,
        &EffectiveStats,
        &Faction,
    )>,
    targets: Query<(&PlayerId, &PlayerPosition, &Shape, &Faction), Without<Tower>>,
) {
    for (
        mut tower_tower,
        mut tower_imperative,
        tower_player_position,
        tower_effective_stats,
        tower_faction,
    ) in towers.iter_mut()
    {
        let mut closest_target = None;
        for (target_player_id, target_player_position, target_shape, target_faction) in
            targets.iter()
        {
            if target_faction == tower_faction {
                continue;
            }

            let target_in_range = tower_player_position.0.distance(target_player_position.0)
                < tower_effective_stats.0.attack_range + target_shape.radius;

            if !target_in_range {
                continue;
            }

            let target_distance = tower_player_position.0.distance(target_player_position.0);
            if tower_tower.last_target_player_id == Some(*target_player_id) {
                closest_target = Some((target_player_id, target_distance));
                break;
            }

            let target_is_closer = closest_target
                .map(|(_, closest_target_distance)| target_distance < closest_target_distance)
                .unwrap_or(true);
            if target_is_closer {
                closest_target = Some((target_player_id, target_distance));
            }
        }
        let Some((target_player_id, _)) = closest_target else {
            *tower_imperative = Imperative::Idle;
            tower_tower.last_target_player_id = None;
            continue;
        };

        *tower_imperative = Imperative::AttackTarget(AbilitySlot::A, *target_player_id);
        tower_tower.last_target_player_id = Some(*target_player_id);
    }
}

fn minion_ai_walk(
    mut minions: Query<(&mut Imperative, &PlayerPosition, &Faction), With<Minion>>,
    nexuses: Query<(&PlayerPosition, &Faction), With<Nexus>>,
) {
    for (mut minion_imperative, minion_player_position, minion_faction) in minions.iter_mut() {
        if *minion_imperative != Imperative::Idle {
            continue;
        }
        let mut closest_target = None;
        for (nexus_player_position, nexus_faction) in nexuses.iter() {
            if nexus_faction == minion_faction {
                continue;
            }
            let target_distance = minion_player_position.0.distance(nexus_player_position.0);
            let target_is_closer = closest_target
                .map(|(_, closest_target_distance)| target_distance < closest_target_distance)
                .unwrap_or(true);
            if target_is_closer {
                closest_target = Some((nexus_player_position.0, target_distance));
            }
        }
        let Some((target_player_position, _)) = closest_target else {
            *minion_imperative = Imperative::Idle;
            continue;
        };
        *minion_imperative = Imperative::WalkTo(target_player_position);
    }
}
fn minion_ai_attack(
    mut minions: Query<(&mut Imperative, &PlayerPosition, &EffectiveStats, &Faction), With<Minion>>,
    targets: Query<(&PlayerId, &PlayerPosition, &Shape, &Faction)>,
) {
    for (mut minion_imperative, minion_player_position, minion_effective_stats, minion_faction) in
        minions.iter_mut()
    {
        let mut closest_target = None;
        for (target_player_id, target_player_position, target_shape, target_faction) in
            targets.iter()
        {
            if target_faction == minion_faction {
                continue;
            }
            let target_in_range = minion_player_position.0.distance(target_player_position.0)
                < minion_effective_stats.0.attack_range + target_shape.radius;
            if !target_in_range {
                continue;
            }
            let target_distance = minion_player_position.0.distance(target_player_position.0);
            let target_is_closer = closest_target
                .map(|(_, closest_target_distance)| target_distance < closest_target_distance)
                .unwrap_or(true);
            if target_is_closer {
                closest_target = Some((target_player_id, target_distance));
            }
        }
        let Some((target_player_id, _)) = closest_target else {
            *minion_imperative = Imperative::Idle;
            continue;
        };
        *minion_imperative = Imperative::AttackTarget(AbilitySlot::A, *target_player_id);
    }
}

fn minion_despawn(
    minions: Query<(Entity, &PlayerId, &Health), With<Minion>>,
    mut commands: Commands,
    mut entity_map: ResMut<EntityMap>,
) {
    for (minion_entity, minion_player_id, minion_health) in minions.iter() {
        if minion_health.health <= 0. {
            commands.entity(minion_entity).despawn();
            entity_map.0.remove(&minion_player_id.0);
        }
    }
}

fn nexus_spawn_minions(
    nexuses: Query<(&Nexus, &PlayerPosition, &Faction)>,
    mut commands: Commands,
    mut entity_map: ResMut<EntityMap>,
) {
    for (nexus_nexus, nexus_player_position, nexus_faction) in nexuses.iter() {
        if nexus_nexus.spawn_minions.just_finished() {
            let client_ids = generate_client_ids(5, &entity_map);
            for client_id in client_ids {
                let entity = commands.spawn(MinionBundle::new(
                    client_id,
                    nexus_player_position.0,
                    *nexus_faction,
                ));
                entity_map.0.insert(client_id, entity.id());
            }
        }
    }
}

fn generate_client_ids(n: u64, entity_map: &ResMut<EntityMap>) -> Vec<u64> {
    let mut rng = rand::thread_rng();
    let mut k = 0;
    let mut client_ids = vec![];
    while k < n {
        let client_id = rng.gen();
        if entity_map.0.contains_key(&client_id) {
            continue;
        }
        client_ids.push(client_id);
        k += 1;
    }
    client_ids
}

fn nexus_tick(mut nexuses: Query<&mut Nexus>, time: Res<Time>) {
    let dt = time.delta();
    for mut nexus in nexuses.iter_mut() {
        nexus.spawn_minions.tick(dt);
    }
}