// 这是最简单的系统类型。它只是每次运行时打印 "This game is fun!"
fn print_message_system() {
    println!("This game is fun!");
}

// 系统也可以读取和修改资源。这个系统在每次更新时开始一个新的"轮次"
// 注意："mut" 表示资源是"可变的"
// Res<GameRules> 是只读的。ResMut<GameState> 可以修改资源
fn new_round_system(game_rules: Res<GameRules>, mut game_state: ResMut<GameState>) {
    game_state.current_round += 1;
    println!(
        "Begin round {} of {}",
        game_state.current_round, game_rules.max_rounds
    );
}

// 这个系统更新所有具有 `Player`、`Score` 和 `PlayerStreak` 组件的实体的分数
fn score_system(mut query: Query<(&Player, &mut Score, &mut PlayerStreak)>) {
    for (player, mut score, mut streak) in &mut query {
        let scored_a_point = random::<bool>();
        if scored_a_point {
            // 不可变访问组件通过常规引用完成 - `player` 的类型是 `&Player`
            // 可变访问组件通过 `Mut<T>` 类型完成 - `score` 的类型是 `Mut<Score>`
            // `Mut<T>` 实现了 `Deref<T>`，所以可以使用标准字段更新语法
            score.value += 1;
            // 匹配枚举需要解引用
            *streak = match *streak {
                PlayerStreak::Hot(n) => PlayerStreak::Hot(n + 1),
                PlayerStreak::Cold(_) | PlayerStreak::None => PlayerStreak::Hot(1),
            };
            println!(
                "{} scored a point! Their score is: {} ({})",
                player.name, score.value, *streak
            );
        }
    }
}

// 这个系统在所有具有 `Player` 和 `Score` 组件的实体上运行
// 它还访问 `GameRules` 资源来确定玩家是否获胜
fn score_check_system(
    game_rules: Res<GameRules>,
    mut game_state: ResMut<GameState>,
    query: Query<(&Player, &Score)>,
) {
    for (player, score) in &query {
        if score.value == game_rules.winning_score {
            game_state.winning_player = Some(player.name.clone());
        }
    }
}

fn main() {
    // 创建一个简单的闭包
    let simple_closure = || {
        // 这是一个什么都不做的闭包
        info!("Hello from a simple closure!");
    };

    // 创建一个带有'input'值的闭包
    let complex_closure = |mut value: String| {
        move || {
            info!("Hello from a complex closure! {}", value);

            // 我们可以在闭包内修改值。这将在调用之间保存
            value = format!("{value} - updated");
        }
    };

    let outside_variable = "bar".to_string();

    App::new()
        .add_plugins(LogPlugin::default())
        // 我们可以使用闭包作为系统
        .add_systems(Update, simple_closure)
        // 或者我们可以使用更复杂的闭包，并传递参数来初始化 Local 变量
        .add_systems(Update, complex_closure("foo".into()))
        // 我们也可以内联闭包
        .add_systems(Update, || {
            info!("Hello from an inlined closure!");
        })
        // 或使用闭包外部的变量
        .add_systems(Update, move || {
            info!(
                "Hello from an inlined closure that captured the 'outside_variable'! {}",
                outside_variable
            );
            // 你可以使用 outside_variable 或此闭包内的任何其他变量
            // 它们的状态将被保存
        })
        .run();
}

// 类型参数在函数名之后，但在普通参数之前
// 这里，`Component` trait 是 T 的 trait 约束，我们的泛型类型
fn cleanup_system<T: Component>(mut commands: Commands, query: Query<Entity, With<T>>) {
    for e in &query {
        commands.entity(e).despawn();
    }
}

fn main() {
    App::new()
        .add_plugins(DefaultPlugins)
        .init_state::<AppState>()
        .add_systems(Startup, setup_system)
        .add_systems(
            Update,
            (
                print_text_system,
                transition_to_in_game_system.run_if(in_state(AppState::MainMenu)),
            ),
        )
        // 清理系统
        // 使用 ::<T> (turbofish) 语法传递系统应该操作的类型
        .add_systems(OnExit(AppState::MainMenu), cleanup_system::<MenuClose>)
        .add_systems(OnExit(AppState::InGame), cleanup_system::<LevelUnload>)
        .run();
}

use bevy::{
    ecs::system::{RunSystemOnce, SystemId},
    prelude::*,
};

#[derive(Component)]
struct Callback(SystemId);

#[derive(Component)]
struct Triggered;

fn setup_with_commands(mut commands: Commands) {
    let system_id = commands.register_system(system_a);
    commands.spawn((Callback(system_id), A));
}

fn setup_with_world(world: &mut World) {
    // 我们可以手动运行一次
    world.run_system_once(system_b).unwrap();
    // 或使用 Callback
    let system_id = world.register_system(system_b);
    world.spawn((Callback(system_id), B));
}

/// 用 `Triggered` 组件标记具有我们想要运行的回调的实体
fn trigger_system(
    mut commands: Commands,
    query_a: Single<Entity, With<A>>,
    query_b: Single<Entity, With<B>>,
    input: Res<ButtonInput<KeyCode>>,
) {
    if input.just_pressed(KeyCode::KeyA) {
        let entity = *query_a;
        commands.entity(entity).insert(Triggered);
    }
    if input.just_pressed(KeyCode::KeyB) {
        let entity = *query_b;
        commands.entity(entity).insert(Triggered);
    }
}

/// 如果实体也有 `Triggered` 组件，则运行与每个 `Callback` 组件关联的系统
///
/// 这可以在独占系统中完成，而不是使用 `Commands`（如果首选）
fn evaluate_callbacks(query: Query<(Entity, &Callback), With<Triggered>>, mut commands: Commands) {
    for (entity, callback) in query.iter() {
        commands.run_system(callback.0);
        commands.entity(entity).remove::<Triggered>();
    }
}

fn system_a(entity_a: Single<Entity, With<Text>>, mut writer: TextUiWriter) {
    *writer.text(*entity_a, 3) = String::from("A");
    info!("A: One shot system registered with Commands was triggered");
}

fn system_b(entity_b: Single<Entity, With<Text>>, mut writer: TextUiWriter) {
    *writer.text(*entity_b, 3) = String::from("B");
    info!("B: One shot system registered with World was triggered");
}

// 这个系统通过尝试解析 Message 资源产生 Result<usize> 输出
fn parse_message_system(message: Res<Message>) -> Result<usize, ParseIntError> {
    message.parse::<usize>()
}

// 这个系统接受 Result<usize> 输入，并打印解析的值或错误消息
// 尝试将 Message 资源更改为不是整数的内容。你应该看到错误消息被打印
fn handler_system(In(result): In<Result<usize, ParseIntError>>) {
    match result {
        Ok(value) => println!("parsed message: {value}"),
        Err(err) => println!("encountered an error: {err:?}"),
    }
}

fn main() {
    App::new()
        .insert_resource(Message("42".to_string()))
        .add_systems(
            Update,
            (
                parse_message_system.pipe(handler_system),
                data_pipe_system.map(|out| info!("{out}")),
                parse_message_system.map(|out| debug!("{out:?}")),
            ),
        )
        .run();
}

// 如果你真的需要完整、立即的读写访问世界或资源，你可以使用"独占系统"
// 警告：这些会阻止所有其他系统的并行执行，直到它们完成
// 所以如果你想要最大化并行性，通常应该避免它们
fn exclusive_player_system(world: &mut World) {
    // 这与 "new_player_system" 做同样的事情
    let total_players = world.resource_mut::<GameState>().total_players;
    let should_add_player = {
        let game_rules = world.resource::<GameRules>();
        let add_new_player = random::<bool>();
        add_new_player && total_players < game_rules.max_players
    };
    // 随机添加一个新玩家
    if should_add_player {
        println!("Player {} has joined the game!", total_players + 1);
        world.spawn((
            Player {
                name: format!("Player {}", total_players + 1),
            },
            Score { value: 0 },
            PlayerStreak::None,
        ));

        let mut game_state = world.resource_mut::<GameState>();
        game_state.total_players += 1;
    }
}

// 这个系统只在恰好有一个匹配实体时运行
fn track_targets(
    // `Single` 确保系统只在恰好有一个匹配实体时运行
    mut player: Single<(&mut Transform, &Player)>,
    // `Option<Single>` 永远不会阻止系统运行，但如果没有恰好一个匹配实体，它将是 `None`
    enemy: Option<Single<&Transform, (With<Enemy>, Without<Player>)>>,
    time: Res<Time>,
) {
    let (player_transform, player) = &mut *player;
    if let Some(enemy_transform) = enemy {
        // 找到敌人，旋转并朝它移动
        // ...
    } else {
        // 找到 0 个或多个敌人，继续搜索
        // ...
    }
}

// 这个系统只在至少有一个匹配实体时运行
fn move_targets(mut enemies: Populated<(&mut Transform, &mut Enemy)>, time: Res<Time>) {
    for (mut transform, mut target) in &mut *enemies {
        // ...
    }
}

use bevy::ecs::error::warn;

fn main() {
    let mut app = App::new();
    // 默认情况下，返回错误的可失败系统会 panic
    //
    // 我们可以通过设置自定义错误处理器来改变这一点，它适用于整个应用
    // （你也可以为特定的 `World` 设置它）
    // 这里我们使用内置错误处理器之一
    // Bevy 为 `panic`、`error`、`warn`、`info`、`debug`、`trace` 和 `ignore` 提供内置处理器
    app.set_error_handler(warn);

    app.add_plugins(DefaultPlugins);
    app.add_systems(Startup, setup);
    app.add_systems(Startup, failing_commands);

    // 单个系统也可以通过管道输出结果来处理：
    app.add_systems(
        PostStartup,
        failing_system.pipe(|result: In<Result>| {
            let _ = result.0.inspect_err(|err| info!("captured error: {err}"));
        }),
    );

    // 可失败观察者也被支持
    app.add_observer(fallible_observer);

    app.run();
}

/// 一个调用多个可失败函数并使用问号运算符的系统的示例
fn setup(
    mut commands: Commands,
    mut meshes: ResMut<Assets<Mesh>>,
    mut materials: ResMut<Assets<StandardMaterial>>,
) -> Result {
    // ...
    Ok(())
}

/// 这个系统总是失败验证，因为我们从未创建同时具有 `Player` 和 `Enemy` 组件的实体
fn failing_system(world: &mut World) -> Result {
    world
        // `get_resource` 返回 `Option<T>`，所以我们使用 `ok_or` 将其转换为 `Result`
        // 然后我们可以调用 `?` 来传播错误
        .get_resource::<UninitializedResource>()
        // 我们可以在这里提供 `str`，因为 `BevyError` 实现了 `From<&str>`
        .ok_or("Resource not initialized")?;

    Ok(())
}