mod planets;

use std::net::{SocketAddr, UdpSocket};
use std::time::{SystemTime, UNIX_EPOCH};
use bevy::prelude::*;
use bevy_rapier2d::prelude::{Collider, Restitution, RigidBody, Velocity};
use bevy_replicon::prelude::{FromClient, Replicated, RepliconChannels};
use bevy_replicon_renet2::netcode::{NativeSocket, NetcodeServerTransport, ServerAuthentication, ServerSetupConfig};
use bevy_replicon_renet2::renet2::{ConnectionConfig, RenetServer};
use bevy_replicon_renet2::RenetChannelsExt;
use crate::ecs::{Ball, Ground, SendBallHere};
use crate::server::planets::planets_plugin;

pub struct ServerPlugin {
    pub bind: SocketAddr,
    pub max_clients: usize,
}
impl Plugin for ServerPlugin {
    fn build(&self, app: &mut App) {
        let bind = self.bind.clone();
        let max_clients = self.max_clients.clone();

        app
            .add_systems(FixedPreUpdate, bevy_replicon::server::increment_tick) // !!important!! do not remove or move
            .add_systems(Startup, move |mut commands: Commands, channels: Res<RepliconChannels>| {
                let server = RenetServer::new(ConnectionConfig::from_channels(
                    channels.server_configs(),
                    channels.client_configs()
                ));

                let server_config = ServerSetupConfig {
                    current_time: SystemTime::now().duration_since(UNIX_EPOCH).unwrap(),
                    max_clients: max_clients,
                    protocol_id: 0,
                    authentication: ServerAuthentication::Unsecure,
                    socket_addresses: vec![vec![bind]]
                };
                let socket = UdpSocket::bind(bind).unwrap();

                let transport = NetcodeServerTransport::new(server_config, NativeSocket::new(socket).unwrap()).unwrap();

                commands.insert_resource(server);
                commands.insert_resource(transport);

                info!("websocket server listening");
            })
            .add_systems(Startup, setup_physics)
            .add_systems(PreUpdate, receive_send_ball_here)
            .add_plugins(planets_plugin);
    }
}

fn setup_physics(mut commands: Commands) {
    commands.spawn(Collider::cuboid(500.0, 50.0))
        .insert(Transform::from_xyz(0.0, -100.0, 0.0))
        .insert(Restitution::coefficient(1.0))
        .insert(Ground)
        .insert(Replicated);

    commands.spawn(RigidBody::Dynamic)
        .insert(Collider::ball(50.0))
        .insert(Restitution::coefficient(1.0))
        .insert(Transform::from_xyz(0.0, 400.0, 0.0))
        .insert(Velocity::default())
        .insert(Ball)
        .insert(Replicated);
}

fn receive_send_ball_here(mut events: EventReader<FromClient<SendBallHere>>, mut ball: Query<(&mut Transform, &mut Velocity), With<Ball>>) {
    for FromClient { client_entity, event } in events.read() {
        for (mut position, mut velocity) in &mut ball {
            position.translation.x = event.0.x;
            position.translation.y = event.0.y;
            velocity.linvel = Vec2::ZERO;
            velocity.angvel = 0.0;
        }
    }
}