use std::{collections::HashMap, f32::consts::PI};

use godot::{
    classes::{AudioStreamPlayer3D, GpuParticles3D, RandomNumberGenerator},
    prelude::*,
};
use serde::{Deserialize, Serialize};

use crate::{
    game::Game,
    player::{DamageSource, shootable::Shootable},
    replay::StandaloneReplayManager,
    util::{RaycastResult, cast_ray, shotgun_ray},
};

pub trait Weapon {
    fn shoot(
        &mut self,
        player_rid: Rid,
        player_id: u16,
        from: Vector3,
        to: Vector3,
        up: Vector3,
        deal_damage: bool,
        play_fx: bool,
    ) -> bool;
    fn get_type(&self) -> WeaponType;
    fn get_max_cd(&self) -> f64;
    fn get_remaining_cd(&self) -> f64;
    fn set_remaining_cd(&mut self, cd: f64);
}

#[derive(Debug, Clone, Copy, Deserialize, Serialize, PartialEq, PartialOrd)]
pub enum WeaponType {
    Raygun,
    Shotgun,
    Ball,
}

#[derive(GodotClass)]
#[class(base=Node3D, init)]
pub struct Raygun {
    #[export]
    sound_emitter: Option<Gd<AudioStreamPlayer3D>>,
    #[export]
    bullet_prefab: Option<Gd<PackedScene>>,
    #[export]
    bullet_source: Option<Gd<Node3D>>,
    #[export]
    decal: Option<Gd<PackedScene>>,

    #[export]
    cooldown: f64,

    cooldown_remaining: f64,

    base: Base<Node3D>,
}

#[godot_api]
impl INode3D for Raygun {
    fn process(&mut self, delta: f64) {
        self.cooldown_remaining -= delta;
    }
}

#[godot_dyn]
impl Weapon for Raygun {
    fn shoot(
        &mut self,
        player: Rid,
        player_id: u16,
        from: Vector3,
        to: Vector3,
        _: Vector3,
        deal_damage: bool,
        play_fx: bool,
    ) -> bool {
        if self.cooldown_remaining > 0. {
            return false;
        }

        if let Some(emitter) = &mut self.sound_emitter
            && play_fx
        {
            emitter.play();
        }

        if let Some(source) = self.bullet_source.clone() {
            let target = cast_ray(
                from,
                to,
                &self.base().get_world_3d(),
                &Array::from_iter(vec![player]),
                None,
            );

            if play_fx {
                let target_clone = target.clone();
                self.run_deferred(|s| {
                    if let Some(target) = target_clone {
                        add_decal(&target, s.decal.clone());
                    }
                });
            }

            let beam_dir = (to - source.get_global_position()).normalized();
            let beam_end = target
                .as_ref()
                .map(|r| r.position)
                .unwrap_or(source.get_global_position() + beam_dir * 100.);
            let delta = beam_end - source.get_global_position();
            godot_print!("{}", delta);

            if let Some(prefab) = &self.bullet_prefab
                && play_fx
            {
                let mut bullet = prefab.instantiate_as::<Beam>();

                bullet.bind_mut().source = Some(source.get_global_position());
                bullet.bind_mut().target = Some(beam_end);

                self.run_deferred(move |_| {
                    if let Some(mut game) = Game::singleton()
                        && let Some(map) = &mut game.bind_mut().current_map
                    {
                        map.add_child(&bullet);
                    } else if let Some(playback) =
                        &mut StandaloneReplayManager::singleton().bind_mut().playback
                        && let Some(map) = &mut playback.bind_mut().current_map
                    {
                        map.add_child(&bullet);
                    }
                });
            }

            if deal_damage && let Some(target) = target {
                if let Ok(mut shootable) = target.collider.clone().try_dynify::<dyn Shootable>() {
                    self.run_deferred(move |_| {
                        shootable.dyn_bind_mut().on_shoot(
                            DamageSource::Player(player_id),
                            100,
                            delta,
                        );
                    });
                }
            }
        }

        self.cooldown_remaining = self.cooldown;

        true
    }

    fn get_type(&self) -> WeaponType {
        WeaponType::Raygun
    }

    fn get_max_cd(&self) -> f64 {
        self.cooldown
    }

    fn get_remaining_cd(&self) -> f64 {
        self.cooldown_remaining
    }

    fn set_remaining_cd(&mut self, cd: f64) {
        self.cooldown_remaining = cd;
    }
}

#[derive(GodotClass)]
#[class(base=Node3D, init)]
pub struct Shotgun {
    #[export]
    sound_emitter: Option<Gd<AudioStreamPlayer3D>>,
    #[export]
    vfx: Option<Gd<GpuParticles3D>>,

    #[export]
    cooldown: f64,

    #[export]
    decal: Option<Gd<PackedScene>>,

    cooldown_remaining: f64,

    rng: Gd<RandomNumberGenerator>,

    base: Base<Node3D>,
}

#[godot_api]
impl INode3D for Shotgun {
    fn process(&mut self, delta: f64) {
        self.cooldown_remaining -= delta;
    }
}

#[godot_dyn]
impl Weapon for Shotgun {
    fn shoot(
        &mut self,
        player: Rid,
        player_id: u16,
        from: Vector3,
        to: Vector3,
        up: Vector3,
        deal_damage: bool,
        play_fx: bool,
    ) -> bool {
        if self.cooldown_remaining > 0. {
            return false;
        }

        if let Some(audio) = &mut self.sound_emitter
            && play_fx
        {
            audio.play();
        }
        if let Some(vfx) = &mut self.vfx
            && play_fx
        {
            vfx.set_emitting(true);
        }

        let mut colliders: HashMap<Gd<Object>, Vec<Vector3>> = HashMap::new();
        let results = shotgun_ray(
            from,
            to,
            up,
            &self.base().get_world_3d(),
            &Array::from_iter(vec![player]),
            10,
            PI / 2.,
            10.,
            None,
        );
        if play_fx {
            let mut bullet_decal_results = Vec::new();
            for _ in 0..10 {
                if let Some(result) = results
                    .get(self.rng.randi_range(0, results.len() as i32 - 1) as usize)
                    .cloned()
                {
                    bullet_decal_results.push(result);
                }
            }

            for result in bullet_decal_results {
                self.run_deferred(move |s| {
                    add_decal(&result, s.decal.clone());
                });
            }
        }

        for result in &results {
            if let Some(positions) = colliders.get_mut(&result.collider) {
                positions.push(result.position)
            } else {
                colliders.insert(result.collider.clone(), vec![result.position]);
            }
        }

        if deal_damage {
            for (collider, positions) in colliders {
                let position = positions.iter().sum::<Vector3>() / positions.len() as f32;
                let delta = position - from;

                if let Ok(mut shootable) = collider.clone().try_dynify::<dyn Shootable>() {
                    self.run_deferred(move |_| {
                        shootable.dyn_bind_mut().on_shoot(
                            DamageSource::Player(player_id),
                            (500. / delta.length()) as i32,
                            delta.normalized(),
                        );
                    });
                }
            }
        }

        self.cooldown_remaining = self.cooldown;

        true
    }

    fn get_type(&self) -> WeaponType {
        WeaponType::Shotgun
    }

    fn get_max_cd(&self) -> f64 {
        self.cooldown
    }

    fn get_remaining_cd(&self) -> f64 {
        self.cooldown_remaining
    }

    fn set_remaining_cd(&mut self, cd: f64) {
        self.cooldown_remaining = cd;
    }
}

#[derive(GodotClass)]
#[class(base=Node3D, init)]
pub struct Beam {
    pub source: Option<Vector3>,
    pub target: Option<Vector3>,

    distance: f32,
    girth: f32,

    base: Base<Node3D>,
}

#[godot_api]
impl INode3D for Beam {
    fn ready(&mut self) {
        if let (Some(target), Some(source)) = (self.target, self.source) {
            let midway_point = (target + source) / 2.;
            self.distance = source.distance_to(target);
            self.girth = 1.;

            self.scale();
            self.base_mut().look_at_from_position(source, target);
            self.base_mut().set_global_position(midway_point);
        }
    }

    fn process(&mut self, _delta: f32) {
        self.girth = self.girth.lerp(0., 0.07);
        self.scale();
    }
}

impl Beam {
    fn scale(&mut self) {
        let length = Vector3::BACK * self.distance;
        let girth_scale = (Vector3::UP + Vector3::RIGHT) * self.girth;
        self.base_mut().set_scale(length + girth_scale);

        if self.girth < 0.01 {
            self.base_mut().queue_free();
        }
    }
}

#[derive(GodotClass)]
#[class(base=Node3D, init)]
pub struct BallWeapon {
    base: Base<Node3D>,
}

#[godot_dyn]
impl Weapon for BallWeapon {
    fn shoot(
        &mut self,
        _: Rid,
        _: u16,
        _: Vector3,
        _: Vector3,
        _: Vector3,
        _: bool,
        _: bool,
    ) -> bool {
        true
    }

    fn get_type(&self) -> WeaponType {
        WeaponType::Ball
    }

    fn get_max_cd(&self) -> f64 {
        0.
    }

    fn get_remaining_cd(&self) -> f64 {
        0.
    }

    fn set_remaining_cd(&mut self, _: f64) {}
}

fn add_decal(result: &RaycastResult, prefab: Option<Gd<PackedScene>>) {
    if let Some(mut game) = Game::singleton()
        && let Some(map) = &mut game.bind_mut().current_map
        && let Some(prefab) = prefab
    {
        let mut decal = prefab.instantiate_as::<Node3D>();
        map.add_child(&decal);
        decal.set_global_position(result.position);
        let quat = Quaternion::from_rotation_arc(Vector3::UP, result.normal);
        decal.set_global_rotation(quat.get_euler());
    }
}