WaterFlush/Assets/Scripts/UI/UIView/YZT/YZTLayer.cs

using Newtonsoft.Json;
using Newtonsoft.Json.Linq;
using System;
using System.Collections;
using System.Collections.Generic;
using System.Threading.Tasks;
using UnityEngine;
using UnityEngine.Networking;
using UnityEngine.UI;
using UnityAsync;
using WaitUntil = UnityAsync.WaitUntil;
using Best.HTTP.Caching;

[System.Serializable]
public class YZTLayerData
{
    public string layerName;
    public int layerID;
}

public enum LayerUnitType
{
    ZZ = 1,
    BZ,
    NC,
    QXZ,
    JK,
    QT
}

[System.Serializable]
public class LayerUnitData
{
    public bool special;
    public LayerUnitType type;
    public float longitude;
    public float latitude;
    public string name;
    public string name_pri;
    public string text1;
    public string text2;

    public string GetTypeName()
    {
        string result = "";
        switch (type)
        {
            case LayerUnitType.ZZ:
                result = "闸站";
                break;
            case LayerUnitType.BZ:
                result = "泵站";
                break;
            case LayerUnitType.NC:
                result = "农场";
                break;
            case LayerUnitType.QXZ:
                result = "气象站";
                break;
            case LayerUnitType.JK:
                result = "监控";
                break;
            case LayerUnitType.QT:
                result = "其他";
                break;
        }
        return result;
    }
}

[System.Serializable]
public class HotPointData
{
    public LayerUnitType type;
    public float longitude;
    public float latitude;
    public string name;
    public string name_pri;
}


[System.Serializable]
public class SWStationRecordData
{
    public string name;
    public string time;
    public float value;
    public int dir;
}

public class YZTLayer : YZTRootLayer
{
    public VerticalLayoutGroup content;
    public Sprite[] layerSprite;
    public Sprite[] hotPointSprite;
    public LayerBtn layerBtnPrefab;
    public SecLayerBtn secLayerBtnPrefab;

    public YZTLayerData[] layerDatas;

    public RectTransform leftContent;
    public RectTransform middleContent;
    public RectTransform rightContent;

    List<LayerBtn> layerBtns = new List<LayerBtn>();

    public RuntimePoint pointPrefab;
    public GameObject runtimePointObj;
    public RectTransform pointParent;

    List<RuntimePoint> runtimePointLib = new List<RuntimePoint>();

    public GameObject yZTMini;
    public GameObject yZT;

   
    public RectTransform infoRight;

    public Button returnBtn;

    private float clickInterval;
    private Vector3 startClickPosition;

    public Button[] leftButtons;
    public Button layerButton;
    public int currentActiveLeft = 0;

    public RectTransform layerInfo;
    public Button layerInfoExitBtn;

    public List<int> cancelLayer = new List<int>();

    public Sprite[] sprites;

    public Text rainText;
    public Text[] rainTextNum;

    public GameObject thingPrefab;
    public RectTransform thingParent;
    public List<SWStationRecordData> rescordSWStationData = new List<SWStationRecordData>();
    public List<GameObject> thing3s = new List<GameObject>();

    public Button clearBtn;
    // Start is called before the first frame update
    async void Awake()
    {
        viewMode = ViewMode.miniMap;
        await InitData();
        Init();
        InitLeftBtn();
        InitLayerInfo();
        InitLayerBtns();
        InitReturnBtn();
        InitRainInfo();
        InitSWHeightInfo();
        await InitPointData();
        InitPoint();
        
    }

    void InitLeftBtn() {
        for (int i = 0; i < leftButtons.Length; i++) {
            int temp = i;
            leftButtons[i].onClick.AddListener(() =>
            {
                LeftBtnClick(temp);
            });
        }
        LeftBtnClick(0);

        clearBtn.onClick.AddListener(() => {
            if (clearBtn.GetComponent<Image>().sprite == sprites[0])
            {
                clearBtn.GetComponent<Image>().sprite = sprites[1];
                leftContent.gameObject.SetActive(false);
                middleContent.gameObject.SetActive(false);
                rightContent.gameObject.SetActive(false);
                clearBtn.GetComponent<RectTransform>().anchoredPosition = new Vector2(-827, clearBtn.GetComponent<RectTransform>().anchoredPosition.y);
            }
            else {
                clearBtn.GetComponent<Image>().sprite = sprites[0];
                leftContent.gameObject.SetActive(true);
                middleContent.gameObject.SetActive(true);
                rightContent.gameObject.SetActive(true);
                clearBtn.GetComponent<RectTransform>().anchoredPosition = new Vector2(-457, clearBtn.GetComponent<RectTransform>().anchoredPosition.y);
            }
            
        });
    }

    async void InitSWHeightInfo() {
        await new WaitUntil(() => {
            return GlobalData.swDatas.Count > 0;
        });
        if (rescordSWStationData.Count < 1)
        {
            for (int i = 0; i < GlobalData.swDatas.Count; i++) {
                SWStationRecordData sWStationRecordData = new SWStationRecordData();
                sWStationRecordData.dir = 0;
                sWStationRecordData.name = GlobalData.swDatas[i].STNM;
                sWStationRecordData.value = (GlobalData.swDatas[i].upz > GlobalData.swDatas[i].dwz)?GlobalData.swDatas[i].upz:GlobalData.swDatas[i].dwz;
                sWStationRecordData.time = DateTime.Now.ToString("MM/dd HH:mm");
                rescordSWStationData.Add(sWStationRecordData);
            }

            for (int i = 0; i < rescordSWStationData.Count; i++)
            {
                GameObject obj = Instantiate(thingPrefab);
                obj.GetComponent<RectTransform>().SetParent(thingParent);
                obj.transform.localScale = Vector3.one;
                obj.transform.GetChild(0).GetComponent<Text>().text = (i + 1).ToString();
                obj.transform.GetChild(1).GetComponent<Text>().text = rescordSWStationData[i].name.ToString();
                obj.transform.GetChild(2).GetComponent<Text>().text = rescordSWStationData[i].time.ToString();
                obj.transform.GetChild(3).GetComponent<Text>().text = rescordSWStationData[i].value.ToString();
                if (rescordSWStationData[i].dir == 0)
                {
                    obj.transform.GetChild(4).localEulerAngles = new Vector3(0, 0, 0);
                }
                else if (rescordSWStationData[i].dir == 1)
                {
                    obj.transform.GetChild(4).localEulerAngles = new Vector3(0, 0, 90);
                }
                else {
                    obj.transform.GetChild(4).localEulerAngles = new Vector3(0, 0, -90);
                }
                thing3s.Add(obj);
            }
        }
        else {
            for (int i = 0; i < GlobalData.swDatas.Count; i++)
            {
                rescordSWStationData[i].name = GlobalData.swDatas[i].STNM;
                float lastValue = rescordSWStationData[i].value;
                rescordSWStationData[i].value = (GlobalData.swDatas[i].upz > GlobalData.swDatas[i].dwz) ? GlobalData.swDatas[i].upz : GlobalData.swDatas[i].dwz;
                rescordSWStationData[i].time = DateTime.Now.ToString("MM/dd HH:mm");
                if (rescordSWStationData[i].value > lastValue)
                {
                    rescordSWStationData[i].dir = 1;
                }
                else if (rescordSWStationData[i].value > lastValue)
                {
                    rescordSWStationData[i].dir = 0;
                }
                else {
                    rescordSWStationData[i].dir = -1;
                }
            }

            for (int i = 0; i < rescordSWStationData.Count; i++)
            {
                thing3s[i].transform.GetChild(0).GetComponent<Text>().text = (i + 1).ToString();
                thing3s[i].transform.GetChild(1).GetComponent<Text>().text = rescordSWStationData[i].name.ToString();
                thing3s[i].transform.GetChild(2).GetComponent<Text>().text = rescordSWStationData[i].time.ToString();
                thing3s[i].transform.GetChild(3).GetComponent<Text>().text = rescordSWStationData[i].value.ToString();
                if (rescordSWStationData[i].dir == 0)
                {
                    thing3s[i].transform.GetChild(4).localEulerAngles = new Vector3(0, 0, 0);
                }
                else if (rescordSWStationData[i].dir == 1)
                {
                    thing3s[i].transform.GetChild(4).localEulerAngles = new Vector3(0, 0, 90);
                }
                else
                {
                    thing3s[i].transform.GetChild(4).localEulerAngles = new Vector3(0, 0, -90);
                }
            }

        }
    }

    async void InitRainInfo() {
        await new WaitUntil(() => {
            return GlobalData.qXZDatas.Count > 0;
        });
        int qxzCount = GlobalData.qXZDatas.Count;
        string maxName = "";
        float maxValue = -99f;
        int value010 = 0;
        int value1025 = 0;
        int value2550 = 0;
        int value50100 = 0;
        int value100200 = 0;
        int value200 = 0;
        for (int i = 0; i < qxzCount; i++) {
            float value = GlobalData.qXZDatas[i].dropSum6;
            if (value > maxValue) {
                
                maxValue = value;
                maxName = GlobalData.qXZDatas[i].STNM;
            }
            if (value >= 0 && value < 10)
            {
                value010++;
            }
            else if (value >= 10 && value < 25)
            {
                value1025++;
            }
            else if (value >= 25 && value < 50)
            {
                value2550++;
            }
            else if (value >= 50 && value < 100)
            {
                value50100++;
            }
            else if (value >= 100 && value < 200)
            {
                value100200++;
            }
            else
            {
                value200++;
            }
        }

        rainText.text = $"数据时间:17日12时至18日12时(过去24小时)\r\n蓄洪区共有{qxzCount}个雨量站，其中几个雨量站监测有降雨最大降雨测站为{maxName}站点，降雨量{maxValue}mm.";
        rainTextNum[0].text = value010.ToString();
        rainTextNum[1].text = value1025.ToString();
        rainTextNum[2].text = value2550.ToString();
        rainTextNum[3].text = value50100.ToString();
        rainTextNum[4].text = value100200.ToString();
        rainTextNum[5].text = value200.ToString();
    }

    void InitLayerInfo() {

        Button[] btns = layerInfo.GetComponentsInChildren<Button>();
        for (int i = 0; i < btns.Length - 2; i++) {
            int temp = i;
            btns[i].onClick.AddListener(() =>
            {
                bool active = btns[temp].GetComponent<CanvasGroup>().alpha > 0.5f;
                btns[temp].GetComponent<CanvasGroup>().alpha = active ? 0.5f : 1.0f;
                bool newActive = !active;
                ChangeRuntimeLayer(temp, newActive);
            });
        }

        layerButton.onClick.AddListener(() => {
            layerInfo.gameObject.SetActive(true);
        });
        layerInfoExitBtn.onClick.AddListener(() =>
        {
            layerInfo.gameObject.SetActive(false);
        });
    }

    void LeftBtnClick(int index,bool record = true) {
        if(record)
            currentActiveLeft = index;
        for (int i = 0; i < leftButtons.Length; i++)
        {
            leftButtons[i].GetComponent<Image>().sprite = sprites[1];
        }
        leftButtons[index].GetComponent<Image>().sprite = sprites[0];

        for (int i = 0; i < leftContent.childCount; i++) {
            leftContent.transform.GetChild(i).gameObject.SetActive(false);
        }
        
        leftContent.transform.GetChild(index).gameObject.SetActive(true);

        if (index == 1) {
            InitSWHeightInfo();
        }
    }
    void InitLayerBtns()
    {
        layerBtns = new List<LayerBtn>();
        for (int i = 0; i < layerDatas.Length; i++)
        {
            LayerBtn layerBtn = Instantiate(layerBtnPrefab);

            layerBtn.SetUseful(false);
            int index = i;
            int num = 0;
            if (i == 0)
            {
                List<LayerUnitData> tempDatas = new List<LayerUnitData>(GlobalData.layerUnitDatas);
                for (int j = 0; j < tempDatas.Count; j++)
                {
                    if (tempDatas[j].special)
                    {
                        int tempJ = j;
                        SecLayerBtn secLayerBtn = Instantiate(secLayerBtnPrefab);
                        secLayerBtn.SetLayerBtnData(tempDatas[j].name);
                        secLayerBtn.GetComponent<RectTransform>().SetParent(layerBtn.secContent.GetComponent<RectTransform>());
                        secLayerBtn.btn.onClick.AddListener(() => {
                            CameraManager.SwitchCamera(0);
                            viewMode = ViewMode.normal;
                            StaticLod.instance.OnFoucusStatic(tempDatas[tempJ].name_pri);
                            yZT.gameObject.SetActive(true);
                            ChangeRightContent(tempJ);
                            middleContent.gameObject.SetActive(false);
                            rightContent.gameObject.SetActive(false);
                            LeftBtnClick(1, false);
                        });
                        num++;
                    }
                    
                }
                layerBtn.secContent.gameObject.SetActive(true);
            }
            else {
                List<LayerUnitData> tempDatas = new List<LayerUnitData>(GlobalData.layerUnitDatas);
                for (int j = 0; j < tempDatas.Count; j++)
                {
                    if ((int)tempDatas[j].type == layerDatas[i].layerID)
                    {
                        int tempJ = j;
                        SecLayerBtn secLayerBtn = Instantiate(secLayerBtnPrefab);
                        secLayerBtn.SetLayerBtnData(tempDatas[j].name);
                        secLayerBtn.GetComponent<RectTransform>().SetParent(layerBtn.secContent.GetComponent<RectTransform>());
                        secLayerBtn.btn.onClick.AddListener(() => {
                            CameraManager.SwitchCamera(0);
                            viewMode = ViewMode.normal;
                            StaticLod.instance.OnFoucusStatic(tempDatas[tempJ].name_pri);
                            yZT.gameObject.SetActive(true);
                            ChangeRightContent(tempJ);
                            middleContent.gameObject.SetActive(false);
                            rightContent.gameObject.SetActive(false);
                            LeftBtnClick(1, false);
                        });
                        num++;
                    }
                }
            }

            layerBtn.btn.GetComponent<Button>().onClick.AddListener(() =>
            {
                for (int j = 0; j < layerBtns.Count; j++)
                {
                    layerBtns[j].SetUseful(false);
                    layerBtns[j].secContent.gameObject.SetActive(false);
                }
                layerBtns[index].SetUseful(true);
                layerBtns[index].secContent.gameObject.SetActive(true);
                //ChangeRuntimeLayer(index);
            });

            layerBtn.SetLayerBtnData(layerSprite[layerDatas[i].layerID], layerDatas[i].layerName, num.ToString());
            layerBtn.GetComponent<RectTransform>().SetParent(content.GetComponent<RectTransform>());
            layerBtn.transform.localScale = Vector3.one;
            layerBtns.Add(layerBtn);
        }
        content.GetComponent<VerticalLayoutGroup>().SetLayoutVertical();
        layerBtns[0].SetUseful(true);
    }

    void ChangeRightContent(int index) {
        for (int i = 0; i < infoRight.childCount; i++) {
            infoRight.GetChild(i).gameObject.SetActive(false);
        }
        infoRight.GetChild(index).gameObject.SetActive(true);
        GameObject title = infoRight.GetChild(index).GetChild(0).GetChild(1).gameObject;
        GameObject text1 = infoRight.GetChild(index).GetChild(0).GetChild(2).gameObject;
        
        if (title != null) 
        {
            title.GetComponent<Text>().text = GlobalData.layerUnitDatas[index].name;
        }
        if (text1 != null)
        {
            text1.GetComponent<Text>().text = GlobalData.layerUnitDatas[index].text1;
        }
        if (infoRight.GetChild(index).GetChild(0).childCount > 3)
        {
            GameObject text2 = infoRight.GetChild(index).GetChild(0).GetChild(3).gameObject;
            if (text2 != null)
            {
                text2.GetComponent<Text>().text = GlobalData.layerUnitDatas[index].text2;
            }
        }
    }

    void InitPoint()
    {
        GameObject shaPan = GameObject.FindGameObjectWithTag("ShaPan");
        for (int i = 0; i < GlobalData.hotPointDatas.Count; i++)
        {
            
            HotPointData temp = GlobalData.hotPointDatas[i];
            Vector3 tempLocalPosition = CoordinateConverter.GeoToUGUISmall(temp.longitude, temp.latitude);
            bool have = false;
            for (int j = 0; j < runtimePointLib.Count; j++)
            {
                if (Vector3.Distance(tempLocalPosition, runtimePointLib[j].bingObj.transform.localPosition) < 0.1)
                {
                    if (runtimePointLib[j].layerIDs.Contains((int)temp.type))
                    {
                        have = true;
                        break;
                    }
                    else {
                        have = true;
                        runtimePointLib[j].Refresh(hotPointSprite[8]);
                        runtimePointLib[j].layerIDs.Add((int)temp.type);
                        
                        break;
                    }
                }
            }
            if (have) {
                continue;
            }

            RuntimePoint newPoint = Instantiate(pointPrefab, Vector3.zero, Quaternion.identity);
            int tempI = i;
            newPoint.GetComponent<RectTransform>().SetParent(pointParent);
            newPoint.InitPoint(hotPointSprite[(int)(temp.type)], temp.name_pri, temp.name);;
            newPoint.layerIDs.Add((int)(temp.type));
            newPoint.bingObj = Instantiate(runtimePointObj).gameObject;
            newPoint.bingObj.transform.SetParent(shaPan.transform.GetChild(6));
            newPoint.bingObj.transform.localEulerAngles = Vector3.zero;
            newPoint.bingObj.transform.localScale = Vector3.one;
            newPoint.bingObj.transform.localPosition = tempLocalPosition;
            newPoint.bingObj.name = temp.name;

            newPoint.onChildClick += OnChooseNewPointClick;

            newPoint.onPointClick = () =>
            {
                OnChooseNewPointClick(temp, newPoint);
            };
            runtimePointLib.Add(newPoint);
        }
    }

    void OnChooseNewPointClick(int selectIndex, RuntimePoint newPoint) {
        if (selectIndex == 0 || selectIndex == 3 || selectIndex == 5)
        {
            OnePicNav.instance.OnButtnClick(2);
        }
        else if (selectIndex == 1 || selectIndex == 2)
        {
            OnePicNav.instance.SwitchToGlobalWeather();
        }
        else if (selectIndex == 4)
        {
            OnePicNav.instance.SwitchToGlobalWaterHeight();
        }
        else if (selectIndex >= 6)
        {
            CameraManager.SwitchCamera(0);
            viewMode = ViewMode.normal;
            StaticLod.instance.OnFoucusStatic(newPoint.staticImp);
            yZT.gameObject.SetActive(true);
            int index = FindIndexByLayerUnitName(newPoint.bingObj.gameObject.name);
            ChangeRightContent(index);
            middleContent.gameObject.SetActive(false);
            rightContent.gameObject.SetActive(false);
            LeftBtnClick(1, false);
        }
    }

    int FindIndexByLayerUnitName(string name) {
        for (int i = 0; i < GlobalData.layerUnitDatas.Count; i++) {
            if (GlobalData.layerUnitDatas[i].name == name.Trim()) {
                return i;
            }
        }
        return -1;
    }

    void OnChooseNewPointClick(HotPointData temp, RuntimePoint newPoint) {
        if (newPoint.layerIDs.Count < 2)
        {
            OnNewPointClick(temp, newPoint);
        }
    }

    void OnNewPointClick(HotPointData temp, RuntimePoint newPoint)
    {
        if ((int)temp.type == 0 || (int)temp.type == 3 || (int)temp.type == 5) {
            OnePicNav.instance.OnButtnClick(2);
        } 
        else if ((int)temp.type == 1 || (int)temp.type == 2) {
            OnePicNav.instance.SwitchToGlobalWeather();
        }
        else if ((int)temp.type == 4)
        {
            OnePicNav.instance.SwitchToGlobalWaterHeight();
        }
        else if ((int)temp.type >= 6)
        {
            CameraManager.SwitchCamera(0);
            viewMode = ViewMode.normal;
            StaticLod.instance.OnFoucusStatic(newPoint.staticImp);
            yZT.gameObject.SetActive(true);
            int index = FindIndexByLayerUnitName(temp.name);
            ChangeRightContent(index);
            middleContent.gameObject.SetActive(false);
            rightContent.gameObject.SetActive(false);
            LeftBtnClick(1, false);
        }
    }

    async Task InitData() {
        await new WaitUntil(() => {
            return GlobalData.layerUnitDatas.Count > 0;
        });
    }

    async Task InitPointData()
    {
        await new WaitUntil(() =>
        {
            return GlobalData.hotPointDatas.Count > 0;
        });
    }

    void Init() {
        yZT.gameObject.SetActive(false);
        middleContent.gameObject.SetActive(true);
        rightContent.gameObject.SetActive(true);
        LeftBtnClick(currentActiveLeft);
    }

    void InitReturnBtn() {
        returnBtn.onClick.AddListener(() =>
        {
            CameraManager.SwitchCamera(1);
            viewMode = ViewMode.miniMap;
            Init();
        });
    }

    void ChangeRuntimeLayer(int layer,bool show) {
        if (show)
        {
            if (cancelLayer.Contains(layer))
            {
                cancelLayer.Remove(layer);
            }
        }
        else {
            if (!cancelLayer.Contains(layer))
            {
                cancelLayer.Add(layer);
            }
        }
        for (int i = 0; i < runtimePointLib.Count; i++) {
            if (runtimePointLib[i].layerIDs.Contains(layer)) {
                if (runtimePointLib[i].layerIDs.Count < 2)
                {
                    runtimePointLib[i].gameObject.SetActive(show);
                }
                else {
                    List<int> tempLayers = new List<int>(runtimePointLib[i].layerIDs);
                    for (int j = 0; j < cancelLayer.Count; j++) {
                        if (tempLayers.Contains(cancelLayer[j])) {
                            tempLayers.Remove(cancelLayer[j]);
                        }
                    }
                    if (tempLayers.Count < 1)
                    {
                        runtimePointLib[i].gameObject.SetActive(false);
                    }
                    else {
                        runtimePointLib[i].gameObject.SetActive(true);
                    }
                }
            }
        }
    }
    void ShootRay()
    {

        Ray ray = CameraManager.instance.mainCamera.ScreenPointToRay(Input.mousePosition);
        RaycastHit hit;

        if (Physics.Raycast(ray, out hit,20000,1<<8|1<<9))
        {
            CameraBird bird = CameraManager.instance.mainCamera.GetComponent<CameraBird>();
            if (hit.collider.gameObject.layer == LayerMask.NameToLayer("EarthTile"))
            {
                if(bird.transform.position.y > 1000)
                {
                    bird.SetCameraToCenterFade(hit.point, 1100);
                }
            }
            else if(hit.collider.gameObject.layer == LayerMask.NameToLayer("StaticImportant"))
            {
                StaticImportant si = hit.collider.gameObject.GetComponent<StaticImportant>();
                int index = StaticLod.instance.OnFoucusStatic(si);
                yZT.gameObject.SetActive(true);
                ChangeRightContent(index);
                middleContent.gameObject.SetActive(false);
                rightContent.gameObject.SetActive(false);
                LeftBtnClick(1,false);
            }
        }
        else
        {
            Debug.Log("No hit");
        }
    }

    private void Update()
    {
        if (Input.GetMouseButtonDown(0)) // 检测鼠标左键点击
        {
            clickInterval = 0.0f;
            startClickPosition = Input.mousePosition;
        }
        clickInterval += Time.deltaTime;
        if (Input.GetMouseButtonUp(0)) {
            if (clickInterval < 0.2f && Vector3.Distance(startClickPosition,Input.mousePosition) < 10f) {
                if (!CameraManager.instance.secondCamera.enabled)
                {
                    ShootRay();
                }
            }
        }
    }
}