futu_cache/qot_right/

backend_apply.rs

//! Split from qot_right.rs: backend / push apply path.
//!
//! CMD 6024 full apply, quota-only apply, CMD 6651 / 6006 / direct-auth push
//! patches, and the shared `apply_backend_projection` field writer.

use super::*;

impl QotRightCache {
    pub fn apply_6651_changes(&self, items: &[(i32, i32, i32)]) -> Vec<i32> {
        let mut d = self.data.write();
        let mut changed_types = Vec::new();

        for &(quote_type, before, after) in items {
            let current = QotRightPushCurrentFacts {
                api_us_qot_right: d.api_us_qot_right,
                us_lv2_arca: d.us_lv2_arca_qot_right,
                us_lv2_nyse: d.us_lv2_nyse_qot_right,
                us_lv2_nasdaq_totalview: d.us_lv2_nasdaq_totalview_qot_right,
            };
            if let Some(projection) = project_qot_right_6651_change_with_current(
                QotRight6651Change {
                    quote_type,
                    before,
                    after,
                },
                current,
            ) {
                apply_backend_projection(&mut d, projection.patch);
                changed_types.push(projection.quote_type);
            }
        }
        if !changed_types.is_empty() {
            drop(d);
            let mut m = self.meta.lock();
            m.freshness = qot_right_after_push_changes(m.freshness.clone(), true);
            if m.freshness.is_fresh() {
                m.last_refresh_at_ms = now_ms();
            }
        }
        changed_types
    }

    pub fn apply_direct_auth_changes(&self, items: &[(i32, u32)]) -> Vec<i32> {
        let mut d = self.data.write();
        let mut changed_types = Vec::new();

        for &(quote_type, after) in items {
            if let Some(projection) =
                project_qot_right_direct_auth_change(QotRightDirectAuthChange { quote_type, after })
            {
                apply_backend_projection(&mut d, projection.patch);
                changed_types.push(projection.quote_type);
            }
        }
        if !changed_types.is_empty() {
            drop(d);
            let mut m = self.meta.lock();
            m.freshness = qot_right_after_push_changes(m.freshness.clone(), true);
            if m.freshness.is_fresh() {
                m.last_refresh_at_ms = now_ms();
            }
        }
        changed_types
    }

    /// Applies one legacy CMD6006 partial authorization push without
    /// reclassifying it as a full CMD6024 snapshot.
    ///
    /// A current route may update an unowned cold cache (provenance remains
    /// `None`) or the full snapshot produced by that same publication epoch.
    /// It may never graft a new-route push onto facts owned by another epoch.
    pub fn apply_6006_auth_changes_if_source(
        &self,
        expected_generation: u64,
        source_publication_epoch: u64,
        items: &[(i32, u32)],
        cn_after: Option<u32>,
    ) -> Option<Vec<i32>> {
        let mut data = self.data.write();
        let mut meta = self.meta.lock();
        if meta.backend_generation != expected_generation
            || meta
                .source_publication_epoch
                .is_some_and(|epoch| epoch != source_publication_epoch)
        {
            return None;
        }

        let mut changed_types = Vec::new();
        for &(quote_type, after) in items {
            if let Some(projection) =
                project_qot_right_direct_auth_change(QotRightDirectAuthChange { quote_type, after })
            {
                apply_backend_projection(&mut data, projection.patch);
                changed_types.push(projection.quote_type);
            }
        }
        if let Some(cn_after) = cn_after {
            let projection = project_qot_right_backend_update(
                QotRightBackendCurrent {
                    us_qot_right: data.us_qot_right,
                },
                QotRightBackendUpdate {
                    cn_got: Some(cn_after),
                    ..Default::default()
                },
            );
            apply_backend_projection(&mut data, projection);
            changed_types.push(2);
        }
        if !changed_types.is_empty() {
            meta.freshness = qot_right_after_push_changes(meta.freshness.clone(), true);
            meta.last_refresh_at_ms = now_ms();
        }
        Some(changed_types)
    }

    /// 从后端 CMD 6024 响应更新权限数据.
    ///
    /// **v1.4.106 codex 1217 F2 [P1] (5月1日)**: us_future_detail 子字段存在 =
    /// 覆盖 (含值=0). 之前 `if cme > 0` 跳过 0 让 LV1 → 0 (No) 实质降级被
    /// silent 保留；但 C++ 逐个 `has_open_api_*_auth()` 判断，父字段存在不代表
    /// 未返回的子市场可按 0 覆盖。
    ///
    /// **v1.4.106 codex 1217 F1**: apply 成功后自动 mark Fresh.
    pub fn update_from_backend(
        &self,
        update: QotRightBackendUpdate,
    ) -> QotRightBackendApplyOutcome {
        let mut data = self.data.write();
        let mut meta = self.meta.lock();
        let expected_generation = meta.backend_generation;
        Self::apply_full_backend_update_locked(
            &mut data,
            &mut meta,
            QotRightFullApplyFacts {
                expected_generation,
                source_publication_epoch: None,
                is_highest: false,
                force_resub: false,
                pushed_notify_version: None,
            },
            update,
        )
    }

    pub fn update_from_backend_if_generation(
        &self,
        facts: QotRightFullApplyFacts,
        update: QotRightBackendUpdate,
    ) -> Option<QotRightBackendApplyOutcome> {
        let mut d = self.data.write();
        let mut m = self.meta.lock();
        if m.backend_generation != facts.expected_generation {
            return None;
        }
        Some(Self::apply_full_backend_update_locked(
            &mut d, &mut m, facts, update,
        ))
    }

    fn apply_full_backend_update_locked(
        d: &mut QotRightData,
        m: &mut QotRightStateMeta,
        facts: QotRightFullApplyFacts,
        update: QotRightBackendUpdate,
    ) -> QotRightBackendApplyOutcome {
        let has_set_qot_right_before = has_set_qot_right_like_cpp(d);
        let public_before = QotRightPublicSnapshot::from(&*d);
        let reconnect_before = QotRightReconnectSnapshot::from(&*d);
        let has_us_utp_before = d.has_us_utp;
        let quota_before = (d.sub_quota, d.history_kl_quota);
        let projection = project_qot_right_backend_update(
            QotRightBackendCurrent {
                us_qot_right: d.us_qot_right,
            },
            update,
        );
        let event_contract_became_level1 = projection.event_contract_qot_right
            == Some(QOT_RIGHT_LEVEL1)
            && d.event_contract_qot_right != QOT_RIGHT_LEVEL1;
        apply_backend_projection(d, projection);
        let quota_data_changed = quota_before != (d.sub_quota, d.history_kl_quota);
        let public_rights_changed = public_before != QotRightPublicSnapshot::from(&*d);
        let reconnect_quote_types = reconnect_before.changed_quote_types(d);
        let has_us_utp_changed = has_us_utp_before != d.has_us_utp;

        // F1 (v1.4.106 codex 1217): apply 成功 → 自动 mark Fresh.
        m.freshness = qot_right_mark_fresh();
        m.source_publication_epoch = facts.source_publication_epoch;
        m.last_refresh_at_ms = now_ms();
        m.event_contract_category_preload_pending |= event_contract_became_level1;

        if facts.is_highest
            && (!reconnect_quote_types.is_empty() || facts.force_resub)
            && facts.pushed_notify_version == Some(m.last_pushed_quote_change_notify_version)
        {
            m.last_pushed_quote_change_notify = None;
        }

        QotRightBackendApplyOutcome {
            public_rights_changed,
            reconnect_quote_types,
            has_set_qot_right_before,
            has_us_utp_changed,
            quota_data_changed,
            // `update_from_backend` is the successful full-response apply owner.
            // Even an absent OpenAPIAuth object yields the current canonical
            // quota projection for the independent APIQuota fingerprint owner.
            quota_projection_available: true,
        }
    }

    pub fn update_quotas_from_backend_if_generation(
        &self,
        expected_generation: u64,
        update: QotRightBackendUpdate,
    ) -> Option<QotRightBackendApplyOutcome> {
        let projection =
            project_qot_right_backend_update(QotRightBackendCurrent::default(), update);
        let mut d = self.data.write();
        let m = self.meta.lock();
        if m.backend_generation != expected_generation {
            return None;
        }
        let quota_before = (d.sub_quota, d.history_kl_quota);
        if let Some(value) = projection.sub_quota {
            d.sub_quota = value;
        }
        if let Some(value) = projection.history_kl_quota {
            d.history_kl_quota = value;
        }
        Some(QotRightBackendApplyOutcome {
            public_rights_changed: false,
            reconnect_quote_types: Vec::new(),
            has_set_qot_right_before: false,
            has_us_utp_changed: false,
            quota_data_changed: quota_before != (d.sub_quota, d.history_kl_quota),
            quota_projection_available: true,
        })
    }
}

fn apply_backend_projection(data: &mut QotRightData, projection: QotRightBackendProjection) {
    if let Some(v) = projection.hk_own_qot_right {
        data.hk_own_qot_right = v;
    }
    if let Some(v) = projection.hk_qot_right {
        data.hk_qot_right = v;
    }
    if let Some(v) = projection.us_own_qot_right {
        data.us_own_qot_right = v;
    }
    if let Some(v) = projection.us_qot_right {
        data.us_qot_right = v;
    }
    if let Some(v) = projection.api_us_qot_right {
        data.api_us_qot_right = v;
    }
    if let Some(v) = projection.has_us_utp {
        data.has_us_utp = v;
    }
    if let Some(v) = projection.has_us_overnight {
        data.has_us_overnight = v;
    }
    if let Some(v) = projection.sh_qot_right {
        data.sh_qot_right = v;
    }
    if let Some(v) = projection.sz_qot_right {
        data.sz_qot_right = v;
    }
    if let Some(v) = projection.hk_option_qot_right {
        data.hk_option_qot_right = v;
    }
    if let Some(v) = projection.hk_future_qot_right {
        data.hk_future_qot_right = v;
    }
    if let Some(v) = projection.hk_option_orderbook_depth {
        data.hk_option_orderbook_depth = Some(v);
    }
    if let Some(v) = projection.hk_future_orderbook_depth {
        data.hk_future_orderbook_depth = Some(v);
    }
    if let Some(v) = projection.has_us_option_qot_right {
        data.has_us_option_qot_right = v;
    }
    if let Some(v) = projection.us_option_qot_right {
        data.us_option_qot_right = v;
    }
    if let Some(v) = projection.us_index_qot_right {
        data.us_index_qot_right = v;
    }
    if let Some(v) = projection.us_otc_qot_right {
        data.us_otc_qot_right = v;
    }
    if let Some(v) = projection.us_cme_future_qot_right {
        data.us_cme_future_qot_right = v;
    }
    if let Some(v) = projection.us_cbot_future_qot_right {
        data.us_cbot_future_qot_right = v;
    }
    if let Some(v) = projection.us_nymex_future_qot_right {
        data.us_nymex_future_qot_right = v;
    }
    if let Some(v) = projection.us_comex_future_qot_right {
        data.us_comex_future_qot_right = v;
    }
    if let Some(v) = projection.us_cboe_future_qot_right {
        data.us_cboe_future_qot_right = v;
    }
    if let Some(v) = projection.sg_future_qot_right {
        data.sg_future_qot_right = v;
    }
    if let Some(v) = projection.jp_future_qot_right {
        data.jp_future_qot_right = v;
    }
    if let Some(v) = projection.sg_stock_qot_right {
        data.sg_stock_qot_right = v;
    }
    if let Some(v) = projection.my_stock_qot_right {
        data.my_stock_qot_right = v;
    }
    if let Some(v) = projection.jp_stock_qot_right {
        data.jp_stock_qot_right = v;
    }
    if let Some(v) = projection.cc_qot_right {
        data.cc_qot_right = v;
    }
    if let Some(v) = projection.has_digital_future_auth {
        data.has_digital_future_auth = v;
    }
    if let Some(v) = projection.cc_pt_orderbook_qot_right {
        data.cc_pt_orderbook_qot_right = v;
    }
    if let Some(v) = projection.event_contract_qot_right {
        data.event_contract_qot_right = v;
    }
    if let Some(ids) = projection.event_contract_prohibited_category_ids {
        data.event_contract_prohibited_category_ids = ids;
    }
    if let Some(v) = projection.us_lv2_arca_qot_right {
        data.us_lv2_arca_qot_right = v;
    }
    if let Some(v) = projection.us_lv2_nyse_qot_right {
        data.us_lv2_nyse_qot_right = v;
    }
    if let Some(v) = projection.us_lv2_nasdaq_totalview_qot_right {
        data.us_lv2_nasdaq_totalview_qot_right = v;
    }
    if let Some(v) = projection.sub_quota {
        data.sub_quota = v;
    }
    if let Some(v) = projection.history_kl_quota {
        data.history_kl_quota = v;
    }
}