essences/

currency.rs

use crate::prelude::*;
use event_system::script::types::ESCurrencyUnit;

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

// Wire-compat note: the variant order is part of the wire format because
// `serde` encodes unit variants as their declaration index, and the wire
// codec (postcard) preserves that index as a varint discriminant.
// Pre-existing variants keep their original positions; all new variants are
// appended after.
//
// Known violation of the append rule: `ProgressPassClaim` was inserted
// before `Cheat`, shifting `Cheat` from declaration index 17 to 18. The
// `Serialize` impl below follows the *declaration* indices (`Cheat` = 18),
// so the wire stays self-consistent with the derived `Deserialize`; the
// `Cheat` index correction shipped as a coupled backend + client release.
// Do not reorder these variants — and never insert in the middle again.
//
// The `Serialize` impl below masquerades new variants as `BundleClaim` for
// serde channels (postcard wire + JSON state patches) so a backend release
// can ship without re-releasing the Unity/Python client. Server-side
// analytics uses `Debug`, not `Serialize`, so the canonical variant still
// reaches the dashboard. Once all clients have shipped knowledge of the new
// variants, the custom impl can be deleted and `Serialize` re-added to the
// derive list.
#[derive(Clone, Copy, Debug, Default, Deserialize, PartialEq, Eq, JsonSchema, Tsify)]
#[tsify(from_wasm_abi, into_wasm_abi)]
pub enum CurrencySource {
    EntityDeath,
    ItemSell,
    AutoItemSell,
    QuestClaim,
    QuestsTrackReward,
    VassalTaskCompletion,
    ReferralLvlUp,
    ReferralDailyReward,
    GiftClaim,
    ArenaTicketBuy,
    ClaimVassalReward,
    ClaimSuzerainReward,
    ArenaMatchmakingRefresh,
    GachaLevelUp,
    PetCaseLevelUp,
    // BundleClaim stays at its original index — also serves as the
    // `#[serde(default)]` fallback for legacy serialized state without a
    // recorded bundle origin.
    #[default]
    BundleClaim,
    AdReward,
    ProgressPassClaim,
    Cheat,
    // Appended in this PR. Bundles are containers; the analytics signal lives
    // in the source that decided to grant the bundle, not in the claim
    // mechanism. Always append new variants — never insert in the middle.
    MailReward,
    DungeonReward,
    OfferBuy,
    ChapterReward,
    NewUserGrant,
    PvpArenaReward,
    PvpVassalReward,
    AfkReward,
    DailyReset,
    RatingReward,
    CoreReset,
}

impl serde::Serialize for CurrencySource {
    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
    where
        S: serde::Serializer,
    {
        // Wire-compat shim. Real wire variants serialize as themselves
        // (matching what `#[derive(Serialize)]` would have produced — same
        // declaration-index, same name), so the derived `Deserialize` decodes
        // them back to the same variant. Backend-only variants masquerade as
        // `BundleClaim` so older clients can still postcard-decode the
        // message. Server-side analytics uses `Debug`, which keeps the
        // canonical name. The indices here MUST equal the declaration indices
        // above — a mismatch makes the postcard round-trip decode to a
        // different variant (see `wire_compat.rs`).
        let (idx, name) = match self {
            Self::EntityDeath => (0u32, "EntityDeath"),
            Self::ItemSell => (1, "ItemSell"),
            Self::AutoItemSell => (2, "AutoItemSell"),
            Self::QuestClaim => (3, "QuestClaim"),
            Self::QuestsTrackReward => (4, "QuestsTrackReward"),
            Self::VassalTaskCompletion => (5, "VassalTaskCompletion"),
            Self::ReferralLvlUp => (6, "ReferralLvlUp"),
            Self::ReferralDailyReward => (7, "ReferralDailyReward"),
            Self::GiftClaim => (8, "GiftClaim"),
            Self::ArenaTicketBuy => (9, "ArenaTicketBuy"),
            Self::ClaimVassalReward => (10, "ClaimVassalReward"),
            Self::ClaimSuzerainReward => (11, "ClaimSuzerainReward"),
            Self::ArenaMatchmakingRefresh => (12, "ArenaMatchmakingRefresh"),
            Self::GachaLevelUp => (13, "GachaLevelUp"),
            Self::PetCaseLevelUp => (14, "PetCaseLevelUp"),
            Self::BundleClaim => (15, "BundleClaim"),
            Self::AdReward => (16, "AdReward"),
            // Declaration index 18 — `ProgressPassClaim` sits at 17. Emitting
            // 17 here would make clients decode Cheat as ProgressPassClaim.
            Self::Cheat => (18, "Cheat"),
            // Backend-only variants — collapse to BundleClaim on the wire.
            Self::MailReward
            | Self::DungeonReward
            | Self::OfferBuy
            | Self::ChapterReward
            | Self::NewUserGrant
            | Self::PvpArenaReward
            | Self::PvpVassalReward
            | Self::AfkReward
            | Self::DailyReset
            | Self::RatingReward
            | Self::CoreReset
            | Self::ProgressPassClaim => (15, "BundleClaim"),
        };
        serializer.serialize_unit_variant("CurrencySource", idx, name)
    }
}

#[derive(Clone, Debug, Serialize, Deserialize, PartialEq, Eq, JsonSchema, Tsify)]
#[tsify(from_wasm_abi, into_wasm_abi)]
pub enum CurrencyConsumer {
    AbilityCaseOpen,
    AbilityCaseSlotUpgrade,
    ItemCaseOpen,
    GiftSend,
    DungeonRaid,
    DungeonFightEnd,
    ClassLevelUp,
    OfferBuy,
    ItemCaseUpgrade,
    CaseUpgradeSpeedUp,
    CaseUpgradeSkip,
    ArenaFight,
    ArenaMatchmakingRefresh,
    ArenaTicketBuy,
    SkinBuy,
    AfkInstantReward,
    StatueRoll,
    TalentUpgrade,
    TalentUpgradeSkip,
    PetCaseOpen,
    // OVT-2517: twin-core level-up. Appended — never insert in the middle.
    CoreUpgrade,
}

#[derive(Clone, Debug, Serialize, Deserialize, PartialEq, Eq, JsonSchema, Tsify)]
pub struct Currency {
    #[schemars(schema_with = "id_schema")]
    pub id: CurrencyId,
    #[schemars(title = "Название")]
    pub name: i18n::I18nString,
    #[schemars(title = "Описание")]
    pub description: i18n::I18nString,
    #[schemars(title = "URL картинки", schema_with = "webp_url_schema")]
    pub icon_url: String,
    #[schemars(title = "Иконка", schema_with = "asset_currency_icon_schema")]
    pub icon_path: String,
}

#[derive(Clone, Debug, Serialize, Deserialize, PartialEq, Eq, Hash, JsonSchema, Tsify, Default)]
pub struct CurrencyUnit {
    #[schemars(schema_with = "currency_link_id_schema")]
    pub currency_id: CurrencyId,
    #[schemars(title = "Количество")]
    pub amount: i64,
}

impl PartialOrd for CurrencyUnit {
    fn partial_cmp(&self, other: &Self) -> Option<std::cmp::Ordering> {
        Some(self.cmp(other))
    }
}

impl Ord for CurrencyUnit {
    fn cmp(&self, other: &Self) -> std::cmp::Ordering {
        match self.currency_id.cmp(&other.currency_id) {
            std::cmp::Ordering::Equal => self.amount.cmp(&other.amount),
            ordering => ordering,
        }
    }
}

pub fn increase_currencies(
    currencies_to_increase: &mut Vec<CurrencyUnit>,
    currencies_to_add: &[CurrencyUnit],
) {
    for add_currency in currencies_to_add {
        if let Some(unit) = currencies_to_increase
            .iter_mut()
            .find(|unit| unit.currency_id == add_currency.currency_id)
        {
            unit.amount += add_currency.amount;
        } else {
            currencies_to_increase.push(add_currency.clone());
        }
    }
}

pub fn decrease_currencies(
    currencies_to_decrease: &mut [CurrencyUnit],
    currencies_to_subtract: &[CurrencyUnit],
) -> anyhow::Result<()> {
    for subtract_currency in currencies_to_subtract {
        if let Some(unit) = currencies_to_decrease
            .iter_mut()
            .find(|unit| unit.currency_id == subtract_currency.currency_id)
        {
            if unit.amount < subtract_currency.amount {
                anyhow::bail!(
                    "Required currency {subtract_currency:?} is bigger than available {unit:?}"
                )
            }

            unit.amount -= subtract_currency.amount;
        } else {
            anyhow::bail!("Given currency {subtract_currency:?} isn't present in currencies")
        }
    }
    Ok(())
}

pub fn force_decrease_currencies(
    currencies_to_decrease: &mut Vec<CurrencyUnit>,
    currencies_to_subtract: &[CurrencyUnit],
) -> anyhow::Result<()> {
    for subtract_currency in currencies_to_subtract {
        if let Some(unit) = currencies_to_decrease
            .iter_mut()
            .find(|unit| unit.currency_id == subtract_currency.currency_id)
        {
            unit.amount -= subtract_currency.amount;
        }
    }

    currencies_to_decrease.retain(|unit| unit.amount != 0);

    Ok(())
}

pub fn check_can_decrease_currencies(
    available_currencies: &[CurrencyUnit],
    required_currencies: &[CurrencyUnit],
) -> bool {
    for subtract_currency in required_currencies {
        if let Some(unit) = available_currencies
            .iter()
            .find(|unit| unit.currency_id == subtract_currency.currency_id)
        {
            if unit.amount < subtract_currency.amount {
                return false;
            }
        } else {
            return false;
        }
    }
    true
}

pub fn from_es_currencies(es_currencies: &[ESCurrencyUnit]) -> Vec<CurrencyUnit> {
    let mut result = vec![];
    for es_currency in es_currencies.iter() {
        result.push(CurrencyUnit {
            currency_id: es_currency.currency_id,
            amount: es_currency.amount,
        });
    }
    result
}