tools/avm_analyzer/avm_analyzer_app/src/app_state.rs

use crate::views::{PerformanceHistory, RenderView, SelectedObject, SelectedObjectKind};

use avm_analyzer_common::{AvmStreamInfo, DEFAULT_PROTO_PATH_FRAME_SUFFIX_TEMPLATE};
use avm_stats::Spatial;
use egui::{Ui, WidgetText};
use egui_dock::TabViewer;

use log::{info, warn};

use crate::settings::{Settings, SharableSettings};
use crate::stream::{
    CacheStrategy, FrameStatus, HttpStreamManager, LocalStreamManager, ServerDecodeManager, Stream, StreamEventType,
};

pub struct AppState {
    pub stream: Option<Stream>,
    pub settings: Settings,
    pub local_stream_manager: LocalStreamManager,
    pub server_decode_manager: ServerDecodeManager,
    pub http_stream_manager: HttpStreamManager,
    pub performance_history: PerformanceHistory,
    pub previous_shared_state: SharableSettings,
}

pub const STATE_URL_QUERY_PARAM_NAME: &str = "state";
pub const LOAD_STREAM_URL_PARAM_NAME: &str = "load_stream";
pub const NUM_FRAMES_URL_PARAM_NAME: &str = "num_frames";

impl AppState {
    pub fn new(saved_settings: Option<String>) -> Self {
        let http_stream_manager = HttpStreamManager::new();
        let local_stream_manager = LocalStreamManager::new();
        let mut stream = None;
        let mut shared_settings = None;
        let mut load_stream_info = None;
        let window = web_sys::window().unwrap();
        if let Ok(search) = window.location().search() {
            if let Ok(params) = web_sys::UrlSearchParams::new_with_str(&search) {
                if let Some(state) = params.get(STATE_URL_QUERY_PARAM_NAME) {
                    shared_settings = Some(state);
                }
                if let Some(load_stream) = params.get(LOAD_STREAM_URL_PARAM_NAME) {
                    let num_frames = params.get(NUM_FRAMES_URL_PARAM_NAME).unwrap_or("1".into());
                    let num_frames = num_frames.parse::<usize>().unwrap_or(1);
                    if let Some(stream_name_end) = load_stream.find(DEFAULT_PROTO_PATH_FRAME_SUFFIX_TEMPLATE) {
                        let stream_name = load_stream[..stream_name_end].to_string();
                        load_stream_info = Some(AvmStreamInfo {
                            stream_name,
                            num_frames,
                            proto_path_template: load_stream,
                            thumbnail_png: None
                        });
                    }
                }
            }
        }

        let mut settings = Settings::from_shared_settings_string(shared_settings.as_deref());
        settings.apply_saved_settings_string(saved_settings);
        if let Some(stream_info) = load_stream_info {
            settings.sharable.selected_stream = Some(stream_info);
            settings.sharable.show_remote_streams = false;
            settings.sharable.streams_url = "".into();
        }

        if settings.sharable.show_remote_streams {
            http_stream_manager.load_stream_list();
        }

        if let Some(stream_info) = &settings.sharable.selected_stream {
            // Unwrap is okay here, since nothing can fail immediately when creating an HTTP stream.
            stream = Some(Stream::from_http(stream_info.clone(), false, settings.sharable.selected_frame, &settings.sharable.streams_url).unwrap());
        } else {
            local_stream_manager.load_demo_stream();
            local_stream_manager
                .check_local_stream_ready(&mut stream)
                .expect("Failed to load demo stream");
        }
        Self {
            stream,
            settings,
            local_stream_manager,
            server_decode_manager: ServerDecodeManager::new(),
            http_stream_manager,
            performance_history: PerformanceHistory::default(),
            previous_shared_state: SharableSettings::default(),
        }
    }
    /// Called whenever the current frame changed. Should reset anything specific to the current frame, e.g. selected objects.
    pub fn check_stream_events(&mut self) {
        if let Some(stream) = self.stream.as_mut() {
            let events = stream.check_events();
            for event in events {
                let event = event.event;
                info!("Event: {event:?}");
                match event {
                    StreamEventType::NewStream => {
                        self.settings.selected_object = None;
                        self.settings.selected_object_leaf = None;
                        self.settings.cached_stat_data = None;
                        self.settings.scroll_to_index = Some(0);
                    }
                    StreamEventType::FrameChanged(index) => {
                        self.settings.selected_object = None;
                        self.settings.selected_object_leaf = None;
                        self.settings.cached_stat_data = None;
                        self.settings.scroll_to_index = Some(index);
                        let limit = if self.settings.persistent.apply_cache_strategy {
                            Some(self.settings.persistent.cache_strategy_limit)
                        } else {
                            None
                        };
                        stream.apply_cache_strategy(CacheStrategy::from_limit(limit));
                    }
                    StreamEventType::FirstFrameLoaded(index) => {
                        info!("First frame loaded: {index}");
                        if let FrameStatus::Loaded(frame) = stream.get_frame(index) {
                            if !self.settings.have_world_bounds_from_shared_settings {
                                self.settings.sharable.world_bounds = frame.rect();
                            }
                            if let Some(shared_selected_object) = self.settings.sharable.selected_object_kind.take() {
                                if let FrameStatus::Loaded(frame) = stream.get_frame(index) {
                                    let is_valid = match &shared_selected_object {
                                        SelectedObjectKind::CodingUnit(obj) => obj.try_resolve(frame).is_some(),
                                        SelectedObjectKind::TransformUnit(obj) => obj.try_resolve(frame).is_some(),
                                        SelectedObjectKind::Superblock(obj) => obj.try_resolve(frame).is_some(),
                                        SelectedObjectKind::Partition(obj) => obj.try_resolve(frame).is_some(),
                                    };
                                    if is_valid {
                                        info!("Restored selected object: {shared_selected_object:?}");
                                        self.settings.selected_object =
                                            Some(SelectedObject::new(shared_selected_object));
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}

impl TabViewer for AppState {
    type Tab = Box<dyn RenderView>;

    fn ui(&mut self, ui: &mut Ui, tab: &mut Self::Tab) {
        if let Err(err) = tab.render(ui, self) {
            warn!("{}", err);
        }
    }

    fn title(&mut self, tab: &mut Self::Tab) -> WidgetText {
        tab.title().into()
    }
}