supreme_cleaner/

dependency_walker.rs

use std::collections::{HashSet, VecDeque};
use std::io;
use std::path::PathBuf;

use supreme_fs::GameStorage;

use crate::path_utils::{build_path_index, resolve_path_from_index};

/// Recursively find all game dependencies starting from known configuration files.
///
/// Roots:
/// - `object_classes.txt`
/// - `board_types.txt`
/// - `player_types.txt`
/// - *cnf.txt
///
/// From there, it parses these files to find references to other files (textures, models, other configs),
/// and recursively resolves them.
pub fn walk_dependencies(
    storage: &GameStorage,
    all_files: &[PathBuf],
    roots: &[PathBuf],
    ignored_extensions: &[&str],
) -> io::Result<Vec<PathBuf>> {
    let root_path = storage.game_path();

    // 1. Build an index for fast resolution from provided files
    let path_index = build_path_index(root_path, all_files);

    // 2. Identify initial roots
    let mut queue = VecDeque::new();
    let mut visited = HashSet::new();

    // Start with explicitly provided roots
    for root in roots {
        if root.exists() && visited.insert(root.clone()) {
            queue.push_back(root.clone());
        }
    }

    // 3. BFS
    while let Some(current_path) = queue.pop_front() {
        // Only parse text-based config files
        // We assume anything we "found" and put in the queue is a dependency we want to keep.
        // We only *parse* it for MORE dependencies if it looks like a config file.
        let is_config = if let Some(ext) = current_path.extension().and_then(|s| s.to_str()) {
            let lower_ext = ext.to_lowercase();
            lower_ext == "txt"
        } else {
            false
        };

        if !is_config {
            continue;
        }

        // Parse content
        if let Ok(content) = storage.read_text(&current_path) {
            let current_dir = current_path.parent().unwrap_or(root_path);

            for line in content.lines() {
                // Heuristic parsing: look for quoted strings that look like paths
                // Logic adapted from txt_processor but simplified for read-only extracting
                extract_paths_from_line(line, |extracted_path| {
                    // Try to resolve this path
                    let normalized = extracted_path.replace('\\', "/");

                    // Ignore obvious non-paths or empty
                    if normalized.trim().is_empty()
                        || (!normalized.contains('.') && !normalized.contains('/'))
                    {
                        return;
                    }

                    // 1. Try absolute resolution (relative to game root)
                    if let Some(resolved) =
                        resolve_path_from_index(root_path, &normalized, &path_index)
                    {
                        // Ignore disallowed extensions
                        if let Some(ext) = resolved.extension().and_then(|e| e.to_str()) {
                            let ext_lower = ext.to_lowercase();
                            if ignored_extensions.contains(&ext_lower.as_str()) {
                                return;
                            }
                        }

                        if visited.insert(resolved.clone()) {
                            queue.push_back(resolved);
                        }
                        return;
                    }

                    // 2. Try relative resolution (relative to current file)
                    // We construct a potential absolute path and check if it exists in our index (by path lookup or file check)
                    // Since index keys are relative to root, we need to convert our potential absolute path to relative to root first?
                    // Or more simply: construct the absolute path, and check if it exists on disk (or in our all_files set for speed?)

                    // Construct absolute path candidates
                    let candidate_abs = current_dir.join(&normalized);

                    // We need to resolve this candidate case-insensitively against our known files
                    // Try to look it up in the path_index when its relative path from root can be computed
                    if let Ok(rel_candidate) = candidate_abs.strip_prefix(root_path) {
                        let rel_key = rel_candidate
                            .to_string_lossy()
                            .replace('\\', "/")
                            .to_lowercase();
                        if let Some(resolved) = path_index.get(&rel_key) {
                            // Ignore disallowed extensions
                            if let Some(ext) = resolved.extension().and_then(|e| e.to_str()) {
                                let ext_lower = ext.to_lowercase();
                                if ignored_extensions.contains(&ext_lower.as_str()) {
                                    return;
                                }
                            }

                            if visited.insert(resolved.clone()) {
                                queue.push_back(resolved.clone());
                            }
                        }
                    }
                });
            }
        }
    }

    // Return all visited files
    Ok(visited.into_iter().collect())
}

/// Extract all quoted strings from a line that might be paths.
fn extract_paths_from_line<F>(line: &str, mut cb: F)
where
    F: FnMut(&str),
{
    let mut search_pos = 0;
    while let Some(quote_start) = line[search_pos..].find('"') {
        let abs_start = search_pos + quote_start + 1;
        if let Some(quote_end) = line[abs_start..].find('"') {
            let abs_end = abs_start + quote_end;
            let value = &line[abs_start..abs_end];

            // Also handle comma separated lists inside quotes in some rare cases?
            // For now assume one path per quoted string, or split by comma if commonly done?
            // "Texture1.bmp, Texture2.bmp" is sometimes seen.
            for part in value.split(',') {
                let trimmed = part.trim();
                if !trimmed.is_empty() {
                    cb(trimmed);
                }
            }

            search_pos = abs_end + 1;
        } else {
            break;
        }
    }
}