#![allow(unsafe_op_in_unsafe_fn)]
#![feature(allocator_api)]
#![feature(backtrace_frames)]
#![feature(const_trait_impl)]
#![feature(const_default)]
#![feature(const_array)]
#![feature(const_closures)]
#![feature(const_block_items)]
#![feature(const_clone)]
#![feature(const_drop_guard)]
#![feature(const_iter)]
#![feature(const_try)]
#![feature(const_try_residual)]

use std::sync::OnceLock;

pub use bevy;
use bevy::{
    DefaultPlugins,
    app::{App, Plugin, PluginGroup, Startup, Update},
    camera::{Camera, Camera2d},
    ecs::{
        error::Result,
        resource::Resource,
        system::{Commands, Res},
    },
    log::{LogPlugin, info},
};
pub use bevy_egui;
use bevy_egui::EguiPlugin;
pub use crossbeam;
pub mod small_vec;

use crate::debug::{DebugLogLayer, DebugPlugin};
pub mod debug;
pub mod ephemeral_pool;
pub mod global_allocator;

pub static EXTERNAL_SYSTEMS_CMDS: OnceLock<
    crossbeam::channel::Sender<Box<dyn Send + Sync + FnOnce(Commands) -> Result>>,
> = OnceLock::new();

#[derive(Resource)]
struct ExternalSystemsCmdRunner(
    crossbeam::channel::Receiver<Box<dyn Send + Sync + FnOnce(Commands) -> Result>>,
);

const ENGINE_DISCLAIMER: &str = "Using VEngine(Modified Bevy Engine)";
const MY_DUTY_AS_A_TRANS_GIRL: &str = "TRANS RIGHTS ARE HUMAN RIGHTS, ENBIES ARE VALID!!!";
const AI_DISCLAIMER: &str = include_str!("../../AI.md");

pub struct VEngine;

fn spawn_egui_camera(mut commands: Commands) {
    commands.spawn((
        Camera2d,
        Camera {
            order: isize::MAX,
            ..Default::default()
        },
    ));
}

fn disclaimers() {
    info!("{}", AI_DISCLAIMER);
    info!("{}", MY_DUTY_AS_A_TRANS_GIRL);
    info!("{}", ENGINE_DISCLAIMER);
}

impl Plugin for VEngine {
    fn build(&self, app: &mut bevy::app::App) {
        let (send, recv) = crossbeam::channel::unbounded();
        EXTERNAL_SYSTEMS_CMDS.set(send).ok();
        app.add_plugins(DefaultPlugins.set(LogPlugin {
            custom_layer: |_| Some(Box::new(DebugLogLayer)),
            ..Default::default()
        }))
        .add_plugins(EguiPlugin {
            ..Default::default()
        })
        .add_plugins(DebugPlugin)
        .insert_resource(ExternalSystemsCmdRunner(recv))
        .add_systems(Update, process_external_cmds)
        .add_systems(Startup, disclaimers);
    }
}

fn process_external_cmds(mut cmds: Commands, reqs: Res<ExternalSystemsCmdRunner>) -> Result {
    for req in reqs.0.try_iter() {
        req(cmds.reborrow())?;
    }
    Ok(())
}

pub fn vengine_app() -> App {
    let mut app = App::new();

    app.add_plugins(VEngine);
    app
}