use crate::{
    aim::AimState,
    billboards::Billboard,
    npc::Hit,
    physics_layers::GameLayer,
    player::{Player, PlayerRig},
    sounds::PlaySound,
    tb_entities::EnemySpawn,
};
use avian3d::prelude::{
    Collider, CollisionLayers, CollisionStarted, LayerMask, PhysicsLayer, Sensor,
};
use bevy::{pbr::NotShadowCaster, prelude::*};
use bevy_polyline::prelude::*;
use bevy_sprite3d::{Sprite3d, Sprite3dBuilder, Sprite3dParams};
use std::f32::consts::PI;

#[derive(Component)]
struct Shot {
    time: f32,
}

const MAX_SHOT_AGES: f32 = 1.;

#[derive(Event, Reflect)]
pub enum TriggerState {
    Active,
    Inactive,
}

#[derive(Resource)]
struct ShotAssets {
    image: Handle<Image>,
    layout: Handle<TextureAtlasLayout>,
}

//TODO: give its own plugin
#[derive(Component, Deref, DerefMut)]
struct AnimationTimer(Timer);

pub fn plugin(app: &mut App) {
    app.add_systems(Startup, setup);
    app.add_systems(
        Update,
        (update, shot_collision, enemy_hit, timeout, animate_sprite),
    );
    app.add_observer(on_trigger_state);
}

fn setup(
    mut commands: Commands,
    asset_server: Res<AssetServer>,
    mut sprite_params: Sprite3dParams,
) {
    let image = asset_server.load("textures/fx/impact.png");
    let layout = TextureAtlasLayout::from_grid(UVec2::splat(256), 7, 6, None, None);
    let texture_atlas_layout = sprite_params.atlas_layouts.add(layout);

    commands.insert_resource(ShotAssets {
        image,
        layout: texture_atlas_layout,
    });
}

fn on_trigger_state(
    trigger: Trigger<TriggerState>,
    mut commands: Commands,
    aim: Res<AimState>,
    player_rot: Query<&Transform, With<PlayerRig>>,
    player_pos: Query<&Transform, With<Player>>,
    target_transform: Query<&Transform, (Without<Player>, Without<PlayerRig>)>,
    time: Res<Time>,
    mut polyline_materials: ResMut<Assets<PolylineMaterial>>,
    mut polylines: ResMut<Assets<Polyline>>,
) {
    if matches!(trigger.event(), TriggerState::Active) {
        commands.trigger(PlaySound::Gun);

        let Some(player_pos) = player_pos.iter().next().map(|t| t.translation) else {
            return;
        };

        let Some(rotation) = player_rot.iter().next().map(|t| t.rotation) else {
            return;
        };

        let rotation = if let Some(target) = aim.target {
            let t = target_transform
                .get(target)
                .expect("target must have transform");
            Transform::from_translation(player_pos)
                .looking_at(t.translation, Vec3::Y)
                .rotation
        } else {
            rotation.mul_quat(Quat::from_rotation_y(PI))
        };

        let mut t = Transform::from_translation(player_pos).with_rotation(rotation);
        t.translation += t.forward().as_vec3() * 2.;

        commands
            .spawn((
                Shot {
                    time: time.elapsed_secs(),
                },
                Collider::capsule_endpoints(0.5, Vec3::new(0., 0., 0.), Vec3::new(0., 0., -3.)),
                CollisionLayers::new(LayerMask(GameLayer::Projectile.to_bits()), LayerMask::ALL),
                Sensor,
                Visibility::default(),
                t,
            ))
            .with_child(PolylineBundle {
                polyline: PolylineHandle(polylines.add(Polyline {
                    vertices: vec![Vec3::Z * 2., Vec3::Z * -2.],
                })),
                material: PolylineMaterialHandle(polyline_materials.add(PolylineMaterial {
                    width: 10.0,
                    color: LinearRgba::rgb(0.9, 0.9, 0.),
                    perspective: false,
                    ..default()
                })),
                ..default()
            });
    }
}

fn update(mut query: Query<&mut Transform, With<Shot>>) {
    for mut transform in query.iter_mut() {
        let forward = transform.forward();
        transform.translation += forward * 2.;
    }
}

fn timeout(mut commands: Commands, query: Query<(Entity, &Shot)>, time: Res<Time>) {
    let current_time = time.elapsed_secs();

    for (e, Shot { time }) in query.iter() {
        if current_time > time + MAX_SHOT_AGES {
            commands.entity(e).despawn_recursive();
        }
    }
}

fn enemy_hit(
    mut commands: Commands,
    mut collision_event_reader: EventReader<CollisionStarted>,
    query_npc: Query<&EnemySpawn>,
) {
    for CollisionStarted(e1, e2) in collision_event_reader.read() {
        if !(query_npc.contains(*e1) || query_npc.contains(*e2)) {
            continue;
        }

        let enemy_entity = if query_npc.contains(*e1) { *e1 } else { *e2 };

        commands.entity(enemy_entity).trigger(Hit { damage: 20 });
    }
}

fn animate_sprite(
    mut commands: Commands,
    time: Res<Time>,
    mut query: Query<(Entity, &mut AnimationTimer, &mut Sprite3d)>,
) {
    for (e, mut timer, mut sprite_3d) in query.iter_mut() {
        timer.tick(time.delta());
        if timer.just_finished() {
            let length = sprite_3d.texture_atlas_keys.as_ref().unwrap().len();
            let atlas = sprite_3d.texture_atlas.as_mut().unwrap();

            if atlas.index < length - 1 {
                atlas.index = atlas.index.saturating_add(1) % length;
            } else {
                commands.entity(e).despawn_recursive();
            }
        }
    }
}

fn shot_collision(
    mut commands: Commands,
    mut collision_event_reader: EventReader<CollisionStarted>,
    query_shot: Query<(&Shot, &Transform)>,
    query_player: Query<&Player>,
    assets: Res<ShotAssets>,
    mut sprite_params: Sprite3dParams,
) {
    for CollisionStarted(e1, e2) in collision_event_reader.read() {
        if !(query_shot.contains(*e1) || query_shot.contains(*e2)) {
            continue;
        }
        // filter out collision with player
        // TODO: give level geo a layer and we can simply use `CollisionLayers`
        if query_player.contains(*e1) || query_player.contains(*e2) {
            continue;
        }

        let shot_entity = if query_shot.contains(*e1) { *e1 } else { *e2 };

        let shot_pos = query_shot.get(shot_entity).unwrap().1.translation;

        commands.entity(shot_entity).despawn_recursive();

        let texture_atlas = TextureAtlas {
            layout: assets.layout.clone(),
            index: 0,
        };

        commands
            .spawn(
                Sprite3dBuilder {
                    image: assets.image.clone(),
                    pixels_per_metre: 128.,
                    alpha_mode: AlphaMode::Blend,
                    unlit: true,
                    ..default()
                }
                .bundle_with_atlas(&mut sprite_params, texture_atlas),
            )
            .insert((
                Billboard,
                Transform::from_translation(shot_pos),
                NotShadowCaster,
                AnimationTimer(Timer::from_seconds(0.01, TimerMode::Repeating)),
            ));
    }
}