/**
 * 国际化 (i18n) 核心模块
 * 支持多语言切换，可扩展其他语言
 *
 * 添加新语言只需：
 * 1. 创建语言文件 js/lang/xx.js（定义 window.LANG_XX）
 * 2. 在下方 languages 数组中添加配置
 */

// 支持的语言配置（集中管理）
// 优先使用 loader.js 提供的配置；未加载时使用此处默认
const i18nLanguages = window.I18N_LANGUAGES || [
  {
    code: 'en',           // 语言代码，用于 localStorage 和内部标识
    label: 'English',     // 显示名称
    dict: 'LANG_EN',      // window 上的字典变量名
    file: 'en.js',        // 语言文件名
    backend: 'english',   // 后端语言标识
    browserMatch: ['en']  // 浏览器语言匹配前缀
  },
  {
    code: 'zh',
    label: '简体中文',
    dict: 'LANG_ZH',
    file: 'zh.js',
    backend: 'chinese',
    browserMatch: ['zh']  // 匹配 zh 但不匹配 zh-tw/zh-hk 等（繁体优先匹配）
  },
  {
    code: 'zht',
    label: '繁體中文',
    dict: 'LANG_ZHT',
    file: 'zht.js',
    backend: 'chinese_traditional',
    // 繁体中文匹配：台湾、香港、澳门、通用繁体标识
    browserMatch: ['zh-tw', 'zh-hk', 'zh-mo', 'zh-hant']
  },
  {
    code: 'de',
    label: 'Deutsch',
    dict: 'LANG_DE',
    file: 'de.js',
    backend: 'german',
    browserMatch: ['de']
  },
  {
    code: 'es',
    label: 'Español',
    dict: 'LANG_ES',
    file: 'es.js',
    backend: 'spanish',
    browserMatch: ['es']
  },
  {
    code: 'fr',
    label: 'Français',
    dict: 'LANG_FR',
    file: 'fr.js',
    backend: 'french',
    browserMatch: ['fr']
  },
  {
    code: 'it',
    label: 'Italiano',
    dict: 'LANG_IT',
    file: 'it.js',
    backend: 'italian',
    browserMatch: ['it']
  },
  {
    code: 'ja',
    label: '日本語',
    dict: 'LANG_JA',
    file: 'ja.js',
    backend: 'japanese',
    browserMatch: ['ja']
  },
  {
    code: 'ko',
    label: '한국어',
    dict: 'LANG_KO',
    file: 'ko.js',
    backend: 'korean',
    browserMatch: ['ko']
  },
  {
    code: 'pt',
    label: 'Português',
    dict: 'LANG_PT',
    file: 'pt.js',
    backend: 'portuguese',
    browserMatch: ['pt']
  },
  {
    code: 'ru',
    label: 'Русский',
    dict: 'LANG_RU',
    file: 'ru.js',
    backend: 'russian',
    browserMatch: ['ru']
  },
  {
    code: 'tr',
    label: 'Türkçe',
    dict: 'LANG_TR',
    file: 'tr.js',
    backend: 'turkish',
    browserMatch: ['tr']
  }
];

// 默认语言
const i18nDefaultLang = window.I18N_DEFAULT_LANG || 'en';

/**
 * 根据浏览器语言自动检测首选语言
 */
function normalizeLangCode(lang) {
  return String(lang || '').toLowerCase().replace(/_/g, '-');
}

function getBrowserLangCandidates() {
  var candidates = [];

  function addCandidate(lang) {
    lang = normalizeLangCode(lang);
    if (!lang || candidates.indexOf(lang) !== -1) return;
    candidates.push(lang);
  }

  try {
    if (navigator.languages && navigator.languages.length) {
      for (var i = 0; i < navigator.languages.length; i++) {
        addCandidate(navigator.languages[i]);
      }
    }

    addCandidate(navigator.language);
    addCandidate(navigator.userLanguage);
    addCandidate(navigator.browserLanguage);
    addCandidate(navigator.systemLanguage);
  } catch (e) {
    // 忽略浏览器语言读取异常
  }

  return candidates;
}

function matchBrowserLang(navLang) {
  var best = null;
  navLang = normalizeLangCode(navLang);
  if (!navLang) return null;

  for (var i = 0; i < i18nLanguages.length; i++) {
    var lang = i18nLanguages[i];
    for (var j = 0; j < lang.browserMatch.length; j++) {
      var match = normalizeLangCode(lang.browserMatch[j]);
      if (navLang === match || navLang.indexOf(match + '-') === 0) {
        if (!best || match.length > best.match.length) {
          best = {
            code: lang.code,
            match: match
          };
        }
      }
    }
  }

  return best ? best.code : null;
}

function detectBrowserLang() {
  var candidates = getBrowserLangCandidates();
  for (var i = 0; i < candidates.length; i++) {
    var matched = matchBrowserLang(candidates[i]);
    if (matched) {
      return matched;
    }
  }

  return i18nDefaultLang;
}

/**
 * 获取有效的语言代码列表
 */
function getValidLangCodes() {
  return i18nLanguages.map(function(lang) { return lang.code; });
}

/**
 * 根据语言代码获取语言配置
 */
function getLangConfig(code) {
  for (var i = 0; i < i18nLanguages.length; i++) {
    if (i18nLanguages[i].code === code) {
      return i18nLanguages[i];
    }
  }
  return null;
}

// 初始化语言：优先使用 localStorage，其次根据浏览器语言自动选择
var initialLang = (function () {
  var validCodes = getValidLangCodes();

  if (window.I18N_SELECTED_LANG && validCodes.indexOf(window.I18N_SELECTED_LANG) !== -1) {
    return window.I18N_SELECTED_LANG;
  }

  try {
    var saved = localStorage.getItem('lang');
    if (saved && validCodes.indexOf(saved) !== -1) {
      return saved;
    }
  } catch (e) {
    // 读取 localStorage 失败时忽略，走自动检测
  }

  var auto = detectBrowserLang();
  try {
    localStorage.setItem('lang', auto);
  } catch (e) {
    // 写入 localStorage 失败时忽略
  }
  return auto;
})();

const i18n = {
  // 当前语言
  lang: initialLang,

  // 语言配置列表（供外部访问）
  languages: i18nLanguages,

  /**
   * 获取当前语言的翻译字典
   */
  getDict() {
    var config = getLangConfig(this.lang);
    if (config && window[config.dict]) {
      return window[config.dict];
    }
    // 回退到默认语言
    var defaultConfig = getLangConfig(i18nDefaultLang);
    return defaultConfig ? window[defaultConfig.dict] : {};
  },

  /**
   * 获取翻译文本
   * @param {string} key - 翻译键，支持点号分隔 (如 'menu.status')
   * @param {Object} params - 可选的替换参数
   */
  t(key, params) {
    const dict = this.getDict();
    let text = key.split('.').reduce((obj, k) => obj && obj[k], dict);

    if (text === undefined) {
      var defaultConfig = getLangConfig(i18nDefaultLang);
      if (defaultConfig && window[defaultConfig.dict]) {
        text = key.split('.').reduce((obj, k) => obj && obj[k], window[defaultConfig.dict]);
      }
      if (text === undefined) {
        console.warn(`[i18n] Missing translation for key: ${key}`);
        return key;
      }
    }

    // 支持参数替换 {0}, {1} 或 {name}
    if (params) {
      if (Array.isArray(params)) {
        params.forEach((val, i) => {
          text = text.replace(new RegExp(`\\{${i}\\}`, 'g'), val);
        });
      } else {
        Object.keys(params).forEach(k => {
          text = text.replace(new RegExp(`\\{${k}\\}`, 'g'), params[k]);
        });
      }
    }

    return text;
  },

  /**
   * 切换语言
   * @param {string} lang - 语言代码
   */
  setLang(lang) {
    if (lang === this.lang) return;

    var config = getLangConfig(lang);
    if (!config) return;

    localStorage.setItem('lang', lang);

    // 异步同步到后端
    const xhr = new XMLHttpRequest();
    xhr.open('GET', '/set_sys?language=' + config.backend, true);

    xhr.onload = () => location.reload();
    xhr.onerror = () => location.reload();

    xhr.send();
  },

  /**
   * 翻译指定根节点内的 i18n 元素
   * @param {Document|Element} root - 翻译作用域，默认整页
   */
  translate(root) {
    var scope = root || document;
    var elements = [];

    function collect(selector) {
      var list = [];
      if (scope.nodeType === 1 && typeof scope.matches === 'function' && scope.matches(selector)) {
        list.push(scope);
      }
      if (typeof scope.querySelectorAll === 'function') {
        var found = scope.querySelectorAll(selector);
        for (var i = 0; i < found.length; i++) {
          list.push(found[i]);
        }
      }
      return list;
    }

    // 翻译 data-i18n 元素
    elements = collect('[data-i18n]');
    elements.forEach(el => {
      const key = el.dataset.i18n;
      const attr = el.dataset.i18nAttr;
      const text = this.t(key);

      if (attr) {
        el.setAttribute(attr, text);
      } else {
        el.textContent = text;
      }
    });

    // 翻译 data-i18n-value 元素
    elements = collect('[data-i18n-value]');
    elements.forEach(el => {
      const key = el.dataset.i18nValue;
      el.value = this.t(key);
    });

    // 翻译 data-i18n-html 元素
    elements = collect('[data-i18n-html]');
    elements.forEach(el => {
      const key = el.dataset.i18nHtml;
      el.innerHTML = this.t(key);
    });

    // 设置页面标题，仅整页翻译时处理
    const titleEl = scope === document ? document.querySelector('[data-i18n-title]') : null;
    if (titleEl) {
      document.title = this.t(titleEl.dataset.i18nTitle);
    }
  },

  /**
   * 初始化页面翻译和语言选择器
   */
  init() {
    this.translate(document);

    // 初始化语言选择器
    this.initLanguageSelector();
  },

  /**
   * 初始化语言选择器（动态生成选项）
   */
  initLanguageSelector() {
    const selector = document.getElementById('langSelect');
    if (!selector) return;

    // 清空现有选项，动态生成
    selector.innerHTML = '';
    for (var i = 0; i < i18nLanguages.length; i++) {
      var lang = i18nLanguages[i];
      var option = document.createElement('option');
      option.value = lang.code;
      option.textContent = lang.label;
      if (lang.code === this.lang) {
        option.selected = true;
      }
      selector.appendChild(option);
    }

    // 绑定切换事件
    selector.onchange = () => {
      this.setLang(selector.value);
    };
  },

  /**
   * 获取当前语言代码
   */
  getLang() {
    return this.lang;
  },

  /**
   * 检查当前是否为简体中文
   */
  isZh() {
    return this.lang === 'zh';
  },

  /**
   * 检查当前是否为英文
   */
  isEn() {
    return this.lang === 'en';
  }
};

// 页面加载完成后自动初始化
if (document.readyState === 'loading') {
  document.addEventListener('DOMContentLoaded', function() {
    i18n.init();
  });
} else {
  i18n.init();
}
