use std::{time::Duration, sync::Arc};
use log::{error};

use rapier2d_f64::prelude::{PhysicsPipeline, RigidBodyHandle};
use starkingdoms_protocol::{ProtocolPlanet, PlanetType, ProtocolPlayer};
use tokio::{time::sleep, sync::RwLock};
use crate::{manager::{ClientHandlerMessage, ClientManager, PhysicsData}, SCALE, planet::Planets};

pub async fn timer_main(mgr: ClientManager, physics_data: Arc<RwLock<PhysicsData>>, world_data: Arc<RwLock<Planets>>) {
    let mut pipeline = PhysicsPipeline::new();
    loop {
        sleep(Duration::from_millis(5)).await;

        physics_data.write().await.tick(&mut pipeline);

        let physics_data = physics_data.read().await;

        let mut protocol_players = vec![];

        for (player_id, player) in mgr.players.read().await.iter() {
            let player_handle = player.handle;
            let player_body = physics_data.rigid_body_set.get(player_handle).unwrap();

            let translation = player_body.translation();
            let rotation = player_body.rotation();

            let username;
            {
                let usernames = mgr.usernames.read().await;
                username = usernames.get(player_id).unwrap().clone();
            }

            protocol_players.push(ProtocolPlayer {
                rotation: rotation.angle(),
                x: translation.x * SCALE,
                y: translation.y * SCALE,
                username,
            });
        }

        for (_addr, client_thread) in mgr.handlers.read().await.iter() {
            match client_thread.tx.send(ClientHandlerMessage::Tick).await {
                Ok(_) => {
                    match client_thread.tx.send(ClientHandlerMessage::PlayersUpdate {players: protocol_players.clone()}).await {
                        Ok(_) => (),
                        Err(e) => {
                            error!("unable to send position packet: {}", e);
                        }
                    };

                    let world = world_data.read().await;
                    let planet_data = world.to_protocol();
                    match client_thread.tx.send(planet_data).await {
                        Ok(_) => (),
                        Err(e) => {
                            error!("unable to send earth packet: {}", e);
                        }
                    };
                }
                Err(e) => {
                    error!("unable to update a client thread: {}", e);
                }
            }
        }
    }
}