use bevy_ecs::prelude::*;
use nalgebra::{Rotation2, Scale3, Translation3};
use starkingdoms_common::packet::{DespawnPartPacket, EnergyUpdatePacket, LoginResponsePacket, MessagePacket, OpenCraftingUiPacket, PartPositionsPacket, PlanetPositionsPacket, PlayerLeavePacket, PlayerListPacket, SpawnPartPacket, SpawnPlayerPacket};
use starkingdoms_common::PartType;
use crate::components::{Camera, Chat, Menu, OtherPlayerBundle, Part, PartBundle, Player, PlayerBundle, PlayerResources, PlayerUsername, ServerId, Texture, Transform};
use crate::networking::texture_name;

pub fn handle_login_response(mut reader: EventReader<LoginResponsePacket>, mut player: Query<Entity, With<Player>>, mut commands: Commands) {
    for packet in reader.read() {
        let player = player.single();
        commands.entity(player).insert(ServerId(packet.id));
    }
}

pub fn handle_message(mut reader: EventReader<MessagePacket>, mut chat: ResMut<Chat>) {
    for message in reader.read() {
        chat.messages.push(
            format!("{}: {}", message.actor, message.content)
        );
    }
}

pub fn handle_existing_players_list(mut reader: EventReader<PlayerListPacket>, mut commands: Commands) {
    for packet in reader.read() {
        for (server_id, username) in &packet.players {
            commands.spawn(OtherPlayerBundle {
                part: PartBundle {
                    transform: Transform {
                        translation: Translation3::new(0.0, 0.0, 0.0),
                        rotation: Rotation2::new(0.0),
                        scale: Scale3::new(25.0, 25.0, 1.0)
                    },
                    texture: Texture {
                        name: "hearty.svg".to_string()
                    },
                    server_id: ServerId(*server_id),
                    part: Part(false),
                },
                username: PlayerUsername {
                    username: username.clone()
                }
            });
        }
    }
}

pub fn handle_spawn_player(mut reader: EventReader<SpawnPlayerPacket>, mut commands: Commands) {
    for SpawnPlayerPacket { id: server_id, username } in reader.read() {
            commands.spawn(OtherPlayerBundle {
                part: PartBundle {
                    transform: Transform {
                        translation: Translation3::new(0.0, 0.0, 0.0),
                        rotation: Rotation2::new(0.0),
                        scale: Scale3::new(25.0, 25.0, 1.0)
                    },
                    texture: Texture {
                        name: "hearty.svg".to_string()
                    },
                    server_id: ServerId(*server_id),
                    part: Part(false),
                },
                username: PlayerUsername {
                    username: username.clone()
                }
            });
    }
}

pub fn handle_spawn_part(mut reader: EventReader<SpawnPartPacket>, mut commands: Commands) {
    for SpawnPartPacket { id: server_id, part } in reader.read() {
        commands.spawn(PartBundle {
                transform: Transform {
                    translation: Translation3::new(part.transform.x, part.transform.y, 0.0),
                    rotation: Rotation2::new(part.transform.rot),
                    scale: Scale3::new(25.0, 25.0, 1.0),
                },
                texture: Texture {
                    name: texture_name(part.part_type, part.flags.attached),
                },
                server_id: ServerId(*server_id),
                part: Part(part.flags.attached),
            });
    }
}

pub fn handle_part_positions(mut reader: EventReader<PartPositionsPacket>, mut parts_query: Query<(Entity, &ServerId, &mut Transform, &mut Texture, &mut Part)>, mut player: Query<&ServerId, With<Player>>, mut camera: ResMut<Camera>) {
    for PartPositionsPacket { parts } in reader.read() {
        for (this_id, part) in parts {
            for (_, server_id, mut transform, mut texture, mut bevy_part) in &mut parts_query {
                if *this_id == server_id.0 {
                    transform.translation.x = part.transform.x;
                    transform.translation.y = part.transform.y;
                    transform.rotation = Rotation2::new(part.transform.rot);

                    if part.flags.attached && !bevy_part.0 {
                        texture.name = texture_name(part.part_type, part.flags.attached);
                        bevy_part.0 = true;
                    } else if !part.flags.attached && bevy_part.0 {
                        texture.name = texture_name(part.part_type, part.flags.attached);
                        bevy_part.0 = false;
                    }
                }

                if part.part_type == PartType::Hearty {
                    let player_id = player.single();
                    if player_id.0 == server_id.0 {
                        camera.x = -part.transform.x;
                        camera.y = -part.transform.y;
                    }
                }
            }
        }
    }
}


pub fn handle_energy_update(mut reader: EventReader<EnergyUpdatePacket>, mut player_res: ResMut<PlayerResources>) {
    for EnergyUpdatePacket { amount, max } in reader.read() {
        player_res.fuel_amount = *amount;
        player_res.fuel_max = *max;
    }
}

pub fn handle_crafting_ui(mut reader: EventReader<OpenCraftingUiPacket>, entities: Query<(Entity, &ServerId)>, mut commands: Commands) {
    for OpenCraftingUiPacket { id } in reader.read() {
        for (entity, server_id) in &entities {
            if server_id.0 == *id {
                commands.entity(entity)
                    .insert(Menu);
            }
        }
    }
}

pub fn handle_player_leave(mut reader: EventReader<PlayerLeavePacket>, mut part_query: Query<(Entity, &ServerId), With<Part>>, mut commands: Commands) {
    for PlayerLeavePacket { id } in reader.read() {
        for (entity, server_id) in &mut part_query {
            if server_id.0 == *id {
                commands.entity(entity).despawn();
            }
        }
    }
}

pub fn handle_despawn_part(mut reader: EventReader<DespawnPartPacket>, mut part_query: Query<(Entity, &ServerId), With<Part>>, mut commands: Commands) {
    for DespawnPartPacket { id } in reader.read() {
        for (entity, server_id) in &mut part_query {
            if server_id.0 == *id {
                commands.entity(entity).despawn();
            }
        }
    }
}