launcher/pages/audio/

ui.rs

use crate::pages::audio;
#[cfg(target_os = "windows")]
use crate::pages::audio::tasks::AdpcmSource;
use crate::pages::audio::types::{MusicPageState, SoundMode, TargetSampleRate};
use crate::tasks::{TaskEvent, spawn_task};
use eframe::egui;
use midas_audio::types::Channels;
#[cfg(target_os = "windows")]
use rodio::Player;
use std::fs::File;
use std::io::Read;
use std::path::Path;
use supreme_config::models::SoundConfig;

/// True while the preview player still has queued/playing audio.
#[cfg(target_os = "windows")]
fn player_active(sink: Option<&Player>) -> bool {
    !sink.is_none_or(rodio::Player::empty)
}

/// Non-Windows stub: the audio preview is compiled out (no rodio).
#[cfg(not(target_os = "windows"))]
fn player_active(_sink: Option<&crate::pages::audio::types::PlayerHandle>) -> bool {
    false
}

pub fn music_page(
    ui: &mut egui::Ui,
    state: &mut MusicPageState,
    sound_config: &mut SoundConfig,
    music_configs: &mut Vec<supreme_music::MusicConfig>,
    storage: &supreme_fs::GameStorage,
) {
    // Handle background task
    let mut task_finished = false;
    if let Some(handle) = &state.task_handle {
        while let Ok(event) = handle.try_recv() {
            match event {
                TaskEvent::SetStatus(status) => state.import_status = status,
                TaskEvent::Finished(res) => {
                    task_finished = true;
                    match res {
                        Ok(new_config) => {
                            music_configs.push(new_config);
                            state.import_status = "Import successful".to_string();
                            state.is_scanned = false; // Trigger re-scan
                        }
                        Err(e) => {
                            state.import_status = format!("Error: {e}");
                        }
                    }
                }
                _ => {}
            }
        }
    }
    if task_finished {
        state.task_handle = None;
    }

    // Initialize audio stream if needed (Windows-only; no audio device on
    // other targets since rodio is gated out there)
    #[cfg(target_os = "windows")]
    if state._stream.is_none()
        && let Ok(stream) = rodio::DeviceSinkBuilder::open_default_sink()
    {
        state._stream = Some(stream);
    }

    let game_path = storage.game_path();
    let music_dir = game_path.join("data/music");

    // Perform one-time scan if needed
    if !state.is_scanned {
        let start = std::time::Instant::now();

        // 1. Reconciliation (One-time expensive op)
        let recon_start = std::time::Instant::now();
        *music_configs = supreme_music::load_and_reconcile_music_configs(&music_dir, game_path);
        let recon_ms = recon_start.elapsed().as_secs_f64() * 1000.0;

        // 2. Metadata and Status Scan
        let scan_start = std::time::Instant::now();
        state.status_cache.clear();
        state.metadata_cache.clear();

        let mut buffer = [0u8; 64];
        for config in music_configs.iter() {
            let abs_path = game_path.join(&config.filename);

            // Single pass: try opening the file.
            let status = if let Ok(mut file) = File::open(&abs_path) {
                // Read header if it exists
                if file.read_exact(&mut buffer).is_ok()
                    && let Ok(metadata) = midas_audio::get_metadata(&buffer)
                {
                    state
                        .metadata_cache
                        .insert(config.filename.clone(), metadata);
                }
                supreme_music::MusicFileStatus::Ok
            } else {
                // Fallback check if it was moved/fixed
                let filename = supreme_music::get_music_filename_only(config);
                if music_dir.join(&filename).exists() {
                    supreme_music::MusicFileStatus::Fixed
                } else {
                    supreme_music::MusicFileStatus::Missing
                }
            };
            state.status_cache.insert(config.filename.clone(), status);
        }
        let scan_ms = scan_start.elapsed().as_secs_f64() * 1000.0;
        let total_ms = start.elapsed().as_secs_f64() * 1000.0;

        state.is_scanned = true;

        // Write performance log
        let timestamp = std::time::SystemTime::now()
            .duration_since(std::time::UNIX_EPOCH)
            .unwrap_or_default()
            .as_secs();

        let perf_data = serde_json::json!({
            "total_ms": total_ms,
            "reconciliation_ms": recon_ms,
            "metadata_scan_ms": scan_ms,
            "file_count": music_configs.len(),
            "timestamp": timestamp,
        });

        if let Err(e) = storage.write_report("music_scan_perf", &perf_data) {
            eprintln!("Failed to write music_scan_perf report: {e}");
        }
    }
    // Display Sound Configuration Header
    ui.horizontal(|ui| {
        ui.heading("Audio Settings");
        ui.with_layout(egui::Layout::right_to_left(egui::Align::Center), |ui| {
            let current_mode = SoundMode::from_config(sound_config);
            let mut mode_val = f64::from(current_mode as u32);

            let response = ui.add(
                egui::Slider::new(&mut mode_val, 0.0..=2.0)
                    .step_by(1.0)
                    .text("Sound and music")
                    .show_value(true)
                    .custom_formatter(|n, _| match n as u32 {
                        0 => "🔇    ".to_string(),
                        1 => "🔊    ".to_string(),
                        2 => "🔊🎵".to_string(),
                        _ => String::new(),
                    }),
            );

            if mode_val < 2.0 {
                ui.colored_label(ui.visuals().warn_fg_color, egui::RichText::new("⚠").size(16.0))
                    .on_hover_text("Suggestion: Enable the music here, and mute it using the in-game setting if you need it off.");
            }

            if response.changed() {
                let new_mode = match mode_val as u32 {
                    0 => SoundMode::Disabled,
                    1 => SoundMode::WithoutMusic,
                    _ => SoundMode::Full,
                };
                new_mode.apply_to_config(sound_config);
            }
            if response.drag_stopped()
                && let Err(e) = sound_config.save(storage, Path::new("Data/Sound_Config.txt"))
            {
                eprintln!("Failed to save sound config: {e}");
            }
        });
    });

    ui.add_space(10.0);

    egui::ScrollArea::vertical()
        .auto_shrink([false, false])
        .show(ui, |ui| {
            // Get the music directory path
            let music_dir = game_path.join("data/music");

            // Check if music directory exists
            if !music_dir.exists() {
                ui.colored_label(egui::Color32::RED, "Music directory not found!");
                return;
            }

            let mut needs_music_save = false;

            ui.add_space(10.0);

            // Display music table
            if music_configs.is_empty() {
                ui.label("No music configurations found.");
            } else {
                // Create a table-like layout
                egui::Grid::new("music_table").striped(true).show(ui, |ui| {
                    // Header row
                    ui.label(""); // Play/Pause
                    ui.label("Filename");
                    ui.label("Info");
                    ui.label("Status");
                    ui.label("Halfpipe");
                    ui.label("Tracks");
                    ui.label("Band or artist name");
                    ui.label("Track name");
                    ui.label("Volume");
                    ui.end_row();

                    // Data rows
                    for config in music_configs.iter_mut() {
                        // Get filename only (without path)
                        let filename = supreme_music::get_music_filename_only(config);

                        // Get file status from cache
                        let status = state
                            .status_cache
                            .get(&config.filename)
                            .cloned()
                            .unwrap_or(supreme_music::MusicFileStatus::Missing);
                        let file_exists = matches!(
                            status,
                            supreme_music::MusicFileStatus::Ok
                                | supreme_music::MusicFileStatus::Fixed
                        );

                        // Play/Pause Button
                        let is_playing = state.current_playing_file.as_ref()
                            == Some(&config.filename)
                            && player_active(state.current_sink.as_ref());

                        if ui.button(if is_playing { "⏸" } else { "▶" }).clicked() {
                            if is_playing {
                                // Pause/Stop
                                #[cfg(target_os = "windows")]
                                if let Some(sink) = &state.current_sink {
                                    sink.stop();
                                }
                                state.current_sink = None;
                                state.current_playing_file = None;
                            } else {
                                // Play
                                #[cfg(not(target_os = "windows"))]
                                {
                                    let _ = file_exists;
                                    eprintln!("Audio preview is only available on Windows builds.");
                                }

                                #[cfg(target_os = "windows")]
                                if file_exists {
                                    // Stop previous
                                    if let Some(sink) = &state.current_sink {
                                        sink.stop();
                                    }
                                    state.current_sink = None;

                                    if let Some(stream) = &state._stream {
                                        let player = Player::connect_new(stream.mixer());
                                        let abs_path = game_path.join(&config.filename);

                                        // We need custom decoder
                                        match File::open(&abs_path) {
                                            Ok(file) => match AdpcmSource::new(
                                                file,
                                                state.target_sample_rate.to_u32(None),
                                            ) {
                                                Ok(source) => {
                                                    player.append(source);
                                                    player.play();
                                                    state.current_sink = Some(player);
                                                    state.current_playing_file =
                                                        Some(config.filename.clone());
                                                }
                                                Err(e) => {
                                                    eprintln!("Failed to create ADPCM source: {e}")
                                                }
                                            },
                                            Err(e) => eprintln!("Failed to open file: {e}"),
                                        }
                                    }
                                }
                            }
                        }

                        // Filename (read-only)
                        ui.label(&filename);

                        // Info Button
                        let info_response = ui.label("ℹ");
                        if let Some(metadata) = state.metadata_cache.get(&config.filename) {
                            info_response.on_hover_ui(|ui| {
                                ui.heading("Audio Metadata");
                                ui.label(format!("Channels: {}", metadata.channels));
                                ui.label(format!("Format: {:?}", metadata.sample_type));
                                ui.label(format!("Frame Length: {}", metadata.frame_length));
                            });
                        }

                        // File status indicator with GUI-level styling
                        match status {
                            supreme_music::MusicFileStatus::Ok => {
                                ui.label("✅")
                                    .on_hover_text("File exists at configured path");
                            }
                            supreme_music::MusicFileStatus::Fixed => {
                                ui.colored_label(egui::Color32::ORANGE, "⚠")
                                    .on_hover_text("Path was automatically fixed - file exists");
                            }
                            supreme_music::MusicFileStatus::Missing => {
                                ui.colored_label(egui::Color32::RED, "❌")
                                    .on_hover_text("File not found");
                            }
                        }

                        // Halfpipe checkbox
                        if ui.checkbox(&mut config.halfpipe, "").changed() {
                            needs_music_save = true;
                        }

                        // Tracks checkbox
                        if ui.checkbox(&mut config.tracks, "").changed() {
                            needs_music_save = true;
                        }

                        // Author text input
                        if ui.text_edit_singleline(&mut config.author).lost_focus() {
                            needs_music_save = true;
                        }

                        // Track name text input
                        if ui.text_edit_singleline(&mut config.track).lost_focus() {
                            needs_music_save = true;
                        }

                        // Volume slider
                        let res = ui.add(egui::Slider::new(&mut config.volume, 0.0..=1.0));
                        if res.drag_stopped() {
                            needs_music_save = true;
                        }

                        ui.end_row();
                    }
                });
            }

            ui.add_space(5.0);

            // Import Settings
            ui.group(|ui| {
                ui.label("Import Settings");

                ui.horizontal(|ui| {
                    ui.label("Channels:");
                    egui::ComboBox::from_id_salt("channels_combo")
                        .selected_text(match state.target_channels {
                            Channels::Mono => "Mono",
                            Channels::Stereo => "Stereo",
                        })
                        .show_ui(ui, |ui| {
                            ui.selectable_value(&mut state.target_channels, Channels::Mono, "Mono");
                            ui.selectable_value(
                                &mut state.target_channels,
                                Channels::Stereo,
                                "Stereo",
                            );
                        });

                    ui.add_space(10.0);

                    ui.label("Bit Depth:");
                    let target_bit_depth = &mut state.target_bit_depth;
                    use crate::pages::audio::types::TargetBitDepth;
                    egui::ComboBox::from_id_salt("bit_depth_combo")
                        .selected_text(match target_bit_depth {
                            TargetBitDepth::Adpcm => "ADPCM",
                            TargetBitDepth::EightBit => "8-bit PCM",
                            TargetBitDepth::SixteenBit => "16-bit PCM",
                        })
                        .show_ui(ui, |ui| {
                            ui.selectable_value(target_bit_depth, TargetBitDepth::Adpcm, "ADPCM");
                            ui.selectable_value(
                                target_bit_depth,
                                TargetBitDepth::EightBit,
                                "8-bit PCM",
                            );
                            ui.selectable_value(
                                target_bit_depth,
                                TargetBitDepth::SixteenBit,
                                "16-bit PCM",
                            );
                        });

                    ui.add_space(10.0);

                    ui.label("Sample Rate:");
                    egui::ComboBox::from_id_salt("sample_rate_combo")
                        .selected_text(match state.target_sample_rate {
                            TargetSampleRate::Original => "Original",
                            TargetSampleRate::Hz11025 => "11025 Hz",
                            TargetSampleRate::Hz22050 => "22050 Hz",
                            TargetSampleRate::Hz44100 => "44100 Hz",
                        })
                        .show_ui(ui, |ui| {
                            ui.selectable_value(
                                &mut state.target_sample_rate,
                                TargetSampleRate::Original,
                                "Original",
                            );
                            ui.selectable_value(
                                &mut state.target_sample_rate,
                                TargetSampleRate::Hz11025,
                                "11025 Hz",
                            );
                            ui.selectable_value(
                                &mut state.target_sample_rate,
                                TargetSampleRate::Hz22050,
                                "22050 Hz",
                            );
                            ui.selectable_value(
                                &mut state.target_sample_rate,
                                TargetSampleRate::Hz44100,
                                "44100 Hz",
                            );
                        });
                });

                if state.task_handle.is_some() {
                    ui.add(egui::Spinner::new());
                    ui.label(&state.import_status);
                } else if ui
                    .button("Select Music File (WAV/MP3/Vorbis/FLAC) to add")
                    .clicked()
                    && let Some(file_path) = rfd::FileDialog::new()
                        .add_filter("WAV", &["wav"])
                        .add_filter("MP3", &["mp3"])
                        .add_filter("Vorbis", &["ogg"])
                        .add_filter("FLAC", &["flac"])
                        .pick_file()
                {
                    let music_dir = music_dir.clone();
                    let target_channels = state.target_channels;
                    let target_sample_rate = state.target_sample_rate;
                    let target_bit_depth = state.target_bit_depth;
                    let storage = storage.clone();

                    state.task_handle = Some(spawn_task(ui.ctx().clone(), move |tx| {
                        let _ = tx.send(TaskEvent::SetStatus("Converting audio...".to_string()));

                        audio::tasks::import_music_file(
                            &file_path,
                            &music_dir,
                            &MusicPageState {
                                target_channels,
                                target_sample_rate,
                                target_bit_depth,
                                ..Default::default()
                            },
                            &storage,
                        )
                    }));
                    state.import_status = "Starting import...".to_string();
                }
            });

            if needs_music_save
                && let Err(e) = supreme_music::save_music_config(&music_dir, music_configs)
            {
                eprintln!("Failed to save music config: {e}");
            }
        });
}