use crate::{module::component::Attach, planet::PlanetType};
use bevy::prelude::{Children, Entity, Query, Res};
use bevy_rapier2d::plugin::RapierContext;

use super::components::{IsMining, VarietyMaterialStorage};
pub fn mine_materials(
    rapier_context: Res<RapierContext>,
    planet_query: Query<(&PlanetType, &Children)>,
    mut mineable_query: Query<(
        Entity,
        &mut Attach,
        Option<&IsMining>,
        Option<&mut VarietyMaterialStorage>,
    )>,
) {
    for (planet_type, children) in &planet_query {
        for (entity1, entity2, intersecting) in
            rapier_context.intersection_pairs_with(*children.first().unwrap())
        {
            if !intersecting {
                continue;
            }
            let other = if *children.first().unwrap() == entity1 {
                entity2
            } else {
                entity1
            };
            let (entity, attach, mineable, _) = match mineable_query.get(other) {
                Ok(m) => m,
                Err(_) => continue,
            };
            let associated_player = match attach.associated_player {
                Some(e) => e,
                None => entity,
            };
            // is the module mining
            if let Some(mineable) = mineable {
                if mineable.0 {
                    if let Some(storage_entity) = find_storage(associated_player, &mineable_query) {
                        let (_, _, _, storage) = mineable_query.get_mut(storage_entity).unwrap();
                        if let Some(mut storage) = storage {
                            if let Ok(material) = planet_type.0.try_into() {
                                match storage.materials.get_mut(&material) {
                                    Some(v) => *v += 1,
                                    None => {
                                        storage.materials.insert(material, 1);
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
pub fn find_storage(
    player: Entity,
    mineable_query: &Query<(
        Entity,
        &mut Attach,
        Option<&IsMining>,
        Option<&mut VarietyMaterialStorage>,
    )>,
) -> Option<Entity> {
    for (entity, attach, _, storage) in mineable_query.iter() {
        if let Some(storage) = storage {
            if attach.associated_player == Some(player) {
                // found a valid storage
                if storage.materials.values().sum::<u32>() > storage.capacity {
                    // cannot store more materials in a filled storage
                    continue;
                }
                return Some(entity);
            } else if attach.associated_player == None {
                // this is a player
                if storage.materials.values().sum::<u32>() > storage.capacity {
                    // cannot store more materials in a filled storage
                    continue;
                }
                return Some(entity);
            }
        }
    }
    return None;
}