use bevy::{math::vec3, prelude::*};
use bevy_rapier2d::prelude::*;

use crate::{module::component::{Attach, CanAttach, LooseAttach, PartFlags, PartType}, planet::PlanetType};

use super::component::Player;

pub fn attach_or_detach(
    select: Entity,
    attached_query: &mut Query<(Entity, &PartType, &mut Transform, &mut Attach,
            &Velocity, Option<&CanAttach>, Option<&LooseAttach>, &mut PartFlags),
        (Without<PlanetType>, Without<Player>),
    >,
    player_query: &mut Query<(Entity, &mut Player, &Transform, &Velocity,
            &mut Attach, &mut PartFlags),
        Without<PlanetType>,
    >,
    part_query: &mut Query<(Entity, &PartType, &mut Transform, &mut Velocity,
            Option<&LooseAttach>, &mut PartFlags),
        (Without<PlanetType>, Without<Player>, Without<Attach>),
    >,
    commands: &mut Commands,
    x: f32,
    y: f32,
    entity: Entity,
) {
    if attached_query.contains(select) {
        let module = attached_query.get(select).unwrap();
        let attach = module.3.clone();
        let lost_energy_capacity = crate::module::detach_recursive(
            commands,
            module.0,
            attached_query,
            player_query,
        );
        let mut module = attached_query.get_mut(select).unwrap();
        module.2.translation = vec3(x, y, 0.);
        if *module.1 == PartType::LandingThruster {
            let sub_entity = attach.children[2].unwrap();
            let mut suspension =
                attached_query.get_mut(sub_entity).unwrap();
            suspension.2.translation = vec3(x, y, 0.);
        }
        let mut player = player_query.get_mut(entity).unwrap().1;
        player.energy_capacity -= lost_energy_capacity;
        player.energy =
            std::cmp::min(player.energy, player.energy_capacity);
        return;
    }
    if crate::module::attach_on_module_tree(
        x,
        y,
        commands,
        entity,
        select,
        entity,
        attached_query,
        part_query,
        player_query,
    ) {
        let mut part = part_query.get_mut(select).unwrap();
        part.5.attached = true; // all of this code is cursed. what the hell is it actually doing
        return;
    }
    // move module to cursor since no attach
    let mut part = part_query.get_mut(select).unwrap();
    part.2.translation = vec3(x, y, 0.);
    if *part.1 == PartType::LandingThruster {
        if let Some(loose_attach) = part.4 {
            let sub_entity = loose_attach.children[2].unwrap();
            let mut part = part_query.get_mut(sub_entity).unwrap();
            part.2.translation = vec3(x, y, 0.);
        }
    }
}

pub fn mouse_picking(
    attached_query: &Query<(Entity, &PartType, &mut Transform, &mut Attach,
            &Velocity, Option<&CanAttach>, Option<&LooseAttach>, &mut PartFlags),
        (Without<PlanetType>, Without<Player>),
    >,
    part_query: &Query<(Entity, &PartType, &mut Transform, &mut Velocity,
            Option<&LooseAttach>, &mut PartFlags),
        (Without<PlanetType>, Without<Player>, Without<Attach>),
    >,
    q_player: &mut Player,
    x: f32,
    y: f32,
    entity: Entity,
) {
    for (m_entity, part_type, transform, m_attach, _velocity, _, _, _) in
        attached_query.iter()
    {
        if *part_type == PartType::LandingThrusterSuspension {
            continue;
        }
        let pos = transform.translation;
        let rel_x = pos.x - x;
        let rel_y = pos.y - y;
        let angle = -transform.rotation.z;
        let x = rel_x * angle.cos() - rel_y * angle.sin();
        let y = rel_x * angle.sin() + rel_y * angle.cos();
        let mut bound = [-0.5, 0.5, -0.5, 0.5]; // left, right, top, bottom
        if let PartType::Cargo = part_type {
            bound = [-0.375, 0.375, -0.5, 0.4375];
        }

        if bound[0] < x
            && x < bound[1]
            && bound[2] < y
            && y < bound[3]
            && m_attach.associated_player.unwrap() == entity
        {
            q_player.selected = Some(m_entity);
            break;
        }
    }
    for (entity, part_type, transform, _, _, _) in part_query.iter() {
        if *part_type == PartType::LandingThrusterSuspension {
            continue;
        }
        let pos = transform.translation;
        let rel_x = pos.x - x;
        let rel_y = pos.y - y;
        let angle = -transform.rotation.z;
        let x = rel_x * angle.cos() - rel_y * angle.sin();
        let y = rel_x * angle.sin() + rel_y * angle.cos();
        let mut bound = [-0.5, 0.5, -0.5, 0.5]; // left, right, top, bottom
        if let PartType::Cargo = part_type {
            bound = [-0.375, 0.375, -0.5, 0.4375];
        }

        if bound[0] < x && x < bound[1] && bound[2] < y && y < bound[3] {
            q_player.selected = Some(entity);
            break;
        }
    }
}