using System;
using System.Collections;
using System.Collections.Generic;
using System.Threading.Tasks;
using UnityEngine;
using UnityEngine.Networking;

[ExecuteInEditMode]
public class SetWebGLText : MonoBehaviour
{
    public static SetWebGLText Instance;
    public static Font webglfont;
    public Font font;
    // Start is called before the first frame update
    void Awake()
    {
        Instance = this;
        webglfont = font;
        //  StartCoroutine(LoadAB());
    }
    IEnumerator Downloadip()
    {
        Debug.Log("开始获取ip文件" + Application.streamingAssetsPath + "/1.txt");
        UnityWebRequest m_webrequest = UnityWebRequest.Get(Application.streamingAssetsPath + "/1.txt");
        yield return m_webrequest.SendWebRequest();

        if (m_webrequest.result != UnityWebRequest.Result.Success)
        {
            Debug.Log("获取ip文件失败==》" + m_webrequest.downloadHandler.error);
            Debug.LogError("Failed to download image");
        }
        else
        {
            DataManager.ip = RemoveWhitespace(m_webrequest.downloadHandler.text);
            Debug.Log("获取ip文件成功==》" + DataManager.ip);

        }
    }
    string RemoveWhitespace(string input)
    {
        // 去除回车、换行、制表符和空格等空白字符
        return input.Replace("\r", "").Replace("\n", "").Replace("\t", "").Replace(" ", "");
    }
    IEnumerator DownloadMacIp()
    {
        string filePath = Application.streamingAssetsPath+"/1.txt";

        Debug.Log("开始获取ip文件"+ filePath);
        if (!stlist.ContainsKey(filePath))
        {
            if (System.IO.File.Exists(filePath))
            {
                Task<string> fileData = System.IO.File.ReadAllTextAsync(filePath);
                while (!fileData.IsCompleted)
                {
                    yield return null;
                }
                DataManager.ip = RemoveWhitespace(fileData.Result);
            }
        }
        else
        {
            yield return null;
        }
    }

    IEnumerator DownloadImageMac(callback url)
    {
        string filePath = url.url;

        if (!stlist.ContainsKey(url.url))
        {
            if (System.IO.File.Exists(filePath))
            {
                Task<byte[]> fileData = System.IO.File.ReadAllBytesAsync(filePath);
                while (!fileData.IsCompleted)
                {
                    yield return null;
                }
                Texture2D texture = new Texture2D(2, 2);
                if (texture.LoadImage(fileData.Result))
                {
                    stlist.Add(url.url, texture);
                    url.msg.Invoke(texture);
                    isload = false;
                }
            }
            else
            {
                isload = false;
                Debug.LogError("Failed to download image   "+ filePath);

            }
        }
        else
        {
            yield return null;
            url.msg.Invoke(stlist[url.url]);
            isload = false;
        }
    }


    IEnumerator LoadAB()
    {
        string filePath = System.IO.Path.Combine(Application.streamingAssetsPath, "stzhongs");
        //UnityWebRequest request = UnityWebRequest.Get(filePath);

        using (UnityWebRequest req = UnityWebRequestAssetBundle.GetAssetBundle(filePath))
        {
            yield return req.SendWebRequest();
            if (req.error == null)
            {
                AssetBundle ab = (req.downloadHandler as DownloadHandlerAssetBundle).assetBundle;
                webglfont = ab.LoadAsset<Font>("stzhongs");
            }
            else
            {
                Debug.Log(filePath );
            }
        }
    }
    Queue<callback> dl = new Queue<callback>();
    public void GetTexture(string url,Action<Texture2D> msg)
    {
        if(stlist.ContainsKey(url))
        {
            msg.Invoke(stlist[url]);
        }
        else
        {

            callback cb = new callback();
            cb.url = url;
            cb.msg = msg;
            dl.Enqueue(cb);
        }
    }
    bool isload;
    private void Update()
    {
        if(dl.Count>0&&!isload)
        {
            isload = true;
            callback cb = dl.Dequeue();
#if UNITY_EDITOR
            StartCoroutine(DownloadImageMac(cb));
#else
            StartCoroutine(DownloadImage(cb));
#endif
#if UNITY_EDITOR
            StartCoroutine(DownloadMacIp());
#else
            StartCoroutine(Downloadip());
#endif
        }
    }

    Dictionary<string, Texture2D> stlist = new Dictionary<string, Texture2D>();

    IEnumerator DownloadImage(callback url)
    {
        if(!stlist.ContainsKey(url.url))
        {
            UnityWebRequest m_webrequest = UnityWebRequestTexture.GetTexture(url.url);
            yield return m_webrequest.SendWebRequest();

            if (m_webrequest.result != UnityWebRequest.Result.Success)
            {
                isload = false;
                Debug.LogError("Failed to download image");
            }
            else
            {


                Texture2D tex = ((DownloadHandlerTexture)m_webrequest.downloadHandler).texture;
                stlist.Add(url.url, tex);
                url.msg.Invoke(tex);
                isload = false;
            }

        }
        else
        {
            yield return null;
            url.msg.Invoke(stlist[url.url]);
            isload = false;
        }
    }

    public class callback
    {
        public string url;
        public Action<Texture2D> msg;
    }

    
}