essences/

bundles.rs

use super::{abilities, currency, items};

use tsify_next::Tsify;

use crate::prelude::*;
use strum_macros::{Display, EnumIter, EnumString};

#[declare]
pub type BundleId = uuid::Uuid;

#[derive(
    Debug,
    Clone,
    Copy,
    EnumString,
    Display,
    Deserialize,
    Serialize,
    Hash,
    Eq,
    PartialEq,
    EnumIter,
    Default,
    JsonSchema,
    Tsify,
)]
#[tsify(namespace)]
pub enum BundleStepType {
    #[default]
    Currency,
    Ability,
    Item,
}

#[derive(Debug, Clone, Serialize, Deserialize, Eq, PartialEq, Tsify, JsonSchema)]
pub struct BundleRawStep {
    #[schemars(title = "Тип элемента в бандле'")]
    pub item_type: BundleStepType,

    #[schemars(
        title = "Валюты (фиксированная награда)",
        description = "Фиксированная валютная награда шага (для шагов типа Currency). \
            Единый источник правды для сервера и клиента — переносит хардкод значений из \
            нативных fixed_currencies fn в конфиг. Если непусто, используется вместо `script`."
    )]
    #[serde(default)]
    pub currencies: Vec<currency::CurrencyUnit>,

    #[schemars(
        title = "Валюты по условию",
        description = "Валютная награда, выбираемая по custom_values персонажа (для шагов \
            типа Currency): ветки проверяются по порядку, первая совпавшая выдаёт свои \
            валюты, иначе — default. Если задано, используется вместо `script`."
    )]
    #[serde(default)]
    pub currency_branch: Option<CurrencyBranchStep>,

    #[schemars(
        title = "Нативная функция валют",
        description = "Имя нативной функции категории currencies, вычисляющей валюты \
            (для шагов типа Currency). Используется только для НЕ-фиксированных наград \
            (afk-начисление); фиксированные награды берутся из `currencies`, выбор по \
            состоянию — из `currency_branch`.",
        schema_with = "currencies_ref_schema"
    )]
    #[serde(default)]
    pub behavior: Option<String>,

    #[schemars(
        title = "Осколки способностей (фиксированная награда)",
        description = "Фиксированный список осколков способностей шага (для шагов типа \
            Ability)."
    )]
    #[serde(default)]
    pub shards: Vec<BundleShardAmount>,

    #[schemars(
        title = "Предметы (фиксированная награда)",
        description = "Фиксированный список template_id предметов шага (для шагов типа \
            Item).",
        schema_with = "item_link_id_array_schema"
    )]
    #[serde(default)]
    pub item_template_ids: Vec<items::ItemTemplateId>,

    #[schemars(
        title = "TTL предметов в секундах",
        description = "Если задано, выданные этим шагом предметы временные: после \
            истечения срока они удаляются на старте следующего боя. null — постоянные \
            предметы. Применяется только к шагам типа Item."
    )]
    #[serde(default)]
    pub item_ttl_seconds: Option<i64>,

    #[schemars(title = "Нужно ли показывать попап")]
    pub has_pop_up: bool,
}

/// Фиксированная выдача осколков одной способности в шаге бандла.
#[derive(Debug, Clone, Serialize, Deserialize, Eq, PartialEq, Tsify, JsonSchema)]
pub struct BundleShardAmount {
    #[schemars(title = "Способность", schema_with = "ability_link_id_schema")]
    pub ability_id: abilities::AbilityId,
    #[schemars(title = "Количество осколков")]
    pub amount: i64,
}

/// Валютная награда шага, выбираемая по `custom_values` персонажа: ветки
/// проверяются по порядку, первая совпавшая выдаёт свои валюты, иначе `default`.
#[derive(Debug, Clone, Serialize, Deserialize, Eq, PartialEq, Tsify, JsonSchema)]
pub struct CurrencyBranchStep {
    #[schemars(title = "Ветки (по порядку)")]
    pub branches: Vec<CurrencyBranch>,
    #[schemars(title = "Валюты по умолчанию")]
    pub default: Vec<currency::CurrencyUnit>,
}

/// Одна ветка [`CurrencyBranchStep`]: условие + валюты при совпадении.
#[derive(Debug, Clone, Serialize, Deserialize, Eq, PartialEq, Tsify, JsonSchema)]
pub struct CurrencyBranch {
    #[schemars(title = "Условие")]
    pub condition: CustomValueCondition,
    #[schemars(title = "Валюты")]
    pub currencies: Vec<currency::CurrencyUnit>,
}

/// Условие над `custom_values` персонажа. Отсутствующий ключ ведёт себя как
/// «не установлен»: `KeyUnset` совпадает, `KeyEquals` — нет, а в `KeysEqual`
/// два отсутствующих ключа равны (как `() == ()` в старых скриптах).
#[derive(Debug, Clone, Serialize, Deserialize, Eq, PartialEq, Tsify, JsonSchema)]
pub enum CustomValueCondition {
    #[schemars(title = "Ключ не установлен")]
    KeyUnset { key: String },
    #[schemars(title = "Ключ равен значению")]
    KeyEquals { key: String, value: i64 },
    #[schemars(title = "Значения двух ключей равны")]
    KeysEqual { left: String, right: String },
}

impl CurrencyBranchStep {
    /// Resolve the step against the character's `custom_values`: first matching
    /// branch wins, otherwise `default`.
    pub fn evaluate(
        &self,
        character: &crate::character_state::CharacterState,
    ) -> &Vec<currency::CurrencyUnit> {
        let value = |key: &str| character.character.custom_values.0.get(key).copied();
        for branch in &self.branches {
            let matches = match &branch.condition {
                CustomValueCondition::KeyUnset { key } => value(key).is_none(),
                CustomValueCondition::KeyEquals { key, value: v } => value(key) == Some(*v),
                CustomValueCondition::KeysEqual { left, right } => value(left) == value(right),
            };
            if matches {
                return &branch.currencies;
            }
        }
        &self.default
    }
}

#[derive(Debug, Clone, Copy, Serialize, Deserialize, Eq, PartialEq, Default, JsonSchema, Tsify)]
#[tsify(namespace)]
pub enum BundleClaimMode {
    #[default]
    Sequential,
    AllAtOnce,
}

#[derive(Debug, Clone, Serialize, Deserialize, Eq, PartialEq, Tsify, JsonSchema)]
pub struct BundleRaw {
    #[schemars(schema_with = "id_schema")]
    pub id: BundleId,

    #[schemars(title = "Содержимое бандла")]
    pub steps: Vec<BundleRawStep>,

    #[schemars(title = "Режим получения наград", default = "default_claim_mode")]
    #[serde(default)]
    pub claim_mode: BundleClaimMode,
}

fn default_claim_mode() -> BundleClaimMode {
    BundleClaimMode::Sequential
}

#[derive(Debug, Clone, Serialize, Deserialize, Eq, PartialEq, JsonSchema, Tsify, Default)]
pub struct BundleAbility {
    pub template: abilities::AbilityTemplate,
    pub shards_amount: i64,
}

#[derive(Debug, Clone, Serialize, Deserialize, Eq, PartialEq, JsonSchema, Tsify)]
#[tsify(into_wasm_abi)]
pub enum BundleElement {
    Currencies(Vec<currency::CurrencyUnit>),
    Abilities(Vec<BundleAbility>),
    Items(Vec<items::Item>),
}

impl Default for BundleElement {
    fn default() -> Self {
        BundleElement::Currencies(Vec::new())
    }
}

#[derive(Clone, Debug, Serialize, Deserialize, PartialEq, Eq, JsonSchema, Tsify, Default)]
pub struct BundleStep {
    pub bundle_id: BundleId,
    pub element: BundleElement,
    pub has_pop_up: bool,
    // Origin of the bundle (e.g. `QuestClaim`, `MailReward`). Propagates into
    // the `CurrencyIncrease` event when the step is claimed so the analytics
    // signal reflects the real source instead of `BundleClaim`.
    //
    // `#[serde(skip)]` keeps this server-only: the field is omitted from the
    // postcard wire payload (preserving the pre-PR layout for older clients)
    // and from JSON state patches. The runtime value is loaded from the
    // `character_bundles.source` DB column at state-build time, so the server
    // always has the correct source even though it never crosses the wire.
    // Default = `BundleClaim` keeps any incidental deserialize from panicking.
    #[serde(skip)]
    pub source: currency::CurrencySource,
}

#[derive(Clone, Debug, Serialize, Deserialize, PartialEq, Eq, JsonSchema, Tsify)]
#[tsify(into_wasm_abi)]
pub enum BundleStepGeneric {
    Sequential(BundleStep),
    AllAtOnce {
        bundle_id: BundleId,
        elements: Vec<BundleElement>,
        has_pop_up: bool,
        // Server-only — see `BundleStep::source` for the rationale.
        #[serde(skip)]
        source: currency::CurrencySource,
    },
}

impl Default for BundleStepGeneric {
    fn default() -> Self {
        BundleStepGeneric::Sequential(BundleStep::default())
    }
}

impl BundleStepGeneric {
    pub fn has_pop_up(&self) -> bool {
        match self {
            BundleStepGeneric::Sequential(step) => step.has_pop_up,
            BundleStepGeneric::AllAtOnce { has_pop_up, .. } => *has_pop_up,
        }
    }

    pub fn bundle_id(&self) -> BundleId {
        match self {
            BundleStepGeneric::Sequential(step) => step.bundle_id,
            BundleStepGeneric::AllAtOnce { bundle_id, .. } => *bundle_id,
        }
    }

    pub fn source(&self) -> currency::CurrencySource {
        match self {
            BundleStepGeneric::Sequential(step) => step.source,
            BundleStepGeneric::AllAtOnce { source, .. } => *source,
        }
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use currency::CurrencySource;
    use uuid::uuid;

    const BUNDLE_ID: BundleId = uuid!("00000000-0000-0000-0000-000000000001");

    #[test]
    fn source_accessor_returns_sequential_step_source() {
        let step = BundleStepGeneric::Sequential(BundleStep {
            bundle_id: BUNDLE_ID,
            element: BundleElement::default(),
            has_pop_up: false,
            source: CurrencySource::QuestClaim,
        });
        assert_eq!(step.source(), CurrencySource::QuestClaim);
    }

    #[test]
    fn source_accessor_returns_all_at_once_source() {
        let step = BundleStepGeneric::AllAtOnce {
            bundle_id: BUNDLE_ID,
            elements: vec![BundleElement::default()],
            has_pop_up: false,
            source: CurrencySource::MailReward,
        };
        assert_eq!(step.source(), CurrencySource::MailReward);
    }

    /// Legacy state serialized before the bundle-source PR has no `source`
    /// field. `#[serde(default)]` should make it round-trip into `BundleClaim`
    /// so we never need to write a state migration.
    #[test]
    fn missing_source_in_serialized_step_defaults_to_bundle_claim() {
        let json = format!(
            r#"{{"bundle_id":"{BUNDLE_ID}","element":{{"Currencies":[]}},"has_pop_up":true}}"#
        );
        let step: BundleStep = serde_json::from_str(&json).unwrap();
        assert_eq!(step.source, CurrencySource::BundleClaim);
    }

    #[test]
    fn missing_source_in_all_at_once_defaults_to_bundle_claim() {
        let json = format!(
            r#"{{"AllAtOnce":{{"bundle_id":"{BUNDLE_ID}","elements":[],"has_pop_up":false}}}}"#
        );
        let generic: BundleStepGeneric = serde_json::from_str(&json).unwrap();
        assert_eq!(generic.source(), CurrencySource::BundleClaim);
    }

    /// `source` is `#[serde(skip)]` so it never reaches the postcard wire or
    /// JSON state patches — pre-PR clients see the same layout they always
    /// did. After a round-trip through serde the field collapses to the
    /// `Default` (`BundleClaim`); the server reads the real source from the
    /// `character_bundles.source` DB column at state-load time, not from this
    /// path, so this is intentional.
    #[test]
    fn source_does_not_round_trip_through_serde() {
        let original = BundleStepGeneric::Sequential(BundleStep {
            bundle_id: BUNDLE_ID,
            element: BundleElement::default(),
            has_pop_up: true,
            source: CurrencySource::OfferBuy,
        });
        let json = serde_json::to_string(&original).unwrap();
        // The serialized form must not mention `source` — that's what makes it
        // wire-compatible with pre-PR clients.
        assert!(
            !json.contains("source"),
            "serialized form leaked source field: {json}"
        );
        let round_tripped: BundleStepGeneric = serde_json::from_str(&json).unwrap();
        assert_eq!(round_tripped.source(), CurrencySource::BundleClaim);
    }

    /// Wire-compat: new `CurrencySource` variants (added in this PR)
    /// masquerade as `BundleClaim` over serde channels so old clients can
    /// decode them. Pre-existing variants pass through unchanged.
    #[test]
    fn new_currency_sources_serialize_as_bundle_claim_for_wire_compat() {
        let new_variants = [
            CurrencySource::MailReward,
            CurrencySource::DungeonReward,
            CurrencySource::OfferBuy,
            CurrencySource::ChapterReward,
            CurrencySource::NewUserGrant,
            CurrencySource::PvpArenaReward,
            CurrencySource::PvpVassalReward,
            CurrencySource::AfkReward,
        ];
        for v in new_variants {
            let json = serde_json::to_string(&v).unwrap();
            assert_eq!(json, "\"BundleClaim\"", "{v:?} leaked over serde");
        }

        // A pre-existing variant must keep its identity.
        assert_eq!(
            serde_json::to_string(&CurrencySource::QuestClaim).unwrap(),
            "\"QuestClaim\"",
        );
    }
}