18xchat/assets/Scripts/Main/Common/LanguageUtils.ts

import { _decorator, sys } from "cc";
import { Language } from "../../schema/schema";
import { ConfigManager } from "../../chat18x/manager/ConfigManager";
import { CommonConfig } from "../Config/CommonConfig";
import li_EventManager from "./li_EventManager";
import Utils from "./Utils";
import { InnerMsgCode } from "../Config/InnerMsgCode";
import { logger } from "db://assets/Scripts/Main/Common/Logger";

const { ccclass } = _decorator;

export enum LanguageType {
  EN = "en", // 英文
  CN = "cn", // 中文
  HI = "hi", // 印地语
}

export enum LanguageEvent {
  LANGUAGE_CHANGED = "LANGUAGE_CHANGED",
}

@ccclass("LanguageUtils")
export default class LanguageUtils {
  private static currentLanguage: LanguageType = LanguageType.EN;
  private static languageCache: Map<string, string> = new Map();
  private static isInitialized: boolean = false;

  public static get CurrentLanguage(): LanguageType {
    if (!this.isInitialized) {
      this.init();
    }
    return this.currentLanguage;
  }

  private static init() {
    if (this.isInitialized) return;
    this.isInitialized = true;
    this.loadLanguageSetting();
  }

  private static loadLanguageSetting() {
    const savedLanguage = sys.localStorage.getItem(
      CommonConfig.StorageConfig.LANGUAGE_SETTING
    );
    if (
      savedLanguage &&
      Object.values(LanguageType).includes(savedLanguage as LanguageType)
    ) {
      this.currentLanguage = savedLanguage as LanguageType;
    } else {
      this.detectSystemLanguage();
    }
    logger.log(
      "LanguageUtils initialized with language:",
      this.currentLanguage
    );
  }

  private static detectSystemLanguage() {
    const systemLanguage = sys.language;
    if (systemLanguage.startsWith("zh")) {
      this.currentLanguage = LanguageType.EN;
    } else if (systemLanguage.startsWith("hi")) {
      this.currentLanguage = LanguageType.HI;
    } else {
      this.currentLanguage = LanguageType.EN;
    }
  }

  public static setLanguage(language: LanguageType): void {
    if (!this.isInitialized) {
      this.init();
    }

    if (this.currentLanguage === language) {
      return;
    }

    this.currentLanguage = language;
    this.languageCache.clear();
    sys.localStorage.setItem(
      CommonConfig.StorageConfig.LANGUAGE_SETTING,
      language
    );

    Utils.sendInnerMsg(InnerMsgCode.LanguageChange, language);
    logger.log("Language changed to:", language);
  }

  public static getText(key: string, defaultText: string = ""): string {
    if (!this.isInitialized) {
      this.init();
    }

    if (!key) {
      return defaultText;
    }

    if (this.languageCache.has(key)) {
      return this.languageCache.get(key);
    }

    if (!ConfigManager.tables || !ConfigManager.tables.TbLanguage) {
      logger.warn("Language table not loaded yet");
      return defaultText || key;
    }

    const languageData = ConfigManager.tables.TbLanguage.get(key);
    if (!languageData) {
      logger.warn(`Language key not found: ${key}`);
      return defaultText || key;
    }

    let text: string = "";
    switch (this.currentLanguage) {
      case LanguageType.EN:
        text = languageData.languageEn;
        break;
      case LanguageType.CN:
        text = languageData.languageCn;
        break;
      case LanguageType.HI:
        text = languageData.languageHi;
        break;
      default:
        text = languageData.languageEn;
    }

    if (!text || text.length === 0) {
      text = languageData.languageEn || defaultText || key;
    }

    this.languageCache.set(key, text);
    return text;
  }

  public static getTextByLanguage(
    key: string,
    language: LanguageType = LanguageType.EN,
    defaultText: string = ""
  ): string {
    if (!this.isInitialized) {
      this.init();
    }

    if (!key) {
      return defaultText;
    }

    if (!ConfigManager.tables || !ConfigManager.tables.TbLanguage) {
      logger.warn("Language table not loaded yet");
      return defaultText || key;
    }

    const languageData = ConfigManager.tables.TbLanguage.get(key);
    if (!languageData) {
      logger.warn(`Language key not found: ${key}`);
      return defaultText || key;
    }

    let text: string = "";
    switch (language) {
      case LanguageType.EN:
        text = languageData.languageEn;
        break;
      case LanguageType.CN:
        text = languageData.languageCn;
        break;
      case LanguageType.HI:
        text = languageData.languageHi;
        break;
      default:
        text = languageData.languageEn;
    }

    if (!text || text.length === 0) {
      text = languageData.languageEn || defaultText || key;
    }

    return text;
  }

  public static getTextWithParams(
    key: string,
    params: { [key: string]: any },
    defaultText: string = ""
  ): string {
    let text = this.getText(key, defaultText);
    
    if (!params || Object.keys(params).length === 0) {
      return text;
    }

    // Replace placeholders in the format {paramName} with actual values
    for (const [paramKey, paramValue] of Object.entries(params)) {
      const placeholder = `{${paramKey}}`;
      text = text.replace(new RegExp(placeholder, 'g'), String(paramValue));
    }

    return text;
  }

  public static getAvailableLanguages(): LanguageType[] {
    return Object.values(LanguageType);
  }

  public static getLanguageDisplayName(language: LanguageType): string {
    switch (language) {
      case LanguageType.EN:
        return "English";
      case LanguageType.CN:
        return "中文";
      case LanguageType.HI:
        return "हिंदी";
      default:
        return language;
    }
  }

  public static clearCache(): void {
    this.languageCache.clear();
  }

  public static onLanguageChanged(
    callback: (language: LanguageType) => void,
    target: any
  ): void {
    Utils.addInnerEL(InnerMsgCode.LanguageChange, target, callback);
  }

  public static offLanguageChanged(
    callback: (language: LanguageType) => void,
    target: any
  ): void {
    Utils.removeInnerEL(InnerMsgCode.LanguageChange, target, callback);
  }
}