using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using Newtonsoft.Json;

namespace TeamAAS.Localization
{
    /// <summary>
    /// 全局多语言管理器 - 支持使用原文（中文/英文等）作为查找 key
    /// </summary>
    public class GlobalLocalizationManager
    {
        private static readonly Lazy<GlobalLocalizationManager> _instance = new Lazy<GlobalLocalizationManager>(() => new GlobalLocalizationManager());
        public static GlobalLocalizationManager Instance => _instance.Value;

        private readonly Dictionary<string, LanguageResourcePack> _languagePacks = new Dictionary<string, LanguageResourcePack>();
        private string _currentLanguage = "zh-CN"; // 默认中文
        private string _fallbackLanguage = "zh-CN"; // 回退语言（用于查找 key）

        /// <summary>
        /// 当前语言（如 "zh-CN", "en-US", "ja-JP"）
        /// </summary>
        public string CurrentLanguage
        {
            get => _currentLanguage;
            set
            {
                if (_currentLanguage != value)
                {
                    _currentLanguage = value;
                    LanguageChanged?.Invoke(this, EventArgs.Empty);
                }
            }
        }

        /// <summary>
        /// 回退语言（用于反向查找原文对应的 key）- 通常是中文
        /// </summary>
        public string FallbackLanguage
        {
            get => _fallbackLanguage;
            set => _fallbackLanguage = value;
        }

        /// <summary>
        /// 语言切换事件
        /// </summary>
        public event EventHandler LanguageChanged;

        /// <summary>
        /// 已加载的语言列表
        /// </summary>
        public IReadOnlyList<string> AvailableLanguages => _languagePacks.Keys.ToList();

        private GlobalLocalizationManager()
        {
        }
        public string GetLanguageName(string languageCode)
        {
            if (_languagePacks.TryGetValue(languageCode, out var pack))
            {
                return pack.LanguageName;
            }
            return languageCode; // 如果没有找到，返回语言代码
        }
        /// <summary>
        /// 从指定目录加载所有语言包（.json 人类可读格式）
        /// </summary>
        /// <param name="localizationDirectory">多语言资源目录，如 "Localization"</param>
        public void LoadLanguagePacks(string localizationDirectory)
        {
            if (!Directory.Exists(localizationDirectory))
            {
                Directory.CreateDirectory(localizationDirectory);
                return;
            }
            _languagePacks.Clear();
            var jsonFiles = Directory.GetFiles(localizationDirectory, "*.json", SearchOption.AllDirectories);
            foreach (var file in jsonFiles)
            {
                try
                {
                    var json = File.ReadAllText(file);
                    var pack = JsonConvert.DeserializeObject<LanguageResourcePack>(json);

                    if (pack != null && !string.IsNullOrWhiteSpace(pack.LanguageCode))
                    {
                        _languagePacks[pack.LanguageCode] = pack;
                        AppLogger.Info($"[Localization] 已加载 JSON 语言包: {pack.LanguageName} ({pack.LanguageCode}) - {file}");
                    }
                }
                catch (Exception ex)
                {
                    AppLogger.Error($"[Localization] 加载 JSON 语言包失败: {file} - {ex.Message}");
                }
            }
        }

        /// <summary>
        /// 添加单个语言包（支持运行时动态添加）
        /// </summary>
        public void AddLanguagePack(LanguageResourcePack pack)
        {
            if (pack == null || string.IsNullOrWhiteSpace(pack.LanguageCode))
                return;

            _languagePacks[pack.LanguageCode] = pack;
        }

        /// <summary>
        /// 翻译文本 - 使用原文作为 key 查找翻译
        /// </summary>
        /// <param name="originalText">原文（如"相机设备"）</param>
        /// <param name="context">可选的上下文信息（如类型名、属性名等）</param>
        /// <returns>翻译后的文本，如果没有找到则返回原文</returns>
        public string Translate(string originalText, string context = null)
        {
            if (string.IsNullOrWhiteSpace(originalText))
                return originalText;

            // 如果当前语言就是回退语言（中文），直接返回原文
            if (_currentLanguage == _fallbackLanguage)
                return originalText;

            // 从当前语言包查找翻译
            if (_languagePacks.TryGetValue(_currentLanguage, out var pack))
            {
                var translation = pack.GetTranslationByOriginalText(originalText, context);
                if (!string.IsNullOrWhiteSpace(translation))
                    return translation;
            }

            // 找不到翻译，返回原文
            return originalText;
        }

        /// <summary>
        /// 获取属性的显示名称翻译
        /// </summary>
        /// <param name="typeName">类型名称</param>
        /// <param name="propertyName">属性名称</param>
        /// <param name="originalDisplayName">原始显示名称（来自 [DisplayName] 特性）</param>
        public string GetPropertyDisplayName(string typeName, string propertyName, string originalDisplayName)
        {
            return Translate(originalDisplayName, $"{typeName}.{propertyName}.DisplayName");
        }

        /// <summary>
        /// 获取属性的描述翻译
        /// </summary>
        public string GetPropertyDescription(string typeName, string propertyName, string originalDescription)
        {
            return Translate(originalDescription, $"{typeName}.{propertyName}.Description");
        }

        /// <summary>
        /// 获取属性的分类翻译
        /// </summary>
        public string GetPropertyCategory(string typeName, string propertyName, string originalCategory)
        {
            return Translate(originalCategory, $"{typeName}.{propertyName}.Category");
        }

        /// <summary>
        /// 获取插件的显示名称翻译
        /// </summary>
        public string GetPluginDisplayName(string pluginId, string originalDisplayName)
        {
            return Translate(originalDisplayName, $"Plugin.{pluginId}.DisplayName");
        }

        /// <summary>
        /// 获取插件的描述翻译
        /// </summary>
        public string GetPluginDescription(string pluginId, string originalDescription)
        {
            return Translate(originalDescription, $"Plugin.{pluginId}.Description");
        }

        /// <summary>
        /// 获取插件类别的翻译
        /// </summary>
        public string GetPluginCategoryName(string originalCategory)
        {
            return Translate(originalCategory, "PluginCategory");
        }

        /// <summary>
        /// 获取枚举值的翻译
        /// </summary>
        public string GetEnumDisplayName(string enumTypeName, string originalEnumValue)
        {
            return Translate(originalEnumValue, $"Enum.{enumTypeName}");
        }

        /// <summary>
        /// 获取通用UI文本翻译
        /// </summary>
        public string GetUIText(string originalText)
        {
            return Translate(originalText, "UI");
        }
    }
}