Wad-goggles/src/lumps.rs

use std::marker;

use ratatui::symbols::Marker;
use wad::Wad;

#[derive(PartialEq, Clone)]
pub enum MarkerType {
    Flat,
    Sprite,
    Texture,
    Sound,
    Map,
    Unknown,
}

#[derive(PartialEq)]
pub enum FileType {
    Map,
    Things,
    Linedefs,
    Sidedefs,
    Vertexes,
    Segs,
    Ssectors,
    Nodes,
    Sectors,
    Reject,
    Blockmap,
    Behavior,
    //
    Flat,
    Sprite,
    Texture,
    Sfx,
}

#[derive(PartialEq)]
pub enum MarkerBoundary {
    Single,
    Begin,
    End,
    Unknown,
}

pub enum LumpType {
    Marker(MarkerType, MarkerBoundary),
    File(FileType),
}

pub struct LumpInfo {
    pub name: String,
    pub size: usize,
    pub lump_type: Option<LumpType>,
}

fn determine_lump_type(
    current_group: &Option<MarkerType>,
    name: &str,
    size: usize,
) -> Option<LumpType> {
    // TODO Make sure that the map lumps are following a map?
    if size == 0 {
        match name {
            "F_START" => return Some(LumpType::Marker(MarkerType::Flat, MarkerBoundary::Begin)),
            "F_END" => return Some(LumpType::Marker(MarkerType::Flat, MarkerBoundary::End)),
            "S_START" => return Some(LumpType::Marker(MarkerType::Sprite, MarkerBoundary::Begin)),
            "S_END" => return Some(LumpType::Marker(MarkerType::Sprite, MarkerBoundary::End)),
            "TX_START" => return Some(LumpType::Marker(MarkerType::Texture, MarkerBoundary::Begin)),
            "TX_END" => return Some(LumpType::Marker(MarkerType::Texture, MarkerBoundary::End)),
            _ => {}
        }
    }
    match name {
        "THINGS" => return Some(LumpType::File(FileType::Things)),
        "LINEDEFS" => return Some(LumpType::File(FileType::Linedefs)),
        "SIDEDEFS" => return Some(LumpType::File(FileType::Sidedefs)),
        "VERTEXES" => return Some(LumpType::File(FileType::Vertexes)),
        "SEGS" => return Some(LumpType::File(FileType::Segs)),
        "SSECTORS" => return Some(LumpType::File(FileType::Ssectors)),
        "NODES" => return Some(LumpType::File(FileType::Nodes)),
        "SECTORS" => return Some(LumpType::File(FileType::Sectors)),
        "REJECT" => return Some(LumpType::File(FileType::Reject)),
        "BLOCKMAP" => return Some(LumpType::File(FileType::Blockmap)),
        "BEHAVIOR" => return Some(LumpType::File(FileType::Behavior)),
        _ => {}
    };
    if let Some(marker_type) = &current_group {
        match marker_type {
            MarkerType::Flat => return Some(LumpType::File(FileType::Flat)),
            MarkerType::Sprite => return Some(LumpType::File(FileType::Sprite)),
            MarkerType::Texture => return Some(LumpType::File(FileType::Texture)),
            _ => {},
        }
    }

    if name.starts_with("MAP") && name.len() == 5 {
        return Some(LumpType::File(FileType::Map));
    }
    None
}

pub fn get_lumps(wad: &Wad) -> Vec<LumpInfo> {
    let mut current_marker_group: Option<MarkerType> = None;
    wad.as_slice()
        .entry_iter()
        .map(|entry| {
            let lump_type = determine_lump_type(&current_marker_group, entry.display_name(), entry.lump.len());

            // Update the iterator state by checking the current lump's type if it's a marker.
            // Open/close marker groups depending on its type.
            match &lump_type {
                Some(LumpType::Marker(marker_type, boundary)) => {
                    if *boundary == MarkerBoundary::End {
                        current_marker_group = None;
                    } else {
                        match marker_type {
                            MarkerType::Flat | MarkerType::Sprite | MarkerType::Texture => current_marker_group = Some(marker_type.clone()),
                            _ => todo!(),
                        }
                    }
                },
                Some(LumpType::File(FileType::Map)) => current_marker_group = Some(MarkerType::Map),
                _ => {}
            };

            LumpInfo {
                name: entry.display_name().to_string(),
                size: entry.lump.len(),
                lump_type: lump_type,
            }
        })
        .collect()
}