using System.Collections.Generic;
using asap.core;
using cfg;
using game;
using UnityEngine;
using UnityEngine.Localization;
using UnityEngine.Localization.Settings;

// TODO Refactor  namespace  to game
namespace GameCore
{
    public class ChangeLanguageEvent
    {
        public string lang;
    }
    // TODO Refactor To Service
    public static class LocalizationMgr
    {
        public static string[] LanguageLanguages;
        public static List<string> enumLanguage;
        public static List<string> languagePackList;
        public static int LanguageIndex { get; private set; } = 1;

        static int unitOfWeight;
        static List<string> unitOfWeightStrs = new List<string> { "UI_FishingRewardPanel_101017", "UI_FishingRewardPanel_101039" };
        static List<double> unitOfWeightValues = new List<double> { 1, 2.20462262f };
        static string unitOfWeightStr = "UI_FishingRewardPanel_101017";
        static double unitOfWeightValue = 1f;

        public static void Init()
        {
            TbLanguageConfig languageConfig = GContext.container.Resolve<cfg.Tables>().TbLanguageConfig;
            List<LanguageConfig> _dataMap = languageConfig.DataList;
            enumLanguage = new List<string>();// GContext.container.Resolve<cfg.Tables>().TbGlobalConfig.LanguageList;
            languagePackList = new List<string>(); //GContext.container.Resolve<cfg.Tables>().TbGlobalConfig.LanguagePackList;
            for (int i = 0; i < _dataMap.Count; i++)
            {
                enumLanguage.Add(_dataMap[i].ID);
                languagePackList.Add(_dataMap[i].LanGroup);
            }

            LanguageLanguages = new string[enumLanguage.Count];
            for (int i = 0; i < enumLanguage.Count; i++)
            {
                if (enumLanguage[i] == "zh_Hans")
                {
                    LanguageLanguages[i] = "中文 (简体)";
                }
                else if (enumLanguage[i] == "zh_Hant")
                {
                    LanguageLanguages[i] = "中文 (繁體)";
                }
                else
                {
                    LanguageLanguages[i] = System.Globalization.CultureInfo.GetCultureInfo(enumLanguage[i]).NativeName;
                }
            }
            SetUnitOfWeight();
            SetLanguage();
        }

        static async void SetLanguage()
        {
            ISettingService setting = GContext.container.Resolve<ISettingService>();
            ILoadResourceService loadResourceService = GContext.container.Resolve<ILoadResourceService>();
            int index = enumLanguage.IndexOf(setting.Lang);
            if (index == -1)
            {
                index = 1;
            }
            string languagePack = languagePackList[index];
            bool isInit = await loadResourceService.CheckResource(languagePack);
            if (!isInit || !enumLanguage.Contains(setting.Lang))
            {
                setting.Lang = GContext.container.Resolve<cfg.Tables>().TbGlobalConfig.LanguageSetting;
                index = enumLanguage.IndexOf(setting.Lang);
            }
            if (index == -1)
            {
                index = 1;
            }
            LanguageIndex = index;// language;

            await LocalizationSettings.InitializationOperation.Task;
            string lang = setting.Lang.Replace('_', '-');
            Locale locale = LocalizationSettings.AvailableLocales.GetLocale(lang);
            if (locale == null)
            {
                Debug.LogError($"未找到语言包: {setting.Lang}");
                return;
            }
            LocalizationSettings.SelectedLocale = locale;
        }

        public static async void SetLanguageAsync(int languageIndex)
        {

            ISettingService setting = GContext.container.Resolve<ISettingService>();
            setting.Lang = enumLanguage[languageIndex];
            LanguageIndex = languageIndex;
            IUserService iUService = GContext.container.Resolve<IUserService>();
            await LocalizationSettings.InitializationOperation.Task;
            string lang = setting.Lang.Replace('_', '-');
            Locale locale = LocalizationSettings.AvailableLocales.GetLocale(lang);
            if (locale == null)
            {
                Debug.LogError($"未找到语言包: {setting.Lang}");
                return;
            }
            await iUService.UpdateLanguage(setting.Lang);
            LocalizationSettings.SelectedLocale = locale;
            GContext.Publish(new ChangeLanguageEvent());
        }

        private static cfg.TbText table;
        private static cfg.TbText TbText
        {
            get
            {
                if (null == table)
                {
                    table = GContext.container.Resolve<cfg.Tables>()?.TbText;
                }
                return table;
            }
        }

        public static string GetText(string text_key)
        {
            if (string.IsNullOrEmpty(text_key))
            {
                return "";
            }
            text_key = text_key.Replace(" ", "");
            if (TbText != null)
            {
                var text_value = TbText.GetOrDefault(text_key);
                if (text_value != null)
                {
                    return text_value.GetText(enumLanguage[LanguageIndex]);
                }
                else
                {
                    GameDebug.LogError($"[LocalizationMgr]GetText: Not found text_key {text_key} in TbText!");
                }
            }
            else
            {
                GameDebug.LogError($"[LocalizationMgr]GetText: Not found tables in DataManager!");
            }

            return text_key;
        }
        public static void SetUnitOfWeight()
        {
            var setting = GContext.container.Resolve<ISettingService>();
            unitOfWeight = setting.UnitOfWeight;
            if (unitOfWeight >= unitOfWeightStrs.Count)
            {
                unitOfWeight = unitOfWeightStrs.Count - 1;
                Debug.LogError($"[LocalizationMgr]SetUnitOfWeight: Not found unitOfWeight {unitOfWeight} in TbText!");
            }
            unitOfWeightStr = unitOfWeightStrs[unitOfWeight];
            unitOfWeightValue = unitOfWeightValues[unitOfWeight];
        }

        public static string GetWeight(double num, bool keep = false)
        {
            num *= unitOfWeightValue;
            if (num < 1000)
            {
                return GetFormatTextValue(
                        unitOfWeightStr,
                         ConvertTools.GetNumberStringRetain(num, keep));
            }
            else
            {
                return GetFormatTextValue(
                    unitOfWeightStr,
                    ConvertTools.GetNumberString((ulong)num, keep));
            }
        }

        public static string GetFormatTextValue(string text_key, params object[] str)
        {

            try
            {
                return GetText(text_key).SafeFormat(str);
            }
            catch
            {
                Debug.LogError($"Localization Format Text Error :{text_key}");
                return text_key;
            }
        }
    }
}