supreme_diagnostics/

lib.rs

use rayon::prelude::*;
use std::collections::HashMap;
use std::fs;
use std::io;
use std::sync::mpsc::Sender;
use std::time::{Instant, SystemTime, UNIX_EPOCH};

use supreme_fs::DiscoverMode;
use supreme_fs::GameStorage;
use supreme_parsing::{decode_bytes, extract_quoted_paths};

#[derive(Clone, serde::Serialize, serde::Deserialize)]
pub struct PathDiagnostics {
    pub scan_timestamp: u64,
    pub total_files_scanned: usize,
    pub total_paths_found: usize,
    pub summary: PathSummary,
    pub files: Vec<FilePathReport>,
}

#[derive(Clone, serde::Serialize, serde::Deserialize)]
pub struct PathSummary {
    pub pass_count: usize,
    pub warn_count: usize,
    pub fixable_count: usize,
    pub error_count: usize,
}

#[derive(Clone, serde::Serialize, serde::Deserialize)]
pub struct FilePathReport {
    pub file_path: String,
    pub file_type: String, // "matlist" or "tricnf"
    pub paths: Vec<PathValidation>,
}

#[derive(Clone, serde::Serialize, serde::Deserialize)]
pub struct PathValidation {
    pub line_number: usize,
    pub original_path: String,
    pub status: PathStatus,
    pub resolved_path: Option<String>, // actual path if found
}

#[derive(Clone, serde::Serialize, serde::Deserialize)]
pub enum PathStatus {
    Pass,    // case-sensitive match
    Warn,    // case-insensitive match only
    Fixable, // wrong path but file exists elsewhere with same filename
    Error,   // no match found
}

pub enum DiagnosticsEvent {
    Log(String),
    SetStatus(String),
    InitProgress(usize),
    IncrementProgress,
    Perf(String, String, u128),   // Operation, Target, Duration_ms
    Finished(Result<(), String>), // Included here for completeness if needed, though launcher handles thread
}

pub fn scan_paths(
    storage: &GameStorage,
    tx: Sender<DiagnosticsEvent>,
) -> io::Result<PathDiagnostics> {
    let start_total = Instant::now();
    let root_path = storage.game_path();
    let data_dir = root_path.join("data");

    if !data_dir.exists() {
        return Err(io::Error::new(
            io::ErrorKind::NotFound,
            "Data directory not found",
        ));
    }

    let _ = tx.send(DiagnosticsEvent::SetStatus(
        "Building file index...".to_string(),
    ));

    // Build a lowercase path index map (reusing snapshot scanning logic)
    let mut path_index: HashMap<String, String> = HashMap::new();
    // Build a filename index to find files by name when path is wrong
    let mut filename_index: HashMap<String, Vec<String>> = HashMap::new();

    let all_files = match storage.discover(DiscoverMode::Files) {
        Ok(files) => files,
        Err(e) => {
            let _ = tx.send(DiagnosticsEvent::Finished(Err(format!(
                "Failed to discover files: {e}",
            ))));
            return Err(e);
        }
    };

    if all_files.is_empty() {
        let _ = tx.send(DiagnosticsEvent::Finished(
            Err("No files found".to_string()),
        ));
        return Err(io::Error::new(
            io::ErrorKind::NotFound,
            "No files found in game directory",
        ));
    }

    for file_path in &all_files {
        if let Ok(relative_path) = file_path.strip_prefix(root_path) {
            let path_str = relative_path.to_string_lossy().replace('\\', "/");
            let normalized_path = strip_texture_resolution_patterns(&path_str);
            let lowercase_key = normalized_path.to_lowercase();
            path_index.insert(lowercase_key, path_str.clone());

            // Also index by filename for fixable path detection
            if let Some(filename) = file_path.file_name().and_then(|f| f.to_str()) {
                let filename_lower = filename.to_lowercase();
                filename_index
                    .entry(filename_lower)
                    .or_default()
                    .push(path_str.clone());
            }
        }
    }

    let _ = tx.send(DiagnosticsEvent::Log(format!(
        "Built index with {} files.",
        path_index.len()
    )));

    let _ = tx.send(DiagnosticsEvent::SetStatus(
        "Finding files to scan...".to_string(),
    ));

    // Find all files matching:
    // Objects: matlist.txt, tricnf.txt, level_data.txt, object_classes.txt
    // Boards: boardcnf.txt, board_mat.txt
    let mut files_to_scan = Vec::new();
    for path in &all_files {
        // Check if file is inside Data directory (case-insensitive check)
        let is_in_data = path.strip_prefix(root_path).is_ok_and(|rel| {
            rel.components()
                .next()
                .is_some_and(|c| c.as_os_str().eq_ignore_ascii_case("data"))
        });

        if is_in_data && let Some(filename) = path.file_name().and_then(|s| s.to_str()) {
            let filename_lower = filename.to_lowercase();
            if filename_lower == "matlist.txt"
                || filename_lower == "tricnf.txt"
                || filename_lower == "level_data.txt"
                || filename_lower == "object_classes.txt"
                || filename_lower == "board_types.txt"
                || filename_lower == "boardcnf.txt"
                || filename_lower == "board_mat.txt"
            {
                files_to_scan.push(path.clone());
            }
        }
    }

    let total_files = files_to_scan.len();
    let _ = tx.send(DiagnosticsEvent::Log(format!(
        "Found {total_files} files to scan.",
    )));
    let _ = tx.send(DiagnosticsEvent::InitProgress(total_files));
    let _ = tx.send(DiagnosticsEvent::SetStatus("Scanning files...".to_string()));

    // Process files in parallel
    let file_reports: Vec<FilePathReport> = files_to_scan
        .par_iter()
        .filter_map(|file_path| {
            let tx = tx.clone();

            let filename = file_path.file_name()?.to_str()?;
            let filename_lower = filename.to_lowercase();
            let file_type = if filename_lower == "matlist.txt" {
                "matlist"
            } else if filename_lower == "tricnf.txt" {
                "tricnf"
            } else if filename_lower == "level_data.txt" {
                "level_data"
            } else if filename_lower == "object_classes.txt" {
                "object_classes"
            } else if filename_lower == "boardcnf.txt" {
                "boardcnf"
            } else if filename_lower == "board_mat.txt" {
                "board_mat"
            } else {
                return None;
            };

            let relative_path = file_path
                .strip_prefix(root_path)
                .unwrap_or(file_path)
                .to_string_lossy()
                .to_string()
                .replace('\\', "/");

            // Read file content with Windows-1252 encoding
            let bytes = match fs::read(file_path) {
                Ok(b) => b,
                Err(e) => {
                    let _ = tx.send(DiagnosticsEvent::Log(format!(
                        "Error reading {relative_path}: {e}",
                    )));
                    return None;
                }
            };

            let content = decode_bytes(&bytes);

            let mut path_validations = Vec::new();

            // Extract paths - all file types use the same key = "value"; format
            for (line_num, line) in content.lines().enumerate() {
                let paths = extract_quoted_paths(line);

                for original_path in paths {
                    // Validate the path using the index
                    let (status, resolved_path) = validate_path_with_index(
                        &path_index,
                        &filename_index,
                        &original_path,
                        &relative_path,
                    );

                    path_validations.push(PathValidation {
                        line_number: line_num + 1,
                        original_path: original_path.clone(),
                        status,
                        resolved_path,
                    });
                }
            }

            let _ = tx.send(DiagnosticsEvent::IncrementProgress);

            if path_validations.is_empty() {
                None
            } else {
                Some(FilePathReport {
                    file_path: relative_path.clone(),
                    file_type: file_type.to_string(),
                    paths: path_validations,
                })
            }
        })
        .collect();

    // Calculate summary statistics
    let mut pass_count = 0;
    let mut warn_count = 0;
    let mut fixable_count = 0;
    let mut error_count = 0;
    let mut total_paths = 0;

    for report in &file_reports {
        for validation in &report.paths {
            total_paths += 1;
            match validation.status {
                PathStatus::Pass => pass_count += 1,
                PathStatus::Warn => warn_count += 1,
                PathStatus::Fixable => fixable_count += 1,
                PathStatus::Error => error_count += 1,
            }
        }
    }

    let diagnostics = PathDiagnostics {
        scan_timestamp: SystemTime::now()
            .duration_since(UNIX_EPOCH)
            .unwrap_or_default()
            .as_secs(),
        total_files_scanned: file_reports.len(),
        total_paths_found: total_paths,
        summary: PathSummary {
            pass_count,
            warn_count,
            fixable_count,
            error_count,
        },
        files: file_reports,
    };

    // Save diagnostics report
    if let Err(e) = storage.write_report("path_diagnostics", &diagnostics) {
        let _ = tx.send(DiagnosticsEvent::Log(format!(
            "Failed to save diagnostics report: {e}"
        )));
    }

    let _ = tx.send(DiagnosticsEvent::Log(format!(
        "Scan complete: {pass_count} pass, {warn_count} warn, {fixable_count} fixable, {error_count} error",
    )));
    let _ = tx.send(DiagnosticsEvent::Log(format!(
        "Report saved to {}",
        storage.get_report_path("path_diagnostics").display()
    )));
    let _ = tx.send(DiagnosticsEvent::Perf(
        "PathScanTotal".to_string(),
        "All".to_string(),
        start_total.elapsed().as_millis(),
    ));

    Ok(diagnostics)
}

fn strip_texture_resolution_patterns(path: &str) -> String {
    // Strip {vlores,lores,medres,hires}/{256,24bit} patterns from paths
    let mut result = path.to_string();

    // Remove resolution folder patterns like /hires/, /medres/, etc.
    let resolution_folders = ["vlores", "lores", "medres", "hires"];
    for folder in &resolution_folders {
        let pattern = format!("/{folder}/");
        if let Some(pos) = result.find(&pattern) {
            result = format!("{}{}", &result[..=pos], &result[pos + pattern.len()..]);
        }
    }

    // Remove bit depth folder patterns like /256/, /24bit/
    let bit_depth_folders = ["256", "24bit"];
    for folder in &bit_depth_folders {
        let pattern = format!("/{folder}/");
        if let Some(pos) = result.find(&pattern) {
            result = format!("{}{}", &result[..=pos], &result[pos + pattern.len()..]);
        }
    }

    result
}

fn validate_path_with_index(
    path_index: &HashMap<String, String>,
    filename_index: &HashMap<String, Vec<String>>,
    original_path: &str,
    current_file_path: &str,
) -> (PathStatus, Option<String>) {
    // Normalize the path by stripping texture resolution patterns
    let normalized_path = strip_texture_resolution_patterns(original_path);
    let lowercase_key = normalized_path.to_lowercase();

    // Try exact match first (case-sensitive)
    if let Some(actual_path) = path_index.get(&normalized_path.to_lowercase())
        && actual_path.to_lowercase() == normalized_path.to_lowercase()
    {
        // Check if the case matches exactly
        if actual_path == &normalized_path {
            return (PathStatus::Pass, Some(actual_path.clone()));
        }
        // Case-insensitive match
        return (PathStatus::Warn, Some(actual_path.clone()));
    }

    // Try with lowercase lookup
    if let Some(actual_path) = path_index.get(&lowercase_key) {
        return (PathStatus::Warn, Some(actual_path.clone()));
    }

    // Path not found - try to find by filename
    if let Some(filename) = original_path.split('/').next_back() {
        let filename_lower = filename.to_lowercase();
        if let Some(matching_paths) = filename_index.get(&filename_lower)
            && !matching_paths.is_empty()
        {
            // Find the best match based on proximity to current_file_path
            let best_match = matching_paths.iter().max_by_key(|path| {
                // Calculate common prefix length
                let path_components = path.split('/');
                let current_components = current_file_path.split('/');
                path_components
                    .zip(current_components)
                    .take_while(|(a, b)| a == b)
                    .count()
            });

            if let Some(best) = best_match {
                let stripped = strip_texture_resolution_patterns(best);
                return (PathStatus::Fixable, Some(stripped));
            }
        }
    }

    // No match found
    (PathStatus::Error, None)
}