mod gravity;
pub mod planets;
pub mod player;
mod world_config;

use bevy::prelude::*;
use bevy_replicon::prelude::RepliconChannels;
use bevy_replicon_renet2::netcode::{BoxedSocket, NetcodeServerTransport, ServerAuthentication, ServerSetupConfig, ServerSocket};
use std::net::{SocketAddr, UdpSocket};
use web_time::{SystemTime, UNIX_EPOCH};

#[cfg(not(target_arch = "wasm32"))]
use bevy_replicon_renet2::netcode::{
    NativeSocket, WebSocketAcceptor, WebSocketServer, WebSocketServerConfig,
};

use crate::server::gravity::newtonian_gravity_plugin;
use crate::server::planets::planets_plugin;
use crate::server::player::player_management_plugin;
use crate::server::world_config::world_config_plugin;
use bevy_replicon_renet2::RenetChannelsExt;
use bevy_replicon_renet2::renet2::{ConnectionConfig, RenetServer};
use tokio::runtime::Runtime;

#[derive(Resource)]
pub struct RtResource {
    rt: Runtime
}

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

        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 rt = tokio::runtime::Runtime::new().unwrap();

                        let ws_config = WebSocketServerConfig {
                            acceptor: WebSocketAcceptor::Plain {
                                has_tls_proxy: true,
                            },
                            listen: bind_ws,
                            max_clients,
                        };
                        let ws_server =
                            WebSocketServer::new(ws_config, rt.handle().clone()).unwrap();

                        let native_socket =
                            NativeSocket::new(UdpSocket::bind(bind_native).unwrap()).unwrap();

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

                        let transport = NetcodeServerTransport::new_with_sockets(
                            server_config,
                            vec![BoxedSocket::new(native_socket), BoxedSocket::new(ws_server)],
                        )
                        .unwrap();

                        commands.insert_resource(server);
                        commands.insert_resource(transport);
                    commands.insert_resource(RtResource {
                        rt
                    });

                        info!("websocket/native server listening");

                },
            )
            .add_plugins(planets_plugin)
            .add_plugins(world_config_plugin)
            .add_plugins(newtonian_gravity_plugin)
            .add_plugins(player_management_plugin);
    }
}