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

pub fn handle_login_response(
    mut reader: EventReader<LoginResponsePacket>,
    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)>,
    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();
            }
        }
    }
}