use std::collections::HashMap;

use bevy_ecs::{entity::Entity, event::Events, query::With, world::World};
use starkingdoms_common::{packet::Packet, PartType, PlanetType};

use crate::ecs::{Camera, Planet, Player, RecvPacket, Rotation, Scale, SendPacket, Shear, SpriteBundle, SpriteTexture, Translation};

#[cfg(target_arch = "wasm32")]
#[path = "ws_wasm.rs"]
pub mod ws;
#[cfg(not(target_arch = "wasm32"))]
#[path = "ws_native.rs"]
pub mod ws;

pub fn process_packets(
    world: &mut World,
    send_packet_events: &mut Events<SendPacket>,
    recv_packet_events: &mut Events<RecvPacket>,
    planet_types: &mut HashMap<PlanetType, (Entity, u32)>,
) {
    use Packet::*;
    let mut recv_cursor = recv_packet_events.get_cursor();
    for recv in recv_cursor.read(&recv_packet_events) {
        match &recv.0 {
            PartPositions { parts } => {
                for (id, part) in parts {
                    if part.part_type == PartType::Hearty {
                        let mut player_query = world.query_filtered::<(&mut Translation, &mut Rotation), With<Player>>();
                        let mut camera = world.resource_mut::<Camera>();
                        camera.x = part.transform.x;
                        camera.y = part.transform.y;
                        tracing::info!("camera real {:?}", camera);
                        for (mut translation, mut rotation) in player_query.iter_mut(world) {
                            translation.x = part.transform.x;
                            translation.y = part.transform.y;
                            rotation.radians = part.transform.rot;
                            tracing::info!("part real {:?}", translation);
                        }
                        tracing::info!("part {:?}", part.transform);
                    }
                }
            }
            PlanetPositions { planets } => {
                for (server_id, planet) in planets {
                    let mut planet_query = world.query_filtered::<(&mut Translation, &mut Rotation), With<Planet>>();
                    if !planet_types.contains_key(&planet.planet_type) {
                        let entity = world.spawn(SpriteBundle {
                            position: Translation { x: planet.transform.x, y: planet.transform.y },
                            shear: Shear { x: 0.0, y: 0.0 },
                            rotation: Rotation { radians: planet.transform.rot },
                            scale: Scale { width: planet.radius, height: planet.radius },
                            texture: SpriteTexture {
                                texture: match planet.planet_type {
                                    PlanetType::Sun => "sun",
                                    PlanetType::Mercury => "mercury",
                                    PlanetType::Venus => "venus",
                                    PlanetType::Earth => "earth",
                                    PlanetType::Moon => "moon",
                                    PlanetType::Mars => "mars",
                                    PlanetType::Jupiter => "jupiter",
                                    PlanetType::Saturn => "saturn",
                                    PlanetType::Uranus => "uranus",
                                    PlanetType::Neptune => "neptune",
                                    PlanetType::Pluto => "pluto",
                                }.to_string()
                            },
                        });
                        planet_types.insert(planet.planet_type, (entity.id(), *server_id));
                        tracing::info!("{:?}", planet.transform);
                    }
                }
            }
            _ => {}
        }
    }
}