wowlab_parsers/parsers/simc/

parser.rs

// #t(file: rust_alloc_in_loop) parser builds owned strings per token during profile parsing, unavoidable

use std::collections::BTreeMap;

use wowlab_types::{constants::MAX_PLAYER_LEVEL, game::GearSlot, sim::FastMap};

use super::{
    errors::SimcParseError,
    lexer::{Token, lex},
    types::{
        Character, CharacterInfo, CurrencyEntry, Item, Loadout, Profession, Profile, SlotWatermark,
        Talents, UpgradeCurrency, WowClass,
    },
};
use crate::parsers::TokenStream;

const UPGRADE_CURRENCY_PARTS: usize = 3;
const SLOT_WATERMARK_PARTS: usize = 3;

/// Scalar assignments the profile builder consumes directly.
const PROFILE_SCALAR_KEYS: [&str; 9] = [
    "level",
    "race",
    "spec",
    "region",
    "server",
    "role",
    "talents",
    "professions",
    "zandalari_loa",
];

/// Parse a `SimC` profile string into structured data.
///
/// # Errors
///
/// Returns [`SimcParseError`] when the tokenized profile is incomplete or contains invalid values.
pub fn parse(input: &str) -> Result<Profile, SimcParseError> {
    let mut tokens = Vec::new();

    for (result, span) in lex(input).spanned() {
        match result {
            Ok(token) => tokens.push(token),
            Err(()) => return Err(SimcParseError::invalid_token(span.start)),
        }
    }

    let loadouts = extract_loadouts(&tokens);
    let bag_items = extract_bag_items(&tokens);
    let weekly_rewards = extract_weekly_rewards(&tokens);
    let character_info = extract_character_info(&tokens);
    let loot_spec = extract_loot_spec(&tokens);

    let parser = Parser {
        stream: TokenStream::new(&tokens),
        class: None,
        name: None,
        assignments: FastMap::default(),
        equipment: Vec::new(),
        bag_items,
        weekly_rewards,
        loadouts,
        character_info,
        loot_spec,
    };

    parser.parse()
}

struct Parser<'a> {
    stream: TokenStream<'a, Token<'a>>,

    class: Option<WowClass>,
    name: Option<String>,
    assignments: FastMap<String, String>,
    equipment: Vec<Item>,
    bag_items: Vec<Item>,
    weekly_rewards: Vec<Item>,
    loadouts: Vec<Loadout>,
    character_info: Option<CharacterInfo>,
    loot_spec: Option<String>,
}

impl<'a> Parser<'a> {
    fn peek(&self) -> Option<&Token<'a>> {
        self.stream.peek()
    }

    fn advance(&mut self) -> Option<&Token<'a>> {
        self.stream.advance()
    }

    fn skip_newlines(&mut self) {
        while matches!(self.peek(), Some(Token::Newline)) {
            self.advance();
        }
    }

    fn skip_to_line_end(&mut self) {
        while !matches!(self.peek(), Some(Token::Newline) | None) {
            self.advance();
        }
    }

    fn parse(mut self) -> Result<Profile, SimcParseError> {
        self.skip_newlines();

        while !self.stream.is_empty() {
            self.parse_line();
            self.skip_newlines();
        }

        self.build_profile()
    }

    fn parse_line(&mut self) {
        if matches!(self.peek(), Some(Token::Ident(_))) {
            self.parse_assignment();
        } else {
            self.advance();
        }
    }

    fn parse_assignment(&mut self) {
        let key = match self.advance() {
            Some(Token::Ident(k)) => *k,
            _ => return,
        };

        let Some(append) = self.parse_assignment_operator() else {
            self.skip_to_line_end();

            return;
        };

        if key == "actions" || key.starts_with("actions.") {
            self.skip_to_line_end();

            return;
        }

        if let Some(class) = WowClass::parse(key) {
            if append {
                self.skip_to_line_end();

                return;
            }

            self.class = Some(class);
            self.name = Some(self.parse_string_value());

            return;
        }

        if GearSlot::from_slug(key).is_some() {
            if append {
                self.skip_to_line_end();

                return;
            }

            self.parse_equipment(key);

            return;
        }

        let value = self.parse_value();

        self.store_assignment(key, value, append);
    }

    fn parse_assignment_operator(&mut self) -> Option<bool> {
        match self.peek() {
            Some(Token::Eq) => {
                self.advance();

                Some(false)
            }
            Some(Token::Plus) => {
                self.advance();

                if !matches!(self.peek(), Some(Token::Eq)) {
                    return None;
                }

                self.advance();

                Some(true)
            }
            _ => None,
        }
    }

    fn store_assignment(&mut self, key: &str, value: String, append: bool) {
        if append {
            self.assignments
                .entry(key.to_string())
                .or_default()
                .push_str(&value);
        } else {
            self.assignments.insert(key.to_string(), value);
        }
    }

    fn parse_string_value(&mut self) -> String {
        match self.advance() {
            Some(Token::String(s) | Token::SingleString(s) | Token::Ident(s)) => s.to_string(),
            Some(Token::Number(n)) => n.to_string(),
            _ => String::new(),
        }
    }

    fn parse_value(&mut self) -> String {
        let mut parts = Vec::new();

        loop {
            match self.peek() {
                Some(
                    Token::String(s) | Token::SingleString(s) | Token::Ident(s) | Token::Float(s),
                ) => {
                    parts.push((*s).to_string());
                    self.advance();
                }
                Some(Token::Number(n)) => {
                    parts.push((*n).to_string());
                    self.advance();
                }
                Some(
                    token @ (Token::Slash
                    | Token::Plus
                    | Token::Minus
                    | Token::Star
                    | Token::Percent
                    | Token::Eq
                    | Token::Colon
                    | Token::Bang
                    | Token::Amp
                    | Token::Pipe
                    | Token::Lt
                    | Token::Gt
                    | Token::Question
                    | Token::LParen
                    | Token::RParen),
                ) => {
                    parts.push(operator_text(token).to_string());
                    self.advance();
                }
                _ => break,
            }
        }

        parts.join("")
    }

    fn parse_equipment(&mut self, slot_name: &str) {
        let Some(slot) = GearSlot::from_slug(slot_name) else {
            return;
        };

        if !matches!(self.peek(), Some(Token::Comma)) {
            self.parse_value();
        }

        if matches!(self.peek(), Some(Token::Comma)) {
            self.advance();
        }

        let kv = self.parse_kv_pairs();

        let id = kv.get("id").and_then(|s| s.parse().ok()).unwrap_or(0);

        if id == 0 {
            return;
        }

        self.equipment.push(Item {
            gear: wowlab_types::game::GearEntry {
                slot,
                id,
                bonus_ids: parse_id_list(kv.get("bonus_id")),
                enchant_id: kv.get("enchant_id").and_then(|s| s.parse().ok()),
                gem_ids: parse_id_list(kv.get("gem_id")),
                crafted_stats: parse_id_list(kv.get("crafted_stats")),
                crafting_quality: kv.get("crafting_quality").and_then(|s| s.parse().ok()),
                drop_level: kv.get("drop_level").and_then(|s| s.parse().ok()),
                ilevel: kv.get("ilevel").and_then(|s| s.parse().ok()),
            },
            enchant: kv.get("enchant").cloned(),
            suffix: kv.get("suffix").and_then(|s| s.parse().ok()),
            gem_bonus_ids: parse_id_list(kv.get("gem_bonus_id")),
            titan_disc_id: kv.get("titan_disc_id").and_then(|s| s.parse().ok()),
        });
    }

    fn parse_kv_pairs(&mut self) -> FastMap<String, String> {
        let mut result = FastMap::default();

        while let Some(Token::Ident(k)) = self.peek() {
            let key = k.to_string();

            self.advance();

            if !matches!(self.peek(), Some(Token::Eq)) {
                break;
            }

            self.advance();

            let value = self.parse_kv_value();

            result.insert(key, value);

            if matches!(self.peek(), Some(Token::Comma)) {
                self.advance();
            } else {
                break;
            }
        }

        result
    }

    fn parse_kv_value(&mut self) -> String {
        let mut parts = Vec::new();

        loop {
            match self.peek() {
                Some(Token::Number(n)) => {
                    parts.push((*n).to_string());
                    self.advance();
                }
                Some(Token::Slash) => {
                    parts.push("/".to_string());
                    self.advance();
                }
                Some(Token::Ident(s)) => {
                    parts.push((*s).to_string());
                    self.advance();
                }
                _ => break,
            }
        }

        parts.join("")
    }

    fn build_profile(&self) -> Result<Profile, SimcParseError> {
        let class = self.class.ok_or_else(SimcParseError::missing_class)?;
        let name = self.name.clone().ok_or_else(SimcParseError::missing_name)?;

        let character = Character {
            name,
            level: self
                .get_u32("level")
                .unwrap_or_else(|| u32::from(MAX_PLAYER_LEVEL)),
            race: self
                .get_title_case("race")
                .unwrap_or_else(|| "Unknown".to_string()),
            class,
            spec: self.get_title_case("spec"),
            region: self.assignments.get("region").map(|s| s.to_uppercase()),
            server: self.assignments.get("server").cloned(),
            role: self.assignments.get("role").cloned(),
            professions: self.parse_professions(),
            zandalari_loa: self.get_title_case("zandalari_loa"),
            loot_spec: self.loot_spec.clone().map(|s| title_case(&s)),
        };

        let talents = Talents {
            encoded: self.assignments.get("talents").cloned().unwrap_or_default(),
            loadouts: self.loadouts.clone(),
        };
        let expansion_talents = self.parse_expansion_talents();

        let mut extra = self.assignments.clone();

        for key in PROFILE_SCALAR_KEYS {
            extra.remove(key);
        }

        extra.retain(|key, _| expansion_talent_system(key).is_none());

        Ok(Profile {
            character,
            equipment: self.equipment.clone(),
            bag_items: self.bag_items.clone(),
            weekly_rewards: self.weekly_rewards.clone(),
            talents,
            expansion_talents,
            extra,
            character_info: self.character_info.clone(),
        })
    }

    fn get_u32(&self, key: &str) -> Option<u32> {
        self.assignments.get(key).and_then(|s| s.parse().ok())
    }

    fn get_title_case(&self, key: &str) -> Option<String> {
        self.assignments.get(key).map(|s| title_case(s))
    }

    fn parse_professions(&self) -> Vec<Profession> {
        let Some(s) = self.assignments.get("professions") else {
            return Vec::new();
        };

        s.split('/')
            .filter_map(|part| {
                let (name, rank) = part.split_once('=')?;

                Some(Profession {
                    name: title_case(name),
                    rank: rank.parse().ok()?,
                })
            })
            .collect()
    }

    fn parse_expansion_talents(&self) -> BTreeMap<String, Vec<String>> {
        self.assignments
            .iter()
            .filter_map(|(key, value)| {
                let system = expansion_talent_system(key)?;
                let selections: Vec<_> = value
                    .split('/')
                    .filter(|selection| !selection.is_empty())
                    .map(str::to_string)
                    .collect();

                (!selections.is_empty()).then(|| (system.to_string(), selections))
            })
            .collect()
    }
}

const fn operator_text(token: &Token<'_>) -> &'static str {
    match token {
        Token::Slash => "/",
        Token::Plus => "+",
        Token::Minus => "-",
        Token::Star => "*",
        Token::Percent => "%",
        Token::Eq => "=",
        Token::Colon => ":",
        Token::Bang => "!",
        Token::Amp => "&",
        Token::Pipe => "|",
        Token::Lt => "<",
        Token::Gt => ">",
        Token::Question => "?",
        Token::LParen => "(",
        Token::RParen => ")",
        _ => "",
    }
}

fn expansion_talent_system(key: &str) -> Option<&str> {
    let system = key.strip_suffix("_talents")?;

    (!system.is_empty() && !matches!(system, "class" | "spec" | "hero")).then_some(system)
}

fn extract_loadouts(tokens: &[Token<'_>]) -> Vec<Loadout> {
    let mut loadouts = Vec::new();
    let mut pending_name: Option<String> = None;

    for token in tokens {
        if let Token::Comment(c) = token {
            let text = c.strip_prefix('#').unwrap_or(c).trim();

            if let Some(name) = text
                .strip_prefix("Saved Loadout:")
                .or_else(|| text.strip_prefix("Saved loadout:"))
            {
                pending_name = Some(name.trim().to_string());
            } else if let Some(rest) = text.strip_prefix("talents=") {
                if let Some(name) = pending_name.take() {
                    loadouts.push(Loadout {
                        name,
                        encoded: rest.trim().to_string(),
                    });
                }
            }
        }
    }

    loadouts
}

fn extract_commented_items(
    tokens: &[Token<'_>],
    start_marker: &str,
    end_marker: &str,
) -> Vec<Item> {
    let mut items = Vec::new();
    let mut in_section = false;

    for token in tokens {
        if let Token::Comment(c) = token {
            let text = c.strip_prefix('#').unwrap_or(c).trim();

            if text.starts_with(start_marker) {
                in_section = true;
                continue;
            }

            if text.starts_with(end_marker) {
                break;
            }

            if !in_section {
                continue;
            }

            if text.is_empty() || !text.contains('=') {
                continue;
            }

            if let Some(item) = parse_bag_item_line(text) {
                items.push(item);
            }
        }
    }

    items
}

fn extract_bag_items(tokens: &[Token<'_>]) -> Vec<Item> {
    extract_commented_items(tokens, "## Gear from Bags", "## Additional Character Info")
}

fn extract_weekly_rewards(tokens: &[Token<'_>]) -> Vec<Item> {
    extract_commented_items(
        tokens,
        "## Weekly Reward Choices",
        "## End of Weekly Reward Choices",
    )
}

fn extract_loot_spec(tokens: &[Token<'_>]) -> Option<String> {
    for token in tokens {
        if let Token::Comment(c) = token {
            let text = c.strip_prefix('#').unwrap_or(c).trim();

            if let Some(value) = text.strip_prefix("loot_spec=") {
                return Some(value.to_string());
            }
        }
    }

    None
}

fn parse_bag_item_line(line: &str) -> Option<Item> {
    let (slot_part, rest) = line.split_once('=')?;
    let slot = GearSlot::from_slug(slot_part)?;

    let kv = parse_comment_kv_pairs(rest);

    let id = kv.get("id").and_then(|s| s.parse().ok())?;

    if id == 0 {
        return None;
    }

    Some(Item {
        gear: wowlab_types::game::GearEntry {
            slot,
            id,
            bonus_ids: parse_id_list(kv.get("bonus_id")),
            enchant_id: kv.get("enchant_id").and_then(|s| s.parse().ok()),
            gem_ids: parse_id_list(kv.get("gem_id")),
            crafted_stats: parse_id_list(kv.get("crafted_stats")),
            crafting_quality: kv.get("crafting_quality").and_then(|s| s.parse().ok()),
            drop_level: kv.get("drop_level").and_then(|s| s.parse().ok()),
            ilevel: kv.get("ilevel").and_then(|s| s.parse().ok()),
        },
        enchant: kv.get("enchant").cloned(),
        suffix: kv.get("suffix").and_then(|s| s.parse().ok()),
        gem_bonus_ids: parse_id_list(kv.get("gem_bonus_id")),
        titan_disc_id: kv.get("titan_disc_id").and_then(|s| s.parse().ok()),
    })
}

fn parse_comment_kv_pairs(input: &str) -> FastMap<String, String> {
    let mut result = FastMap::default();

    let input = input.strip_prefix(',').unwrap_or(input);

    for part in input.split(',') {
        if let Some((key, value)) = part.split_once('=') {
            result.insert(key.to_string(), value.to_string());
        }
    }

    result
}

fn parse_id_list(value: Option<&String>) -> Option<Vec<u32>> {
    let s = value?;
    let nums: Vec<u32> = s.split('/').filter_map(|p| p.parse().ok()).collect();

    if nums.is_empty() { None } else { Some(nums) }
}

fn title_case(s: &str) -> String {
    s.split('_')
        .map(|w| {
            let mut c = w.chars();

            match c.next() {
                Some(first) => first.to_uppercase().chain(c).collect(),
                None => String::new(),
            }
        })
        .collect::<Vec<_>>()
        .join(" ")
}

fn extract_character_info(tokens: &[Token<'_>]) -> Option<CharacterInfo> {
    let mut info = CharacterInfo::default();
    let mut in_section = false;
    let mut has_data = false;

    for token in tokens {
        if let Token::Comment(c) = token {
            let text = c.strip_prefix('#').unwrap_or(c).trim();

            if text.starts_with("## Additional Character Info") {
                in_section = true;
                continue;
            }

            if let Some(checksum) = text.strip_prefix("Checksum:") {
                info.checksum = Some(checksum.trim().to_string());
                has_data = true;
                continue;
            }

            if !in_section {
                continue;
            }

            if let Some(value) = text.strip_prefix("catalyst_currencies=") {
                info.catalyst_currencies = parse_catalyst_currencies(value);
                has_data = true;
            } else if let Some(value) = text.strip_prefix("upgrade_currencies=") {
                info.upgrade_currencies = parse_upgrade_currencies(value);
                has_data = true;
            } else if let Some(value) = text.strip_prefix("slot_high_watermarks=") {
                info.slot_high_watermarks = parse_slot_watermarks(value);
                has_data = true;
            } else if let Some(value) = text.strip_prefix("upgrade_achievements=") {
                info.upgrade_achievements =
                    value.split('/').filter_map(|s| s.parse().ok()).collect();
                has_data = true;
            }
        }
    }

    has_data.then_some(info)
}

fn parse_catalyst_currencies(value: &str) -> Vec<CurrencyEntry> {
    value
        .split('/')
        .filter_map(|part| {
            let (id, amount) = part.split_once(':')?;

            Some(CurrencyEntry {
                id: id.parse().ok()?,
                amount: amount.parse().ok()?,
            })
        })
        .collect()
}

fn parse_upgrade_currencies(value: &str) -> Vec<UpgradeCurrency> {
    value
        .split('/')
        .filter_map(|part| {
            let mut parts = part.splitn(UPGRADE_CURRENCY_PARTS, ':');
            let currency_type = parts.next()?.to_string();
            let id = parts.next()?.parse().ok()?;
            let amount = parts.next()?.parse().ok()?;

            Some(UpgradeCurrency {
                currency_type,
                id,
                amount,
            })
        })
        .collect()
}

fn parse_slot_watermarks(value: &str) -> Vec<SlotWatermark> {
    value
        .split('/')
        .filter_map(|part| {
            let mut parts = part.splitn(SLOT_WATERMARK_PARTS, ':');
            let slot = parts.next()?.parse().ok()?;
            let current = parts.next()?.parse().ok()?;
            let max = parts.next()?.parse().ok()?;

            Some(SlotWatermark { slot, current, max })
        })
        .collect()
}

#[cfg(test)]
mod tests;