MREdustryXR/Assets/FrameWork/Scripts/Window/WindowsManager.cs

using LitJson;
using System;
using System.Collections;
using System.Collections.Generic;
using System.Reflection;
using UnityEngine;
using static WindowConfig;

public class WindowsManager : MonoSingleton<WindowsManager>
{
    public delegate void OnTipBackEvent(string msg);
    public static OnTipBackEvent OnTipBackChange;
    public bool isShowTip;
    public WindowItemConfig wConfig;
    [HideInInspector]
    public Canvas canvasRoot;
    public List<windowItemGameObject> windowItemGameObjectList;
    public WindowConfig windowsConfig;


    private void Awake()
    {
        StartCoroutine(CheckIsStart());
    }

    void initShowWindow()
    {
        for (int i = 0; i < windowItemGameObjectList.Count; i++)
        {
            if(windowItemGameObjectList[i].type == windowsConfig.initShowWindow)
            {
                windowItemGameObjectList[i].window.SetActive(true);
            }
            else
            {
                windowItemGameObjectList[i].window.SetActive(false);
            }
        }
    }

    public bool isStart = false;
    IEnumerator CheckIsStart()
    {
        while (HttpSDKAction.Instance.jsonData == "")
        {
            yield return null;
        }
       // RoadManager.Instance.gameObject.SetActive(false);
        isStart = true;
        canvasRoot = GameObject.Instantiate(windowsConfig.canvas);
        for (int i = 0; i < windowsConfig.initComponent.Count; i++)
        {
           canvasRoot.gameObject.AddComponent(GetTypeByName(windowsConfig.initComponent[i].name));
        }
        windowItemGameObjectList = new List<windowItemGameObject>();
        initWindowList(windowsConfig.windowItemGameObjectList, windowItemGameObjectList, canvasRoot.transform);
        initShowWindow();
    }
    public static System.Type GetTypeByName(string name)
    {
        foreach (Assembly assembly in System.AppDomain.CurrentDomain.GetAssemblies())
        {
            foreach (System.Type type in assembly.GetTypes())
            {
                if (type.Name == name)
                    return type;
            }
        }

        return null;
    }
    void initWindowList(List<windowItemGameObject> list, List<windowItemGameObject> nowlist,Transform parent)
    {
        if(list!=null)
        {
            for (int i = 0; i < list.Count; i++)
            {
                windowItemGameObject wg = new windowItemGameObject();
                wg.type = list[i].type;
                wg.parentType = list[i].parentType;
                wg.window = GameObject.Instantiate(list[i].window, parent);
                wg.window.name = list[i].window.name;
                wg.windowItemGameObjectList = new List<windowItemGameObject>();
                initGameObject(wg.window);
                initWindowList(list[i].windowItemGameObjectList, wg.windowItemGameObjectList, wg.window.transform);
                nowlist.Add(wg);
            }
        }
    }

    void initGameObject(GameObject go)
    {
        go.transform.localPosition = Vector3.zero;
        go.transform.localEulerAngles = Vector3.zero;
        go.transform.localScale = Vector3.one;
    }


    public GameObject GetPrefab(windowType wt,string name)
    {
        for (int i = 0; i < wConfig.list.Count; i++)
        {
            if(wConfig.list[i].type==wt)
            {
                for (int j = 0; j < wConfig.list[i].PrefabList.Count; j++)
                {
                    if(wConfig.list[i].PrefabList[j].name==name)
                    {
                        return wConfig.list[i].PrefabList[j].obj;
                    }
                }
            }
        }
        return null;
    }
    Queue<TipData> tdlist = new Queue<TipData>();
    void setWindowData(windowType wt,GameObject go, string data)
    {
        TipData td = new TipData();
        td.data = data;
        td.go = go;
        td.wt = wt;
        tdlist.Enqueue(td);
        
    }

    bool isChangzhu(windowType wt)
    {
        switch (wt)
        {
            case windowType.Top:
                return true;
        }
        return false;

    }


    bool isHuLue(windowType wt)
    {
        switch (wt)
        {
            case windowType.Tip:
                return true;
            case windowType.Tip2:
                return true;
            case windowType.Error:
                return true;
        }
        return false;

    }

    Stack<windowType> wlist = new Stack<windowType>();
    public void show(windowType wt,bool needHandle = true,string data="")
    {
        List<windowItemGameObject> wglist = getWindow(wt, needHandle);
        for (int i = 0; i < wglist.Count; i++)
        {
            bool isTip = isHuLue(wglist[i].type);
            Debug.Log("isTip===>"+ isTip);
            setWindowData(wglist[i].type, wglist[i].window, data);
            if(!isTip)
                showManagerWindow(windowItemGameObjectList, wglist, wglist[i].type, needHandle);
        }
        switch(wt)
        {
            case windowType.XunJianStart:
                closeWindow(windowItemGameObjectList,windowType.Top);
                break;
            case windowType.XunJianLB:
                showWindow(windowItemGameObjectList, windowType.Top);
                break;
        }

        if(wlist.Count>0)
        {
            if(wlist.Peek()!=wt&& !wlist.Contains(wt))
            {
                wlist.Push(wt);
            }
        }else
        {
            wlist.Push(wt);
        }
    }

    windowItemGameObject showitem(List<windowItemGameObject> list,windowType wt, bool needHandle = true)
    {
        for (int i = 0; i < list.Count; i++)
        {
            windowItemGameObject wg = showitem(list[i].windowItemGameObjectList, wt);
            if(wg!=null)
            {
                return wg;

            }
            if (list[i].type == wt)
            {
                return list[i];
            }
        }
        return null;
    }

    List<windowItemGameObject> getWindow(windowType wt, bool needHandle = true)
    {
        List<windowItemGameObject> wiList = new List<windowItemGameObject>();
        int ct = 0;
        while (true)
        {
            windowItemGameObject wg = checkWindow(wt, needHandle);
            if (wg==null)
            {
                return wiList;
            }else
            {
                wt = wg.parentType;
                wiList.Add(wg);
            }
            ct++;
            if(ct>10000)
            {
                Debug.LogError("눗왯삿혤呵겨");
                return new List<windowItemGameObject>();
            }
        }
    }

    windowItemGameObject checkWindow( windowType wt, bool needHandle = true)
    {
        //璣冷
        for (int i = 0; i < windowItemGameObjectList.Count; i++)
        {
            if (windowItemGameObjectList[i].type == wt)
            {
                return windowItemGameObjectList[i];
            }
            windowItemGameObject wg = showitem(windowItemGameObjectList[i].windowItemGameObjectList, wt, needHandle);
            if (wg!=null)
            {
                return wg;
            }
        }
        return null;
    }

    void showWindow(List<windowItemGameObject> list, windowType wt)
    {

        //璣冷
        for (int i = 0; i < list.Count; i++)
        {
            if (list[i].type == wt)
            {
                list[i].window.SetActive(true);
            }
            showWindow(list[i].windowItemGameObjectList, wt);
        }

    }
    void closeWindow(List<windowItemGameObject> list, windowType wt)
    {

        //璣冷
        for (int i = 0; i < list.Count; i++)
        {
            if (list[i].type == wt)
            {
                list[i].window.SetActive(false);
            }
            closeWindow(list[i].windowItemGameObjectList, wt);
        }

    }

    void showManagerWindow(List<windowItemGameObject> list, List<windowItemGameObject> wglist, windowType wt, bool needHandle = true)
    {

        //璣冷
        for (int i = 0; i < list.Count; i++)
        {
            if (list[i].type == wt)
            {
                list[i].window.SetActive(true) ;
            }
            else
            {
                if(!isChangzhu(list[i].type)&& needHandle&& !isHuLue(list[i].type))
                {
                    bool isShow=false;
                    for (int j = 0; j < wglist.Count; j++)
                    {
                        if(wglist[j].type== list[i].type)
                        {
                            isShow = true;
                        }
                    }
                    if(!isShow)
                    {
                        list[i].window.SetActive(false);
                    }
                }

            }
            showManagerWindow(list[i].windowItemGameObjectList, wglist, wt, needHandle);
        }
    }

    private void Update()
    {
        if(tdlist.Count>0&&!isShowTip)
        {
            TipData td = tdlist.Dequeue();
            Debug.Log("硫구鞫刻Tip");
            switch (td.wt)
            {
                case windowType.Tip2:
                    Tip2Window t2w = td.go.GetComponent<Tip2Window>();
                    td.go.SetActive(true);
                    isShowTip = true;
                    t2w.showTxt(td.data, () => {

                        OnTipBackChange?.Invoke("");
                    });
                    break;
                case windowType.Tip:
                    Tip1Window tw = td.go.GetComponent<Tip1Window>();
                    td.go.SetActive(true);
                    isShowTip = true;
                    JsonData d = JsonMapper.ToObject(td.data);
                    Color c = new Color(float.Parse(d["cr"].ToString()), float.Parse(d["cg"].ToString()), float.Parse(d["cb"].ToString()), float.Parse(d["ca"].ToString()));
                    List<string> blist = new List<string>();
                    blist.Add(d["blist"][0].ToString());
                    blist.Add(d["blist"][1].ToString());
                    blist.Add(d["blist"][2].ToString());
                    tw.show(d["title"].ToString(), d["info"].ToString(),bool.Parse( d["isQianWang"].ToString()), bool.Parse(d["isSuccess"].ToString()), getTexture(d["Texture"].ToString()), c, blist, (string msg)=> {

                        OnTipBackChange?.Invoke(msg);

                    });
                    break;
                case windowType.Error:
                    saveNowWindowAndClose(false);
                    ErrorManager em = td.go.GetComponent<ErrorManager>();
                    td.go.SetActive(true);
                    isShowTip = true;
                    JsonData de = JsonMapper.ToObject(td.data);
                    Color ce = new Color(float.Parse(de["cr"].ToString()), float.Parse(de["cg"].ToString()), float.Parse(de["cb"].ToString()), float.Parse(de["ca"].ToString()));
                    List<string> bliste = new List<string>();
                    bliste.Add(de["blist"][0].ToString());
                    bliste.Add(de["blist"][1].ToString());
                    bliste.Add(de["blist"][2].ToString());
                    em.show(de["title"].ToString(), de["info"].ToString(), ce, getTexture(de["Texture"].ToString()), bliste, (string msg) => {

                        saveNowWindowAndClose(true);
                        OnTipBackChange?.Invoke(msg);

                    },bool.Parse(de["isText"].ToString()), de["djsMsg"].ToString(),int.Parse(de["time"].ToString()));

                    
                    break;
            }
        }
    }
    List<windowItemGameObject> showList;
    void saveNowWindowAndClose(bool isRef)
    {
        if(!isRef)
        {

            showList = new List<windowItemGameObject>();
            for (int i = 0; i < windowItemGameObjectList.Count; i++)
            {
                if (windowItemGameObjectList[i].window.activeSelf&& windowItemGameObjectList[i].type!= windowType.Error)
                {
                    showList.Add(windowItemGameObjectList[i]);
                    windowItemGameObjectList[i].window.SetActive(false);
                }
            }
        }else
        {
            for (int i = 0; i < showList.Count; i++)
            {
                showList[i].window.SetActive(true);
            }

        }
    }



    public Texture getTexture(string texId)
    {

        for (int i = 0; i < wConfig.listTexture.Count; i++)
        {
            if(wConfig.listTexture[i].PrefabList.name== texId)
            {
                return wConfig.listTexture[i].PrefabList.obj;
            }
        }
        return null;
    }

    public JsonData getErrorData(string title, string info, Color color, string icon, List<string> backList, bool isText = true, string djsMsg = "", int time = 5)
    {
        JsonData data = new JsonData();
        data["title"] = title;
        data["info"] = info;
        data["isText"] = isText;
        data["djsMsg"] = djsMsg;
        data["time"] = time;
        data["Texture"] = icon;
        data["blist"] = new JsonData();
        for (int i = 0; i < 3; i++)
        {
            data["blist"].Add(backList[i]);
        }
        data["cr"] = color.r;
        data["cg"] = color.g;
        data["cb"] = color.b;
        data["ca"] = color.a;
        return data;
    }

    public JsonData getTip1Data(string title, string info, bool isQianWang, bool isSuccess, string texID, Color color, List<string> backList)
    {
        JsonData data = new JsonData();
        data["title"] = title;
        data["info"] = info;
        data["isQianWang"] = isQianWang;
        data["isSuccess"] = isSuccess;
        data["Texture"] = texID;
        data["blist"] = new JsonData();
        for (int i = 0; i < 3; i++)
        {
            data["blist"].Add(backList[i]);
        }
        data["cr"] = color.r;
        data["cg"] = color.g;
        data["cb"] = color.b;
        data["ca"] = color.a;
        return data;
    }

    public class TipData
    {
        public windowType wt;
        public GameObject go;
        public string data;
    }
}