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

[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 List<int> cancelLayer = new List<int>();

    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() {

        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);
    }
    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.onPointClick = () =>
            {
                OnChooseNewPointClick(temp, newPoint);
            };
            runtimePointLib.Add(newPoint);
        }
    }


    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);
        }
        else { 
        
        }
    }

    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();
                }
            }
        }
    }
}