tools/avm_analyzer/avm_analyzer_app/src/app.rs

use eframe::Storage;
use egui::{CentralPanel, TopBottomPanel};
use egui_dock::NodeIndex;
use egui_dock::{DockArea, DockState};

use log::{info, warn};
use wasm_bindgen::JsValue;
use web_time::{Duration, Instant};

use crate::app_state::{AppState, STATE_URL_QUERY_PARAM_NAME};
use crate::stream::{ChangeFrame, CurrentFrame, HTTP_POLL_PERIOD_SECONDS};
use crate::views::{
    handle_drag_and_drop, BlockInfoViewer, CoeffsViewer, ControlsViewer, DecodeProgressViewer, DetailedPixelViewer,
    FrameInfoViewer, FrameSelectViewer, FrameViewer, MenuBar, PerformanceViewer, RenderView, SelectedObjectKind,
    SettingsViewer, StatsViewer, StreamSelectViewer, SymbolInfoViewer,
};

type TabType = Box<dyn RenderView>;

pub struct AvmAnalyzerApp {
    state: AppState,
    dock_state: DockState<TabType>,
}

const SAVED_SETTINGS_KEY: &str = "settings";
impl AvmAnalyzerApp {
    pub fn new(cc: &eframe::CreationContext<'_>) -> Self {
        let mut saved_settings = None;
        if let Some(storage) = cc.storage {
            if let Some(settings) = storage.get_string(SAVED_SETTINGS_KEY) {
                saved_settings = Some(settings);
            }
        }
        let mut dock_state: DockState<TabType> = DockState::new(vec![Box::new(FrameViewer)]);
        let surface = dock_state.main_surface_mut();

        let [others_view, _frames_view] =
            surface.split_above(NodeIndex::root(), 0.15, vec![Box::new(FrameSelectViewer)]);
        let [yuv_view, _info_view] = surface.split_left(
            others_view,
            0.2,
            vec![
                Box::new(FrameInfoViewer),
                Box::new(BlockInfoViewer),
                Box::new(SymbolInfoViewer),
                Box::new(StatsViewer),
            ],
        );

        let [_, _] = surface.split_below(yuv_view, 0.8, vec![Box::new(ControlsViewer)]);
        let state = AppState::new(saved_settings);

        Self { state, dock_state }
    }

    pub fn check_keyboard_input(&mut self, ctx: &egui::Context) {
        if let Some(stream) = self.state.stream.as_mut() {
            if ctx.input(|i| i.key_pressed(egui::Key::ArrowLeft)) {
                stream.change_frame(ChangeFrame::prev().order(self.state.settings.persistent.frame_sort_order));
            } else if ctx.input(|i| i.key_pressed(egui::Key::ArrowRight)) {
                stream.change_frame(ChangeFrame::next().order(self.state.settings.persistent.frame_sort_order));
            }
        }
    }

    pub fn check_playback(&mut self) {
        let playback = &mut self.state.settings.playback;
        if playback.playback_running {
            if let Some(stream) = self.state.stream.as_mut() {
                let current_time = Instant::now();
                let elapsed = current_time - playback.current_frame_display_instant;
                let time_between_frames = Duration::from_secs_f32(1.0 / playback.playback_fps);
                if elapsed > time_between_frames {
                    playback.current_frame_display_instant = current_time;
                    let changed = stream.change_frame(
                        ChangeFrame::next()
                            .order(self.state.settings.persistent.frame_sort_order)
                            .allow_loop(playback.playback_loop)
                            .loaded_only(playback.show_loaded_frames_only),
                    );
                    if !changed {
                        playback.playback_running = false;
                    }
                }
            }
        }
    }
}

impl eframe::App for AvmAnalyzerApp {
    fn update(&mut self, ctx: &egui::Context, frame: &mut eframe::Frame) {
        self.state.check_stream_events();
        self.state
            .server_decode_manager
            .check_progress(&mut self.state.stream, &mut self.state.http_stream_manager, &self.state.settings.sharable.streams_url);
        self.check_keyboard_input(ctx);
        self.check_playback();
        handle_drag_and_drop(ctx, &mut self.state);

        if let Some(stream) = self.state.stream.as_mut() {
            stream.check_promises();
        }

        ctx.input(|input| {
            self.state
                .performance_history
                .on_new_frame(input.time, frame.info().cpu_usage)
        });

        ctx.request_repaint_after(Duration::from_secs_f32(HTTP_POLL_PERIOD_SECONDS));
        if let Err(err) = self
            .state
            .local_stream_manager
            .check_local_stream_ready(&mut self.state.stream)
        {
            warn!("{}", err);
        };

        let menu_bar = MenuBar {};
        TopBottomPanel::top(menu_bar.title()).show(ctx, |ui| {
            if let Err(err) = menu_bar.render(ui, &mut self.state) {
                warn!("{}", err);
            }
        });
        CentralPanel::default()
            .frame(egui::Frame::central_panel(&ctx.style()).inner_margin(0.))
            .show(ctx, |ui| {
                DockArea::new(&mut self.dock_state)
                    .show_close_buttons(false)
                    .show_add_buttons(false)
                    .draggable_tabs(false)
                    .show_tab_name_on_hover(false)
                    .show_inside(ui, &mut self.state);
            });

        let close_window = false;
        let mut show_stream_select = self.state.settings.show_stream_select;
        egui::Window::new("Load Stream")
            .default_width(800.0)
            .open(&mut show_stream_select)
            .collapsible(false)
            .show(ctx, |ui| {
                if let Err(err) = StreamSelectViewer.render(ui, &mut self.state) {
                    warn!("{}", err);
                }
            });
        if !show_stream_select || close_window {
            self.state.settings.show_stream_select = false;
        }

        let mut show_decode_progress: bool = self.state.settings.show_decode_progress;
        egui::Window::new("Decode Progress")
            .open(&mut show_decode_progress)
            .default_width(800.0)
            .default_height(600.0)
            .collapsible(false)
            .show(ctx, |ui| {
                if let Err(err) = DecodeProgressViewer.render(ui, &mut self.state) {
                    warn!("{}", err);
                }
            });
        self.state.settings.show_decode_progress = show_decode_progress;

        let mut show_performance_window: bool = self.state.settings.show_performance_window;
        egui::Window::new("Performance")
            .open(&mut show_performance_window)
            .collapsible(false)
            .show(ctx, |ui| {
                if let Err(err) = PerformanceViewer.render(ui, &mut self.state) {
                    warn!("{}", err);
                }
            });
        self.state.settings.show_performance_window = show_performance_window;

        let mut show_settings_window: bool = self.state.settings.show_settings_window;
        egui::Window::new("Settings")
            .open(&mut show_settings_window)
            .default_width(800.0)
            .default_height(600.0)
            .resizable(true)
            .collapsible(false)
            .show(ctx, |ui| {
                if let Err(err) = SettingsViewer.render(ui, &mut self.state) {
                    warn!("{}", err);
                }
            });
        self.state.settings.show_settings_window = show_settings_window;

        let mut show_pixel_viewer: bool = self.state.settings.sharable.show_pixel_viewer;
        let pixel_viewer_title = match &self.state.settings.selected_object {
            None => {
                show_pixel_viewer = false;
                "".to_string()
            }
            Some(selected_object) => {
                if let Some(frame) = self.state.stream.current_frame() {
                    selected_object
                        .rect(frame)
                        .map(|rect| {
                            format!(
                                "Pixels: {}x{} block at (x={}, y={})",
                                rect.width() as i32,
                                rect.height() as i32,
                                rect.left_top().x as i32,
                                rect.left_top().y as i32
                            )
                        })
                        .unwrap_or_default()
                } else {
                    "".to_string()
                }
            }
        };
        egui::Window::new(pixel_viewer_title)
            .id("Pixels".into())
            .open(&mut show_pixel_viewer)
            .default_width(400.0)
            .default_height(400.0)
            .resizable(true)
            .collapsible(false)
            .show(ctx, |ui| {
                if let Err(err) = DetailedPixelViewer.render(ui, &mut self.state) {
                    warn!("{}", err);
                }
            });
        self.state.settings.sharable.show_pixel_viewer = show_pixel_viewer;

        let mut show_coeffs_viewer: bool = self.state.settings.sharable.show_coeffs_viewer;
        let mut coeffs_viewer_title = "".to_string();
        match &self.state.settings.selected_object {
            None => {
                show_coeffs_viewer = false;
            }
            Some(selected_object) => {
                if let Some(frame) = self.state.stream.current_frame() {
                    if matches!(selected_object.kind, SelectedObjectKind::TransformUnit(_)) {
                        coeffs_viewer_title = selected_object
                            .rect(frame)
                            .map(|rect| {
                                format!(
                                    "Coeffs: {}x{} block at (x={}, y={})",
                                    rect.width() as i32,
                                    rect.height() as i32,
                                    rect.left_top().x as i32,
                                    rect.left_top().y as i32
                                )
                            })
                            .unwrap_or_default();
                    }
                }
            }
        };
        egui::Window::new(coeffs_viewer_title)
            .id("Coeffs".into())
            .open(&mut show_coeffs_viewer)
            .default_width(400.0)
            .default_height(400.0)
            .resizable(true)
            .collapsible(false)
            .show(ctx, |ui| {
                if let Err(err) = CoeffsViewer.render(ui, &mut self.state) {
                    warn!("{}", err);
                }
            });
        self.state.settings.sharable.show_coeffs_viewer = show_coeffs_viewer;

        if self.state.settings.persistent.update_sharable_url {
            let shared_state = self.state.settings.create_shared_settings(&self.state.stream);
            if shared_state != self.state.previous_shared_state {
                self.state.previous_shared_state = shared_state.clone();
                let window = web_sys::window().unwrap();
                let shared_settings_str = shared_state.encode();
                if let Ok(history) = window.history() {
                    if let Err(err) = history.replace_state_with_url(
                        &JsValue::NULL,
                        "AVM Analyzer",
                        Some(&format!("?{STATE_URL_QUERY_PARAM_NAME}={shared_settings_str}")),
                    ) {
                        warn!("Unable to set URL state: {err:?}");
                    }
                }
            }
        }
        // TODO(comc): Add selected tab to shared settings.
        // let find_me: Box<dyn RenderView> = Box::new(StatsViewer);
        // let idx = self.dock_state.find_tab(&find_me);
    }

    fn save(&mut self, storage: &mut dyn Storage) {
        info!("Saved settings to local storage.");
        if let Ok(saved_settings) = serde_json::to_string(&self.state.settings.persistent) {
            storage.set_string(SAVED_SETTINGS_KEY, saved_settings);
        } else {
            warn!("Error serialize saved settings.")
        }
    }

    fn auto_save_interval(&self) -> std::time::Duration {
        Duration::from_secs_f32(5.0)
    }
}