use std::f32::consts::PI;

use bevy::prelude::*;
use bevy_rapier2d::prelude::{AdditionalMassProperties, Collider, ExternalForce, ExternalImpulse, MassProperties, ReadMassProperties, RigidBody, Sensor};
use bevy_replicon::prelude::{ConnectedClient, FromClient, Replicated};
use crate::config::planet::Planet;
use crate::ecs::{Part, PartBundle, Player, PlayerThrust, ThrustEvent};
use crate::server::world_config::WorldConfigResource;

pub fn player_management_plugin(app: &mut App) {
    app
        .add_systems(PreUpdate, reset_movement)
        .add_systems(Update, (handle_new_players, player_thrust));
}

fn reset_movement(
    mut players: Query<(&mut ExternalForce, &mut ExternalImpulse)>
) {
    for (mut force, mut impulse) in &mut players {
        force.force = Vec2::ZERO;
        force.torque = 0.0;
        impulse.impulse = Vec2::ZERO;
    }
}

fn handle_new_players(mut commands: Commands, q_new_clients: Query<Entity, Added<ConnectedClient>>, world_config: Res<WorldConfigResource>, planets: Query<(&Transform, &Planet)>) {
    let Some(wc) = &world_config.config else { return; };
    for joined_player in &q_new_clients {
        // find earth
        let (earth_pos, earth_planet) = planets.iter().find(|p| p.1.name == "Earth").expect("earth is missing? (check that the planet is named 'Earth')");
        let angle = rand::random::<f32>() * std::f32::consts::TAU;
        let offset = earth_planet.radius + 150.0;
        let mut new_transform = Transform::from_xyz(angle.cos() * offset, angle.sin() * offset, 0.0);
        new_transform.rotate_z(angle);
        new_transform.translation += earth_pos.translation;


        commands.entity(joined_player)
            .insert(PartBundle {
                part: Part {
                    sprite: "textures/hearty.png".to_string(),
                    width: wc.part.default_width,
                    height: wc.part.default_height,
                    mass: wc.part.default_mass
                },
                transform: new_transform,
                collider: Collider::cuboid(wc.part.default_width / 2.0, wc.part.default_height / 2.0),
                additional_mass_properties: AdditionalMassProperties::MassProperties(MassProperties {
                    local_center_of_mass: Vec2::ZERO,
                    mass: wc.part.default_mass,
                    principal_inertia: 7.5,
                })
            })
            .insert(Replicated)
            .insert(ExternalForce::default())
            .insert(PlayerThrust::default())
            .insert(Player {
                client: joined_player,
            });
    }
}

fn player_thrust(
    mut players: Query<(&Transform, &mut ExternalForce, &mut PlayerThrust)>,
    mut thrust_event: EventReader<FromClient<ThrustEvent>>,
    world_config: Res<WorldConfigResource>,
) {
    use ThrustEvent::*;
    for event in thrust_event.read() {
        let FromClient { client_entity, event } = event;
        let Ok((_, _, mut thrust)) = players.get_mut(*client_entity) else { continue };
        match *event {
            Up(on) => thrust.up = on,
            Down(on) => thrust.down = on,
            Left(on) => thrust.left = on,
            Right(on) => thrust.right = on,
        }
    }
    for (transform, mut force, thrust) in &mut players {
        let Some(world_config) = &world_config.config else { return; };

        let forward = (transform.rotation * Vec3::Y).xy();
        let mut external_force = ExternalForce::default();
        let mut thrusters = [0.0; 4]; // counterclockwise wrt +y axis
        if thrust.up {
            thrusters[1] = 1.0;
            thrusters[2] = 1.0;
        }
        if thrust.down {
            thrusters[0] = 1.0;
            thrusters[3] = 1.0;
        }
        if thrust.left {
            thrusters[0] = 1.0;
            thrusters[2] = 1.0;
        }
        if thrust.right {
            thrusters[1] = 1.0;
            thrusters[3] = 1.0;
        }
        let half_size = Vec2::new(world_config.part.default_width/2.0, world_config.part.default_height/2.0).length();
        external_force += ExternalForce::at_point(
            -forward*thrusters[0]*world_config.hearty.thrust,
            transform.translation.xy() + half_size*Vec2::new((1.0*PI/4.0).cos(), (1.0*PI/4.0).sin()).rotate(forward),
            transform.translation.xy(),
        );
        external_force += ExternalForce::at_point(
            forward*thrusters[1]*world_config.hearty.thrust,
            transform.translation.xy() + half_size*Vec2::new((3.0*PI/4.0).cos(), (3.0*PI/4.0).sin()).rotate(forward),
            transform.translation.xy(),
        );
        external_force += ExternalForce::at_point(
            forward*thrusters[2]*world_config.hearty.thrust,
            transform.translation.xy() + half_size*Vec2::new((5.0*PI/4.0).cos(), (5.0*PI/4.0).sin()).rotate(forward),
            transform.translation.xy(),
        );
        external_force += ExternalForce::at_point(
            -forward*thrusters[3]*world_config.hearty.thrust,
            transform.translation.xy() + half_size*Vec2::new((7.0*PI/4.0).cos(), (7.0*PI/4.0).sin()).rotate(forward),
            transform.translation.xy(),
        );
        *force += external_force;
    }
}