configs/

game_config.rs

use essences::abilities::{AbilityRarity, AbilityTemplate};
use essences::ability_presets::AbilityPresetsSettings;
use essences::bundles::BundleRaw;
use essences::chats::ChatSettings;
use essences::class;
use essences::currency::Currency;
use essences::dungeons::DungeonTemplate;
use essences::effect::Effect;
use essences::fighting::FightTemplate;
use essences::game::{AbilitySlotsLevel, Chapter, CharacterLevel, EntityTemplate, PetSlotsLevel};
use essences::gatings::Gatings;
use essences::generation::{BotsSettings, UsersGeneratingSettings};
use essences::gift::GiftTemplate;
use essences::item_case::{InventoryLevel, ItemCasesSettingsByLevel};
use essences::items::{Attribute, ItemRarity, ItemTemplate};
use essences::mail::MailTemplate;
use essences::offers::{OfferTemplate, ShopTabConfig};
use essences::pets::{PetRarity, PetTemplate};
use essences::progress_pass::ProgressPassConfig;
use essences::quest::{QuestGroupType, QuestTemplate, QuestsProgressionSettings};
use essences::ratings::RatingSettings;
use essences::referrals::ReferralLevelInfo;
use essences::skins::{ConfigSkin, SkinsSettings};
use essences::vassals::VassalTaskTemplate;
use schemars::JsonSchema;

use serde::{Deserialize, Serialize};
use tsify_next::Tsify;

use crate::abilities::{AbilityCasesSettingsByLevel, AbilityLevel, Projectile};
use crate::ads_settings::{AdsSettings, BirdVariant};
use crate::afk_rewards::{AfkRewardBonusType, AfkRewardsByLevel, AfkRewardsSettings};
use crate::buffs::BuffTemplate;
use crate::cheats::{CheatScript, TestPlayerScript};
use crate::events::EventDescription;
use crate::fighting::{ArenaLeague, ArenaSettings, FightSettings, PvpSettings};
use crate::game_settings::GameSettings;
use crate::matchmaking::MatchmakingSettings;
use crate::pets::{PetCasesSettingsByLevel, PetLevel};
use crate::reports::ReportsSettings;
use crate::statue::{StatueBonusTypeConfig, StatueLevelConfig, StatueSettings};
use crate::tutorial::TutorialStep;
use crate::validated_types::NonEmptyVec;
use crate::vassals::VassalsSettings;
use essences::statue::StatueBonusGrade;
use essences::talent_tree::{TalentTemplate, TalentTreeSettings};

#[derive(Clone, Serialize, Deserialize, JsonSchema, Tsify)]
#[tsify(into_wasm_abi)]
pub struct GameConfig {
    #[schemars(title = "Атрибуты")]
    pub attributes: Vec<Attribute>,

    #[schemars(title = "Настройки сундука-гачи-айтемов")]
    pub item_cases_settings: Vec<ItemCasesSettingsByLevel>,

    #[schemars(
        title = "Настройки игры",
        description = "Отдельные значения, которые используются в игре"
    )]
    pub game_settings: GameSettings,

    #[schemars(
        title = "Настройки действий за рекламу",
        description = "Все настройки действий, связанные с рекламой"
    )]
    pub ads_settings: AdsSettings,

    #[schemars(title = "Предметы")]
    pub items: Vec<ItemTemplate>,

    #[schemars(title = "Редкости предметов")]
    pub item_rarities: Vec<ItemRarity>,

    #[schemars(title = "Скины")]
    pub skins: Vec<ConfigSkin>,

    #[schemars(title = "Настройки скинов для кастомизации")]
    pub skins_settings: SkinsSettings,

    #[schemars(title = "Эффекты")]
    pub effects: Vec<Effect>,

    #[schemars(title = "Способности")]
    pub abilities: Vec<AbilityTemplate>,

    #[schemars(title = "Настройки сундука-гачи-скилов")]
    pub ability_cases_settings: NonEmptyVec<AbilityCasesSettingsByLevel>,

    #[schemars(title = "Редкости способностей")]
    pub ability_rarities: Vec<AbilityRarity>,

    #[schemars(title = "Уровни способностей")]
    pub ability_levels: Vec<AbilityLevel>,

    #[schemars(title = "Настройки боя")]
    pub fight_settings: FightSettings,

    #[schemars(title = "Враги")]
    pub entities: Vec<EntityTemplate>,

    #[schemars(title = "Шаблоны данжей")]
    pub dungeon_templates: Vec<DungeonTemplate>,

    #[schemars(title = "Шаблоны боев")]
    pub fight_templates: Vec<FightTemplate>,

    #[schemars(title = "Главы кампании")]
    pub chapters: Vec<Chapter>,

    #[schemars(title = "Уровни игрока")]
    pub character_levels: Vec<CharacterLevel>,

    #[schemars(title = "Уровни слотов способностей")]
    pub ability_slots_levels: Vec<AbilitySlotsLevel>,

    #[schemars(title = "Реферальные уровни игрока")]
    pub patron_levels: Vec<ReferralLevelInfo>,

    #[schemars(title = "Квесты")]
    pub quests: Vec<QuestTemplate>,

    #[schemars(title = "Настройки прогрессии квестов")]
    pub quests_progression_settings: QuestsProgressionSettings,

    #[schemars(title = "Настройки вассалов")]
    pub vassals_settings: VassalsSettings,

    #[schemars(title = "Поручения")]
    pub vassal_tasks: Vec<VassalTaskTemplate>,

    #[schemars(title = "Настройки PvP")]
    pub pvp_settings: PvpSettings,

    #[schemars(title = "Подарки")]
    pub gifts: Vec<GiftTemplate>,

    #[schemars(title = "Шаблоны писем")]
    pub mail_templates: Vec<MailTemplate>,

    #[schemars(title = "Валюты")]
    pub currencies: Vec<Currency>,

    #[schemars(title = "Уровни инвентаря")]
    pub inventory_levels: Vec<InventoryLevel>,

    #[schemars(title = "Настройки арены")]
    pub arena_settings: ArenaSettings,

    #[schemars(title = "Настройки лиг")]
    pub arena_leagues: Vec<ArenaLeague>,

    #[schemars(title = "Настройки матчмейкинга")]
    pub matchmaking_settings: MatchmakingSettings,

    #[schemars(title = "Описания эвентов")]
    pub event_descriptions: Vec<EventDescription>,

    #[schemars(title = "Классы персонажа")]
    pub classes: Vec<class::Class>,

    #[schemars(title = "Уровни прокачки классов")]
    pub class_levels: Vec<class::ClassLevels>,

    #[schemars(title = "Список проджектайлов")]
    pub projectiles: Vec<Projectile>,

    #[schemars(title = "Список бандлов")]
    pub bundles: Vec<BundleRaw>,

    #[schemars(title = "Настройки пресетов способностей")]
    pub ability_presets_settings: AbilityPresetsSettings,

    #[schemars(title = "Настройки ботов")]
    pub bots_settings: BotsSettings,

    #[schemars(title = "Настройки репортов")]
    pub reports_settings: ReportsSettings,

    #[schemars(title = "Настройки афк наград")]
    pub afk_rewards_settings: AfkRewardsSettings,

    #[schemars(title = "Уровни афк наград")]
    pub afk_rewards_levels: Vec<AfkRewardsByLevel>,

    #[schemars(title = "Настройки генерации параметров пользователя")]
    pub users_generating_settings: UsersGeneratingSettings,

    #[schemars(title = "Шаги туториала")]
    pub tutorial_steps: Vec<TutorialStep>,

    #[schemars(title = "Настройки чатов")]
    pub chats_settings: Vec<ChatSettings>,

    #[schemars(title = "Шаблоны офферов")]
    pub offers_templates: Vec<OfferTemplate>,

    #[schemars(title = "Вкладки магазина")]
    pub shop_tabs: Vec<ShopTabConfig>,

    #[schemars(title = "Настройки рейтингов")]
    pub ratings_settings: Vec<RatingSettings>,

    #[schemars(title = "Набор скриптов для читов")]
    pub cheat_scripts: Vec<CheatScript>,

    #[schemars(
        title = "Скрипты генерации тестового игрока",
        description = "Используется только в режиме читов. Каждый скрипт в формате TestPlayerResult — задаёт предметы, способности, петов, уровень, класс и силу тестового игрока. Выбирается по индексу."
    )]
    pub test_player_scripts: Vec<TestPlayerScript>,

    #[schemars(title = "Гейтинги")]
    pub gatings: Gatings,

    #[schemars(title = "Шаблоны петов")]
    pub pet_templates: Vec<PetTemplate>,

    #[schemars(title = "Редкости петов")]
    pub pet_rarities: Vec<PetRarity>,

    #[schemars(title = "Уровни петов")]
    pub pet_levels: Vec<PetLevel>,

    #[schemars(title = "Уровни слотов петов")]
    pub pet_slots_levels: Vec<PetSlotsLevel>,

    #[schemars(title = "Настройки сундука-гачи-петов")]
    pub pet_cases_settings: Vec<PetCasesSettingsByLevel>,

    #[schemars(title = "Настройки дерева талантов")]
    pub talent_tree_settings: TalentTreeSettings,

    #[schemars(title = "Таланты")]
    pub talents: Vec<TalentTemplate>,

    #[schemars(title = "Грейды бонусов статуи")]
    pub statue_bonus_grades: NonEmptyVec<StatueBonusGrade>,

    #[schemars(title = "Типы бонусов статуи (стат × грейд)")]
    pub statue_bonus_type_configs: NonEmptyVec<StatueBonusTypeConfig>,

    #[schemars(title = "Таблица уровней статуи")]
    pub statue_level_configs: NonEmptyVec<StatueLevelConfig>,

    #[schemars(title = "Настройки статуи героя")]
    pub statue_settings: StatueSettings,

    #[schemars(title = "Шаблоны баффов")]
    pub buff_templates: Vec<BuffTemplate>,

    #[schemars(title = "Настройки прогресс пасса")]
    pub progress_pass: ProgressPassConfig,

    #[schemars(title = "Варианты рекламных птиц")]
    pub bird_variants: Vec<BirdVariant>,
}

impl std::fmt::Debug for GameConfig {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "GameConfig")
    }
}

impl GameConfig {
    pub fn clone_translate(&self, translator: &i18n::translator::Translator, locale: &str) -> Self {
        let mut config = self.clone();
        for ability in &mut config.abilities {
            ability.name = translator.translate(&ability.name, locale);
            ability.description = translator.translate(&ability.description, locale);
        }

        for attribute in &mut config.attributes {
            attribute.name = translator.translate(&attribute.name, locale);
            attribute.description = translator.translate(&attribute.description, locale);
            if let Some(prefix) = &attribute.prefix {
                attribute.prefix = Some(translator.translate(prefix, locale));
            }
            if let Some(suffix) = &attribute.suffix {
                attribute.suffix = Some(translator.translate(suffix, locale));
            }
        }

        for effect in &mut config.effects {
            effect.name = translator.translate(&effect.name, locale);
        }

        for event in &mut config.event_descriptions {
            event.description = translator.translate(&event.description, locale);
        }

        for item in &mut config.items {
            item.name = translator.translate(&item.name, locale);
        }

        for item_rarity in &mut config.item_rarities {
            item_rarity.name = translator.translate(&item_rarity.name, locale);
        }

        for skin in &mut config.skins {
            skin.name = translator.translate(&skin.name, locale);
        }

        for ability_rarity in &mut config.ability_rarities {
            ability_rarity.name = translator.translate(&ability_rarity.name, locale);
        }

        for quest in &mut config.quests {
            quest.title = translator.translate(&quest.title, locale);
            quest.description = translator.translate(&quest.description, locale);
        }

        for vassal_task in &mut config.vassal_tasks {
            vassal_task.title = translator.translate(&vassal_task.title, locale);
        }

        for currency in &mut config.currencies {
            currency.name = translator.translate(&currency.name, locale);
            currency.description = translator.translate(&currency.description, locale);
        }

        for mail_template in &mut config.mail_templates {
            mail_template.title = translator.translate(&mail_template.title, locale);
            mail_template.message = translator.translate(&mail_template.message, locale);
        }

        for league in &mut config.arena_leagues {
            league.name = translator.translate(&league.name, locale);
        }

        for fight in &mut config.fight_templates {
            fight.title = translator.translate(&fight.title, locale);
        }

        for class in &mut config.classes {
            class.name = translator.translate(&class.name, locale);
            class.description = translator.translate(&class.description, locale);
            class.weapon_type = translator.translate(&class.weapon_type, locale);
        }

        for dungeon in &mut config.dungeon_templates {
            dungeon.title = translator.translate(&dungeon.title, locale);
            dungeon.description = translator.translate(&dungeon.description, locale);

            for tip in &mut dungeon.tips {
                tip.tip = translator.translate(&tip.tip, locale);
            }
        }

        for step in &mut config.tutorial_steps {
            step.text = translator.translate(&step.text, locale);
        }

        for offer in &mut config.offers_templates {
            offer.title = translator.translate(&offer.title, locale);
            if let Some(limit_buy_text) = &offer.limit_buy_text {
                offer.limit_buy_text = Some(translator.translate(limit_buy_text, locale));
            }
        }

        for shop_tab in &mut config.shop_tabs {
            shop_tab.name = translator.translate(&shop_tab.name, locale);
        }

        for chapter in &mut config.chapters {
            chapter.title = translator.translate(&chapter.title, locale);
        }

        for pet_template in &mut config.pet_templates {
            pet_template.name = translator.translate(&pet_template.name, locale);
        }

        for pet_rarity in &mut config.pet_rarities {
            pet_rarity.name = translator.translate(&pet_rarity.name, locale);
        }

        for talent in &mut config.talents {
            talent.name = translator.translate(&talent.name, locale);
            talent.description = translator.translate(&talent.description, locale);
        }

        config.ability_presets_settings.default_preset_name =
            translator.translate(&config.ability_presets_settings.default_preset_name, locale);

        for grade in &mut config.statue_bonus_grades {
            grade.name = translator.translate(&grade.name, locale);
        }

        for buff in &mut config.buff_templates {
            buff.title = translator.translate(&buff.title, locale);
            buff.description = translator.translate(&buff.description, locale);
        }

        for skin in &mut config.skins {
            if let Some(unlock_description) = &skin.unlock_description {
                skin.unlock_description = Some(translator.translate(unlock_description, locale));
            }
        }

        config
    }

    pub fn validate(&self) {
        // TODO: Also check empty vectors, too big numbers, invalid references, 0 div
        if !Self::has_unique_ids(&self.items) {
            panic!("Not unique item ids in config");
        }

        self.validate_ability_gacha_settings();

        Self::validate_afk_rewards(
            &self.afk_rewards_levels,
            &self.afk_rewards_settings,
            &self.currencies,
            &self.abilities,
            &self.items,
            &self.bundles,
        );
        Self::validate_loop_task_chain(&self.quests);
        self.validate_pet_config();
        self.validate_pet_gacha_settings();
        self.validate_statue_settings();
        self.validate_class_levels();
        self.validate_class_abilities();
        Self::validate_progress_pass_config(&self.progress_pass);
        self.validate_progress_pass_references();
    }

    /// Per-class invariants for `Class.class_abilities`:
    ///  - disjoint from that class's `basic_abilities`;
    ///  - every referenced ability template exists and has `is_gacha_ability == false`
    ///    (class actives must never drop from the gacha pool per the design doc).
    fn validate_class_abilities(&self) {
        use std::collections::HashSet;

        for class in &self.classes {
            let basics: HashSet<_> = class.basic_abilities.iter().copied().collect();
            let mut seen = HashSet::new();
            for ability_id in &class.class_abilities {
                if !seen.insert(*ability_id) {
                    panic!(
                        "Class {}: duplicate ability_id {ability_id} in class_abilities",
                        class.id
                    );
                }
                if basics.contains(ability_id) {
                    panic!(
                        "Class {}: ability {ability_id} appears in both basic_abilities and class_abilities",
                        class.id
                    );
                }
                let Some(template) = self.abilities.iter().find(|a| a.id == *ability_id) else {
                    panic!(
                        "Class {}: class_abilities references unknown ability_id {ability_id}",
                        class.id
                    );
                };
                if template.is_gacha_ability {
                    panic!(
                        "Class {}: class_ability {ability_id} has is_gacha_ability=true; class actives must be excluded from the gacha pool",
                        class.id
                    );
                }
            }
        }
    }

    fn validate_class_levels(&self) {
        use std::collections::HashMap;

        let mut by_class: HashMap<class::ClassId, Vec<u64>> = HashMap::new();
        for row in &self.class_levels {
            by_class.entry(row.class_id).or_default().push(row.level);
        }

        for (class_id, mut levels) in by_class {
            levels.sort();
            let mut dedup = levels.clone();
            dedup.dedup();
            if dedup.len() != levels.len() {
                panic!("ClassLevels for class {class_id}: duplicate level entries");
            }
            for (i, level) in levels.iter().enumerate() {
                let expected = (i as u64) + 1;
                if *level != expected {
                    panic!(
                        "ClassLevels for class {class_id}: expected contiguous levels starting at 1, got {level} at position {expected}"
                    );
                }
            }
        }
    }

    pub fn class_level(&self, class_id: class::ClassId, level: u64) -> Option<&class::ClassLevels> {
        self.class_levels
            .iter()
            .find(|row| row.class_id == class_id && row.level == level)
    }

    fn validate_progress_pass_config(progress_pass: &essences::progress_pass::ProgressPassConfig) {
        use std::collections::HashSet;

        let mut tier_values: HashSet<u32> = HashSet::new();
        for tier in &progress_pass.tiers {
            if tier.quest_template_ids.is_empty() {
                panic!(
                    "ProgressPassConfig: tier {} has no quest_template_ids",
                    tier.tier
                );
            }
            if !tier_values.insert(tier.tier) {
                panic!("ProgressPassConfig: duplicate tier value {}", tier.tier);
            }
        }
    }

    fn validate_progress_pass_references(&self) {
        let pp = &self.progress_pass;

        if pp.tiers.is_empty() {
            return;
        }

        if !self
            .offers_templates
            .iter()
            .any(|o| o.id == pp.premium_offer_template_id)
        {
            panic!(
                "ProgressPassConfig: premium_offer_template_id {} does not match any offer template",
                pp.premium_offer_template_id
            );
        }

        for tier in &pp.tiers {
            for quest_id in &tier.quest_template_ids {
                let Some(quest) = self.quests.iter().find(|q| q.id == *quest_id) else {
                    panic!(
                        "ProgressPassConfig: tier {} references unknown quest template {quest_id}",
                        tier.tier
                    );
                };
                if quest.quest_group_type != QuestGroupType::ProgressPass {
                    panic!(
                        "ProgressPassConfig: tier {} references quest {quest_id} whose group is {:?}, expected ProgressPass",
                        tier.tier, quest.quest_group_type
                    );
                }
            }

            if !self
                .bundles
                .iter()
                .any(|b| b.id == tier.free_reward_bundle_id)
            {
                panic!(
                    "ProgressPassConfig: tier {} free_reward_bundle_id {} does not match any bundle",
                    tier.tier, tier.free_reward_bundle_id
                );
            }
            if !self
                .bundles
                .iter()
                .any(|b| b.id == tier.paid_reward_bundle_id)
            {
                panic!(
                    "ProgressPassConfig: tier {} paid_reward_bundle_id {} does not match any bundle",
                    tier.tier, tier.paid_reward_bundle_id
                );
            }
        }
    }

    fn validate_loop_task_chain(quests: &[QuestTemplate]) {
        use std::collections::{HashMap, HashSet};

        let loop_quests: Vec<&QuestTemplate> = quests
            .iter()
            .filter(|q| q.quest_group_type == QuestGroupType::LoopTask)
            .collect();

        if loop_quests.is_empty() {
            return;
        }

        let all_quest_ids: HashSet<_> = quests.iter().map(|q| q.id).collect();
        let loop_quest_ids: HashSet<_> = loop_quests.iter().map(|q| q.id).collect();

        // 1. No duplicate codes among LoopTask quests
        let mut code_to_quest: HashMap<&str, &QuestTemplate> = HashMap::new();
        for q in &loop_quests {
            if let Some(code) = &q.code
                && let Some(existing) = code_to_quest.insert(code.as_str(), q)
            {
                panic!(
                    "LoopTask: duplicate code '{}' on quests {} and {}",
                    code, existing.id, q.id
                );
            }
        }

        // 2. Every next_quest_ids reference must point to an existing quest
        for q in &loop_quests {
            for next_id in &q.next_quest_ids {
                if !all_quest_ids.contains(next_id) {
                    panic!(
                        "LoopTask: quest {} ('{}') has next_quest_id {} that does not exist",
                        q.id,
                        q.code.as_deref().unwrap_or("<no code>"),
                        next_id
                    );
                }
            }
        }

        // 3. Discover numbered sequences (loop_task.{type}.{N}) and verify each is
        //    a gapless 1..=max chain where N chains to N+1 via next_quest_ids.
        let mut sequences: HashMap<String, Vec<(u32, &QuestTemplate)>> = HashMap::new();
        for (code, quest) in &code_to_quest {
            let parts: Vec<&str> = code.split('.').collect();
            // codes look like "loop_task.{type}.{number_or_name}"
            if parts.len() == 3
                && parts[0] == "loop_task"
                && let Ok(n) = parts[2].parse::<u32>()
            {
                sequences
                    .entry(parts[1].to_string())
                    .or_default()
                    .push((n, quest));
            }
        }

        for (seq_type, mut entries) in sequences {
            entries.sort_by_key(|(n, _)| *n);

            // Must start from 1
            if entries[0].0 != 1 {
                panic!(
                    "LoopTask: sequence 'loop_task.{}' starts at {} instead of 1",
                    seq_type, entries[0].0
                );
            }

            // No gaps
            for (i, (n, _)) in entries.iter().enumerate() {
                let expected = (i as u32) + 1;
                if *n != expected {
                    panic!(
                        "LoopTask: sequence 'loop_task.{}' has gap — expected {} but found {}",
                        seq_type, expected, n
                    );
                }
            }

            // Each N must chain to N+1 via next_quest_ids (except last).
            if seq_type != "loop" {
                for window in entries.windows(2) {
                    let (n, quest) = window[0];
                    let (_, next_quest) = window[1];
                    if !quest.next_quest_ids.contains(&next_quest.id) {
                        panic!(
                            "LoopTask: 'loop_task.{}.{}' (quest {}) does not chain to 'loop_task.{}.{}' (quest {}) via next_quest_ids",
                            seq_type,
                            n,
                            quest.id,
                            seq_type,
                            n + 1,
                            next_quest.id
                        );
                    }
                }
            }
        }

        // 4. Every LoopTask quest must be reachable: either has a code (discoverable by scripts)
        //    or is in the next_quest_ids graph from any quest in the config
        let mut reachable: HashSet<essences::quest::QuestId> = HashSet::new();

        // Reachable by code
        for q in code_to_quest.values() {
            reachable.insert(q.id);
        }

        // Reachable by next_quest_ids graph (BFS from all quests that reference LoopTask quests)
        let mut stack: Vec<essences::quest::QuestId> = Vec::new();
        for q in quests {
            for next_id in &q.next_quest_ids {
                if loop_quest_ids.contains(next_id) {
                    stack.push(*next_id);
                }
            }
        }
        while let Some(id) = stack.pop() {
            if !reachable.insert(id) {
                continue;
            }
            if let Some(q) = loop_quests.iter().find(|q| q.id == id) {
                for next_id in &q.next_quest_ids {
                    if loop_quest_ids.contains(next_id) {
                        stack.push(*next_id);
                    }
                }
            }
        }

        for q in &loop_quests {
            if !reachable.contains(&q.id) {
                panic!(
                    "LoopTask: quest {} ('{}') is unreachable — no code and not in next_quest_ids chain from a starting quest",
                    q.id,
                    q.code.as_deref().unwrap_or("<no code>")
                );
            }
        }
    }

    fn validate_afk_rewards(
        afk_levels: &[AfkRewardsByLevel],
        afk_settings: &AfkRewardsSettings,
        currencies: &[Currency],
        abilities: &[AbilityTemplate],
        items: &[ItemTemplate],
        bundles: &[BundleRaw],
    ) {
        use std::collections::HashSet;

        let currency_ids: HashSet<_> = currencies.iter().map(|c| c.id).collect();
        let ability_ids: HashSet<_> = abilities.iter().map(|a| a.id).collect();
        let item_ids: HashSet<_> = items.iter().map(|i| i.id).collect();
        let bundle_ids: HashSet<_> = bundles.iter().map(|b| b.id).collect();

        // bonus_calculation_rate_sec > 0 is enforced by NonZeroU64 type

        if !bundle_ids.contains(&afk_settings.bundle_id) {
            panic!(
                "AfkRewardsSettings: bundle_id {} not found in bundles",
                afk_settings.bundle_id
            );
        }

        let chapter_levels: Vec<_> = afk_levels.iter().map(|r| r.chapter_level).collect();
        let unique_levels: HashSet<_> = chapter_levels.iter().collect();
        if chapter_levels.len() != unique_levels.len() {
            panic!("AfkRewardsByLevel: Two or more afk reward levels have equal chapter_level");
        }

        for level_rewards in afk_levels {
            for rate in &level_rewards.currency_rates {
                if !currency_ids.contains(&rate.currency_id) {
                    panic!(
                        "AfkRewardsByLevel chapter_level={}: currency_id {} not found in currencies",
                        level_rewards.chapter_level, rate.currency_id
                    );
                }
                // rate_per_minute > 0 is enforced by PositiveF64 type
            }

            // bonus_weights non-empty is enforced by NonEmptyVec type
            // bonus_weight.weight > 0 is enforced by PositiveF64 type
            // bonus_weight.count > 0 is enforced by PositiveI64 type

            for bonus_weight in &level_rewards.bonus_weights {
                match &bonus_weight.bonus_type {
                    AfkRewardBonusType::Currency(currency_id) => {
                        if !currency_ids.contains(currency_id) {
                            panic!(
                                "AfkRewardsByLevel chapter_level={}: bonus Currency id {} not found",
                                level_rewards.chapter_level, currency_id
                            );
                        }
                    }
                    AfkRewardBonusType::Ability(ability_id) => {
                        if !ability_ids.contains(ability_id) {
                            panic!(
                                "AfkRewardsByLevel chapter_level={}: bonus Ability id {} not found",
                                level_rewards.chapter_level, ability_id
                            );
                        }
                    }
                    AfkRewardBonusType::Item(item_id) => {
                        if !item_ids.contains(item_id) {
                            panic!(
                                "AfkRewardsByLevel chapter_level={}: bonus Item id {} not found",
                                level_rewards.chapter_level, item_id
                            );
                        }
                    }
                }
            }
        }
    }

    fn validate_ability_gacha_settings(&self) {
        use std::collections::HashSet;

        let gacha = &self.game_settings.ability_gacha;
        let currency_ids: HashSet<_> = self.currencies.iter().map(|currency| currency.id).collect();
        let rarity_ids: HashSet<_> = self
            .ability_rarities
            .iter()
            .map(|rarity| rarity.id)
            .collect();
        let class_rarity_ids: HashSet<_> = self
            .classes
            .iter()
            .map(|class| class.ability_rarity_id)
            .collect();

        // small_roll_cost > 0, big_roll_cost > 0, slot_max_level > 0 enforced by PositiveI64
        // wishlist_weight_multiplier >= 1.0 enforced by WeightMultiplier type
        // wishlist_slots > 0 still needs runtime check (u8, not wrapped)
        if gacha.wishlist_slots == 0 {
            panic!("AbilityGachaSettings: wishlist_slots must be > 0");
        }
        if gacha.slot_level_costs.len() != gacha.slot_max_level.get() as usize {
            panic!(
                "AbilityGachaSettings: slot_level_costs length ({}) must match slot_max_level ({})",
                gacha.slot_level_costs.len(),
                gacha.slot_max_level.get()
            );
        }
        if gacha.slot_level_bonus_levels.len() != gacha.slot_max_level.get() as usize + 1 {
            panic!(
                "AbilityGachaSettings: slot_level_bonus_levels length ({}) must be slot_max_level + 1 ({})",
                gacha.slot_level_bonus_levels.len(),
                gacha.slot_max_level.get() + 1
            );
        }
        // slot_level_costs values > 0 enforced by PositiveI64 type
        for bonus in &gacha.slot_level_bonus_levels {
            if *bonus < 0 {
                panic!("AbilityGachaSettings: slot_level_bonus_levels values must be >= 0");
            }
        }
        if !currency_ids.contains(&gacha.slot_upgrade_currency_id) {
            panic!(
                "AbilityGachaSettings: slot_upgrade_currency_id {} not found in currencies",
                gacha.slot_upgrade_currency_id
            );
        }

        // ability_cases_settings non-empty is enforced by NonEmptyVec type

        let mut settings_by_level = self.ability_cases_settings.to_vec();
        settings_by_level.sort_by_key(|level_settings| level_settings.level);

        // Validate boundary levels: at most one, must be the last level.
        let boundary_count = settings_by_level
            .iter()
            .filter(|s| s.is_boundary_level)
            .count();
        if boundary_count > 1 {
            panic!("AbilityCasesSettings: at most one boundary level is allowed");
        }
        if boundary_count == 1 && !settings_by_level.last().unwrap().is_boundary_level {
            panic!("AbilityCasesSettings: the boundary level must be the last level");
        }

        let mut previous_level = 0;
        let mut previous_opens = -1;
        for (idx, level_settings) in settings_by_level.iter().enumerate() {
            if level_settings.level <= previous_level {
                panic!("AbilityCasesSettings: levels must be unique and strictly increasing");
            }
            if level_settings.opens_to_upgrade < 0 {
                panic!(
                    "AbilityCasesSettings level {}: opens_to_upgrade must be >= 0",
                    level_settings.level
                );
            }
            if level_settings.opens_to_upgrade < previous_opens {
                panic!(
                    "AbilityCasesSettings level {}: opens_to_upgrade must be non-decreasing",
                    level_settings.level
                );
            }
            previous_level = level_settings.level;
            previous_opens = level_settings.opens_to_upgrade;

            // Boundary levels only need level + opens_to_upgrade; skip all other validations.
            if level_settings.is_boundary_level {
                continue;
            }

            let mut previous_checkpoint_opens = -1;
            for checkpoint in &level_settings.checkpoints {
                if checkpoint.required_opens <= 0 {
                    panic!(
                        "AbilityCasesSettings level {}: checkpoint required_opens must be > 0",
                        level_settings.level
                    );
                }
                if checkpoint.required_opens <= previous_checkpoint_opens {
                    panic!(
                        "AbilityCasesSettings level {}: checkpoint required_opens must be strictly increasing",
                        level_settings.level
                    );
                }
                previous_checkpoint_opens = checkpoint.required_opens;

                // Checkpoint required_opens is relative to the current level's
                // opens_to_upgrade. It must not exceed the range of this level
                // (i.e. the gap to the next level's opens_to_upgrade).
                if let Some(next) = settings_by_level.get(idx + 1) {
                    let level_range = next.opens_to_upgrade - level_settings.opens_to_upgrade;
                    if checkpoint.required_opens > level_range {
                        panic!(
                            "AbilityCasesSettings level {}: checkpoint required_opens ({}) exceeds level range ({})",
                            level_settings.level, checkpoint.required_opens, level_range
                        );
                    }
                }

                for currency_reward in &checkpoint.currency_rewards {
                    if currency_reward.amount <= 0 {
                        panic!(
                            "AbilityCasesSettings level {}: checkpoint currency reward must be > 0",
                            level_settings.level
                        );
                    }
                    if !currency_ids.contains(&currency_reward.currency_id) {
                        panic!(
                            "AbilityCasesSettings level {}: checkpoint currency {} not found",
                            level_settings.level, currency_reward.currency_id
                        );
                    }
                }

                for ability_reward in &checkpoint.ability_rewards {
                    if ability_reward.amount < 0 {
                        panic!(
                            "AbilityCasesSettings level {}: checkpoint ability reward amount must be >= 0",
                            level_settings.level
                        );
                    }
                    if ability_reward.amount > 0
                        && !rarity_ids.contains(&ability_reward.min_rarity_id)
                    {
                        panic!(
                            "AbilityCasesSettings level {}: checkpoint ability reward min_rarity_id {} not found",
                            level_settings.level, ability_reward.min_rarity_id
                        );
                    }
                }
            }

            for rarity_id in &level_settings.allowed_wishlist_rarity_ids {
                if !rarity_ids.contains(rarity_id) {
                    panic!(
                        "AbilityCasesSettings level {}: allowed wishlist rarity {} not found",
                        level_settings.level, rarity_id
                    );
                }
                if class_rarity_ids.contains(rarity_id) {
                    panic!(
                        "AbilityCasesSettings level {}: class rarity {} cannot be in wishlist",
                        level_settings.level, rarity_id
                    );
                }
            }

            for evolve_rule in &level_settings.evolve_rules {
                if evolve_rule.small_roll_tries < 0 {
                    panic!(
                        "AbilityCasesSettings level {}: evolve small_roll_tries must be >= 0",
                        level_settings.level
                    );
                }
                if evolve_rule.big_roll_tries < 0 {
                    panic!(
                        "AbilityCasesSettings level {}: evolve big_roll_tries must be >= 0",
                        level_settings.level
                    );
                }
                if evolve_rule.small_roll_tries == 0 && evolve_rule.big_roll_tries == 0 {
                    panic!(
                        "AbilityCasesSettings level {}: evolve rule must have at least one non-zero tries",
                        level_settings.level
                    );
                }
                if !rarity_ids.contains(&evolve_rule.from_rarity_id) {
                    panic!(
                        "AbilityCasesSettings level {}: evolve from rarity {} not found",
                        level_settings.level, evolve_rule.from_rarity_id
                    );
                }
                // rarity_weight.weight > 0 enforced by PositiveF64 type
                let mut sum_weight = 0.0;
                for rarity_weight in &evolve_rule.to_rarity_weights {
                    if !rarity_ids.contains(&rarity_weight.rarity_id) {
                        panic!(
                            "AbilityCasesSettings level {}: evolve to rarity {} not found",
                            level_settings.level, rarity_weight.rarity_id
                        );
                    }
                    sum_weight += rarity_weight.weight.get();
                }
                if sum_weight > 1.0 + f64::EPSILON {
                    panic!(
                        "AbilityCasesSettings level {}: evolve to_rarity_weights sum must be <= 1.0, got {}",
                        level_settings.level, sum_weight
                    );
                }
            }

            for currency_reward in &level_settings.big_roll_currency_rewards {
                if currency_reward.amount <= 0 {
                    panic!(
                        "AbilityCasesSettings level {}: big-roll currency reward amount must be > 0",
                        level_settings.level
                    );
                }
                if !currency_ids.contains(&currency_reward.currency_id) {
                    panic!(
                        "AbilityCasesSettings level {}: big-roll currency {} not found",
                        level_settings.level, currency_reward.currency_id
                    );
                }
            }

            let big_roll_shards = &level_settings.big_roll_shards;
            let shards_total: u64 = big_roll_shards.iter().map(|s| s.count as u64).sum();
            let expected_total =
                gacha.big_roll_cost.get() as u64 + gacha.big_roll_bonus_drops as u64;
            if shards_total != expected_total {
                panic!(
                    "AbilityCasesSettings level {}: big_roll_shards total ({}) must equal big_roll_cost + bonus_drops ({})",
                    level_settings.level, shards_total, expected_total
                );
            }
            for shard in big_roll_shards {
                if shard.count == 0 {
                    panic!(
                        "AbilityCasesSettings level {}: big_roll_shards count must be > 0",
                        level_settings.level
                    );
                }
                if !rarity_ids.contains(&shard.min_rarity_id) {
                    panic!(
                        "AbilityCasesSettings level {}: big_roll_shards rarity {} not found",
                        level_settings.level, shard.min_rarity_id
                    );
                }
            }
        }

        if settings_by_level[0].level != 1 || settings_by_level[0].opens_to_upgrade != 0 {
            panic!("AbilityCasesSettings: level 1 with opens_to_upgrade = 0 is required");
        }
    }

    fn validate_pet_config(&self) {
        use std::collections::HashSet;

        let pet_template_ids: HashSet<_> = self.pet_templates.iter().map(|t| t.id).collect();
        if pet_template_ids.len() != self.pet_templates.len() {
            panic!("PetConfig: duplicate pet template ids");
        }

        let pet_rarity_ids: HashSet<_> = self.pet_rarities.iter().map(|r| r.id).collect();
        if pet_rarity_ids.len() != self.pet_rarities.len() {
            panic!("PetConfig: duplicate pet rarity ids");
        }

        let ability_ids: HashSet<_> = self.abilities.iter().map(|a| a.id).collect();
        let attribute_ids: HashSet<_> = self.attributes.iter().map(|a| a.id).collect();

        for template in &self.pet_templates {
            if let Some(ability_id) = template.active_ability_id
                && !ability_ids.contains(&ability_id)
            {
                panic!(
                    "PetConfig: pet template {} has active_ability_id {} not found in abilities",
                    template.id, ability_id
                );
            }
            if let Some(ability_id) = template.passive_ability_id
                && !ability_ids.contains(&ability_id)
            {
                panic!(
                    "PetConfig: pet template {} has passive_ability_id {} not found in abilities",
                    template.id, ability_id
                );
            }
            if !pet_rarity_ids.contains(&template.rarity_id) {
                panic!(
                    "PetConfig: pet template {} has rarity_id {} not found in pet_rarities",
                    template.id, template.rarity_id
                );
            }
            for stat in &template.stats {
                if !attribute_ids.contains(&stat.attribute_id) {
                    panic!(
                        "PetConfig: pet template {} has stat attribute_id {} not found in attributes",
                        template.id, stat.attribute_id
                    );
                }
            }
        }

        for pet_level in &self.pet_levels {
            if !pet_rarity_ids.contains(&pet_level.rarity_id) {
                panic!(
                    "PetConfig: pet level {} has rarity_id {} not found in pet_rarities",
                    pet_level.level, pet_level.rarity_id
                );
            }
            if pet_level.required_shards < 0 {
                panic!(
                    "PetConfig: pet level {} (rarity {}) required_shards must be >= 0",
                    pet_level.level, pet_level.rarity_id
                );
            }
        }
    }

    /// Mirror of `validate_ability_gacha_settings` for the pet gacha:
    /// same level/checkpoint/big-roll invariants on `pet_cases_settings`,
    /// minus the ability-only parts (slot upgrades, evolve rules, class rarities).
    fn validate_pet_gacha_settings(&self) {
        use std::collections::HashSet;

        let gacha = &self.game_settings.pet_gacha;
        let currency_ids: HashSet<_> = self.currencies.iter().map(|currency| currency.id).collect();
        let rarity_ids: HashSet<_> = self.pet_rarities.iter().map(|rarity| rarity.id).collect();

        // roll_price_in_diamonds > 0, small_roll_cost > 0, big_roll_cost > 0 enforced by PositiveI64
        // wishlist_weight_multiplier >= 1.0 enforced by WeightMultiplier type
        // wishlist_slots > 0 still needs runtime check (u8, not wrapped)
        if gacha.wishlist_slots == 0 {
            panic!("PetGachaSettings: wishlist_slots must be > 0");
        }
        if !currency_ids.contains(&gacha.currency_id) {
            panic!(
                "PetGachaSettings: currency_id {} not found in currencies",
                gacha.currency_id
            );
        }

        if self.pet_cases_settings.is_empty() {
            panic!("PetCasesSettings: must not be empty");
        }

        let mut settings_by_level = self.pet_cases_settings.clone();
        settings_by_level.sort_by_key(|level_settings| level_settings.level);

        // Validate boundary levels: at most one, must be the last level.
        let boundary_count = settings_by_level
            .iter()
            .filter(|s| s.is_boundary_level)
            .count();
        if boundary_count > 1 {
            panic!("PetCasesSettings: at most one boundary level is allowed");
        }
        if boundary_count == 1 && !settings_by_level.last().unwrap().is_boundary_level {
            panic!("PetCasesSettings: the boundary level must be the last level");
        }

        let mut previous_level = 0;
        let mut previous_opens = -1;
        for (idx, level_settings) in settings_by_level.iter().enumerate() {
            if level_settings.level <= previous_level {
                panic!("PetCasesSettings: levels must be unique and strictly increasing");
            }
            if level_settings.opens_to_upgrade < 0 {
                panic!(
                    "PetCasesSettings level {}: opens_to_upgrade must be >= 0",
                    level_settings.level
                );
            }
            if level_settings.opens_to_upgrade < previous_opens {
                panic!(
                    "PetCasesSettings level {}: opens_to_upgrade must be non-decreasing",
                    level_settings.level
                );
            }
            previous_level = level_settings.level;
            previous_opens = level_settings.opens_to_upgrade;

            // Boundary levels only need level + opens_to_upgrade; skip all other validations.
            if level_settings.is_boundary_level {
                continue;
            }

            // The drop pool: every roll on this level draws a rarity from these weights.
            if level_settings.rarity_weights.is_empty() {
                panic!(
                    "PetCasesSettings level {}: rarity_weights must not be empty",
                    level_settings.level
                );
            }
            // rarity_weight.weight > 0 enforced by PositiveF64 type
            for rarity_weight in &level_settings.rarity_weights {
                if !rarity_ids.contains(&rarity_weight.rarity_id) {
                    panic!(
                        "PetCasesSettings level {}: rarity weight rarity {} not found",
                        level_settings.level, rarity_weight.rarity_id
                    );
                }
            }

            let mut previous_checkpoint_opens = -1;
            for checkpoint in &level_settings.checkpoints {
                if checkpoint.required_opens <= 0 {
                    panic!(
                        "PetCasesSettings level {}: checkpoint required_opens must be > 0",
                        level_settings.level
                    );
                }
                if checkpoint.required_opens <= previous_checkpoint_opens {
                    panic!(
                        "PetCasesSettings level {}: checkpoint required_opens must be strictly increasing",
                        level_settings.level
                    );
                }
                previous_checkpoint_opens = checkpoint.required_opens;

                // Checkpoint required_opens is relative to the current level's
                // opens_to_upgrade. It must not exceed the range of this level
                // (i.e. the gap to the next level's opens_to_upgrade).
                if let Some(next) = settings_by_level.get(idx + 1) {
                    let level_range = next.opens_to_upgrade - level_settings.opens_to_upgrade;
                    if checkpoint.required_opens > level_range {
                        panic!(
                            "PetCasesSettings level {}: checkpoint required_opens ({}) exceeds level range ({})",
                            level_settings.level, checkpoint.required_opens, level_range
                        );
                    }
                }

                for currency_reward in &checkpoint.currency_rewards {
                    if currency_reward.amount <= 0 {
                        panic!(
                            "PetCasesSettings level {}: checkpoint currency reward must be > 0",
                            level_settings.level
                        );
                    }
                    if !currency_ids.contains(&currency_reward.currency_id) {
                        panic!(
                            "PetCasesSettings level {}: checkpoint currency {} not found",
                            level_settings.level, currency_reward.currency_id
                        );
                    }
                }

                for pet_reward in &checkpoint.pet_rewards {
                    if pet_reward.amount < 0 {
                        panic!(
                            "PetCasesSettings level {}: checkpoint pet reward amount must be >= 0",
                            level_settings.level
                        );
                    }
                    if pet_reward.amount > 0 && !rarity_ids.contains(&pet_reward.min_rarity_id) {
                        panic!(
                            "PetCasesSettings level {}: checkpoint pet reward min_rarity_id {} not found",
                            level_settings.level, pet_reward.min_rarity_id
                        );
                    }
                }
            }

            for rarity_id in &level_settings.allowed_wishlist_rarity_ids {
                if !rarity_ids.contains(rarity_id) {
                    panic!(
                        "PetCasesSettings level {}: allowed wishlist rarity {} not found",
                        level_settings.level, rarity_id
                    );
                }
            }

            for currency_reward in &level_settings.big_roll_currency_rewards {
                if currency_reward.amount <= 0 {
                    panic!(
                        "PetCasesSettings level {}: big-roll currency reward amount must be > 0",
                        level_settings.level
                    );
                }
                if !currency_ids.contains(&currency_reward.currency_id) {
                    panic!(
                        "PetCasesSettings level {}: big-roll currency {} not found",
                        level_settings.level, currency_reward.currency_id
                    );
                }
            }

            let big_roll_shards = &level_settings.big_roll_shards;
            let shards_total: u64 = big_roll_shards.iter().map(|s| s.count as u64).sum();
            let expected_total =
                gacha.big_roll_cost.get() as u64 + gacha.big_roll_bonus_drops as u64;
            if shards_total > expected_total {
                panic!(
                    "PetCasesSettings level {}: big_roll_shards total ({}) must not exceed big_roll_cost + bonus_drops ({})",
                    level_settings.level, shards_total, expected_total
                );
            }
            if shards_total != expected_total {
                // The ability gacha enforces strict equality here. Current live
                // pet content ships shard totals below big_roll_cost + bonus_drops,
                // so a hard panic would fail config load on the existing config.
                // Warn until the content is fixed, then promote this to a panic.
                tracing::warn!(
                    "PetCasesSettings level {}: big_roll_shards total ({}) does not match big_roll_cost + bonus_drops ({})",
                    level_settings.level,
                    shards_total,
                    expected_total
                );
            }
            for shard in big_roll_shards {
                if shard.count == 0 {
                    panic!(
                        "PetCasesSettings level {}: big_roll_shards count must be > 0",
                        level_settings.level
                    );
                }
                if !rarity_ids.contains(&shard.min_rarity_id) {
                    panic!(
                        "PetCasesSettings level {}: big_roll_shards rarity {} not found",
                        level_settings.level, shard.min_rarity_id
                    );
                }
            }
        }

        if settings_by_level[0].level != 1 || settings_by_level[0].opens_to_upgrade != 0 {
            panic!("PetCasesSettings: level 1 with opens_to_upgrade = 0 is required");
        }
    }

    fn validate_statue_settings(&self) {
        use std::collections::HashSet;

        let statue = &self.statue_settings;
        let currency_ids: HashSet<_> = self.currencies.iter().map(|c| c.id).collect();
        let attribute_ids: HashSet<_> = self.attributes.iter().map(|a| a.id).collect();

        if !currency_ids.contains(&statue.currency_id) {
            panic!(
                "StatueSettings: currency_id {} not found in currencies",
                statue.currency_id
            );
        }

        // statue_bonus_grades non-empty enforced by NonEmptyVec type

        let grade_ids: HashSet<_> = self.statue_bonus_grades.iter().map(|g| g.id).collect();
        if grade_ids.len() != self.statue_bonus_grades.len() {
            panic!("statue_bonus_grades: duplicate grade ids");
        }

        // roll_costs non-empty enforced by NonEmptyVec type
        // roll_costs cost > 0 enforced by PositiveI64 type

        // statue_bonus_type_configs non-empty enforced by NonEmptyVec type
        for bonus_type in &self.statue_bonus_type_configs {
            if !attribute_ids.contains(&bonus_type.attribute_id) {
                panic!(
                    "statue_bonus_type_configs attribute_id {} not found in attributes",
                    bonus_type.attribute_id
                );
            }
            // grade_values non-empty enforced by NonEmptyVec type
            for grade_value in &bonus_type.grade_values {
                if !grade_ids.contains(&grade_value.grade_id) {
                    panic!(
                        "statue_bonus_type_configs attribute {} references unknown grade_id {}",
                        bonus_type.attribute_id, grade_value.grade_id
                    );
                }
                // grade_value.value > 0 enforced by PositiveI32 type
            }
        }

        // statue_level_configs non-empty enforced by NonEmptyVec type
        if self.statue_level_configs[0].level != 1
            || self.statue_level_configs[0].required_experience != 0
        {
            panic!("statue_level_configs must start with level=1 and required_experience=0");
        }
        let mut prev_level = 0;
        let mut prev_exp = -1;
        for level_config in &self.statue_level_configs {
            if level_config.level <= prev_level {
                panic!("statue_level_configs levels must be strictly increasing");
            }
            if level_config.required_experience <= prev_exp && level_config.level > 1 {
                panic!(
                    "statue_level_configs level={} required_experience must be strictly increasing",
                    level_config.level
                );
            }
            // slot_count > 0 enforced by NonZeroU64 type
            // sets_count > 0 enforced by NonZeroU64 type
            // grade_weights non-empty enforced by NonEmptyVec type
            for weight in &level_config.grade_weights {
                if !grade_ids.contains(&weight.grade_id) {
                    panic!(
                        "statue_level_configs level={} grade_weights references unknown grade_id {}",
                        level_config.level, weight.grade_id
                    );
                }
                // weight > 0 enforced by PositiveF64 type
            }
            prev_level = level_config.level;
            prev_exp = level_config.required_experience;
        }
    }

    fn has_unique_ids(items: &[ItemTemplate]) -> bool {
        let mut ids = std::collections::HashSet::new();
        items.iter().all(|item| ids.insert(item.id))
    }
}

#[derive(Debug, Clone, Copy)]
pub struct NextFightInfo {
    pub next_chapter_level: i64,
    pub next_fight_number: i64,
    pub next_fight_id: Option<essences::fighting::FightTemplateId>,
}

#[derive(Debug, Clone, Serialize, Deserialize, JsonSchema, Tsify)]
#[tsify(into_wasm_abi, from_wasm_abi)]
pub enum GetConfigResponse {
    Ok { config: Box<GameConfig> },
    Error { code: String, message: String },
}

#[cfg(test)]
mod tests {
    use super::*;
    use essences::offers::OfferTemplateId;
    use essences::progress_pass::{ProgressPassConfig, ProgressPassTierTemplate};
    use uuid::uuid;

    fn tier(tier: u32, quest_template_ids: Vec<uuid::Uuid>) -> ProgressPassTierTemplate {
        ProgressPassTierTemplate {
            tier,
            quest_template_ids,
            free_reward_bundle_id: uuid::Uuid::nil(),
            paid_reward_bundle_id: uuid::Uuid::nil(),
        }
    }

    fn pp_config(tiers: Vec<ProgressPassTierTemplate>) -> ProgressPassConfig {
        ProgressPassConfig {
            tiers,
            premium_offer_template_id: OfferTemplateId::nil(),
        }
    }

    #[test]
    fn validate_progress_pass_accepts_valid_config() {
        let config = pp_config(vec![
            tier(1, vec![uuid!("aa000000-0000-0000-0000-000000000001")]),
            tier(
                2,
                vec![
                    uuid!("aa000000-0000-0000-0000-000000000001"),
                    uuid!("bb000000-0000-0000-0000-000000000002"),
                ],
            ),
            tier(3, vec![uuid!("cc000000-0000-0000-0000-000000000003")]),
        ]);
        GameConfig::validate_progress_pass_config(&config);
    }

    #[test]
    fn validate_progress_pass_accepts_empty_tiers() {
        let config = pp_config(vec![]);
        GameConfig::validate_progress_pass_config(&config);
    }

    #[test]
    #[should_panic(expected = "ProgressPassConfig: tier 2 has no quest_template_ids")]
    fn validate_progress_pass_rejects_empty_quest_template_ids() {
        let config = pp_config(vec![
            tier(1, vec![uuid!("aa000000-0000-0000-0000-000000000001")]),
            tier(2, vec![]),
        ]);
        GameConfig::validate_progress_pass_config(&config);
    }

    #[test]
    #[should_panic(expected = "ProgressPassConfig: duplicate tier value 1")]
    fn validate_progress_pass_rejects_duplicate_tier_numbers() {
        let config = pp_config(vec![
            tier(1, vec![uuid!("aa000000-0000-0000-0000-000000000001")]),
            tier(1, vec![uuid!("bb000000-0000-0000-0000-000000000002")]),
        ]);
        GameConfig::validate_progress_pass_config(&config);
    }

    #[test]
    fn validate_pet_gacha_settings_accepts_test_config() {
        let config = crate::tests_game_config::generate_game_config_for_tests();
        config.validate_pet_gacha_settings();
    }

    #[test]
    #[should_panic(expected = "PetCasesSettings: must not be empty")]
    fn validate_pet_gacha_settings_rejects_empty_cases_settings() {
        let mut config = crate::tests_game_config::generate_game_config_for_tests();
        config.pet_cases_settings.clear();
        config.validate_pet_gacha_settings();
    }

    #[test]
    #[should_panic(expected = "PetCasesSettings: level 1 with opens_to_upgrade = 0 is required")]
    fn validate_pet_gacha_settings_rejects_missing_level_one() {
        let mut config = crate::tests_game_config::generate_game_config_for_tests();
        config.pet_cases_settings.remove(0);
        config.validate_pet_gacha_settings();
    }

    #[test]
    #[should_panic(expected = "rarity weight rarity")]
    fn validate_pet_gacha_settings_rejects_unknown_rarity_in_weights() {
        let mut config = crate::tests_game_config::generate_game_config_for_tests();
        config.pet_cases_settings[0].rarity_weights[0].rarity_id =
            uuid!("ffffffff-ffff-ffff-ffff-ffffffffffff");
        config.validate_pet_gacha_settings();
    }

    #[test]
    #[should_panic(expected = "rarity_weights must not be empty")]
    fn validate_pet_gacha_settings_rejects_empty_rarity_weights() {
        let mut config = crate::tests_game_config::generate_game_config_for_tests();
        config.pet_cases_settings[0].rarity_weights.clear();
        config.validate_pet_gacha_settings();
    }

    #[test]
    #[should_panic(expected = "must not exceed big_roll_cost + bonus_drops")]
    fn validate_pet_gacha_settings_rejects_shard_total_above_big_roll_drops() {
        let mut config = crate::tests_game_config::generate_game_config_for_tests();
        config.pet_cases_settings[0].big_roll_shards[0].count = 200;
        config.validate_pet_gacha_settings();
    }

    #[test]
    #[should_panic(expected = "big_roll_shards rarity")]
    fn validate_pet_gacha_settings_rejects_unknown_shard_rarity() {
        let mut config = crate::tests_game_config::generate_game_config_for_tests();
        config.pet_cases_settings[0].big_roll_shards[0].min_rarity_id =
            uuid!("ffffffff-ffff-ffff-ffff-ffffffffffff");
        config.validate_pet_gacha_settings();
    }

    #[test]
    #[should_panic(expected = "checkpoint required_opens must be strictly increasing")]
    fn validate_pet_gacha_settings_rejects_non_increasing_checkpoints() {
        let mut config = crate::tests_game_config::generate_game_config_for_tests();
        let checkpoint = config.pet_cases_settings[0].checkpoints[0].clone();
        config.pet_cases_settings[0].checkpoints.push(checkpoint);
        config.validate_pet_gacha_settings();
    }

    #[test]
    #[should_panic(expected = "PetGachaSettings: wishlist_slots must be > 0")]
    fn validate_pet_gacha_settings_rejects_zero_wishlist_slots() {
        let mut config = crate::tests_game_config::generate_game_config_for_tests();
        config.game_settings.pet_gacha.wishlist_slots = 0;
        config.validate_pet_gacha_settings();
    }

    #[test]
    #[should_panic(expected = "not found in pet_rarities")]
    fn validate_pet_config_rejects_unknown_pet_level_rarity() {
        let mut config = crate::tests_game_config::generate_game_config_for_tests();
        config.pet_levels[0].rarity_id = uuid!("ffffffff-ffff-ffff-ffff-ffffffffffff");
        config.validate_pet_config();
    }
}