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::hashbrown::HashMap;
use bevy::utils::*;
use lightyear::prelude::*;
use lightyear::server::events::MessageEvent;
use rand::rngs::ThreadRng;
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_select_champion,
                    receive_message_select_faction,
                ),
            )
            .add_systems(
                Update,
                (receive_message_imperative, receive_message_activation),
            )
            .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(receive_message_activation)
                    .after(receive_message_imperative),
            )
            .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,
                (tower_ai, (minion_ai_attack, minion_ai_walk).chain())
                    .before(imperative_attack_approach),
            )
            .add_systems(FixedUpdate, despawn)
            .add_systems(FixedUpdate, player_respawn)
            .add_systems(FixedUpdate, (nexus_tick, nexus_spawn_minions))
            .add_systems(
                FixedUpdate,
                movement_collision
                    .after(imperative_attack_approach)
                    .after(imperative_walk_to),
            );
    }
}

const TOWER_DISTANCE: f32 = 400.;

fn setup(mut commands: Commands, mut entity_map: ResMut<EntityMap>) {
    let [blue_tower_1, blue_tower_2, blue_tower_3, blue_nexus, red_tower_1, red_tower_2, red_tower_3, red_nexus] =
        generate_client_ids::<8>(&entity_map).into();

    for (n, client_id) in [(0, blue_tower_1), (1, blue_tower_2), (2, blue_tower_3)].iter() {
        let entity = commands.spawn(TowerBundle::new(
            *client_id,
            Vec2::new(0., TOWER_DISTANCE / 2. + *n as f32 * TOWER_DISTANCE),
            Faction::Yellow,
        ));
        entity_map.0.insert(*client_id, entity.id());
    }
    {
        let client_id = blue_nexus;
        let entity = commands.spawn(NexusBundle::new(
            client_id,
            Vec2::new(0., TOWER_DISTANCE / 2. + 3. * TOWER_DISTANCE),
            Faction::Yellow,
        ));
        entity_map.0.insert(client_id, entity.id());
    }

    for (n, client_id) in [(0, red_tower_1), (1, red_tower_2), (2, red_tower_3)].iter() {
        let entity = commands.spawn(TowerBundle::new(
            *client_id,
            Vec2::new(0., -TOWER_DISTANCE / 2. - *n as f32 * TOWER_DISTANCE),
            Faction::Purple,
        ));
        entity_map.0.insert(*client_id, entity.id());
    }
    {
        let client_id = red_nexus;
        let entity = commands.spawn(NexusBundle::new(
            client_id,
            Vec2::new(0., -TOWER_DISTANCE / 2. - 3. * TOWER_DISTANCE),
            Faction::Purple,
        ));
        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_select_champion(
    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 receive_message_select_faction(
    entity_map: Res<EntityMap>,
    mut commands: Commands,
    mut reader: EventReader<MessageEvent<SelectFaction>>,
) {
    for event in reader.read() {
        let client_id = event.context();
        let SelectFaction(faction) = event.message();
        let Some(entity) = entity_map.0.get(client_id) else {
            continue;
        };
        commands.entity(*entity).insert(*faction);
    }
}

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

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

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 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, &PlayerColor)>,
    mut positions: Query<&mut PlayerPosition>,
    shapes: Query<&Shape>,
    champions: Query<&Champion>,
) {
    for (id, mut imperative, effective_stats, player_color) 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),
                            ProjectileColor(player_color.0),
                        ));
                        *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>,
    projectiles: Query<(Entity, &mut Projectile)>,
    mut targets: Query<(
        Entity,
        &PlayerId,
        &PlayerPosition,
        &Shape,
        &EffectiveStats,
        &mut Health,
    )>,
) {
    for (entity, projectile) in projectiles.iter() {
        let (despawn, hit_target): (bool, Option<Entity>) = (|| match &projectile.type_ {
            ProjectileType::Free(free_projectile) => {
                let mut closest_target: Option<(Entity, f32)> = None;
                for (
                    target_entity,
                    target_player_id,
                    target_player_position,
                    target_shape,
                    _target_effective_stats,
                    _target_health,
                ) in targets.iter()
                {
                    if *target_player_id == projectile.source_player {
                        continue;
                    }
                    let target_distance =
                        free_projectile.position.distance(target_player_position.0);
                    if target_distance > target_shape.radius {
                        continue;
                    }
                    let target_is_closer = closest_target
                        .map(|(_, closest_distance)| target_distance < closest_distance)
                        .unwrap_or(true);
                    if target_is_closer {
                        closest_target = Some((target_entity, target_distance));
                    }
                }
                if let Some((target_entity, _)) = closest_target {
                    (true, Some(target_entity))
                } else {
                    (
                        free_projectile
                            .position
                            .distance(free_projectile.starting_position)
                            >= free_projectile.max_distance,
                        None,
                    )
                }
            }
            ProjectileType::Instant(instant_projectile) => {
                let Some(target_entity) = entity_map.0.get(&instant_projectile.target_player.0)
                else {
                    return (true, None);
                };
                (true, Some(*target_entity))
            }
            ProjectileType::Targeted(targeted_projectile) => {
                let Some(target_entity) = entity_map.0.get(&targeted_projectile.target_player.0)
                else {
                    return (true, None);
                };
                let Ok((
                    target_entity,
                    _target_player_id,
                    target_player_position,
                    target_shape,
                    _target_effective_stats,
                    _target_health,
                )) = targets.get(*target_entity)
                else {
                    return (true, None);
                };
                if targeted_projectile
                    .position
                    .distance(target_player_position.0)
                    < target_shape.radius
                {
                    (true, Some(target_entity))
                } else {
                    (false, None)
                }
            }
        })();
        if despawn {
            commands.entity(entity).despawn();
        }
        let Some(hit_entity) = hit_target else {
            continue;
        };
        let Ok((
            _hit_entity,
            hit_player_id,
            _hit_player_position,
            _hit_shape,
            hit_effective_stats,
            mut hit_health,
        )) = targets.get_mut(hit_entity)
        else {
            continue;
        };
        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);
                projectile.damage.scale(multiplier)
            }
            _ => projectile.damage,
        };
        let applied_damage = damage.apply(hit_effective_stats.0);
        hit_health.apply_damage(applied_damage);
        let _ = connection_manager.send_message_to_target::<Input, HealthChanged>(
            HealthChanged(HealthEvent {
                target_player: *hit_player_id,
                health_gained: -applied_damage,
            }),
            NetworkTarget::All,
        );
    }
}

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), With<Player>>,
) {
    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::<Input, 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,
    )>,
    non_player_targets: Query<
        (Entity, &PlayerId, &PlayerPosition, &Shape, &Faction),
        (Without<Tower>, Without<Player>),
    >,
    player_targets: Query<
        (Entity, &PlayerId, &PlayerPosition, &Shape, &Faction),
        (Without<Tower>, With<Player>),
    >,
) {
    for (
        mut tower_tower,
        mut tower_imperative,
        tower_player_position,
        tower_effective_stats,
        tower_faction,
    ) in towers.iter_mut()
    {
        let target_is_valid = |target_faction: &Faction,
                               target_player_position: &PlayerPosition,
                               target_shape: &Shape| {
            if target_faction == tower_faction {
                return false;
            }

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

        if let Some(last_target) = tower_tower.last_target {
            if let Ok((_, _, target_player_position, target_shape, target_faction)) =
                non_player_targets.get(last_target.entity)
            {
                if target_is_valid(target_faction, target_player_position, target_shape) {
                    return;
                }
            } else if let Ok((_, _, target_player_position, target_shape, target_faction)) =
                player_targets.get(last_target.entity)
            {
                if target_is_valid(target_faction, target_player_position, target_shape) {
                    return;
                }
            }
        }

        let update_closest_target =
            |closest_target: &mut Option<(LastTarget, f32)>,
             target_entity: Entity,
             target_player_id: &PlayerId,
             target_player_position: &PlayerPosition| {
                let target_distance = tower_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((
                        LastTarget {
                            entity: target_entity,
                            player_id: *target_player_id,
                        },
                        target_distance,
                    ));
                }
            };

        let determine_target =
            |closest_target: &mut Option<(LastTarget, f32)>,
             (
                target_entity,
                target_player_id,
                target_player_position,
                target_shape,
                target_faction,
            ): (Entity, &PlayerId, &PlayerPosition, &Shape, &Faction)| {
                if !target_is_valid(target_faction, target_player_position, target_shape) {
                    return;
                }
                update_closest_target(
                    closest_target,
                    target_entity,
                    target_player_id,
                    target_player_position,
                );
            };

        let mut closest_non_player_target: Option<(LastTarget, f32)> = None;
        for target in non_player_targets.iter() {
            determine_target(&mut closest_non_player_target, target);
        }

        let mut closest_player_target: Option<(LastTarget, f32)> = None;
        if closest_non_player_target.is_none() {
            for target in player_targets.iter() {
                determine_target(&mut closest_player_target, target);
            }
        }

        let closest_target = closest_non_player_target.or(closest_player_target);
        let Some((target, _)) = closest_target else {
            *tower_imperative = Imperative::Idle;
            tower_tower.last_target = None;
            continue;
        };

        *tower_imperative = Imperative::AttackTarget(AbilitySlot::A, target.player_id);
        tower_tower.last_target = Some(target);
    }
}

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 despawn(
    minions: Query<(Entity, &PlayerId, &Health), Without<Player>>,
    mut commands: Commands,
    mut entity_map: ResMut<EntityMap>,
) {
    for (entity, player_id, health) in minions.iter() {
        if health.health <= 0. {
            commands.entity(entity).despawn();
            entity_map.0.remove(&player_id.0);
        }
    }
}

fn player_respawn(
    mut players: Query<(&mut Health, &mut PlayerPosition, &EffectiveStats), With<Player>>,
) {
    for (mut health, mut player_position, effective_stats) in players.iter_mut() {
        if health.health <= 0. {
            health.health = effective_stats.0.max_health;
            health.shield = 0.;
            player_position.0 = Vec2::ZERO;
        }
    }
}

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<const N: usize>(entity_map: &ResMut<EntityMap>) -> [ClientId; N] {
    let mut rng = rand::thread_rng();
    let mut k = 0;
    let mut client_ids = vec![];
    while k < N {
        let client_id = ClientId::Local(rng.gen());
        if entity_map.0.contains_key(&client_id) {
            continue;
        }
        client_ids.push(client_id);
        k += 1;
    }
    client_ids.try_into().unwrap()
}

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

pub fn movement_collision(
    mut entities: Query<(
        Entity,
        &mut PlayerPosition,
        &Shape,
        Option<&Immovable>,
        Option<&Imperative>,
    )>,
) {
    let mut corrections = HashMap::<Entity, Vec2>::new();
    let mut rng = rand::thread_rng();
    for (entity, entity_player_position, entity_shape, entity_immovable, entity_imperative) in
        entities.iter()
    {
        let stationary = entity_immovable.is_some() || {
            entity_imperative
                .map(|imperative| match imperative {
                    Imperative::WalkTo(_) => false,
                    _ => true,
                })
                .unwrap_or(true)
        };
        for (
            other_entity,
            other_entity_player_position,
            other_entity_shape,
            other_entity_immovable,
            other_entity_imperative,
        ) in entities.iter()
        {
            if other_entity == entity {
                continue;
            }
            let other_stationary = other_entity_immovable.is_some() || {
                other_entity_imperative
                    .map(|other_imperative| match other_imperative {
                        Imperative::WalkTo(_) => false,
                        _ => true,
                    })
                    .unwrap_or(true)
            };
            let distance = entity_player_position
                .0
                .distance(other_entity_player_position.0);
            let overlap_distance = entity_shape.radius + other_entity_shape.radius - distance;
            let is_intersecting = overlap_distance > 0.;
            if !is_intersecting {
                continue;
            }
            let correction_direction = (entity_player_position.0 - other_entity_player_position.0)
                .try_normalize()
                .unwrap_or(random_unit_vector(&mut rng));
            let displacement_factor = if stationary {
                0.
            } else if other_stationary {
                1.
            } else {
                other_entity_shape.radius / (entity_shape.radius + other_entity_shape.radius)
            };
            let force = displacement_factor * overlap_distance * correction_direction;
            if let Some(existing_force) = corrections.get_mut(&entity) {
                *existing_force += force;
            } else {
                corrections.insert(entity, force);
            }
        }
    }
    for (entity, mut entity_player_position, _, _, _) in entities.iter_mut() {
        entity_player_position.0 += *(corrections.get(&entity).unwrap_or(&Vec2::ZERO));
    }
}

fn random_unit_vector(rng: &mut ThreadRng) -> Vec2 {
    loop {
        if let Some(v) = Vec2::new(rng.gen(), rng.gen()).try_normalize() {
            return v;
        }
    }
}