#![warn(clippy::pedantic)] // Be annoying, and disable specific irritating lints if needed
#![deny(
    clippy::allow_attributes_without_reason,
    clippy::assertions_on_result_states
)]
#![warn(clippy::if_then_some_else_none)]
#![allow(clippy::type_complexity, reason = "Bevy makes this a nightmare")]
#![allow(clippy::needless_pass_by_value, reason = "Bevy makes this a nightmare")]
#![allow(
    clippy::cast_precision_loss,
    clippy::cast_possible_truncation,
    clippy::cast_sign_loss,
    reason = "We cast ints to floats a lot"
)]
#![allow(clippy::missing_panics_doc, reason = "Gamedev! We panic a lot")]
#![allow(clippy::too_many_arguments, reason = "Le Bevy:tm:")]
#![allow(
    clippy::too_many_lines,
    reason = "With the three of us, this is impossible"
)]

pub mod attachment;
pub mod client;
pub mod client_plugins;
pub mod config;
pub mod ecs;
#[cfg(all(not(target_arch = "wasm32"), feature = "particle_editor"))]
pub mod particle_editor;
pub mod particles;
#[cfg(all(not(target_arch = "wasm32"), feature = "native"))]
pub mod server;
#[cfg(all(not(target_arch = "wasm32"), feature = "native"))]
pub mod server_plugins;
pub mod shared_plugins;

pub mod physics;
pub mod prelude;

#[cfg(target_arch = "wasm32")]
pub mod wasm_entrypoint;
#[cfg(target_arch = "wasm32")]
pub use wasm_entrypoint::*;

use bevy::log::{tracing_subscriber, LogPlugin};
use crate::prelude::*;
use clap::Parser;
use crate::client_plugins::ClientPluginGroup;
#[cfg(not(target_arch = "wasm32"))]
use crate::server_plugins::ServerPluginGroup;
use std::net::{IpAddr, Ipv4Addr, Ipv6Addr, SocketAddr};
use std::process::exit;
use std::str::FromStr;
use std::time::Duration;
use bevy::app::ScheduleRunnerPlugin;
use bevy::diagnostic::FrameCountPlugin;
use bevy::state::app::StatesPlugin;
use bevy::time::TimePlugin;
use bevy::ui::UiPlugin;
use tracing_subscriber::EnvFilter;
use tracing_subscriber::filter::Directive;
use tracing_subscriber::util::SubscriberInitExt;
use crate::shared_plugins::SharedPluginGroup;

#[derive(Parser, Debug, Clone)]
#[command(version, about)]
enum Cli {
    Client {
        #[arg(short, long)]
        server: String,
        #[arg(long, action)]
        hotpatching_enabled: bool,
    },
    #[cfg(not(target_arch = "wasm32"))]
    Server {
        #[arg(short = 'b', long)]
        bind: SocketAddr,
        #[arg(short = 'r', long)]
        tick_rate: f32,
        #[arg(short = 'C', long)]
        max_clients: usize,
        #[arg(long, action)]
        with_client: bool,
        #[arg(long, action)]
        hotpatching_enabled: bool
    },
    #[cfg(all(not(target_arch = "wasm32"), feature = "particle_editor"))]
    ParticleEditor {},
}

fn run(cli: Cli) -> AppExit {
    let mut app = App::new();

    match cli {
        Cli::Client { server, hotpatching_enabled } => {
            if hotpatching_enabled {
                warn!("-+-+-+-+-+-+- Starting with hotpatching enabled -+-+-+-+-+-+-");
                warn!("This can result in segfaults and inconsistent behavior! If there is weirdness, try disabling it.");
                warn!("-+-+-+-+-+-+- Starting with hotpatching enabled -+-+-+-+-+-+-");
            }
            app.add_plugins(
                DefaultPlugins.build()
                    .disable::<LogPlugin>()
                    .disable::<UiPlugin>()
            );
            app.add_plugins(ClientPluginGroup { server: Some(server) });
            app.add_plugins(SharedPluginGroup);
        }
        #[cfg(not(target_arch = "wasm32"))]
        Cli::Server {
            bind,
            tick_rate,
            max_clients,
            hotpatching_enabled,
            with_client
        } => {
            if hotpatching_enabled {
                warn!("-+-+-+-+-+-+- Starting with hotpatching enabled -+-+-+-+-+-+-");
                warn!("This can result in segfaults and inconsistent behavior! If there is weirdness, try disabling it.");
                warn!("-+-+-+-+-+-+- Starting with hotpatching enabled -+-+-+-+-+-+-");
            }
            if cfg!(target_family = "wasm") {
                eprintln!("the server cannot run on webassembly");
                exit(1);
            }


            if with_client {
                app.add_plugins(
                    DefaultPlugins.build()
                        .disable::<LogPlugin>()
                        .disable::<UiPlugin>()
                );
                app.add_plugins(|app: &mut App| {
                    app.add_systems(Startup, crate::server::player::join::ls_magically_invent_player);
                });
            } else {
               app
                   .add_plugins(AssetPlugin::default())
                   .add_plugins(StatesPlugin)
                    .add_plugins(TaskPoolPlugin::default())
                    .add_plugins(FrameCountPlugin)
                    .add_plugins(TimePlugin)
                    .add_plugins(ScheduleRunnerPlugin::run_loop(Duration::from_secs_f32(
                        1.0 / tick_rate,
                    )));
            }

            app.add_plugins(SharedPluginGroup);

            let mut pg = ServerPluginGroup {
                bind,
                tick_rate,
                max_clients,
            }.build();
            if with_client {
                pg = pg.add_group(ClientPluginGroup {
                    server: None
                });
            }
            app.add_plugins(pg);
        }
        #[cfg(all(not(target_arch = "wasm32"), feature = "particle_editor"))]
        Cli::ParticleEditor {} => {
            app.add_plugins(crate::particle_editor::particle_editor_plugin);
        }
    }

    app.run()
}

fn main() -> AppExit {
    let cli = Cli::parse();

    tracing_subscriber::fmt()
        .with_env_filter(
            EnvFilter::from_default_env().add_directive(Directive::from_str("naga=error").unwrap()),
        )
        .finish()
        .init();

    ctrlc::set_handler(|| {
        info!("caught ^C, ciao!");
        exit(0);
    }).unwrap();

    match cli {
        Cli::Client { .. } => { run(cli) },
        Cli::ParticleEditor { .. } => { run(cli) },
        Cli::Server { with_client, bind, hotpatching_enabled, .. } => {
            run(cli)
            /*
            if !with_client {
                run(cli)
            } else {
                warn!("-----------------------------------------");
                warn!("RUNNING IN EXPERIMENTAL LISTENSERVER MODE");
                warn!("-----------------------------------------");
                warn!("This mode is HIGHLY EXPERIMENTAL, relies on janky threading, and may or may not work at all.");
                warn!("Use at your own risk. If weird things happen, try running separately.");
                warn!("-----------------------------------------");
                warn!("RUNNING IN EXPERIMENTAL LISTENSERVER MODE");
                warn!("-----------------------------------------");

                let scli_clone = cli.clone();
                let server_thread = std::thread::Builder::new()
                    .name("server".to_string())
                    .spawn(move || {
                        info!("starting server thread...");
                        run(scli_clone)
                    })
                    .unwrap();

                let clt_exit;

                    info!("starting client thread...");

                    let is_multicast = bind.ip().is_unspecified();

                    let target_ip = if is_multicast {
                        if bind.ip().is_ipv4() { IpAddr::V4(Ipv4Addr::LOCALHOST) } else { IpAddr::V6(Ipv6Addr::LOCALHOST) }
                    } else {
                        bind.ip()
                    };
                    let target_port = bind.port();
                    let target_ip_str = match target_ip {
                        IpAddr::V4(a) => a.to_string(),
                        IpAddr::V6(a) => format!("[{a}]"),
                    };
                    let target_url = format!("ws://{target_ip_str}:{target_port}");
                    info!("starting the client with autocalculated target server url {target_url}");

                    let cli2 = Cli::Client { server: target_url, hotpatching_enabled };

                    clt_exit = run(cli2);

                    if let AppExit::Error(c) = clt_exit {
                        error!("client exited with error {c}");
                    }
                    info!("-------- CLIENT HAS EXITED --------");
                    info!("  ^C  to stop the server");

                let srv_exit = server_thread.join().unwrap();

                match srv_exit {
                    AppExit::Error(c) => AppExit::Error(c),
                    _ => match clt_exit {
                        AppExit::Error(c) => AppExit::Error(c),
                        _ => AppExit::Success
                    }
                }*/
        }
    }
}