traaains/ui/track/segment/signals_list/item/

data.rs

use std::panic;

use bevy::{
    ecs::{
        component::Component,
        entity::Entity,
        event::EntityEvent,
        hierarchy::{ChildOf, Children},
        observer::On,
        query::With,
        system::{Commands, Query},
    },
    feathers::{
        controls::{FeathersCheckbox, FeathersSelect},
        display::{label_dim, label_small},
    },
    log::tracing,
    scene::{Scene, SceneList, bsn, on},
    ui::{Checked, Display, FlexDirection, InteractionDisabled, Node, px},
    ui_widgets::ValueChange,
};

use crate::{
    sim::signal::{
        Signals,
        main::{MainSignal, MainSignalState, MainSignalStateDiscriminants, MaxSpeed},
    },
    ui::{
        Target,
        segment::signals_list::item::{
            SignalListItem, data::max_speed_select::max_speed_toggle, find_root_with_target,
        },
    },
};

mod is_repeat;
mod main_state_select;
mod max_speed_select;

#[derive(Clone, Copy, Component, Default)]
enum MaxSpeedField {
    #[default]
    MaxSpeed,
    NextSpeed,
}

#[derive(Component, Clone, Default)]
pub struct SignalData;

fn is_checkbox_checked(value: bool) -> Box<dyn Scene> {
    if value {
        Box::new(bsn! {Checked})
    } else {
        Box::new(bsn! {})
    }
}

fn update_checkbox_visual(checked: bool, checkbox: Entity, cmd: &mut Commands) {
    if checked {
        cmd.entity(checkbox).insert(Checked);
    } else {
        cmd.entity(checkbox).remove::<Checked>();
    }
}

fn on_value_change_summon(
    e: On<ValueChange<bool>>,
    mut cmd: Commands,
    target: Query<(Entity, &Target), With<SignalListItem>>,
    children: Query<&ChildOf>,
    mut signals: Query<&mut Signals>,
) {
    update_checkbox_visual(e.value, e.event_target(), &mut cmd);

    let Some((_, target_signal)) = find_root_with_target(e.event_target(), &target, &children)
    else {
        tracing::error!(
            "Could not find parent UI entity with a target component pointing to a signal!"
        );
        return;
    };

    if let Ok(mut signal) = signals.get_mut(target_signal) {
        match &mut *signal {
            Signals::Main(main_signal) => match &mut main_signal.state {
                MainSignalState::Stop { summon } => *summon = e.value,
                _ => panic!("Unexpected signal type!"),
            },
            _ => panic!("Unexpected signal type!"),
        }
    }
}

fn is_summon_checkbox(is_summon: bool) -> impl Scene {
    bsn! {
        @FeathersCheckbox
        @is_checkbox_checked(is_summon)
        on(on_value_change_summon)
    }
}

fn main_stop(is_summon: bool) -> impl SceneList {
    bsn! {
        @label_small("Summon?")
        --
        @is_summon_checkbox(is_summon)
    }
}

fn max_speed_input(curr_max_speed: &Option<MaxSpeed>, field: MaxSpeedField) -> Box<dyn Scene> {
    match curr_max_speed {
        Some(max_speed) => Box::new(bsn! {
            Node {
                display: Display::Flex,
                flex_direction: FlexDirection::Row
            }
            Children [
                @max_speed_toggle(curr_max_speed.is_some(), field)
                @max_speed_select::max_speed_select(max_speed, field)
            ]
        }),
        None => Box::new(bsn! {
            Node {
                display: Display::Flex,
                flex_direction: FlexDirection::Row
            }
            Children [
                @max_speed_toggle(curr_max_speed.is_some(), field)
                --
                @FeathersSelect
                InteractionDisabled
            ]
        }),
    }
}

fn main_warning(max_speed: &Option<MaxSpeed>, next_speed: &Option<MaxSpeed>) -> impl SceneList {
    bsn! {
        @label_small("Max speed:")
        --
        @max_speed_input(max_speed, MaxSpeedField::MaxSpeed)
        --
        @label_small("Next speed:")
        --
        @max_speed_input(next_speed, MaxSpeedField::NextSpeed)
    }
}

fn main_free(max_speed: &Option<MaxSpeed>) -> impl SceneList {
    bsn! {
        @label_small("Max speed:")
        --
        @max_speed_input(max_speed, MaxSpeedField::MaxSpeed)
    }
}

fn main_data(main_signal: &MainSignal) -> Box<dyn SceneList> {
    match &main_signal.state {
        MainSignalState::Stop { summon } => Box::new(main_stop(*summon)),
        MainSignalState::Warning {
            max_speed,
            next_speed,
        } => Box::new(main_warning(max_speed, next_speed)),
        MainSignalState::Free { max_speed } => Box::new(main_free(max_speed)),
    }
}

// Having the two nested children in here is a bit redundant, but it helps with with rebuilding the UI on signal change

pub fn signal_data_main(main_signal: &MainSignal) -> impl Scene {
    let state_var = match &main_signal.state {
        MainSignalState::Stop { summon: _ } => MainSignalStateDiscriminants::Stop,
        MainSignalState::Warning {
            max_speed: _,
            next_speed: _,
        } => MainSignalStateDiscriminants::Warning,
        MainSignalState::Free { max_speed: _ } => MainSignalStateDiscriminants::Free,
    };

    bsn! {
        Node {
            display: Display::Flex,
            flex_direction: FlexDirection::Column,
            padding: px(4)
        }
        Children [
            @label_small("Is a repeat signal?")
            --
            @is_repeat::is_repeat_checkbox(main_signal.is_repeat)
            --
            @label_small("State")
            --
            @main_state_select::main_state_select(state_var)
            --
            @label_small("Main signal data")
            --
            {main_data(main_signal)}
        ]
    }
}

pub fn signal_data_stop() -> impl Scene {
    bsn! {
        Node {
            display: Display::Flex,
            flex_direction: FlexDirection::Column,
            padding: px(4)
        }
        Children [
            @label_dim("No data")
        ]
    }
}

pub fn signal_data(signal_var: &Signals) -> impl Scene {
    let signal_data_inner: Box<dyn Scene> = match signal_var {
        Signals::Main(main_signal) => Box::new(signal_data_main(main_signal)),
        Signals::Stop => Box::new(signal_data_stop()),
    };

    bsn! {
        SignalData
        Node {}
        Children [@signal_data_inner]
    }
}