essences/

autochest.rs

use crate::gatings::AutoChestGatings;
use crate::prelude::*;

use crate::items::Attribute;
use crate::items::AttributeId;
use crate::items::Item;
use crate::items::ItemRarity;
use crate::items::ItemRarityId;

#[derive(Clone, Debug, Serialize, Deserialize, PartialEq, Eq, JsonSchema, Tsify)]
pub struct AutoChest {
    pub active_filter: Option<AutoChestFilter>,
    pub filters: Vec<AutoChestFilter>,
    pub power_compare_enabled: bool,
    pub batch_size: i64,
}

impl Default for AutoChest {
    fn default() -> Self {
        Self {
            active_filter: None,
            filters: Vec::new(),
            power_compare_enabled: true,
            batch_size: 0,
        }
    }
}

#[declare]
pub type AutoChestFilterId = Uuid;

#[derive(Clone, Default, Debug, Serialize, Deserialize, PartialEq, Eq, JsonSchema, Tsify)]
pub struct AutoChestFilter {
    pub id: AutoChestFilterId,
    pub name: String,
    pub rarity_id: Option<ItemRarityId>,
    pub guaranteed_attribute_enabled: bool,
    pub guaranteed_attribute_id: Option<AttributeId>,
    pub additional_attribute_enabled: bool,
    pub additional_attribute_ids: Vec<AttributeId>,
}

impl AutoChestFilter {
    pub fn validate(
        &self,
        cur_chapter_level: i64,
        character_level: i64,
        attributes: &[Attribute],
        autochest_gatings: &AutoChestGatings,
    ) -> anyhow::Result<()> {
        // Auto-chest unlock gates on CHARACTER LEVEL (rewards manual chest-opening
        // → faster leveling → earlier auto-open). The filter sub-capabilities
        // (rarity / guaranteed-stat) below stay chapter-gated — they have their
        // own thresholds.
        if character_level < autochest_gatings.autochest_button_unlock_character_level {
            anyhow::bail!(
                "Auto chest is not enabled at character_level = {}",
                character_level
            )
        }

        if self.rarity_id.is_some() && cur_chapter_level < autochest_gatings.rarity_filter_unlock {
            anyhow::bail!(
                "Rarity filter is not available on cur_chapter_level = {}",
                cur_chapter_level
            )
        }

        if let Some(guaranteed_attribute_id) = self.guaranteed_attribute_id {
            if cur_chapter_level < autochest_gatings.guaranteed_stat_unlock {
                anyhow::bail!(
                    "Guaranteed stat filter is not available on cur_chapter_level = {}",
                    cur_chapter_level
                )
            }

            let Some(guaranteed_attr) = attributes
                .iter()
                .find(|attr| attr.id == guaranteed_attribute_id)
            else {
                anyhow::bail!(
                    "Tried finding guaranteed_attribute with id = {}, but didn't find it in config",
                    guaranteed_attribute_id
                )
            };

            if !guaranteed_attr.is_ui_visible {
                anyhow::bail!(
                    "Provided guaranteed attribute = {:?}, shouldn't be in auto chest",
                    guaranteed_attr
                )
            }
        }

        if !self.additional_attribute_ids.is_empty() {
            if self.additional_attribute_ids.len() > 3 {
                anyhow::bail!(
                    "More additional attributes provided: {}, than allowed: 3",
                    self.additional_attribute_ids.len(),
                )
            }

            let required_chapter = match self.additional_attribute_ids.len() {
                1 => autochest_gatings.first_additional_stat_unlock,
                2 => autochest_gatings.second_additional_stat_unlock,
                3 => autochest_gatings.third_additional_stat_unlock,
                _ => unreachable!(),
            };

            if cur_chapter_level < required_chapter {
                anyhow::bail!(
                    "Additional stats filter with {} attribute(s) is not available on cur_chapter_level = {}",
                    self.additional_attribute_ids.len(),
                    cur_chapter_level
                )
            }

            for additional_attr_id in &self.additional_attribute_ids {
                let Some(additional_attr) = attributes
                    .iter()
                    .find(|attr| attr.id == *additional_attr_id)
                else {
                    anyhow::bail!(
                        "Tried finding additional_attribute with id = {}, but didn't find it in config",
                        additional_attr_id
                    )
                };

                if !additional_attr.is_ui_visible {
                    anyhow::bail!(
                        "Provided additional attribute = {:?}, shouldn't be in auto chest",
                        additional_attr
                    )
                }
            }
        }

        Ok(())
    }
}

/// Split a batch of freshly dropped items into (sell, equip).
///
/// `item_powers` and `equipped_item_powers` must both be "character power with
/// that item equipped" — see `OverlordState::auto_chest_power_maps`, which is
/// the only supported way to build them. Mixing the marginal `item_power`
/// category into either map silently re-introduces a ranking that disagrees
/// with the client's own compare.
pub fn filter_items(
    items: &[Item],
    filter: &Option<AutoChestFilter>,
    power_compare_enabled: bool,
    item_rarities: &Vec<ItemRarity>,
    item_powers: &std::collections::HashMap<uuid::Uuid, i64>,
    equipped_item_powers: &std::collections::HashMap<crate::items::EquipmentSlotKey, i64>,
) -> anyhow::Result<(Vec<Item>, Vec<Item>)> {
    let mut items_to_sell = vec![];
    let mut items_to_equip = vec![];

    let filter_rarity = if let Some(filter) = filter
        && let Some(rarity_id) = filter.rarity_id
    {
        let Some(rarity) = item_rarities.iter().find(|r| r.id == rarity_id) else {
            anyhow::bail!(
                "Couldn't find filter rarity_id = {}, in provided item_rarities = {:?}",
                rarity_id,
                item_rarities
            );
        };
        Some(rarity)
    } else {
        None
    };

    for item in items {
        if let Some(filter_rarity) = filter_rarity
            && item.rarity.order < filter_rarity.order
        {
            items_to_sell.push(item.clone());
            continue;
        }

        if let Some(filter) = filter {
            if filter.guaranteed_attribute_enabled
                && let Some(guaranteed_attribute_id) = filter.guaranteed_attribute_id
                && !item
                    .attributes
                    .iter()
                    .any(|item_attr| item_attr.attr_id == guaranteed_attribute_id)
            {
                items_to_sell.push(item.clone());
                continue;
            }

            if filter.additional_attribute_enabled
                && !filter.additional_attribute_ids.is_empty()
                && !filter.additional_attribute_ids.iter().any(|id| {
                    item.attributes
                        .iter()
                        .any(|item_attr| *id == item_attr.attr_id)
                })
            {
                items_to_sell.push(item.clone());
                continue;
            }
        }

        // Compare power against the equipped item in the same logical slot.
        if power_compare_enabled
            && let Some(&equipped_power) = equipped_item_powers.get(&item.equipment_slot_key())
            && let Some(&item_power) = item_powers.get(&item.id)
            && item_power < equipped_power
        {
            items_to_sell.push(item.clone());
            continue;
        }

        items_to_equip.push(item.clone());
    }

    Ok((items_to_sell, items_to_equip))
}