wowlab_parsers/parsers/transform/

global.rs

use wowlab_types::{
    colors::{argb_to_hex, rgb_to_hex},
    data::{ClassDataFlat, GlobalColorFlat, GlobalStringFlat},
};

#[cfg(feature = "dbc")]
use super::{super::dbc::DbcData, super::errors::TransformError, resolve_icon_file_name};

const DEFAULT_COLOR_COMPONENT: i32 = 255;

/// Transform a single `ChrClasses` row into a flat class record.
///
/// # Errors
///
/// Returns [`TransformError`] when `class_id` is absent from the DBC data.
pub fn transform_class(dbc: &DbcData, class_id: i32) -> Result<ClassDataFlat, TransformError> {
    let class = dbc
        .chr_classes
        .get(&class_id)
        .ok_or_else(|| TransformError::class_not_found(class_id))?;

    let color = rgb_to_hex(
        class.ClassColorR.unwrap_or(DEFAULT_COLOR_COMPONENT),
        class.ClassColorG.unwrap_or(DEFAULT_COLOR_COMPONENT),
        class.ClassColorB.unwrap_or(DEFAULT_COLOR_COMPONENT),
    );

    let file_name = resolve_icon_file_name(dbc, class.IconFileDataID);

    Ok(ClassDataFlat {
        id: class.ID,
        name: class.Name_lang.clone().unwrap_or_default().into(),
        filename: class.Filename.clone().unwrap_or_default().into(),
        icon_file_id: class.IconFileDataID,
        file_name: file_name.into(),
        color: color.into(),
        spell_class_set: class.SpellClassSet,
        primary_stat_priority: class.PrimaryStatPriority,
        roles_mask: class.RolesMask,
    })
}

/// Transform every `ChrClasses` row into flat class records.
#[must_use]
pub fn transform_all_classes(dbc: &DbcData) -> Vec<ClassDataFlat> {
    super::transform_all(dbc.chr_classes.keys().copied(), "class", |class_id| {
        transform_class(dbc, class_id)
    })
}

/// Transform a single `GlobalColor` row into a flat record.
///
/// # Errors
///
/// Returns [`TransformError`] when `color_id` is absent from the DBC data.
pub fn transform_global_color(
    dbc: &DbcData,
    color_id: i32,
) -> Result<GlobalColorFlat, TransformError> {
    let row = dbc
        .global_color
        .get(&color_id)
        .ok_or_else(|| TransformError::global_color_not_found(color_id))?;

    Ok(GlobalColorFlat {
        id: row.ID,
        name: row.LuaConstantName.clone().into(),
        color: argb_to_hex(row.Color).into(),
    })
}

/// Transform every `GlobalColor` row into flat records.
#[must_use]
pub fn transform_all_global_colors(dbc: &DbcData) -> Vec<GlobalColorFlat> {
    super::transform_all(
        dbc.global_color.keys().copied(),
        "global color",
        |color_id| transform_global_color(dbc, color_id),
    )
}

/// Transform a single `GlobalStrings` row into a flat localized string record.
///
/// # Errors
///
/// Returns [`TransformError`] when `string_id` is absent from the DBC data.
pub fn transform_global_string(
    dbc: &DbcData,
    string_id: i32,
) -> Result<GlobalStringFlat, TransformError> {
    let row = dbc
        .global_strings
        .get(&string_id)
        .ok_or_else(|| TransformError::global_string_not_found(string_id))?;

    Ok(GlobalStringFlat {
        id: row.ID,
        tag: row.BaseTag.clone().into(),
        value: row.TagText_lang.clone().unwrap_or_default(),
        flags: row.Flags,
    })
}

/// Transform every `GlobalStrings` row into flat records.
#[must_use]
pub fn transform_all_global_strings(dbc: &DbcData) -> Vec<GlobalStringFlat> {
    super::transform_all(
        dbc.global_strings.keys().copied(),
        "global string",
        |string_id| transform_global_string(dbc, string_id),
    )
}

#[cfg(test)]
mod tests {
    use googletest::prelude::*;

    use super::*;
    use crate::parsers::{
        dbc::rows::{ChrClassesRow, GlobalColorRow, GlobalStringsRow, ManifestInterfaceDataRow},
        transform::fixtures::{class_row, dbc},
    };

    #[gtest]
    fn transform_class_missing_errors() -> Result<()> {
        let dbc = dbc();

        verify_that!(
            transform_class(&dbc, 999).unwrap_err().to_string(),
            eq("Class 999 not found in DBC cache")
        )
    }

    #[gtest]
    fn transform_class_color_and_identity() -> Result<()> {
        let mut dbc = dbc();

        dbc.chr_classes.insert(
            4,
            ChrClassesRow {
                Name_lang: Some("Rogue".to_string()),
                SpellClassSet: 8,
                ClassColorR: Some(255),
                ClassColorG: Some(0),
                ClassColorB: Some(0),
                ..class_row(4)
            },
        );

        let flat = transform_class(&dbc, 4)?;

        verify_that!(flat.id, eq(4))?;
        verify_that!(flat.name.as_str(), eq("Rogue"))?;
        verify_that!(flat.spell_class_set, eq(8))?;

        verify_that!(flat.color.as_str(), eq(rgb_to_hex(255, 0, 0).as_str()))
    }

    #[gtest]
    fn transform_class_color_defaults_to_white() -> Result<()> {
        let mut dbc = dbc();

        dbc.chr_classes.insert(1, class_row(1));

        let flat = transform_class(&dbc, 1)?;

        verify_that!(flat.color.as_str(), eq(rgb_to_hex(255, 255, 255).as_str()))
    }

    #[gtest]
    fn transform_class_icon_fallback_when_non_positive() -> Result<()> {
        let mut dbc = dbc();

        dbc.chr_classes.insert(
            1,
            ChrClassesRow {
                IconFileDataID: 0,
                ..class_row(1)
            },
        );

        let flat = transform_class(&dbc, 1)?;

        verify_that!(flat.file_name.as_str(), eq("inv_misc_questionmark"))
    }

    #[gtest]
    fn transform_class_icon_resolved_from_manifest() -> Result<()> {
        let mut dbc = dbc();

        dbc.chr_classes.insert(
            1,
            ChrClassesRow {
                IconFileDataID: 500,
                ..class_row(1)
            },
        );
        dbc.manifest_interface_data.insert(
            500,
            ManifestInterfaceDataRow {
                ID: 500,
                FilePath: "Interface/Icons/".to_string(),
                FileName: "ClassIcon_Rogue.BLP".to_string(),
            },
        );

        let flat = transform_class(&dbc, 1)?;

        verify_that!(flat.file_name.as_str(), eq("classicon_rogue"))
    }

    #[gtest]
    fn transform_global_color_missing_errors() -> Result<()> {
        let dbc = dbc();

        verify_that!(
            transform_global_color(&dbc, 7).unwrap_err().to_string(),
            eq("Global color 7 not found in DBC cache")
        )
    }

    #[gtest]
    fn transform_global_color_known_answer() -> Result<()> {
        let mut dbc = dbc();
        let raw = i32::from_ne_bytes(0xFFA3_35EE_u32.to_ne_bytes());

        dbc.global_color.insert(
            7,
            GlobalColorRow {
                ID: 7,
                LuaConstantName: "EPIC".to_string(),
                Color: raw,
            },
        );

        let flat = transform_global_color(&dbc, 7)?;

        verify_that!(flat.name.as_str(), eq("EPIC"))?;

        verify_that!(flat.color.as_str(), eq(argb_to_hex(raw).as_str()))
    }

    #[gtest]
    fn transform_global_string_missing_errors() -> Result<()> {
        let dbc = dbc();

        verify_that!(
            transform_global_string(&dbc, 3).unwrap_err().to_string(),
            eq("Global string 3 not found in DBC cache")
        )
    }

    #[gtest]
    fn transform_global_string_present_and_empty_value() -> Result<()> {
        let mut dbc = dbc();

        dbc.global_strings.insert(
            3,
            GlobalStringsRow {
                ID: 3,
                BaseTag: "SPELL_FAILED".to_string(),
                TagText_lang: Some("Not ready yet.".to_string()),
                Flags: 5,
            },
        );
        dbc.global_strings.insert(
            4,
            GlobalStringsRow {
                ID: 4,
                BaseTag: "EMPTY".to_string(),
                TagText_lang: None,
                Flags: 0,
            },
        );

        let present = transform_global_string(&dbc, 3)?;

        verify_that!(present.tag.as_str(), eq("SPELL_FAILED"))?;
        verify_that!(present.value.as_str(), eq("Not ready yet."))?;
        verify_that!(present.flags, eq(5))?;

        let empty = transform_global_string(&dbc, 4)?;

        verify_that!(empty.value.as_str(), eq(""))
    }
}