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::health::*;
use crate::shared::health_event::*;
use crate::shared::imperative::*;
use crate::shared::player::*;
use crate::shared::projectile::*;
use crate::shared::stats::*;
use crate::shared::*;
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);
    }
}

fn setup(mut commands: Commands, mut entity_map: ResMut<EntityMap>) {
    let client_id = 1;
    let entity = commands.spawn(PlayerBundle::new(1, Vec2::ZERO, Color::GRAY));
    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)>,
    mut positions: Query<&mut PlayerPosition>,
    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 distance = target_position.0.distance(position.0);
                if distance > effective_stats.0.attack_range {
                    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>,
    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 distance = target_position.0.distance(position.0);
                if distance <= effective_stats.0.attack_range {
                    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,
                        )));
                        if ability_slot != AbilitySlot::A {
                            *imperative = Imperative::Idle;
                        }
                    }
                }
            }
            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)>,
) {
    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) in projectile_targets.iter() {
                    if *player == projectile.source_player {
                        continue;
                    }
                    let distance = free_projectile.position.distance(position.0);
                    if distance > PLAYER_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) {
                        health.apply_damage(projectile.damage);
                        let _ = connection_manager
                            .send_message_to_target::<Channel1, HealthChanged>(
                                HealthChanged(HealthEvent {
                                    target_player,
                                    health_gained: -projectile.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();
    for mut buffs in buffses.iter_mut() {
        if let Some(ref mut timer) = &mut buffs.haste {
            timer.tick(dt);
        }
        if let Some(ref mut timer) = &mut buffs.shield {
            timer.tick(dt);
        }
        if let Some(ref mut timer) = &mut buffs.slow {
            timer.tick(dt);
        }
        if let Some(ref mut timer) = &mut buffs.speed {
            timer.tick(dt);
        }
    }
}

fn buffs_despawn(mut buffses: Query<&mut Buffs>) {
    for mut buffs in buffses.iter_mut() {
        if let Some(timer) = &buffs.haste {
            if timer.finished() {
                buffs.haste = None;
            }
        }
        if let Some(timer) = &buffs.shield {
            if timer.finished() {
                buffs.shield = None;
            }
        }
        if let Some(timer) = &buffs.slow {
            if timer.finished() {
                buffs.slow = None;
            }
        }
        if let Some(timer) = &buffs.speed {
            if timer.finished() {
                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)>,
    area_of_effects: Query<&AreaOfEffect>,
    mut commands: Commands,
) {
    for area_of_effect in area_of_effects.iter() {
        for (player_id, player_position) 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_RADIUS
            {
                area_of_effect.activate()(&mut commands, area_of_effect.source_player, *player_id);
            }
        }
    }
}