futu_cache/event_contract/

catalog.rs

use super::*;

impl EventContractCache {
    #[must_use]
    pub fn is_category_ready(&self) -> bool {
        !self.category.load().categories.is_empty()
    }

    #[must_use]
    pub fn has_competition_generation(&self, category_id: u32) -> bool {
        self.category
            .load()
            .competitions_by_category
            .contains_key(&category_id)
    }

    pub fn apply_category_response(
        &self,
        body: &[u8],
        app_lang: i32,
    ) -> Result<(), EventContractCacheError> {
        let response = GetEventCategoryResponse::decode(body)
            .map_err(|error| EventContractCacheError::Decode(error.to_string()))?;
        if response.ret_code != Some(0) {
            return Err(EventContractCacheError::Validation(
                "event contract category backend ret_code is not success",
            ));
        }

        let _writer = self.category_writer.lock();
        let previous = self.category_snapshot();
        let mut next = CategoryGeneration {
            competitions_by_category: previous.competitions_by_category.clone(),
            ..CategoryGeneration::default()
        };
        let mut category_ids = std::collections::BTreeSet::new();
        let mut category_values = std::collections::BTreeSet::new();

        for item in response.mix_category_items {
            let id = required_nonzero(item.category_id, "category_id is missing or zero")?;
            let value = required_string(item.category, "category is missing or empty")?;
            if !category_ids.insert(id) || !category_values.insert(value.clone()) {
                return Err(EventContractCacheError::Validation(
                    "duplicate event contract category",
                ));
            }
            next.categories.push(Category {
                id,
                value,
                name: localized(item.name.as_ref(), app_lang),
            });

            let mut tags_by_value = std::collections::BTreeMap::<String, Tag>::new();
            for mix in item.mix_items {
                let Some(value) = mix.tag.filter(|value| !value.is_empty()) else {
                    continue;
                };
                let tag_id = mix
                    .sub_category_item
                    .as_ref()
                    .and_then(|tag| tag.sub_category_id)
                    .or(mix.mix_item_id)
                    .unwrap_or(0);
                // Frozen C++ 10.9.6918 treats sub_category_id=0 as an
                // "All" pseudo category and never publishes it.
                if tag_id == 0 {
                    continue;
                }
                let entry = tags_by_value.entry(value.clone()).or_insert_with(|| Tag {
                    id: tag_id,
                    category_id: id,
                    value,
                    name: localized(mix.name.as_ref(), app_lang),
                    scopes: Vec::new(),
                });
                for scope in mix.competition_scopes {
                    let scope_id =
                        required_nonzero(scope.id, "competition scope id is missing or zero")?;
                    let scope_value = required_string(
                        scope.competition_scope,
                        "competition scope is missing or empty",
                    )?;
                    if entry
                        .scopes
                        .iter()
                        .all(|candidate| candidate.id != scope_id)
                    {
                        entry.scopes.push(Scope {
                            id: scope_id,
                            value: scope_value,
                            name: localized(scope.name.as_ref(), app_lang),
                        });
                    }
                }
            }
            for sub in item.sub_category_items {
                let value = required_string(sub.tag, "sub-category tag is missing or empty")?;
                if tags_by_value.contains_key(&value) {
                    continue;
                }
                let tag_id =
                    required_nonzero(sub.sub_category_id, "sub-category id is missing or zero")?;
                tags_by_value.insert(
                    value.clone(),
                    Tag {
                        id: tag_id,
                        category_id: id,
                        value,
                        name: localized(sub.name.as_ref(), app_lang),
                        scopes: Vec::new(),
                    },
                );
            }
            next.tags.extend(tags_by_value.into_values());
        }
        if next.categories.is_empty() {
            return Err(EventContractCacheError::Validation(
                "event contract category response is empty",
            ));
        }
        self.category.store(Arc::new(next));
        Ok(())
    }

    pub fn apply_competition_response(
        &self,
        category_id: u32,
        body: &[u8],
        app_lang: i32,
    ) -> Result<(), EventContractCacheError> {
        if category_id == 0 {
            return Err(EventContractCacheError::Validation(
                "competition category id is zero",
            ));
        }
        let response = GetCompetitionMixListResponse::decode(body)
            .map_err(|error| EventContractCacheError::Decode(error.to_string()))?;
        if response.ret_code != Some(0) {
            return Err(EventContractCacheError::Validation(
                "event contract competition backend ret_code is not success",
            ));
        }
        let _writer = self.category_writer.lock();
        let previous = self.category_snapshot();
        if previous
            .categories
            .iter()
            .all(|category| category.id != category_id)
        {
            return Err(EventContractCacheError::Validation(
                "competition category is absent from category generation",
            ));
        }

        let mut next = (*previous).clone();
        let mut rows = Vec::new();
        for group in response.sub_category_groups {
            let Some(sub) = group.sub_category else {
                continue;
            };
            let tag_id =
                required_nonzero(sub.sub_category_id, "competition tag id is missing or zero")?;
            let tag = required_string(sub.tag, "competition tag is missing or empty")?;

            if let Some(cached_tag) = next
                .tags
                .iter_mut()
                .find(|candidate| candidate.category_id == category_id && candidate.value == tag)
            {
                cached_tag.id = tag_id;
            }
            for content in group.content_items {
                // Frozen C++ only accepts ContentType::Competition (wire 3);
                // topic and counters are intentionally ignored.
                if content.content_type != Some(3) {
                    continue;
                }
                let Some(competition) = content.competition else {
                    return Err(EventContractCacheError::Validation(
                        "competition content lacks competition payload",
                    ));
                };
                rows.push(Competition {
                    id: required_nonzero(competition.id, "competition id is missing or zero")?,
                    category_id,
                    tag_id,
                    tag: tag.clone(),
                    value: required_string(
                        competition.competition,
                        "competition value is missing or empty",
                    )?,
                    name: localized(competition.name.as_ref(), app_lang),
                });
            }
        }
        next.competitions_by_category.insert(category_id, rows);
        self.category.store(Arc::new(next));
        Ok(())
    }
}

fn required_nonzero(
    value: Option<u32>,
    message: &'static str,
) -> Result<u32, EventContractCacheError> {
    value
        .filter(|value| *value != 0)
        .ok_or(EventContractCacheError::Validation(message))
}

fn required_string(
    value: Option<String>,
    message: &'static str,
) -> Result<String, EventContractCacheError> {
    value
        .filter(|value| !value.is_empty())
        .ok_or(EventContractCacheError::Validation(message))
}

pub(super) fn localized(value: Option<&LocaleString>, app_lang: i32) -> String {
    let Some(value) = value else {
        return String::new();
    };
    // Ref: frozen C++ aec0f6cda1 Src/Common/Common.h language enum:
    // 2=en-US, 0=zh-CN, 1=zh-HK, 3=ja-JP. Prefer the negotiated app language,
    // then the same stable product fallback order.
    [app_lang, 2, 0, 1, 3]
        .into_iter()
        .find_map(|language_id| {
            value.str_context.iter().find_map(|item| {
                (item.language_id == Some(language_id))
                    .then(|| item.context.clone())
                    .flatten()
                    .filter(|context| !context.is_empty())
            })
        })
        .or_else(|| {
            value
                .str_context
                .iter()
                .find_map(|item| item.context.clone().filter(|context| !context.is_empty()))
        })
        .unwrap_or_default()
}