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;

[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;
}

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

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 Sprite[] sprites;

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

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

        
    }

    void InitLayerInfo() {
        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);
    }
    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];
            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 = CoordinateConverter.GeoToUGUISmall(temp.longitude, temp.latitude);
            newPoint.bingObj.name = temp.name;
            newPoint.btn.onClick.AddListener(() =>
            {
                CameraManager.SwitchCamera(0);
                viewMode = ViewMode.normal;
                if((int)temp.type >= 6)
                    StaticLod.instance.OnFoucusStatic(newPoint.staticImp);
                yZT.gameObject.SetActive(true);
                ChangeRightContent(tempI);
                middleContent.gameObject.SetActive(false);
                rightContent.gameObject.SetActive(false);
                LeftBtnClick(1, false);
            });
            runtimePointLib.Add(newPoint);
        }
    }

    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) {
        for (int i = 0; i < runtimePointLib.Count; i++) {
            runtimePointLib[i].gameObject.SetActive(false);
            if (runtimePointLib[i].layerIDs.Contains(layer)) {
                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();
                }
            }
        }
    }
}