disclady 0.4.0

Pure Rust library and CLI utility for optical and storage disc image heuristics, inspection, and format detection (CD, DVD, GDI, Hard Disk, LaserDisc, CHD).
Documentation
//! Dreamcast GDI (.gdi) descriptor parser and analyzer.

use std::fs::File;
use std::path::{Path, PathBuf};

use crate::types::{
    Confidence, DiscDescriptor, DiscError, DiscType, Platform, TrackDescriptor, TrackType,
    VolumeInfo,
};

/// High-density GD-ROM area start threshold (nominally LBA 45000).
pub const GDROM_HIGH_DENSITY_LBA: u64 = 40000;

/// Analyzes a `.gdi` file on disk, validating tracks and inspecting files when available.
pub(crate) fn inspect_gdi<P: AsRef<Path>>(gdi_path: P) -> Result<DiscDescriptor, DiscError> {
    let path = gdi_path.as_ref();
    let content = std::fs::read_to_string(path).map_err(|e| {
        DiscError::Io(std::io::Error::new(
            e.kind(),
            format!("Failed to read GDI file '{}': {e}", path.display()),
        ))
    })?;

    let base_dir = path.parent().unwrap_or_else(|| Path::new("."));
    Ok(parse_gdi_internal(&content, Some(base_dir), Some(path)))
}

/// Parses GDI descriptor content into a `DiscDescriptor` with strict format validation.
///
/// An optional base directory can be provided to resolve relative file references.
///
/// # Examples
///
/// ```
/// use disclady::gdi::parse_gdi_descriptor;
/// use disclady::DiscType;
///
/// let gdi = "3\n1 0 4 2352 track01.bin 0\n2 600 0 2352 track02.raw 0\n3 45000 4 2352 track03.bin 0\n";
/// let desc = parse_gdi_descriptor(gdi, None);
/// assert_eq!(desc.disc_type, DiscType::Gdi);
/// assert_eq!(desc.tracks.len(), 3);
/// ```
pub fn parse_gdi_descriptor(content: &str, base_dir: Option<&Path>) -> DiscDescriptor {
    parse_gdi_internal(content, base_dir, None)
}

fn parse_gdi_internal(
    content: &str,
    base_dir: Option<&Path>,
    gdi_path: Option<&Path>,
) -> DiscDescriptor {
    let mut lines = content.lines().map(|l| l.trim()).filter(|l| !l.is_empty());

    let track_count_str = match lines.next() {
        Some(s) => s,
        None => return DiscDescriptor::unknown("Empty GDI descriptor file"),
    };

    let expected_tracks = match track_count_str.parse::<usize>() {
        Ok(n) if (3..=99).contains(&n) => n,
        _ => {
            return DiscDescriptor::unknown(format!(
                "Invalid GDI track count '{track_count_str}': must be between 3 and 99"
            ))
        }
    };

    let mut tracks = Vec::with_capacity(expected_tracks);
    let mut has_high_density = false;
    let mut total_size_bytes = 0u64;

    for (index, line) in lines.enumerate() {
        if index >= expected_tracks {
            break;
        }

        let tokens = tokenize_gdi_line(line);
        if tokens.len() < 5 {
            return DiscDescriptor::unknown(format!(
                "Malformed GDI line #{}: insufficient tokens (expected >= 5)",
                index + 2
            ));
        }

        let track_num = match tokens[0].parse::<u32>() {
            Ok(num) if num == (index + 1) as u32 => num,
            _ => {
                return DiscDescriptor::unknown(format!(
                    "Invalid GDI track sequence: expected track #{}, found '{}'",
                    index + 1,
                    tokens[0]
                ))
            }
        };

        let start_lba = match tokens[1].parse::<u64>() {
            Ok(lba) => lba,
            Err(_) => {
                return DiscDescriptor::unknown(format!(
                    "Invalid GDI start LBA '{}' on track #{track_num}",
                    tokens[1]
                ))
            }
        };

        let track_type_code = match tokens[2].parse::<u32>() {
            Ok(code) if code == 0 || code == 4 => code,
            _ => {
                return DiscDescriptor::unknown(format!(
                    "Invalid GDI track type '{}' on track #{track_num} (expected 0 or 4)",
                    tokens[2]
                ))
            }
        };

        let sector_size = match tokens[3].parse::<u32>() {
            Ok(sz) if sz == 2048 || sz == 2352 || sz == 2336 => sz,
            _ => {
                return DiscDescriptor::unknown(format!(
                    "Invalid GDI sector size '{}' on track #{track_num}",
                    tokens[3]
                ))
            }
        };

        let filename = &tokens[4];

        if track_num == 1 && start_lba != 0 {
            return DiscDescriptor::unknown(format!(
                "Invalid GDI descriptor: track 1 must start at LBA 0 (found {start_lba})"
            ));
        }

        if start_lba >= GDROM_HIGH_DENSITY_LBA {
            has_high_density = true;
        }

        let track_type = match track_type_code {
            0 => TrackType::Audio,
            4 => TrackType::GdiData,
            _ => TrackType::Unknown,
        };

        let resolved_path = match base_dir {
            Some(dir) => dir.join(filename),
            None => PathBuf::from(filename),
        };

        let mut sector_count = None;
        if resolved_path.exists() {
            if let Ok(meta) = std::fs::metadata(&resolved_path) {
                if meta.len() == 0 {
                    return DiscDescriptor::unknown(format!(
                        "Referenced GDI track file '{}' is empty (0 bytes)",
                        resolved_path.display()
                    ));
                }
                total_size_bytes += meta.len();
                if sector_size > 0 {
                    sector_count = Some(meta.len() / (sector_size as u64));
                }
            }
        }

        tracks.push(TrackDescriptor {
            track_number: track_num,
            track_type,
            sector_size,
            start_lba,
            sector_count,
            file_path: Some(resolved_path),
            pregap_sectors: None,
        });
    }

    if tracks.len() != expected_tracks {
        return DiscDescriptor::unknown(format!(
            "GDI specifies {expected_tracks} tracks, but only {} valid track lines were found",
            tracks.len()
        ));
    }

    if !has_high_density {
        return DiscDescriptor::unknown(
            "Invalid GDI descriptor: missing high-density partition (no track with LBA >= 40000)"
                .to_string(),
        );
    }

    let primary_sector_size = tracks.first().map(|t| t.sector_size).unwrap_or(2352);
    let total_sectors = if total_size_bytes > 0 && primary_sector_size > 0 {
        Some(total_size_bytes / (primary_sector_size as u64))
    } else {
        None
    };

    let mut volume_info = VolumeInfo {
        platform: Some(Platform::Dreamcast),
        ..Default::default()
    };

    if let Some(track3) = tracks
        .iter()
        .find(|t| t.start_lba >= GDROM_HIGH_DENSITY_LBA)
    {
        if let Some(ref path) = track3.file_path {
            if path.exists() {
                if let Ok(mut file) = File::open(path) {
                    let meta_len = file.metadata().map(|m| m.len()).unwrap_or(0);
                    if meta_len > 0 {
                        let mut disc_reader = crate::metadata::StreamDiscReader::new(
                            &mut file,
                            track3.sector_size,
                            meta_len,
                        );
                        let meta = crate::metadata::inspect_metadata(&mut disc_reader, gdi_path);
                        let mut pvd_sec = [0u8; 2048];
                        if crate::metadata::DiscReader::read_sector(
                            &mut disc_reader,
                            16,
                            &mut pvd_sec,
                        )
                        .is_ok()
                        {
                            if let Some(pvd_vol) = crate::iso::parse_iso_pvd(&pvd_sec) {
                                volume_info = pvd_vol;
                            }
                        }
                        meta.apply_to_volume_info(&mut volume_info);
                        volume_info.platform = Some(Platform::Dreamcast);
                        if volume_info.system_identifier.is_none() {
                            volume_info.system_identifier = Some("SEGA SEGAKATANA".to_string());
                        }

                        let mut sec0 = [0u8; 2048];
                        if crate::metadata::DiscReader::read_sector(&mut disc_reader, 0, &mut sec0)
                            .is_ok()
                            && sec0.starts_with(b"SEGA SEGAKATANA ")
                        {
                            let dc_meta = crate::console::extract_dreamcast_full_metadata(&sec0);
                            if volume_info.publisher_identifier.is_none() {
                                volume_info.publisher_identifier = dc_meta.publisher;
                            }
                            if volume_info.application_identifier.is_none() {
                                volume_info.application_identifier = dc_meta.boot_file;
                            }
                        }
                    }
                }
            }
        }
    }

    if volume_info.title.is_none() {
        if let Some(clean_title) = gdi_path.and_then(crate::metadata::sanitize_image_basename) {
            volume_info.title = Some(clean_title);
        }
    }

    let track_count = tracks.len();
    let base_summary = format!(
        "Dreamcast GDI image with {} tracks (high-density GD-ROM partition verified)",
        track_count
    );
    let id_str = volume_info
        .disc_id
        .as_deref()
        .map(|id| format!(" [{id}]"))
        .unwrap_or_default();
    let title_str = volume_info
        .title
        .as_deref()
        .map(|t| format!(" \"{t}\""))
        .unwrap_or_default();

    let summary = if !id_str.is_empty() || !title_str.is_empty() {
        format!("Sega Dreamcast disc{id_str}{title_str} ({base_summary})")
    } else {
        base_summary
    };

    DiscDescriptor {
        disc_type: DiscType::Gdi,
        confidence: Confidence::Definitive,
        primary_sector_size,
        total_sectors,
        total_size_bytes: if total_size_bytes > 0 {
            Some(total_size_bytes)
        } else {
            None
        },
        tracks,
        volume_info: Some(Box::new(volume_info)),
        summary,
        chd_plan: None,
    }
}

fn tokenize_gdi_line(line: &str) -> Vec<String> {
    let mut tokens = Vec::new();
    let mut chars = line.chars().peekable();

    while let Some(&c) = chars.peek() {
        if c.is_whitespace() {
            chars.next();
            continue;
        }

        if c == '"' {
            chars.next();
            let mut s = String::new();
            for sc in chars.by_ref() {
                if sc == '"' {
                    break;
                }
                s.push(sc);
            }
            tokens.push(s);
        } else {
            let mut word = String::new();
            while let Some(&wc) = chars.peek() {
                if wc.is_whitespace() || wc == '"' {
                    break;
                }
                word.push(wc);
                chars.next();
            }
            tokens.push(word);
        }
    }

    tokens
}

/// Extracts all file paths referenced by track directives in a GDI descriptor on disk.
pub(crate) fn extract_gdi_referenced_files<P: AsRef<Path>>(gdi_path: P) -> Vec<PathBuf> {
    let path = gdi_path.as_ref();
    let content = match std::fs::read_to_string(path) {
        Ok(c) => c,
        Err(_) => return Vec::new(),
    };
    let base_dir = path.parent().unwrap_or_else(|| Path::new("."));
    extract_gdi_referenced_files_from_content(&content, Some(base_dir))
}

/// Extracts all file paths referenced by track directives from raw GDI content.
pub fn extract_gdi_referenced_files_from_content(
    content: &str,
    base_dir: Option<&Path>,
) -> Vec<PathBuf> {
    let mut lines = content.lines().map(|l| l.trim()).filter(|l| !l.is_empty());
    // Skip track count header
    let _ = lines.next();

    let mut files = Vec::new();
    for line in lines {
        let tokens = tokenize_gdi_line(line);
        if tokens.len() >= 5 {
            let filename = &tokens[4];
            let normalized = filename.replace('\\', "/");
            let file_path = Path::new(&normalized);

            let is_win_drive = normalized.len() >= 2
                && normalized.as_bytes()[0].is_ascii_alphabetic()
                && normalized.as_bytes()[1] == b':';

            let resolved = match base_dir {
                Some(dir) => {
                    if is_win_drive {
                        if let Some(name) = Path::new(&normalized).file_name() {
                            dir.join(name)
                        } else {
                            PathBuf::from(&normalized)
                        }
                    } else if file_path.is_absolute() {
                        file_path.to_path_buf()
                    } else {
                        dir.join(file_path)
                    }
                }
                None => file_path.to_path_buf(),
            };
            files.push(resolved);
        }
    }
    files
}