#![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;
#[cfg(feature = "target_client")]
pub mod client;
#[cfg(feature = "target_client")]
pub mod client_plugins;
pub mod config;
pub mod ecs;
#[cfg(feature = "target_particle_editor")]
pub mod particle_editor;
pub mod particles;
#[cfg(feature = "target_server")]
pub mod server;
#[cfg(feature = "target_server")]
pub mod server_plugins;
pub mod shared_plugins;
pub mod world_config;

pub mod physics;
pub mod prelude;

#[cfg(target_arch = "wasm32")]
pub mod wasm_entrypoint;
mod cli;
mod build_meta;
mod thrust;

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

use crate::cli::StkArgs;
use crate::prelude::*;
#[cfg(feature = "target_client")]
use crate::client_plugins::ClientPluginGroup;
#[cfg(feature = "target_server")]
use crate::server_plugins::ServerPluginGroup;


#[allow(unused_mut, reason = "Conditional compilation hell")]
fn run(cli: StkArgs) -> AppExit {
    let mut app = App::new();

    match cli {
        #[cfg(feature = "target_client")]
        StkArgs::Client {
            #[cfg(feature = "target_net_client")]
            server
        } => {
            app.add_plugins(
                DefaultPlugins.build()
                    .disable::<bevy::log::LogPlugin>()
                    .disable::<bevy::ui::UiPlugin>()
            );

            #[cfg(feature = "target_net_client")]
            app.add_plugins(ClientPluginGroup { server: Some(server) });
            app.add_plugins(ClientPluginGroup { server: None });
            app.add_plugins(shared_plugins::SharedPluginGroup);
        }
        #[cfg(feature = "target_server")]
        StkArgs::Server {
            bind_to,
            tick_rate,
            max_clients,
            #[cfg(feature = "target_client")]
            with_client
        } => {
            let mut with_client_all = false;
            #[cfg(feature = "target_client")]
            if with_client {
                with_client_all = true;
                app.add_plugins(
                    DefaultPlugins.build()
                        .disable::<bevy::log::LogPlugin>()
                        .disable::<bevy::ui::UiPlugin>()
                );
                app.add_plugins(|app: &mut App| {
                    app.add_systems(Startup, server::player::join::ls_magically_invent_player);
                });
            }
            if !with_client_all {
               app
                   .add_plugins(AssetPlugin::default())
                   .add_plugins(bevy::state::app::StatesPlugin)
                    .add_plugins(TaskPoolPlugin::default())
                    .add_plugins(bevy::diagnostic::FrameCountPlugin)
                    .add_plugins(bevy::time::TimePlugin)
                    .add_plugins(bevy::app::ScheduleRunnerPlugin::run_loop(std::time::Duration::from_secs_f32(
                        1.0 / tick_rate,
                    )));
            }

            app.add_plugins(shared_plugins::SharedPluginGroup);

            let mut pg = ServerPluginGroup {
                bind: bind_to,
                tick_rate,
                max_clients: max_clients.into(),
            }.build();

            #[cfg(feature = "target_client")]
            if with_client {
                pg = pg.add_group(ClientPluginGroup {
                    server: None
                });
            }

            app.add_plugins(pg);
        }
        #[cfg(feature = "target_particle_editor")]
        StkArgs::ParticleEditor {} => {
            app.add_plugins(crate::particle_editor::particle_editor_plugin);
        }
    }

    app.run()
}

#[cfg(feature = "platform_wasm")]
fn main() {
    // noop on webassembly
}

#[cfg(feature = "platform_native")]
fn main() -> AppExit {
    use tracing_subscriber::util::SubscriberInitExt;
    use bevy::log::{tracing_subscriber};

    let cli = crate::cli::parse_args();

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

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

    run(cli)
}