using UnityEngine;
using System;
using System.Collections;
using System.Collections.Generic;
using System.Xml;
using UnityEngine.UI;

public class Language
{
	public enum Enabled
    {
		English,
		ChineseSimplified,
        ChineseTraditional,
    }

	public enum LangType
	{
		Public
	}

    private static bool Inited;

	public static string[] availableArr = new string[]{Enabled.ChineseSimplified.ToString(), Enabled.English.ToString(), Enabled.ChineseTraditional.ToString() };

	private static SystemLanguage defaultLan = SystemLanguage.English;

	public static string lan = SystemLanguage.English.ToString();
    public static string lanForUI = SystemLanguage.English.ToString();

    public static Dictionary<CurrentLanguage, TextAsset> LanguageDic
    {
        get
        {
            if (languageDic == null)
            {
                languageDic = new Dictionary<CurrentLanguage, TextAsset>();
                languageDic.Add(CurrentLanguage.English, ResourceManager.Load<TextAsset>("English", Folder.Config));
                languageDic.Add(CurrentLanguage.ChineseSimplified, ResourceManager.Load<TextAsset>("ChineseSimplified", Folder.Config));
                languageDic.Add(CurrentLanguage.ChineseTraditional, ResourceManager.Load<TextAsset>("ChineseTraditional", Folder.Config));
            }
            return languageDic;
        }
    }
    public static Dictionary<CurrentLanguage, TextAsset> languageDic;

    public static Dictionary<CurrentLanguage, List<XmlDocument>> XmlDocumentDictionary = new Dictionary<CurrentLanguage, List<XmlDocument>>();
    //{
    //    get
    //    {
    //        if (xmlDocumentDictionary == null)
    //        {
    //            InitLanguageDocument();
    //        }
    //        return xmlDocumentDictionary;
    //    }
    //}
    //public static Dictionary<CurrentLanguage, List<XmlDocument>> xmlDocumentDictionary;

    //public static void InitLanguageDocument()
    //{
    //    xmlDocumentDictionary = new Dictionary<CurrentLanguage, List<XmlDocument>>();
    //    XmlDocument xmlDocument = new XmlDocument();
    //    xmlDocument.LoadXml(LanguageDic[CurrentLanguage.English].text);
    //    xmlDocumentDictionary.Add(CurrentLanguage.English, new List<XmlDocument> { xmlDocument });
    //    xmlDocument = new XmlDocument();
    //    xmlDocument.LoadXml(LanguageDic[CurrentLanguage.ChineseSimplified].text);
    //    xmlDocumentDictionary.Add(CurrentLanguage.ChineseSimplified, new List<XmlDocument> { xmlDocument });
    //    xmlDocument = new XmlDocument();
    //    xmlDocument.LoadXml(LanguageDic[CurrentLanguage.ChineseTraditional].text);
    //    xmlDocumentDictionary.Add(CurrentLanguage.ChineseTraditional, new List<XmlDocument> { xmlDocument });
    //}

    public static void AddLanguageDocument(CurrentLanguage language, XmlDocument document)
    {
        //if (xmlDocumentDictionary == null)
        //{
        //    InitLanguageDocument();
        //}
        if (XmlDocumentDictionary.ContainsKey(language))
        {
            XmlDocumentDictionary[language].Add(document);
        }
        else
        {
            XmlDocumentDictionary.Add(language, new List<XmlDocument> {document});
        }
    }

    public static void Initialize()
    {
        if (Inited)
        {
            return;
        }
        Inited = true;

        LanguageManager.CurrentLanguage = ConfigManager.GetStringFormConfig("Language").ToEnum<CurrentLanguage>();
        if (Initializer.Instance.AuditEdition)
        {
            LanguageManager.CurrentLanguage = CurrentLanguage.ChineseSimplified;
        }

        if (LanguageManager.CurrentLanguage == CurrentLanguage.Default)
        {
            if (Application.systemLanguage == SystemLanguage.ChineseSimplified)
            {
                LanguageManager.CurrentLanguage = CurrentLanguage.ChineseSimplified;
            }
            else if (Application.systemLanguage == SystemLanguage.ChineseTraditional)
            {
                LanguageManager.CurrentLanguage = CurrentLanguage.ChineseTraditional;
            }
            else
            {
                LanguageManager.CurrentLanguage = CurrentLanguage.English;
            }
        }

        if (LanguageManager.CurrentLanguage == CurrentLanguage.English)
        {
            ResourceManager.Get<Button>(CanvasLabel.L_TraChi).interactable = true;
            ResourceManager.Get<Button>(CanvasLabel.L_SimChi).interactable = true;
            ResourceManager.Get<Button>(CanvasLabel.L_English).interactable = false;

            ResourceManager.Get<Button>(CanvasLabel.L_TraChi).image.color = Lib.LightGray;
            ResourceManager.Get<Button>(CanvasLabel.L_SimChi).image.color = Lib.LightGray;
            ResourceManager.Get<Button>(CanvasLabel.L_English).image.color = Lib.Orange;
        }
        else if (LanguageManager.CurrentLanguage == CurrentLanguage.ChineseSimplified)
        {
            ResourceManager.Get<Button>(CanvasLabel.L_TraChi).interactable = true;
            ResourceManager.Get<Button>(CanvasLabel.L_SimChi).interactable = false;
            ResourceManager.Get<Button>(CanvasLabel.L_English).interactable = true;

            ResourceManager.Get<Button>(CanvasLabel.L_TraChi).image.color = Lib.LightGray;
            ResourceManager.Get<Button>(CanvasLabel.L_SimChi).image.color = Lib.Orange;
            ResourceManager.Get<Button>(CanvasLabel.L_English).image.color = Lib.LightGray;
        }
        else if (LanguageManager.CurrentLanguage == CurrentLanguage.ChineseTraditional)
        {
            ResourceManager.Get<Button>(CanvasLabel.L_TraChi).interactable = false;
            ResourceManager.Get<Button>(CanvasLabel.L_SimChi).interactable = true;
            ResourceManager.Get<Button>(CanvasLabel.L_English).interactable = true;

            ResourceManager.Get<Button>(CanvasLabel.L_TraChi).image.color = Lib.Orange;
            ResourceManager.Get<Button>(CanvasLabel.L_SimChi).image.color = Lib.LightGray;
            ResourceManager.Get<Button>(CanvasLabel.L_English).image.color = Lib.LightGray;
        }
    }

    public static void SwitchLanguage(CurrentLanguage currentLanguage)
    {
        LanguageManager.CurrentLanguage = currentLanguage;

        //TextAsset textAsset = LanguageDic[currentLanguage];

        //xmls = new XmlDocument();
        //xmls.LoadXml(textAsset.text);
    }

    //public static void Init(string lan)
    //{
    //    Debug.Log("Init Language " + lan);

    //    Language.lan = lan;

    //    string path = "XML/Language/";
    //    TextAsset textAsset = ResourcesUtil.GetInstance().GetTextAsset("XML/Language/" + lan);
    //    if (textAsset == null)
    //    {
    //        Debug.LogError("Can not find language use default " + defaultLan);
    //        textAsset = ResourcesUtil.GetInstance().GetTextAsset("XML/Language/" + defaultLan.ToString());
    //        Language.lan = defaultLan.ToString();
    //    }

    //    if (xml == null)
    //        xml = new XmlDocument();
    //    xml.LoadXml(text);
    //}

 //   public static bool initialized
	//{
	//	get{
	//		return xmls != null;
	//	}
	//}

	public static void LoadFromResource()
	{
		//TextAsset textasset = ResourcesManager.Instance.LoadConfig("xml/lan", lan);
		//xmls = new XmlDocument ();
		//xml.LoadXml (textasset.text);
	}

	public static void Load(System.Action callBack)
	{
		//Language.lan = GetSpecifiedLang();
//		ResourcesManager.Instance.LoadAsset<TextAsset> ("xml/lan", lan, (objs) => {
//			if (objs != null && objs.Length > 0 && objs[0] != null) {
//				xml = new XmlDocument ();
//				xml.LoadXml ((objs[0] as TextAsset).text);
////				Debug.LogError("bundleLoad-->"+(objs[0] as TextAsset).text);
//			} else {
//				TextAsset textasset = ResourcesManager.Instance.LoadConfig("xml/lan", lan);
//				xml = new XmlDocument ();
//				xml.LoadXml (textasset.text);
////				Debug.LogError("resourceLoad-->"+(textasset.text));
//			} 
//			callBack();
//		});


//		AssetBundleLoader.Load(path, lan.ToString(), typeof(TextAsset), (object asset)=>{
//			xml = new XmlDocument();
//			xml.LoadXml((asset as TextAsset).text);
////			AssetBundleUtil.GetInstance().GetFont(AssetBundleUtil.Url.Font, lan.ToString(), (Font assetFont)=>{
////				font = assetFont;
////			});
//			font = ResourcesUtil.GetInstance().GetFont(ResourcesUtil.Url.Font, lan);
////			font = ResourcesUtil.GetInstance().GetFont(ResourcesUtil.Url.Font, Enabled.Chinese.ToString());
//			callBack();
//		}, true);
	}
	/// <summary>
	/// 替换字符获取新的字符串
	/// </summary>
	/// <param name="old">需要替换的字符串</param>
	/// <param name="_replace">替换的数组</param>
	/// <returns></returns>
	public static string GetReplacedText(string old, params System.Object[] _replace)
	{
		if (old == "" || old == null) return "";
		string replaceStr = old;
		int length = _replace.Length;
		for (int i = 0; i < length; i++)
		{
			replaceStr = replaceStr.Replace("_$" + i + "_", _replace[i].ToString());
		}
		return replaceStr;
	}

	public static string GetStr(string id,LangType type = LangType.Public)
	{
		return GetStr (type.ToString(),id);
	}

    public static string GetStr(string pageAndID)
    {
        string[] strings = pageAndID.Split(new[] {"__"}, StringSplitOptions.None);
        return GetStr(strings[0], strings[1]);
    }

    public static string GetStr(string pageAndID, SystemLanguage language)
    {
        string[] strings = pageAndID.Split(new[] { "__" }, StringSplitOptions.None);
        CurrentLanguage currentLanguage;
        if (language == SystemLanguage.ChineseSimplified)
        {
            currentLanguage = CurrentLanguage.ChineseSimplified;
        }
        else if (language == SystemLanguage.ChineseTraditional)
        {
            currentLanguage = CurrentLanguage.ChineseTraditional;
        }
        else
        {
            currentLanguage = CurrentLanguage.English;
        }
        return GetStr(strings[0], strings[1], currentLanguage);
    }

    public static string GetStr(string page, string id)
    {
        return GetStr(page, id, LanguageManager.CurrentLanguage);
    }

    public static bool ContainNode(string page, string id)
    {
        CurrentLanguage language = LanguageManager.CurrentLanguage;
        List<XmlDocument> documents = XmlDocumentDictionary[language];
        foreach (var document in documents)
        {
            XmlNode pageNode = document.SelectSingleNode("lan/" + page);
            if (pageNode == null)
            {
                continue;
            }
            XmlNode node = pageNode.SelectSingleNode(id);
            if (node != null)
            {
                return true;
            }
        }
        return false;
    }

    public static string GetStr(string page, string id, CurrentLanguage language)
    {
        if (Initializer.Instance.AuditEdition)
        {
            language = CurrentLanguage.ChineseSimplified;
        }

        List<XmlDocument> documents = XmlDocumentDictionary[language];

        foreach (var document in documents)
        {
            XmlNode pageNode = document.SelectSingleNode("lan/" + page);
            if (pageNode == null)
            {
                continue;
            }
            XmlNode node = pageNode.SelectSingleNode(id);
            if (node != null)
            {
                return node.InnerText.Replace("\\n", "\n");
            }
        }

        string error = "Topic missing page[" + page + "] id[" + id + "]";
        Debug.LogError(error);
        return error;
    }

    public static string GetShareUrl()
    {
        string pageAndId;
        if (Application.isEditor)
        {
            pageAndId = LanguageLabel.Android__ShareUrl;
        }
        else if (Application.platform == RuntimePlatform.IPhonePlayer)
        {
            pageAndId = LanguageLabel.IOS__ShareUrl;
        }
        else if (Application.isMobilePlatform)
        {
            pageAndId = LanguageLabel.Android__ShareUrl;
        }
        else
        {
            throw new Exception();
        }
        return GetStr(pageAndId);
    }

	private static Font defaultFont;
	public static Font font; 

  //  public static Font GetFont()
  //  {
		//if (xmls == null || font == null)
  //      {
		//	if(defaultFont == null)
		//	{
		//		Debug.LogError("Language not init");
  //              defaultFont = Font.CreateDynamicFontFromOSFont("Arial", 20);
  //          }
  //          return defaultFont;
  //      }
		//return font;
  //      //return "Fonts/" + SystemLanguage.ChineseTraditional.ToString();
  //      //return "Fonts/" + SystemLanguage.Chinese.ToString();
  //  }

    public static Font GetFont(Enabled font)
    {
		return null;
        //return ResourcesUtil.GetInstance().GetFont(ResourcesUtil.Url.Font, font.ToString());
    }

    public static Font GetSystemFont()
    {
        return Font.CreateDynamicFontFromOSFont("Arial", 20);
    }

    public static Font GetNumberFont()
    {
		return null;
        //return ResourcesUtil.GetInstance().GetFont(ResourcesUtil.Url.Font, "Number");
    }

	public static string GetSpecifiedLang1()
    {
        string language = "";
        if (Application.systemLanguage.ToString() == SystemLanguage.ChineseSimplified.ToString())
            language = SystemLanguage.Chinese.ToString();
        else
            language = Application.systemLanguage.ToString();

        if (!isInEnabled(language))
            language = defaultLan.ToString();

#if UNITY_EDITOR || UNITY_STANDALONE
        language = SystemLanguage.English.ToString();
#endif

//		language = SystemLanguage.Chinese.ToString();
		language = SystemLanguage.English.ToString();

        return language;

    }

    private static bool isInEnabled(string value)
    {
        bool isIn = false;
        foreach (string name in Enum.GetNames(typeof(Enabled)))
        {
            if (value == name)
                return true;
        }
        return isIn;
    }

    //public static bool IsLanguageInit()
    //{
    //    return (xmls == null) ? false : true;
    //}

    public static string GetLanguagePath()
    {
        return "XML/lan/" + lan;
    }

}