supreme_music/

lib.rs

use serde::{Deserialize, Serialize};
use std::collections::HashSet;
use std::fs;
use std::io::Write;
use std::path::{Path, PathBuf};

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct MusicConfig {
    pub filename: String,
    pub halfpipe: bool,
    pub tracks: bool,
    pub author: String,
    pub track: String,
    pub volume: f32,
}

#[must_use]
pub fn discover_music_files(music_dir: &Path) -> Vec<PathBuf> {
    let mut music_files = Vec::new();

    if let Ok(entries) = fs::read_dir(music_dir) {
        for entry in entries.flatten() {
            let path = entry.path();
            if path.is_file()
                && path.extension().and_then(|ext| ext.to_str()) == Some("adp")
                && let Some(file_name) = path.file_name().and_then(|n| n.to_str())
                && file_name != "menu.adp"
            {
                music_files.push(path);
            }
        }
    }

    music_files.sort();
    music_files
}

#[must_use]
pub fn load_music_config(music_dir: &Path) -> Vec<MusicConfig> {
    let music_config_path = music_dir.join("music_config.txt");
    let mut configs = Vec::new();

    if let Ok(content) = fs::read_to_string(music_config_path) {
        // Parse the music config file
        let mut current_config = MusicConfig {
            filename: String::new(),
            halfpipe: false,
            tracks: false,
            author: String::new(),
            track: String::new(),
            volume: 0.3,
        };

        let mut in_music_block = false;

        for line in content.lines() {
            let line = line.trim();

            if line == "Music {" {
                in_music_block = true;
                current_config = MusicConfig {
                    filename: String::new(),
                    halfpipe: false,
                    tracks: false,
                    author: String::new(),
                    track: String::new(),
                    volume: 0.3,
                };
            } else if line == "};" && in_music_block {
                in_music_block = false;
                if !current_config.filename.is_empty() {
                    configs.push(current_config.clone());
                }
                // Reset for next block
                current_config = MusicConfig {
                    filename: String::new(),
                    halfpipe: false,
                    tracks: false,
                    author: String::new(),
                    track: String::new(),
                    volume: 0.3,
                };
            } else if in_music_block && let Some(equals_pos) = line.find('=') {
                let key = line[..equals_pos].trim();
                let value = line[equals_pos + 1..].trim().trim_end_matches(';').trim();

                match key {
                    "filename" => current_config.filename = value.trim_matches('"').to_string(),
                    "halfpipe" => current_config.halfpipe = value == "1",
                    "tracks" => current_config.tracks = value == "1",
                    "author" => current_config.author = value.trim_matches('"').to_string(),
                    "track" => current_config.track = value.trim_matches('"').to_string(),
                    "volume" => current_config.volume = value.parse().unwrap_or(0.3),
                    _ => {}
                }
            }
        }
    }

    configs
}

pub fn save_music_config(
    music_dir: &Path,
    configs: &[MusicConfig],
) -> Result<(), Box<dyn std::error::Error>> {
    let music_config_path = music_dir.join("music_config.txt");
    let mut file = fs::File::create(music_config_path)?;

    // Get the absolute path of the music directory to construct proper paths
    let absolute_music_path = music_dir.canonicalize()?;
    let drive_root = if let Some(parent) = absolute_music_path.parent() {
        if let Some(grandparent) = parent.parent() {
            grandparent.to_path_buf()
        } else {
            parent.to_path_buf()
        }
    } else {
        absolute_music_path.clone()
    };

    for config in configs {
        writeln!(file, "Music {{")?;

        // Convert the filename to an absolute path from drive root
        let file_path = if config.filename.starts_with("data/music/") {
            // This is already a relative path, convert to absolute from drive root
            let relative_path = config.filename.trim_start_matches("data/music/");
            let mut absolute_path = drive_root.join("data/music");
            for part in relative_path.split('/') {
                absolute_path = absolute_path.join(part);
            }
            absolute_path
        } else {
            // Try to interpret as absolute path
            PathBuf::from(&config.filename)
        };

        // Convert to string and normalize path separators
        let path_string = file_path.to_string_lossy().to_string();
        let normalized_path = path_string.replace('\\', "/");

        // Strip Windows \\?\ prefix if present
        let cleaned = normalized_path.trim_start_matches("//?/");

        // Strip drive letter (e.g. "C:/")
        let cleaned = if cleaned.len() > 2 && cleaned.chars().nth(1) == Some(':') {
            &cleaned[2..] // remove "C:"
        } else {
            cleaned
        };

        // Remove leading slash if present
        let cleaned = cleaned.trim_start_matches('/');

        writeln!(file, "    filename = \"{cleaned}\";")?;
        writeln!(
            file,
            "    halfpipe = {};",
            if config.halfpipe { "1" } else { "0" }
        )?;
        writeln!(
            file,
            "    tracks = {};",
            if config.tracks { "1" } else { "0" }
        )?;
        writeln!(file, "    author = \"{}\";", config.author)?;
        writeln!(file, "    track = \"{}\";", config.track)?;
        writeln!(file, "    volume = {};", config.volume)?;
        writeln!(file, "}};")?;
        writeln!(file)?;
    }

    Ok(())
}

#[must_use]
pub fn load_and_reconcile_music_configs(music_dir: &Path, game_path: &Path) -> Vec<MusicConfig> {
    if !music_dir.exists() {
        return Vec::new();
    }

    // Load existing configs
    let configs = load_music_config(music_dir);

    // Discover all ADP files and create a mapping by filename
    let adp_files = discover_music_files(music_dir);

    use std::collections::HashMap;
    let mut adp_file_map = HashMap::new();
    for adp_file in &adp_files {
        if let Some(file_name) = adp_file.file_name().and_then(|n| n.to_str()) {
            let relative_path = adp_file.strip_prefix(music_dir).unwrap_or(adp_file);
            let full_path = format!("data/music/{}", relative_path.display());
            adp_file_map.insert(file_name.to_string(), (adp_file.clone(), full_path));
        }
    }

    // Reconcile configs with actual files
    let mut final_configs = Vec::new();
    let mut seen_filenames = HashSet::new();

    // First pass: process existing configs and fix paths if needed
    for mut config in configs {
        // Extract filename from path
        let filename = if let Some(last_slash) = config.filename.rfind('/') {
            config.filename[last_slash + 1..].to_string()
        } else {
            config.filename.clone()
        };

        // Check if this filename already exists in our final configs
        if seen_filenames.contains(&filename) {
            continue; // Skip duplicates
        }
        seen_filenames.insert(filename.clone());

        // Check if the file exists at the configured path
        let configured_path = game_path.join(&config.filename);
        let file_exists_at_configured_path = configured_path.exists();

        // Check if the file exists anywhere in the music directory
        if let Some((actual_file, correct_path)) = adp_file_map.get(&filename) {
            let file_exists = actual_file.exists();

            if file_exists {
                if !file_exists_at_configured_path {
                    // Path is broken but file exists - fix the path
                    config.filename = correct_path.clone();
                }
                final_configs.push(config);
            } else {
                // File doesn't exist at all - keep the config but mark as missing
                final_configs.push(config);
            }
        } else {
            // No corresponding file found - keep the config but mark as missing
            final_configs.push(config);
        }
    }

    // Second pass: add configs for files that don't have existing configs
    for (file_name, (_adp_file, full_path)) in &adp_file_map {
        if !seen_filenames.contains(file_name) {
            seen_filenames.insert(file_name.clone());

            final_configs.push(MusicConfig {
                filename: full_path.clone(),
                halfpipe: true,
                tracks: true,
                author: "Unknown".to_string(),
                track: file_name.trim_end_matches(".adp").replace('_', " ").clone(),
                volume: 0.3,
            });
        }
    }

    final_configs
}

#[derive(Debug, Clone, PartialEq)]
pub enum MusicFileStatus {
    /// File exists at the configured path
    Ok,
    /// Path was automatically fixed
    Fixed,
    /// File not found at all
    Missing,
}

#[must_use]
pub fn get_music_file_status(config: &MusicConfig, game_path: &Path) -> MusicFileStatus {
    // Convert relative path to absolute path
    let configured_path = if config.filename.starts_with("data/music/") {
        game_path.join(&config.filename)
    } else {
        game_path.join("data/music").join(&config.filename)
    };

    // Check if file exists at the configured path
    let file_exists_at_configured_path = configured_path.exists();

    // Check if file exists anywhere in the music directory (path was fixed)
    let filename = if let Some(last_slash) = config.filename.rfind('/') {
        &config.filename[last_slash + 1..]
    } else {
        &config.filename
    };

    let music_dir = game_path.join("data/music");
    let file_exists_anywhere = music_dir.join(filename).exists();

    // Return status enum
    if file_exists_at_configured_path {
        MusicFileStatus::Ok
    } else if file_exists_anywhere {
        MusicFileStatus::Fixed
    } else {
        MusicFileStatus::Missing
    }
}

#[must_use]
pub fn get_music_filename_only(config: &MusicConfig) -> String {
    // Extract just the filename from the full path
    if let Some(last_slash) = config.filename.rfind('/') {
        config.filename[last_slash + 1..].to_string()
    } else {
        config.filename.clone()
    }
}

pub fn generate_music_config_file(music_dir: &Path) -> Result<(), Box<dyn std::error::Error>> {
    // Discover all music files
    let music_files = discover_music_files(music_dir);

    // Create default configs for each music file
    let mut configs = Vec::new();

    for music_file in music_files {
        if let Some(file_name) = music_file.file_name().and_then(|n| n.to_str()) {
            let relative_path = music_file.strip_prefix(music_dir).unwrap_or(&music_file);
            let full_path = format!("data/music/{}", relative_path.display());

            configs.push(MusicConfig {
                filename: full_path,
                halfpipe: true,
                tracks: true,
                author: String::new(),
                track: file_name.trim_end_matches(".adp").replace('_', " ").clone(),
                volume: 0.3,
            });
        }
    }

    // Save the config
    save_music_config(music_dir, &configs)?;

    Ok(())
}