futu_core/

localization.rs

//! C++ OpenD-compatible language-pack lookup.
//!
//! C++ loads `Resources/Languages/{zh_cn,en}/*.ini` at GUI startup and then
//! resolves `FTStringDefine.StringID` through `core::lang::tr(...)`.
//! Refs:
//! - FutuOpenD/Src/FTGatewayGui/Application.cpp:66-99
//! - FutuOpenD/Src/NNProtoCenter/Basic/MultiLanguage/FTQueryLanguage.cpp:285-334
//! - FutuOpenD/Src/NNProtoCenter/Basic/MultiLanguage/FTQueryLanguage.cpp:380-401

use std::collections::BTreeMap;
use std::fs;
use std::path::{Path, PathBuf};
use std::sync::OnceLock;
use std::time::{SystemTime, UNIX_EPOCH};

use serde::{Deserialize, Serialize};
use sha2::{Digest, Sha256};

mod remote;
mod runtime_catalog;
mod store;
pub use remote::{
    LanguagePackAutoUpdateOptions, LanguagePackAutoUpdateOutcome, LanguagePackAutoUpdateState,
    LanguagePackRemoteUpdateOptions, auto_update_language_pack,
    ensure_allowed_language_pack_remote_scheme, language_pack_manifest_url,
    update_language_pack_from_endpoint,
};
use runtime_catalog::RuntimeLanguageCatalog;
pub use store::LanguageStore;

const CACHE_DIR_ENV: &str = "FUTU_LANGUAGE_PACK_CACHE_DIR";
const FALLBACK_MAX_BYTES: usize = 32 * 1024;
const MANIFEST_SCHEMA_VERSION: u32 = 1;
const UPDATE_STATUS_FILE: &str = "update-status.json";
const LAST_ERROR_MAX_BYTES: usize = 1024;

#[derive(Debug)]
struct RuntimeLanguageCatalogState {
    cache_root: PathBuf,
    catalog: RuntimeLanguageCatalog,
}

static RUNTIME_LANGUAGE_CATALOG: OnceLock<RuntimeLanguageCatalogState> = OnceLock::new();

// Minimal fallback deliberately covers only StringID values already exercised by
// Rust OpenD public handlers/fixtures. Unknown backend StringID values must stay
// `None` until a cache/imported language pack provides them.
const MINIMAL_FALLBACK_INI: &[(LanguageId, &str)] = &[
    (
        LanguageId::English,
        concat!(
            "150183=No\n",
            "191555=Thank you for trusting and using Futubull's products and services. ",
            "View <a href=\"{{privacy_url}}\">Privacy Policy</a>.\n",
            "204444={1} SPAC Warrant(s) for every {0} SPAC Share(s)\n",
            "204549=The current valuation is reasonable\n",
            "204552=is in the industry overvaluation range\n",
            // Older backend deployments still emit the original Morningstar
            // StringID family from C++ static_lang.ini:12742-12755.
            "256354=Wide\n",
            "256355=Narrow\n",
            "256356=None\n",
            "256357=Low\n",
            "256358=Medium\n",
            "256359=High\n",
            "256360=Very High\n",
            "256361=Extreme\n",
            "256362=Exemplary\n",
            "256363=Standard\n",
            "256365=Not Rated\n",
            "256366=Strong\n",
            "256368=Moderate\n",
            "256369=Weak\n",
            // C++ ships these labels in Config/Languages/en/static_lang.ini:15364-15378
            // and projects them through core::lang::tr for Morningstar fields in
            // NNBiz_Qot_MorningstarResearch.cpp:73-119. They must remain available
            // before a downloaded language pack exists; replace only if C++ changes
            // the authoritative StringID rows.
            "267143=Wide\n",
            "267144=Narrow\n",
            "267145=None\n",
            "267146=Low\n",
            "267147=Medium\n",
            "267148=High\n",
            "267149=Very High\n",
            "267150=Extreme\n",
            "267151=Exemplary\n",
            "267152=Standard\n",
            "267153=Poor\n",
            "267154=Not Rated\n",
            "267155=Strong\n",
            "267156=Moderate\n",
            "267157=Weak\n",
        ),
    ),
    (
        LanguageId::SimplifiedChinese,
        concat!(
            "150183=否\n",
            "191555=感谢您信任并使用富途牛牛的产品和服务。查看",
            "<a href=\"{{privacy_url}}\">《隐私政策》</a>。\n",
            "204444=每{0}股SPAC股份获发{1}份SPAC权证\n",
            "204549=当前估值合理\n",
            "204552=处于行业高估区间\n",
            // Older backend deployments still emit the original Morningstar
            // StringID family from C++ static_lang.ini:11861-11874.
            "256354=宽\n",
            "256355=窄\n",
            "256356=无评级\n",
            "256357=较低\n",
            "256358=中等\n",
            "256359=较高\n",
            "256360=很高\n",
            "256361=极高\n",
            "256362=优秀\n",
            "256363=标准\n",
            "256365=未评级\n",
            "256366=高\n",
            "256368=中\n",
            "256369=低\n",
            // C++ authoritative zh-CN rows:
            // Config/Languages/zh_cn/static_lang.ini:14480-14494.
            "267143=宽\n",
            "267144=窄\n",
            "267145=无评级\n",
            "267146=较低\n",
            "267147=中等\n",
            "267148=较高\n",
            "267149=很高\n",
            "267150=极高\n",
            "267151=优秀\n",
            "267152=标准\n",
            "267153=欠佳\n",
            "267154=未评级\n",
            "267155=高\n",
            "267156=中\n",
            "267157=低\n",
        ),
    ),
];

/// C++ language ids that are actually accepted by `FTQueryLanguage`.
///
/// `LanguageID_HK=1` exists in C++ headers, but `CheckLanguageIDInternal` only
/// accepts Simplified Chinese and English, so `1` normalizes to English.
#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub enum LanguageId {
    SimplifiedChinese = 0,
    English = 2,
}

impl LanguageId {
    pub const fn cache_name(self) -> &'static str {
        match self {
            Self::SimplifiedChinese => "zh_cn",
            Self::English => "en",
        }
    }

    pub fn from_cache_name(value: &str) -> Option<Self> {
        match value.trim().to_ascii_lowercase().as_str() {
            "zh_cn" | "zh-cn" | "sc" | "cn" => Some(Self::SimplifiedChinese),
            "en" | "en_us" | "en-us" => Some(Self::English),
            _ => None,
        }
    }
}

#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize)]
#[serde(rename_all = "snake_case")]
pub enum LanguagePackKind {
    Api,
    Static,
}

impl LanguagePackKind {
    pub const fn file_name(self) -> &'static str {
        match self {
            Self::Api => "api_lang.ini",
            Self::Static => "static_lang.ini",
        }
    }

    pub const fn as_str(self) -> &'static str {
        match self {
            Self::Api => "api",
            Self::Static => "static",
        }
    }
}

#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "snake_case")]
pub enum LanguagePackRuntimeSource {
    LastGoodCache,
    MinimalFallback,
}

impl LanguagePackRuntimeSource {
    pub const fn as_str(self) -> &'static str {
        match self {
            Self::LastGoodCache => "last_good_cache",
            Self::MinimalFallback => "minimal_fallback",
        }
    }
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct LanguagePackManifest {
    pub schema_version: u32,
    pub pack_version: String,
    pub source: String,
    pub profile: Option<String>,
    pub updated_at_unix: u64,
    pub entries: Vec<LanguagePackManifestEntry>,
    pub last_error: Option<String>,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct LanguagePackManifestEntry {
    pub lang: String,
    pub kind: LanguagePackKind,
    pub path: String,
    pub sha256: String,
    pub bytes: u64,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
struct LanguagePackUpdateStatus {
    updated_at_unix: u64,
    last_error: Option<String>,
}

#[derive(Debug, Clone)]
pub struct LanguagePackFile {
    pub language: LanguageId,
    pub kind: LanguagePackKind,
    pub bytes: Vec<u8>,
}

#[derive(Debug, Clone)]
pub struct LanguagePackInstallOptions {
    pub cache_root: PathBuf,
    pub pack_version: String,
    pub source: String,
    pub profile: Option<String>,
}

#[derive(Debug, Clone, Serialize)]
pub struct LanguagePackStatus {
    pub cache_root: String,
    /// Fully validated disk source available to the next runtime catalog
    /// initialization. This is not live per-process catalog provenance.
    pub runtime_source: &'static str,
    pub pack_version: Option<String>,
    pub source: Option<String>,
    pub profile: Option<String>,
    pub entries: Vec<LanguagePackStatusEntry>,
    pub last_error: Option<String>,
}

#[derive(Debug, Clone, Serialize)]
pub struct LanguagePackStatusEntry {
    pub lang: String,
    pub kind: &'static str,
    pub sha256: String,
    pub bytes: u64,
    pub path: String,
}

pub trait LanguagePackSource {
    fn source(&self) -> LanguagePackRuntimeSource;
    fn load(&self) -> Result<LanguageStore, String>;
}

#[derive(Debug, Clone)]
pub struct FileCacheLanguagePackSource {
    pub cache_root: PathBuf,
}

impl LanguagePackSource for FileCacheLanguagePackSource {
    fn source(&self) -> LanguagePackRuntimeSource {
        LanguagePackRuntimeSource::LastGoodCache
    }

    fn load(&self) -> Result<LanguageStore, String> {
        load_last_good_store(&self.cache_root)
    }
}

#[derive(Debug, Clone, Copy)]
pub struct MinimalFallbackLanguagePackSource;

impl LanguagePackSource for MinimalFallbackLanguagePackSource {
    fn source(&self) -> LanguagePackRuntimeSource {
        LanguagePackRuntimeSource::MinimalFallback
    }

    fn load(&self) -> Result<LanguageStore, String> {
        Ok(load_minimal_fallback_store())
    }
}

/// Normalize an OpenD app language id the same way C++ `FTQueryLanguage` does.
pub fn normalize_language_id(language_id: i32) -> LanguageId {
    match language_id {
        0 => LanguageId::SimplifiedChinese,
        2 => LanguageId::English,
        _ => LanguageId::English,
    }
}

pub fn translate_embedded_key(language: LanguageId, key: u32) -> Option<String> {
    translate_runtime_key(language, key)
}

pub fn bind_runtime_language_pack_cache_root(cache_root: impl Into<PathBuf>) -> Result<(), String> {
    let requested = cache_root.into();
    if let Some(existing) = RUNTIME_LANGUAGE_CATALOG.get() {
        return compare_runtime_language_pack_cache_roots(&existing.cache_root, &requested);
    }

    let candidate = runtime_language_catalog_state(requested.clone());
    if RUNTIME_LANGUAGE_CATALOG.set(candidate).is_ok() {
        return Ok(());
    }

    let existing = RUNTIME_LANGUAGE_CATALOG.get().ok_or_else(|| {
        format!(
            "runtime language catalog state unavailable after initialization race: requested={}",
            requested.display()
        )
    })?;
    compare_runtime_language_pack_cache_roots(&existing.cache_root, &requested)
}

fn compare_runtime_language_pack_cache_roots(
    existing: &Path,
    requested: &Path,
) -> Result<(), String> {
    if existing == requested {
        Ok(())
    } else {
        Err(format!(
            "language-pack cache root already bound: existing={}, requested={}",
            existing.display(),
            requested.display()
        ))
    }
}

pub fn translate_runtime_key(language: LanguageId, key: u32) -> Option<String> {
    runtime_language_catalog().translate_key(language, key)
}

pub fn translate_embedded_key_with_template(
    language: LanguageId,
    key: u32,
    template: &BTreeMap<String, String>,
) -> Option<String> {
    translate_runtime_key_with_template(language, key, template)
}

pub fn translate_runtime_key_with_template(
    language: LanguageId,
    key: u32,
    template: &BTreeMap<String, String>,
) -> Option<String> {
    runtime_language_catalog().translate_key_with_template(language, key, template)
}

pub fn default_language_pack_cache_root() -> PathBuf {
    if let Some(dir) = std::env::var_os(CACHE_DIR_ENV) {
        return PathBuf::from(dir);
    }
    dirs::cache_dir()
        .unwrap_or_else(|| PathBuf::from("."))
        .join("futu-opend-rs")
        .join("language-packs")
}

pub fn language_pack_status(cache_root: Option<&Path>) -> LanguagePackStatus {
    let cache_root = cache_root
        .map(Path::to_path_buf)
        .unwrap_or_else(default_language_pack_cache_root);
    let manifest = read_manifest(&cache_root).ok();
    let loaded = FileCacheLanguagePackSource {
        cache_root: cache_root.clone(),
    }
    .load()
    .is_ok();
    let runtime_source = if loaded {
        LanguagePackRuntimeSource::LastGoodCache
    } else {
        LanguagePackRuntimeSource::MinimalFallback
    };
    let update_status = read_update_status(&cache_root).ok();
    let entries = manifest
        .as_ref()
        .map(|manifest| {
            manifest
                .entries
                .iter()
                .map(|entry| LanguagePackStatusEntry {
                    lang: entry.lang.clone(),
                    kind: entry.kind.as_str(),
                    sha256: entry.sha256.clone(),
                    bytes: entry.bytes,
                    path: entry.path.clone(),
                })
                .collect()
        })
        .unwrap_or_default();

    LanguagePackStatus {
        cache_root: cache_root.display().to_string(),
        runtime_source: runtime_source.as_str(),
        pack_version: manifest
            .as_ref()
            .map(|manifest| manifest.pack_version.clone()),
        source: manifest.as_ref().map(|manifest| manifest.source.clone()),
        profile: manifest
            .as_ref()
            .and_then(|manifest| manifest.profile.clone()),
        entries,
        last_error: update_status
            .and_then(|status| status.last_error)
            .or_else(|| manifest.and_then(|manifest| manifest.last_error)),
    }
}

pub fn record_language_pack_update_error(cache_root: &Path, error: &str) -> Result<(), String> {
    write_update_status(cache_root, Some(truncate_error(error)))
}

pub fn import_language_pack_dir(
    dir: &Path,
    options: LanguagePackInstallOptions,
) -> Result<LanguagePackManifest, String> {
    let files = collect_language_pack_files(dir)?;
    install_language_pack_files(files, options)
}

pub fn install_language_pack_files(
    files: Vec<LanguagePackFile>,
    options: LanguagePackInstallOptions,
) -> Result<LanguagePackManifest, String> {
    if files.is_empty() {
        return Err("language pack import contains no supported ini files".to_string());
    }

    validate_language_pack_files(&files)?;

    fs::create_dir_all(&options.cache_root).map_err(|error| {
        format!(
            "create language-pack cache dir {}: {error}",
            options.cache_root.display()
        )
    })?;
    let suffix = unique_install_suffix();
    let temp_last_good_root = options.cache_root.join(format!("last-good.tmp-{suffix}"));
    if temp_last_good_root.exists() {
        fs::remove_dir_all(&temp_last_good_root).map_err(|error| {
            format!(
                "remove stale language-pack temp dir {}: {error}",
                temp_last_good_root.display()
            )
        })?;
    }

    let mut entries = Vec::new();
    for file in files {
        let rel = format!("{}/{}", file.language.cache_name(), file.kind.file_name());
        let dst = temp_last_good_root.join(&rel);
        if let Some(parent) = dst.parent() {
            fs::create_dir_all(parent).map_err(|error| {
                format!("create language-pack dir {}: {error}", parent.display())
            })?;
        }
        write_atomic(&dst, &file.bytes)?;
        entries.push(LanguagePackManifestEntry {
            lang: file.language.cache_name().to_string(),
            kind: file.kind,
            path: format!("last-good/{rel}"),
            sha256: language_pack_sha256_hex(&file.bytes),
            bytes: file.bytes.len() as u64,
        });
    }

    entries.sort_by(|left, right| {
        (left.lang.as_str(), left.kind).cmp(&(right.lang.as_str(), right.kind))
    });

    let manifest = LanguagePackManifest {
        schema_version: MANIFEST_SCHEMA_VERSION,
        pack_version: options.pack_version,
        source: options.source,
        profile: options.profile,
        updated_at_unix: unix_now(),
        entries,
        last_error: None,
    };
    let manifest_bytes = serde_json::to_vec_pretty(&manifest)
        .map_err(|error| format!("serialize language-pack manifest: {error}"))?;
    let staged_manifest = options
        .cache_root
        .join(format!("manifest.json.next-{suffix}"));
    write_atomic(&staged_manifest, &manifest_bytes)?;
    replace_last_good_root(&options.cache_root, &temp_last_good_root, &suffix)?;
    rename_file(&staged_manifest, &options.cache_root.join("manifest.json"))?;
    write_update_status(&options.cache_root, None)?;
    Ok(manifest)
}

fn runtime_language_catalog_state(cache_root: PathBuf) -> RuntimeLanguageCatalogState {
    let catalog = RuntimeLanguageCatalog::from_cache_root(&cache_root);
    RuntimeLanguageCatalogState {
        cache_root,
        catalog,
    }
}

fn runtime_language_catalog() -> &'static RuntimeLanguageCatalog {
    &RUNTIME_LANGUAGE_CATALOG
        .get_or_init(|| runtime_language_catalog_state(default_language_pack_cache_root()))
        .catalog
}

fn collect_language_pack_files(dir: &Path) -> Result<Vec<LanguagePackFile>, String> {
    let mut files = Vec::new();
    for language in [LanguageId::English, LanguageId::SimplifiedChinese] {
        for kind in [LanguagePackKind::Api, LanguagePackKind::Static] {
            let path = find_language_pack_file(dir, language, kind);
            let Some(path) = path else {
                continue;
            };
            let bytes = fs::read(&path)
                .map_err(|error| format!("read language pack {}: {error}", path.display()))?;
            files.push(LanguagePackFile {
                language,
                kind,
                bytes,
            });
        }
    }
    Ok(files)
}

fn find_language_pack_file(
    dir: &Path,
    language: LanguageId,
    kind: LanguagePackKind,
) -> Option<PathBuf> {
    let rel = language.cache_name();
    [
        dir.join(rel).join(kind.file_name()),
        dir.join("last-good").join(rel).join(kind.file_name()),
    ]
    .into_iter()
    .find(|path| path.is_file())
}

fn validate_language_pack_files(files: &[LanguagePackFile]) -> Result<(), String> {
    for file in files {
        let text = std::str::from_utf8(&file.bytes).map_err(|error| {
            format!(
                "{} {} is not valid UTF-8: {error}",
                file.language.cache_name(),
                file.kind.as_str()
            )
        })?;
        let mut store = LanguageStore::new();
        let count = store.load_ini_count(file.language, text);
        if count == 0 {
            return Err(format!(
                "{} {} contains no numeric language keys",
                file.language.cache_name(),
                file.kind.as_str()
            ));
        }
    }
    Ok(())
}

fn load_last_good_store(cache_root: &Path) -> Result<LanguageStore, String> {
    let manifest = read_manifest(cache_root)?;
    let mut store = LanguageStore::new();
    let mut entries = manifest.entries.clone();
    entries.sort_by_key(|entry| {
        let lang_order = match LanguageId::from_cache_name(&entry.lang) {
            Some(LanguageId::English) => 0,
            Some(LanguageId::SimplifiedChinese) => 1,
            None => 9,
        };
        let kind_order = match entry.kind {
            LanguagePackKind::Api => 0,
            LanguagePackKind::Static => 1,
        };
        (lang_order, kind_order)
    });

    for entry in entries {
        let Some(language) = LanguageId::from_cache_name(&entry.lang) else {
            continue;
        };
        let path = cache_root.join(&entry.path);
        let bytes = fs::read(&path)
            .map_err(|error| format!("read cached language pack {}: {error}", path.display()))?;
        let actual = language_pack_sha256_hex(&bytes);
        if actual != entry.sha256 {
            return Err(format!(
                "cached language pack checksum mismatch for {}: expected {}, got {}",
                entry.path, entry.sha256, actual
            ));
        }
        let text = std::str::from_utf8(&bytes).map_err(|error| {
            format!("cached language pack {} is not UTF-8: {error}", entry.path)
        })?;
        store.load_ini(language, text);
    }

    Ok(store)
}

fn read_manifest(cache_root: &Path) -> Result<LanguagePackManifest, String> {
    let path = cache_root.join("manifest.json");
    let bytes = fs::read(&path)
        .map_err(|error| format!("read language-pack manifest {}: {error}", path.display()))?;
    let manifest: LanguagePackManifest = serde_json::from_slice(&bytes)
        .map_err(|error| format!("parse language-pack manifest {}: {error}", path.display()))?;
    if manifest.schema_version != MANIFEST_SCHEMA_VERSION {
        return Err(format!(
            "unsupported language-pack manifest schema_version {}",
            manifest.schema_version
        ));
    }
    Ok(manifest)
}

fn read_update_status(cache_root: &Path) -> Result<LanguagePackUpdateStatus, String> {
    let path = cache_root.join(UPDATE_STATUS_FILE);
    let bytes = fs::read(&path).map_err(|error| {
        format!(
            "read language-pack update status {}: {error}",
            path.display()
        )
    })?;
    serde_json::from_slice(&bytes).map_err(|error| {
        format!(
            "parse language-pack update status {}: {error}",
            path.display()
        )
    })
}

fn write_update_status(cache_root: &Path, last_error: Option<String>) -> Result<(), String> {
    fs::create_dir_all(cache_root).map_err(|error| {
        format!(
            "create language-pack cache dir {}: {error}",
            cache_root.display()
        )
    })?;
    let status = LanguagePackUpdateStatus {
        updated_at_unix: unix_now(),
        last_error,
    };
    let bytes = serde_json::to_vec_pretty(&status)
        .map_err(|error| format!("serialize language-pack update status: {error}"))?;
    write_atomic(&cache_root.join(UPDATE_STATUS_FILE), &bytes)
}

fn load_minimal_fallback_store() -> LanguageStore {
    debug_assert!(
        minimal_fallback_bytes() <= FALLBACK_MAX_BYTES,
        "minimal fallback catalog must stay small"
    );
    let mut store = LanguageStore::new();
    for (language, text) in MINIMAL_FALLBACK_INI {
        store.load_ini(*language, text);
    }
    store
}

fn minimal_fallback_bytes() -> usize {
    MINIMAL_FALLBACK_INI
        .iter()
        .map(|(_, text)| text.len())
        .sum()
}

pub fn language_pack_sha256_hex(bytes: &[u8]) -> String {
    let mut hasher = Sha256::new();
    hasher.update(bytes);
    hex::encode(hasher.finalize())
}

fn write_atomic(path: &Path, bytes: &[u8]) -> Result<(), String> {
    if let Some(parent) = path.parent() {
        fs::create_dir_all(parent)
            .map_err(|error| format!("create dir {}: {error}", parent.display()))?;
    }
    let tmp = path.with_extension("tmp");
    fs::write(&tmp, bytes).map_err(|error| format!("write {}: {error}", tmp.display()))?;
    fs::rename(&tmp, path)
        .map_err(|error| format!("rename {} to {}: {error}", tmp.display(), path.display()))
}

fn replace_last_good_root(cache_root: &Path, temp_root: &Path, suffix: &str) -> Result<(), String> {
    let final_root = cache_root.join("last-good");
    let backup_root = cache_root.join(format!("last-good.old-{suffix}"));
    if backup_root.exists() {
        fs::remove_dir_all(&backup_root).map_err(|error| {
            format!(
                "remove stale language-pack backup dir {}: {error}",
                backup_root.display()
            )
        })?;
    }
    if final_root.exists() {
        rename_dir(&final_root, &backup_root)?;
    }
    if let Err(error) = rename_dir(temp_root, &final_root) {
        if backup_root.exists() {
            let _ = rename_dir(&backup_root, &final_root);
        }
        return Err(error);
    }
    if backup_root.exists() {
        fs::remove_dir_all(&backup_root).map_err(|error| {
            format!(
                "remove language-pack backup dir {}: {error}",
                backup_root.display()
            )
        })?;
    }
    Ok(())
}

fn rename_dir(from: &Path, to: &Path) -> Result<(), String> {
    fs::rename(from, to).map_err(|error| {
        format!(
            "rename language-pack dir {} to {}: {error}",
            from.display(),
            to.display()
        )
    })
}

fn rename_file(from: &Path, to: &Path) -> Result<(), String> {
    fs::rename(from, to).map_err(|error| {
        format!(
            "rename language-pack file {} to {}: {error}",
            from.display(),
            to.display()
        )
    })
}

fn unix_now() -> u64 {
    SystemTime::now()
        .duration_since(UNIX_EPOCH)
        .map(|value| value.as_secs())
        .unwrap_or_default()
}

fn unique_install_suffix() -> String {
    let nanos = SystemTime::now()
        .duration_since(UNIX_EPOCH)
        .map(|value| value.as_nanos())
        .unwrap_or_default();
    format!("{}-{nanos}", std::process::id())
}

fn truncate_error(error: &str) -> String {
    if error.len() <= LAST_ERROR_MAX_BYTES {
        return error.to_string();
    }
    let mut end = LAST_ERROR_MAX_BYTES;
    while !error.is_char_boundary(end) {
        end -= 1;
    }
    format!("{}...", &error[..end])
}

#[cfg(test)]
mod tests;