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;
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,
};

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;

// 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",
        ),
    ),
    (
        LanguageId::SimplifiedChinese,
        concat!(
            "150183=否\n",
            "191555=感谢您信任并使用富途牛牛的产品和服务。查看",
            "<a href=\"{{privacy_url}}\">《隐私政策》</a>。\n",
            "204444=每{0}股SPAC股份获发{1}份SPAC权证\n",
            "204549=当前估值合理\n",
            "204552=处于行业高估区间\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,
    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,
    }
}

#[derive(Debug, Clone, Default)]
pub struct LanguageStore {
    texts: BTreeMap<LanguageId, BTreeMap<u32, String>>,
}

impl LanguageStore {
    pub fn new() -> Self {
        Self::default()
    }

    /// Load a C++ language `.ini` text file.
    ///
    /// Lines shaped as `numeric_key=value` start or replace one entry. A line
    /// without a numeric key is appended to the previous entry with a newline,
    /// matching C++ multiline behavior.
    pub fn load_ini(&mut self, language: LanguageId, text: &str) {
        self.load_ini_count(language, text);
    }

    pub fn load_ini_count(&mut self, language: LanguageId, text: &str) -> usize {
        let mut last_key: Option<u32> = None;
        let mut loaded = 0usize;
        let mut lines = text.split('\n').peekable();
        while let Some(raw_line) = lines.next() {
            if raw_line.is_empty() && lines.peek().is_none() {
                break;
            }
            let line = raw_line.strip_suffix('\r').unwrap_or(raw_line);
            if let Some((key_text, value)) = line.split_once('=')
                && let Ok(key) = key_text.parse::<u32>()
            {
                self.texts
                    .entry(language)
                    .or_default()
                    .insert(key, decode_escaped_text(value));
                last_key = Some(key);
                loaded += 1;
                continue;
            }

            if let Some(key) = last_key
                && let Some(existing) = self
                    .texts
                    .get_mut(&language)
                    .and_then(|texts| texts.get_mut(&key))
            {
                existing.push('\n');
                existing.push_str(line);
            }
        }
        loaded
    }

    pub fn translate_key(
        &self,
        language: LanguageId,
        key: u32,
        fallback: Option<&str>,
        allow_english_fallback: bool,
    ) -> Option<String> {
        if let Some(text) = self.find_non_empty(language, key) {
            return Some(text.to_string());
        }
        if allow_english_fallback
            && language != LanguageId::English
            && let Some(text) = self.find_non_empty(LanguageId::English, key)
        {
            return Some(text.to_string());
        }
        fallback.map(ToOwned::to_owned)
    }

    pub fn translate_key_with_template(
        &self,
        language: LanguageId,
        key: u32,
        fallback: Option<&str>,
        allow_english_fallback: bool,
        template: &BTreeMap<String, String>,
    ) -> Option<String> {
        let text = self.translate_key(language, key, fallback, allow_english_fallback)?;
        Some(replace_placeholders(text, template))
    }

    fn find_non_empty(&self, language: LanguageId, key: u32) -> Option<&str> {
        self.texts
            .get(&language)
            .and_then(|texts| texts.get(&key))
            .map(String::as_str)
            .filter(|value| !value.is_empty())
    }
}

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

pub fn translate_runtime_key(language: LanguageId, key: u32) -> Option<String> {
    if let Some(text) = runtime_language_store().translate_key(language, key, None, false) {
        return Some(text);
    }
    if language != LanguageId::English {
        return runtime_language_store().translate_key(LanguageId::English, key, None, false);
    }
    None
}

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> {
    if let Some(text) =
        runtime_language_store().translate_key_with_template(language, key, None, false, template)
    {
        return Some(text);
    }
    if language != LanguageId::English {
        return runtime_language_store().translate_key_with_template(
            LanguageId::English,
            key,
            None,
            false,
            template,
        );
    }
    None
}

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_store() -> &'static LanguageStore {
    static STORE: OnceLock<LanguageStore> = OnceLock::new();
    STORE.get_or_init(|| {
        let cache_root = default_language_pack_cache_root();
        FileCacheLanguagePackSource {
            cache_root: cache_root.clone(),
        }
        .load()
        .unwrap_or_else(|error| {
            tracing::debug!(
                cache_root = %cache_root.display(),
                %error,
                "language_pack_status source=minimal_fallback"
            );
            match MinimalFallbackLanguagePackSource.load() {
                Ok(store) => store,
                Err(fallback_error) => {
                    tracing::error!(
                        %fallback_error,
                        "language_pack_status source=empty fallback_load_failed=true"
                    );
                    LanguageStore::new()
                }
            }
        })
    })
}

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);
    format!("{:x}", 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])
}

fn decode_escaped_text(text: &str) -> String {
    let mut decoded = String::with_capacity(text.len());
    let mut chars = text.chars();
    while let Some(ch) = chars.next() {
        if ch != '\\' {
            decoded.push(ch);
            continue;
        }

        match chars.next() {
            Some('r') => decoded.push('\r'),
            Some('n') => decoded.push('\n'),
            Some('t') => decoded.push('\t'),
            Some('\\') => decoded.push('\\'),
            Some(other) => {
                decoded.push('\\');
                decoded.push(other);
            }
            None => decoded.push('\\'),
        }
    }
    decoded
}

fn replace_placeholders(mut text: String, template: &BTreeMap<String, String>) -> String {
    for (key, value) in template {
        text = text.replace(&format!("{{{{{key}}}}}"), value);
        text = text.replace(&format!("{{{key}}}"), value);
    }
    text
}

#[cfg(test)]
mod tests;