supreme_boards/

lib.rs

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

mod board_config;
pub use board_config::{BoardConfig, parse_board_config, write_board_config};

/// Generates a `board_types.txt` file listing all valid boards.
///
/// # Errors
///
/// Returns an error if the file cannot be created or written to.
pub fn generate_board_types_file(boards_dir: &Path) -> Result<(), Box<dyn std::error::Error>> {
    let board_types_path = boards_dir.join("board_types.txt");
    let mut file = fs::File::create(&board_types_path)?;

    // Get valid board directories (those with boardcnf.txt)
    let valid_boards = get_valid_board_directories(boards_dir);

    // Write board entries
    for board_dir in valid_boards {
        if let Some(board_name) = board_dir.file_name().and_then(|n| n.to_str()) {
            writeln!(
                file,
                "board\n{{\n\tboard_config_file = \"data/boards/{board_name}/boardcnf.txt\";\n}};",
            )?;
        }
    }

    Ok(())
}

#[must_use]
pub fn get_valid_board_directories(boards_dir: &Path) -> Vec<PathBuf> {
    let mut board_dirs = Vec::new();

    if let Ok(entries) = fs::read_dir(boards_dir) {
        for entry in entries.flatten() {
            let path = entry.path();
            if path.is_dir() && board_has_config(&path) {
                board_dirs.push(path);
            }
        }
    }

    // Natural sort the board directories
    natural_sort(&mut board_dirs);
    board_dirs
}

#[must_use]
pub fn board_has_config(board_dir: &Path) -> bool {
    let board_config_path = board_dir.join("boardcnf.txt");
    board_config_path.exists()
}

#[must_use]
pub fn get_available_boards(game_path: &Path) -> std::collections::HashSet<String> {
    let available_boards_path = game_path.join("Saved_Data/available_boards.txt");
    let mut available = std::collections::HashSet::new();

    if let Ok(content) = fs::read_to_string(available_boards_path) {
        for line in content.lines() {
            let line = line.trim();
            if line.is_empty() {
                continue;
            }

            // Parse the format: "board_name",status,
            if let Some(comma_pos) = line.find(',') {
                let board_part = &line[..comma_pos];
                let board_name = board_part.trim_matches('"');

                // Get the rest of the line after the first comma
                let rest = &line[comma_pos + 1..];

                // Find the status (could be followed by another comma or end of line)
                let status_part = if let Some(second_comma_pos) = rest.find(',') {
                    &rest[..second_comma_pos]
                } else {
                    rest.trim()
                };

                // Check if status is 1 (available)
                if status_part.trim() == "1" {
                    available.insert(board_name.to_string());
                }
            }
        }
    }

    available
}

/// Sets whether a board is available in the game.
///
/// # Errors
///
/// Returns an error if the available boards file cannot be read or updated.
pub fn set_board_available(
    game_path: &Path,
    board_name: &str,
    available: bool,
) -> Result<(), Box<dyn std::error::Error>> {
    let available_boards_path = game_path.join("Saved_Data/available_boards.txt");
    let mut available_boards = get_available_boards(game_path);

    if available {
        available_boards.insert(board_name.to_string());
    } else {
        available_boards.remove(board_name);
    }

    // Get all valid boards to maintain the complete list
    let boards_dir = game_path.join("data/boards");
    let all_valid_boards = get_valid_board_directories(&boards_dir);

    // Write using the shared function
    write_available_boards_file(&available_boards_path, &available_boards, &all_valid_boards)?;

    Ok(())
}

/// Generates all necessary board configuration files for the game.
///
/// # Errors
///
/// Returns an error if any of the configuration files cannot be generated.
pub fn generate_all_boards_files(
    boards_dir: &Path,
    game_path: &Path,
) -> Result<(), Box<dyn std::error::Error>> {
    // Always generate board_types.txt (this should reflect all available boards)
    generate_board_types_file(boards_dir)?;

    // Only generate available_boards.txt if it doesn't exist
    let available_boards_path = game_path.join("Saved_Data/available_boards.txt");

    if !available_boards_path.exists() {
        // Generate available_boards.txt with all valid boards enabled by default
        let valid_boards = get_valid_board_directories(boards_dir);

        // Create Saved_Data directory if it doesn't exist
        if let Some(parent) = available_boards_path.parent() {
            fs::create_dir_all(parent)?;
        }

        // Create a set of all valid boards (all enabled by default)
        let mut available_boards = HashSet::new();
        for board_dir in &valid_boards {
            if let Some(board_name) = board_dir.file_name().and_then(|n| n.to_str()) {
                available_boards.insert(board_name.to_string());
            }
        }

        // Write using the shared function
        write_available_boards_file(&available_boards_path, &available_boards, &valid_boards)?;
    }

    Ok(())
}

fn write_available_boards_file(
    available_boards_path: &Path,
    available_boards: &HashSet<String>,
    all_boards: &[PathBuf],
) -> Result<(), Box<dyn std::error::Error>> {
    // Create parent directory if it doesn't exist
    if let Some(parent) = available_boards_path.parent() {
        fs::create_dir_all(parent)?;
    }

    let mut file = fs::File::create(available_boards_path)?;

    writeln!(file, "{{")?;

    // Write all valid boards with their status
    for (index, board_dir) in all_boards.iter().enumerate() {
        if let Some(board_name) = board_dir.file_name().and_then(|n| n.to_str()) {
            let status = if available_boards.contains(board_name) {
                "1"
            } else {
                "0"
            };
            if index > 0 {
                writeln!(file, ",")?;
            }
            write!(file, "    \"{board_name}\",{status}")?;
        }
    }

    writeln!(file, "\n}}")?;

    Ok(())
}

fn natural_sort(paths: &mut [PathBuf]) {
    paths.sort_by(|a, b| {
        let a_name = a.file_name().and_then(|n| n.to_str()).unwrap_or("");
        let b_name = b.file_name().and_then(|n| n.to_str()).unwrap_or("");

        // Extract numeric parts for natural sorting
        let a_num = extract_number(a_name);
        let b_num = extract_number(b_name);

        a_num.cmp(&b_num)
    });
}

fn extract_number(s: &str) -> u32 {
    s.trim_start_matches("board_").parse::<u32>().unwrap_or(0)
}

#[derive(serde::Deserialize)]
struct BoardRawConfig {
    mat_file: String,
}

#[derive(serde::Deserialize)]
struct MatRawConfig {
    material: MaterialData,
}

#[derive(serde::Deserialize)]
struct MaterialData {
    texture: String,
}

/// Get the texture path from a board's configuration files.
/// 1. Reads `boardcnf.txt` to find material file
/// 2. Reads the material file to find the texture field
#[must_use]
pub fn get_board_texture_path(board_dir: &Path) -> Option<PathBuf> {
    let board_config_path = board_dir.join("boardcnf.txt");
    if !board_config_path.exists() {
        return None;
    }

    let config: BoardRawConfig = match supreme_parsing::from_path(&board_config_path) {
        Ok(c) => c,
        Err(e) => {
            eprintln!(
                "Error parsing board config {}: {}",
                board_config_path.display(),
                e
            );
            return None;
        }
    };
    let mat_file_val = &config.mat_file;

    // The material file might be a relative path like "data/boards/board_2/board_mat.txt"
    // or just a filename like "board_mat.txt".
    let mat_file_path = if mat_file_val.contains('/') || mat_file_val.contains('\\') {
        // It's a path. Extract the filename to find it in the board directory.
        let p = Path::new(mat_file_val);
        if let Some(filename) = p.file_name() {
            board_dir.join(filename)
        } else {
            board_dir.join(mat_file_val)
        }
    } else {
        board_dir.join(mat_file_val)
    };

    if !mat_file_path.exists() {
        eprintln!("Material file not found: {}", mat_file_path.display());
        return None;
    }

    let mat_map: MatRawConfig = match supreme_parsing::from_path(&mat_file_path) {
        Ok(m) => m,
        Err(e) => {
            eprintln!(
                "Error parsing material file {}: {}",
                mat_file_path.display(),
                e
            );
            return None;
        }
    };
    Some(PathBuf::from(mat_map.material.texture))
}