using Framework;
using System;
using System.Collections;
using System.Collections.Generic;
using cfg;
using cfg.StringCfg;
using Cysharp.Threading.Tasks;
using Newtonsoft.Json;
using PhxhSDK;
using SimpleJSON;
using UnityEngine;
using Constants = Framework.Constants;

public class StringManager
{
    private static StringManager m_instance;

    //public static LanguageType CurLanguage = LanguageType.Default;
    public static Dictionary<string, string> MixKeyDic;
    public static string MixKeyConfigPath = "Assets/Config/MixKey/MixKeyConfig.json";
    public static StringConfig StringConfig;

    public static StringManager Instance
    {
        get
        {
            if (m_instance == null)
            {
                m_instance = new StringManager();
            }

            return m_instance;
        }
    }

    //public enum LanguageType
    //{
    //    Default,
    //    CN,
    //    TW,
    //    EN,
    //}

    //登录时获取语言
    public static LanguageManager.LanguageType GetLoginLanguageType()
    {
#if UNITY_EDITOR
        var storeData = StorageMgr.Instance.GetStorage<LanguageStorage>("LanguageStorage");
        if (storeData != null)
        {
            if (!storeData.IsSetLanguage)
            {
                var systemLanguage = LanguageManager.Instance.GetDeviceLanguage();
                switch (systemLanguage)
                {
                    case SystemLanguage.Chinese:
                        LanguageManager.Instance.SetCurrentLanguage(LanguageManager.LanguageType.CN);
                        break;
                    case SystemLanguage.ChineseSimplified:
                        LanguageManager.Instance.SetCurrentLanguage(LanguageManager.LanguageType.CN);
                        break;
                    case SystemLanguage.English:
                        LanguageManager.Instance.SetCurrentLanguage(LanguageManager.LanguageType.EN);
                        break;
                    default:
                        LanguageManager.Instance.SetCurrentLanguage(LanguageManager.LanguageType.CN);
                        break;
                }
            }
            else
            {
                LanguageManager.Instance.SetCurrentLanguage(storeData.LanguageType);
            }
            StoreCurLanguage();
        }
#else
        var type = LanguageManager.GetLanguageTypeByIndex();
        DebugUtil.LogError($"--- OnLogin LanguageType:{type}");
        var systemLanguage = LanguageManager.Instance.GetDeviceLanguage();
        DebugUtil.LogError($"--- OnLogin systemLanguage:{systemLanguage}");
        if (type == LanguageManager.LanguageType.Default)
        {
            switch (systemLanguage)
            {
                case SystemLanguage.Chinese:
                    LanguageManager.Instance.SetCurrentLanguage(LanguageManager.LanguageType.CN);
                    break;
                case SystemLanguage.ChineseSimplified:
                    LanguageManager.Instance.SetCurrentLanguage(LanguageManager.LanguageType.CN);
                    break;
                case SystemLanguage.English:
                    DebugUtil.LogError($"--- OnLogin systemLanguage:English");
                    LanguageManager.Instance.SetCurrentLanguage(LanguageManager.LanguageType.EN);
                    break;
                default:
                    LanguageManager.Instance.SetCurrentLanguage(LanguageManager.LanguageType.CN);
                    break;
            }
        }
        else
        {
            DebugUtil.LogError($"--- OnLogin SetCurrentLanguage:{type}");
            LanguageManager.Instance.SetCurrentLanguage(type);
        }
#endif
        
        return LanguageManager.CurLanguage;
    }
    public static string GetLocalizeJsonPath()
    {
        switch (LanguageManager.CurLanguage)
        {
            case LanguageManager.LanguageType.CN:
                return Constants.DATA_LANGUAGE_PATH_CN;
            case LanguageManager.LanguageType.EN:
                return Constants.DATA_LANGUAGE_PATH_EN;
            default:
                return Constants.DATA_LANGUAGE_PATH_CN;
        }
    }

    public static void StoreCurLanguage()
    {
#if UNITY_EDITOR
        var storeData = StorageMgr.Instance.GetStorage<LanguageStorage>("LanguageStorage");
        if (storeData != null)
        {
            storeData.LanguageType = LanguageManager.CurLanguage;
            storeData.IsSetLanguage = true;
            StorageMgr.Instance.SyncForce = true;
        }
#else
        LanguageManager.SetLanguageType(LanguageManager.CurLanguage);
        DebugUtil.LogError($"LanguageType:{LanguageManager.CurLanguage}");
#endif
    }

    #region 读对应文本值
    
    private DataString GetStringConfigByKey(string key)
    {
        var dataString = StringConfig?.GetOrDefault(key);
        if (dataString == null || string.IsNullOrEmpty(dataString.Name))
        {
            DebugUtil.LogWarning("{0}.GetStringConfigByKey: key = {1} is not exist, check table please!!", GetType(),
                key);
        }

        return dataString;
    }

    private string GetStringConfigValue(DataString data)
    {
        string value = "";
        // switch (LanguageManager.CurLanguage)
        // {
        //     case (LanguageManager.LanguageType.Default):
        //     {
        //         value = data.Value;
        //         break;
        //     }
        //     case (LanguageManager.LanguageType.CN):
        //     {
        //         value = data.Value;
        //         break;
        //     }
        //     case (LanguageManager.LanguageType.TW):
        //     {
        //         break;
        //     }
        //     case (LanguageManager.LanguageType.EN):
        //     {
        //         value = data.ValueEn;
        //         break;
        //     }
        //     default:
        //     {
        //         DebugUtil.LogError($"==== 文本翻译的语言不存在相应的枚举值！请检查语言设置！！！ ====");
        //         break;
        //     }
        // }

        value = data.Name;
        //DebugUtil.LogG($"key:{data.Key}, name:{data.Name}");
        value = _GetParamsReplacedStr(data, value);

        return value;
    }

    private string _GetParamsReplacedStr(DataString data, string content)
    {
        if (!content.Contains("[p"))
        {
            return content;
        }

        string retStr = content;
        if (content.Contains("[p0]"))
        {
            var param = _GetParam(data, 0);
            if (param == null || !MixKeyDic.ContainsKey(param))
            {
                DebugUtil.LogError($"MixKey配置有误，StringConfigKey: {data.Key}");
                return content;
            }

            var val = MixKeyDic[param];
            retStr = retStr.Replace("[p0]", val);
        }

        if (content.Contains("[p1]"))
        {
            var param = _GetParam(data, 1);
            if (param == null || !MixKeyDic.ContainsKey(param))
            {
                DebugUtil.LogError($"MixKey配置有误，StringConfigKey: {data.Key}");
                return content;
            }

            var val = MixKeyDic[param];
            retStr = retStr.Replace("[p1]", val);
        }

        if (content.Contains("[p2]"))
        {
            var param = _GetParam(data, 2);
            if (param == null || !MixKeyDic.ContainsKey(param))
            {
                DebugUtil.LogError($"MixKey配置有误，StringConfigKey: {data.Key}");
                return content;
            }

            var val = MixKeyDic[param];
            retStr = retStr.Replace("[p2]", val);
        }

        return retStr;
    }

    private string _GetParam(DataString data, int idx)
    {
        if (idx == 0)
        {
            return data.Param0;
        }

        if (idx == 1)
        {
            return data.Param1;
        }

        if (idx == 2)
        {
            return data.Param2;
        }

        return null;
    }

    public string GetTextByKey(string key)
    {
        DataString dataString = GetStringConfigByKey(key);
        if (dataString != null)
        {
            return GetStringConfigValue(dataString);
        }

        return key;
    }

    public string GetTextFirstParamByKey(string key)
    {
        DataString DataString = GetStringConfigByKey(key);
        if (DataString != null)
        {
            return GetFirstParamValue(DataString);
        }

        return key;
    }

    /// <summary>
    /// 获取string中第一个param的值
    /// </summary>
    private string GetFirstParamValue(DataString data)
    {
        string value = data.Name;

        if (!value.Contains("[p"))
        {
            return null;
        }

        if (value.Contains("[p0]"))
        {
            var param = _GetParam(data, 0);
            if (param == null || !MixKeyDic.ContainsKey(param))
            {
                DebugUtil.LogError($"MixKey配置有误，StringConfigKey: {data.Key}");
                return null;
            }

            return MixKeyDic[param];
        }

        return null;
    }

    public string GetTextByKeyAndParams<T>(string key, T param)
    {
        DataString DataString = GetStringConfigByKey(key);
        string str = key;
        if (DataString != null)
        {
            str = GetStringConfigValue(DataString);
            str = string.Format(str, param);
        }

        return str;
    }

    public string GetTextByKeyAndParams<T0, T1>(string key, T0 param0, T1 param1)
    {
        DataString DataString = GetStringConfigByKey(key);
        string str = key;
        if (DataString != null)
        {
            str = GetStringConfigValue(DataString);
            str = string.Format(str, param0, param1);
        }

        return str;
    }

    public string GetTextByKeyAndParams<T0, T1, T2>(string key, T0 param0, T1 param1, T2 param2)
    {
        DataString DataString = GetStringConfigByKey(key);
        string str = key;
        if (DataString != null)
        {
            str = GetStringConfigValue(DataString);
            str = string.Format(str, param0, param1, param2);
        }

        return str;
    }

    //本地化，后续扩展
    public string GetLocalizeTextByKey(string key)
    {
        return GetTextByKey(key);
    }

    //可填入参数的文本，目前最多支持三个参数
    public string GetLocalizeTextByKeyAndParams(string key, params object[] param)
    {
        if (param.Length <= 0)
        {
            return GetTextByKey(key);
        }
        else if (param.Length == 1)
        {
            return GetTextByKeyAndParams(key, param[0]);
        }
        else if (param.Length == 2)
        {
            return GetTextByKeyAndParams(key, param[0], param[1]);
        }
        else if (param.Length == 3)
        {
            return GetTextByKeyAndParams(key, param[0], param[1], param[2]);
        }

        DebugUtil.LogError(string.Format("==== 请检查文本内容参数个数！！！ 文本Key为 {0} ！ ====", key));
        return "";
    }

    /// <summary>
    /// 获取本地化文本，根据本地化key和参数列表
    /// </summary>
    /// <param name="key"></param>
    /// <param name="param"></param>
    /// <returns></returns>
    public string GetLocalizeTextByKeyAndList(string key, params string[] param)
    {
        if (param == null)
            return GetTextByKey(key);

        switch (param.Length)
        {
            case 0:
                return GetTextByKey(key);
            case 1:
                return GetTextByKeyAndParams(key, param[0]);
            case 2:
                return GetTextByKeyAndParams(key, param[0], param[1]);
            case 3:
                return GetTextByKeyAndParams(key, param[0], param[1], param[2]);
            default:
            {
                DebugUtil.LogError($"==== 请检查文本内容参数个数！！！ 文本Key为 {key} ！ ====");
            }
                return string.Empty;
        }
    }

    //public static void ChangeLanguage(LanguageType language)
    //{
    //    CurLanguage = language;
    //}

    public static string GetStoryTalkText(string key)
    {
        return key;
    }
    
    #endregion

    #region MixKey加载

    public static async UniTask LoadMixKeyDic()
    {
        var txtAsset = await AssetManager.Instance.LoadAssetAsync<TextAsset>(MixKeyConfigPath);
        if (txtAsset == null)
        {
            DebugUtil.LogError("MixKeyConfig 资源无法加载，请检查路径!");
            return;
        }

        var jsonTxt = txtAsset.text;
        var dic = JsonConvert.DeserializeObject<Dictionary<string, string>>(jsonTxt);
        MixKeyDic = dic;
    }

    #endregion
}

public class LanguageStorage
{
    public LanguageManager.LanguageType LanguageType;
    public bool IsSetLanguage;
}