using Newtonsoft.Json;
using Newtonsoft.Json.Linq;
using System;
using System.Collections;
using System.Collections.Generic;
using System.Text.RegularExpressions;
using System.Threading.Tasks;
using Unity.VisualScripting;
using UnityAsync;
using UnityEngine;
using UnityEngine.Networking;
using UnityEngine.UI;

[System.Serializable]
public class MovePlan
{
    public string startPos;
    public string endPos;
    public int humanNum;
    public string time;


}

[System.Serializable]
public class MoveAtten
{
    public string title;
    public string pos;
    public string time;


}

[System.Serializable]
public class ServerMovePlan {
    public bool isAfter;
    public bool isOut;
    public string desc;
    public string from;
    public string to;
    public int manNum;
    public int homeNum;
    public int completeNum;
    public string dateTime;
    public int villageCount;
    public int materialPrize;
}

[System.Serializable]
public class ZYYAData
{
    public int totalRoadCount;
    public float totalmanNum;
    public int totalVillageCount;
    public float totalMaterialPrize;
}
public class RKZYLayer : YZTRootLayer
{
    public Text timeText;

    public LineInfo lineInfo;

    //public List<MovePlan> movePlans;
    public List<Thing1> movePlans;

    public List<MoveAtten> moveAttens;

    public static LineInfo lineInfoStatic;

    public Button beforeBtn;

    public Button afterBtn;

    public Button[] allInOut;

    public RectTransform before;

    public RectTransform after;

    public List<LinePath> linePaths = new List<LinePath>();

    public Sprite[] sprites;

    public int inOutIndex;
    public int beforeAfterIndex;


    public RectTransform title1;
    public RectTransform plan1;
    public RectTransform movePlanBeforeContent;
    public RectTransform movePlanAfterContent;

    public RectTransform title2;
    public RectTransform plan2;
    public RectTransform attenContent;

    public List<ServerMovePlan> allServerMovePlans = new List<ServerMovePlan>();

    public Text[] zYGKText;

    public ZYYAData[] zYYADatas;
    public int zYYAIndex = 0;
    public Text[] zYYAText;
    // Start is called before the first frame update
    async void Start()
    {
        lineInfoStatic = lineInfo;
        //TODO 这一块的path应该从movePlan里面生成而不是默认
        InitAllPath();
        await InitMovePlan();
        InitButton();
        InitAtten();
        await InitBaseData();
    }

    void InitAtten() {
        RectTransform title = Instantiate(title2);
        title.SetParent(attenContent);
        title.localScale = Vector3.one;
        for (int i = 0; i < moveAttens.Count; i++)
        {
            RectTransform plan = Instantiate(plan2);
            plan.SetParent(attenContent);
            plan.localScale = Vector3.one;
            plan.GetChild(0).GetComponent<Text>().text = i.ToString();
            plan.GetChild(1).GetComponent<Text>().text = moveAttens[i].title;
            plan.GetChild(2).GetComponent<Text>().text = moveAttens[i].pos;
            plan.GetChild(3).GetComponent<Text>().text = moveAttens[i].time;
        }
    }

    async Task InitBaseData() {
        bool successInternet = true;
        UnityWebRequest requestData = UnityWebRequest.Get(ServerAddress.APIGetGeBaseData);
        await requestData.SendWebRequest();
        try
        {
            if (requestData.result != UnityWebRequest.Result.Success)
            {
                Debug.LogWarning("RKZYLayer基础数据联网不成功,原因:返request不成功");
                successInternet = false;
            }
            else
            {
                JObject jsonObject = JObject.Parse(requestData.downloadHandler.text);
                JToken codeToken = jsonObject["code"];
                if (codeToken.ToString() == "200")
                {
                    JToken areaToken = jsonObject["data"]["area"];
                    JToken capacityToken = jsonObject["data"]["capacity"];
                    JToken populationToken = jsonObject["data"]["population"];
                    zYGKText[0].text = populationToken.ToString() + "人";
                    zYGKText[1].text = allServerMovePlans.Count.ToString() + "条";
                    zYGKText[2].text = areaToken.ToString() + "km²";
                    zYGKText[3].text = (float.Parse((capacityToken.ToString())) * 100).ToString() + "%";
                }
                else
                {
                    successInternet = false;
                    Debug.LogWarning("RKZYLayer基础数据联网不成功,原因:返序列化失败");
                }
            }

        }
        catch (Exception e)
        {
            successInternet = false;
            Debug.LogWarning("RKZYLayer基础数据联网不成功,原因:" + e.ToString());
        }
    }

    async Task InitMovePlan() {
        bool successInternet = true;
        UnityWebRequest requestData = UnityWebRequest.Get(ServerAddress.APIGetGetMovePlans);
        await requestData.SendWebRequest();
        zYYADatas = new ZYYAData[6] { new ZYYAData(), new ZYYAData() , new ZYYAData() , new ZYYAData() , new ZYYAData() , new ZYYAData() };
        try
        {
            if (requestData.result != UnityWebRequest.Result.Success)
            {
                Debug.LogWarning("RKZYLayer联网不成功，读本地缓存数据,原因:返request不成功");
                successInternet = false;
            }
            else
            {
                JObject jsonObject = JObject.Parse(requestData.downloadHandler.text);

                // 提取data字段的值
                JToken dataToken = jsonObject["data"];
                JToken codeToken = jsonObject["code"];
                if (codeToken.ToString() == "200")
                {
                    allServerMovePlans = JsonConvert.DeserializeObject<List<ServerMovePlan>>(dataToken.ToString());
                    
                }
                else
                {
                    successInternet = false;
                    Debug.LogWarning("XHGKLayer联网不成功，读本地缓存数据,原因:返序列化失败");
                }
            }
            
        }
        catch (Exception e)
        {
            successInternet = false;
            Debug.LogWarning("RKZYLayer联网不成功，读本地缓存数据,原因:" + e.ToString());
        }
        if (!successInternet)
        {
            WWW www = new WWW(Application.streamingAssetsPath + "/moveplan.json");
            await new UnityAsync.WaitUntil(() =>
            {
                return www.isDone;
            });
            allServerMovePlans = JsonConvert.DeserializeObject<List<ServerMovePlan>>(www.text);
            www.Dispose();
        }

        LinePath[] beforeLinePaths = before.GetComponentsInChildren<LinePath>();
        LinePath[] afterLinePaths = after.GetComponentsInChildren<LinePath>();
        int beforeIndex = 0;
        int afterIndex = 0;
        for (int i = 0; i < allServerMovePlans.Count; i++) {
            bool after = allServerMovePlans[i].isAfter;
            bool isOut = allServerMovePlans[i].isOut;
            if (!after)
            {
                beforeLinePaths[beforeIndex].startPos = allServerMovePlans[i].from;
                beforeLinePaths[beforeIndex].endPos = allServerMovePlans[i].to;
                beforeLinePaths[beforeIndex].lineDir = isOut ? LineDir.Out : LineDir.In;
                beforeLinePaths[beforeIndex].linePathContent = allServerMovePlans[i].desc;
                beforeLinePaths[beforeIndex].manNum = allServerMovePlans[i].manNum;
                beforeLinePaths[beforeIndex].homeNum = allServerMovePlans[i].homeNum;
                beforeLinePaths[beforeIndex].completeNum = allServerMovePlans[i].completeNum;
                beforeLinePaths[beforeIndex].dateTime = allServerMovePlans[i].dateTime;
                
                if (beforeLinePaths[beforeIndex].lineDir == LineDir.Out)
                {
                    zYYADatas[1].totalmanNum += allServerMovePlans[i].manNum;
                    zYYADatas[1].totalVillageCount += allServerMovePlans[i].villageCount;
                    zYYADatas[1].totalMaterialPrize += allServerMovePlans[i].materialPrize;
                    zYYADatas[1].totalRoadCount += 1;
                }
                else {
                    zYYADatas[2].totalmanNum += allServerMovePlans[i].manNum;
                    zYYADatas[2].totalVillageCount += allServerMovePlans[i].villageCount;
                    zYYADatas[2].totalMaterialPrize += allServerMovePlans[i].materialPrize;
                    zYYADatas[2].totalRoadCount += 1;
                }
                beforeIndex++;
            }
            else {
                afterLinePaths[afterIndex].startPos = allServerMovePlans[i].from;
                afterLinePaths[afterIndex].endPos = allServerMovePlans[i].to;
                afterLinePaths[afterIndex].lineDir = isOut ? LineDir.Out : LineDir.In;
                afterLinePaths[afterIndex].linePathContent = allServerMovePlans[i].desc;
                afterLinePaths[afterIndex].manNum = allServerMovePlans[i].manNum;
                afterLinePaths[afterIndex].homeNum = allServerMovePlans[i].homeNum;
                afterLinePaths[afterIndex].completeNum = allServerMovePlans[i].completeNum;
                afterLinePaths[afterIndex].dateTime = allServerMovePlans[i].dateTime;
                
                if (afterLinePaths[afterIndex].lineDir == LineDir.Out)
                {
                    zYYADatas[4].totalmanNum += allServerMovePlans[i].manNum;
                    zYYADatas[4].totalVillageCount += allServerMovePlans[i].villageCount;
                    zYYADatas[4].totalMaterialPrize += allServerMovePlans[i].materialPrize;
                    zYYADatas[4].totalRoadCount += 1;
                }
                else
                {
                    zYYADatas[5].totalmanNum += allServerMovePlans[i].manNum;
                    zYYADatas[5].totalVillageCount += allServerMovePlans[i].villageCount;
                    zYYADatas[5].totalMaterialPrize += allServerMovePlans[i].materialPrize;
                    zYYADatas[5].totalRoadCount += 1;
                }
                afterIndex++;
            }

            zYYADatas[0].totalmanNum = zYYADatas[1].totalmanNum + zYYADatas[2].totalmanNum;
            zYYADatas[0].totalVillageCount = zYYADatas[1].totalVillageCount + zYYADatas[2].totalVillageCount;
            zYYADatas[0].totalMaterialPrize = zYYADatas[1].totalMaterialPrize + zYYADatas[2].totalMaterialPrize;
            zYYADatas[0].totalRoadCount = zYYADatas[1].totalRoadCount + zYYADatas[2].totalRoadCount;

            zYYADatas[3].totalmanNum = zYYADatas[4].totalmanNum + zYYADatas[5].totalmanNum;
            zYYADatas[3].totalVillageCount = zYYADatas[4].totalVillageCount + zYYADatas[5].totalVillageCount;
            zYYADatas[3].totalMaterialPrize = zYYADatas[4].totalMaterialPrize + zYYADatas[5].totalMaterialPrize;
            zYYADatas[3].totalRoadCount = zYYADatas[4].totalRoadCount + zYYADatas[5].totalRoadCount;

            RefreshZYYAData();
        }
        
        movePlans = new List<Thing1>();

        RectTransform title = Instantiate(title1);
        title.localScale = Vector3.one;
        title.SetParent(movePlanBeforeContent);

        RectTransform title2 = Instantiate(title1);
        title2.localScale = Vector3.one;
        title2.SetParent(movePlanAfterContent);
        List<ServerMovePlan> serverMovePlans = new List<ServerMovePlan>(); 
        for (int i = 0; i < beforeLinePaths.Length; i++)
        {
            int tempI = i;
            RectTransform plan = Instantiate(plan1);
            plan.SetParent(movePlanBeforeContent);
            Thing1 thing1 = plan.GetComponent<Thing1>();
            thing1.zyTime = ZYTime.Before;
            thing1.lineDir = beforeLinePaths[i].lineDir;
            thing1.bindLinePath = beforeLinePaths[i];
            thing1.GetComponent<Button>().onClick.AddListener(() =>
            {
                for (int i = 0; i < linePaths.Count; i++)
                {
                    linePaths[i].gameObject.SetActive(false);
                }
                thing1.bindLinePath.gameObject.SetActive(true);
            });
            plan.localScale = Vector3.one;
            plan.GetChild(0).GetComponent<Text>().text = i.ToString();
            plan.GetChild(1).GetComponent<Text>().text = beforeLinePaths[i].startPos;
            plan.GetChild(2).GetComponent<Text>().text = beforeLinePaths[i].endPos;
            plan.GetChild(3).GetComponent<Text>().text = beforeLinePaths[i].manNum.ToString();
            plan.GetChild(4).GetComponent<Text>().text = beforeLinePaths[i].dateTime.ToString();
            movePlans.Add(thing1);
            
        }
        for (int i = 0; i < afterLinePaths.Length; i++)
        {
            RectTransform plan = Instantiate(plan1);
            plan.SetParent(movePlanAfterContent);
            Thing1 thing1 = plan.GetComponent<Thing1>();
            thing1.zyTime = ZYTime.After;
            thing1.lineDir = afterLinePaths[i].lineDir;
            thing1.bindLinePath = afterLinePaths[i];
            thing1.GetComponent<Button>().onClick.AddListener(() =>
            {
                for (int i = 0; i < linePaths.Count; i++)
                {
                    linePaths[i].gameObject.SetActive(false);
                }
                thing1.bindLinePath.gameObject.SetActive(true);
            });
            plan.localScale = Vector3.one;
            plan.GetChild(0).GetComponent<Text>().text = i.ToString();
            plan.GetChild(1).GetComponent<Text>().text = afterLinePaths[i].startPos;
            plan.GetChild(2).GetComponent<Text>().text = afterLinePaths[i].endPos;
            plan.GetChild(3).GetComponent<Text>().text = afterLinePaths[i].manNum.ToString();
            plan.GetChild(4).GetComponent<Text>().text = afterLinePaths[i].dateTime.ToString();
            movePlans.Add(thing1);
            
        }
        movePlanAfterContent.gameObject.SetActive(false);

        
    }

    void ChangeLinePathChannel(int index) {
        switch (index)
        {
            case 0:
                for (int i = 0; i < linePaths.Count; i++)
                {
                    linePaths[i].gameObject.SetActive(true);
                }
                break;
            case 1:
                for (int i = 0; i < linePaths.Count; i++)
                {
                    if (linePaths[i].lineDir == LineDir.Out)
                        linePaths[i].gameObject.SetActive(true);
                    else
                        linePaths[i].gameObject.SetActive(false);
                }
                break;
            case 2:
                for (int i = 0; i < linePaths.Count; i++)
                {
                    if (linePaths[i].lineDir == LineDir.In)
                        linePaths[i].gameObject.SetActive(true);
                    else
                        linePaths[i].gameObject.SetActive(false);
                }
                break;
        }
    }

    void RefreshZYYAData() {
        zYYAIndex = beforeAfterIndex * 3 + inOutIndex;
        zYYAText[0].text = zYYADatas[zYYAIndex].totalVillageCount.ToString();
        zYYAText[1].text = (zYYADatas[zYYAIndex].totalmanNum / 10000.0f).ToString("0.00");
        zYYAText[2].text = (zYYADatas[zYYAIndex].totalMaterialPrize / 100000000.0f).ToString("0.00");
        zYYAText[3].text = zYYADatas[zYYAIndex].totalRoadCount.ToString();
    }
    void InitButton() {
        beforeBtn.onClick.AddListener(() => {
            beforeAfterIndex = 0;
            beforeBtn.GetComponent<Image>().sprite = sprites[0];
            afterBtn.GetComponent<Image>().sprite = sprites[1];
            before.gameObject.SetActive(true);
            after.gameObject.SetActive(false);

            movePlanBeforeContent.gameObject.SetActive(true);
            movePlanAfterContent.gameObject.SetActive(false);

            ChangeLinePathChannel(inOutIndex);
            RefreshZYYAData();
        });

        afterBtn.onClick.AddListener(() => {
            beforeAfterIndex = 1;
            beforeBtn.GetComponent<Image>().sprite = sprites[1];
            afterBtn.GetComponent<Image>().sprite = sprites[0];
            before.gameObject.SetActive(false);
            after.gameObject.SetActive(true);

            movePlanBeforeContent.gameObject.SetActive(false);
            movePlanAfterContent.gameObject.SetActive(true);

            ChangeLinePathChannel(inOutIndex);
            RefreshZYYAData();
        });

        allInOut[0].onClick.AddListener(() =>
        {
            inOutIndex = 0;
            ChangeLinePathChannel(0);
            for (int i = 0; i < movePlans.Count; i++)
            {
                movePlans[i].gameObject.SetActive(true);
            }
            allInOut[0].gameObject.GetComponent<Image>().sprite = sprites[0];
            allInOut[1].gameObject.GetComponent<Image>().sprite = sprites[1];
            allInOut[2].gameObject.GetComponent<Image>().sprite = sprites[1];
            RefreshZYYAData();
        });

        allInOut[1].onClick.AddListener(() =>
        {
            inOutIndex = 1;
            ChangeLinePathChannel(1);
            for (int i = 0; i < movePlans.Count; i++)
            {
                if (movePlans[i].lineDir == LineDir.Out)
                    movePlans[i].gameObject.SetActive(true);
                else
                    movePlans[i].gameObject.SetActive(false);
            }
            allInOut[0].gameObject.GetComponent<Image>().sprite = sprites[1];
            allInOut[1].gameObject.GetComponent<Image>().sprite = sprites[0];
            allInOut[2].gameObject.GetComponent<Image>().sprite = sprites[1];
            RefreshZYYAData();
        });
        allInOut[2].onClick.AddListener(() =>
        {
            inOutIndex = 2;
            ChangeLinePathChannel(2);
            for (int i = 0; i < movePlans.Count; i++)
            {
                if (movePlans[i].lineDir == LineDir.In)
                    movePlans[i].gameObject.SetActive(true);
                else
                    movePlans[i].gameObject.SetActive(false);
            }
            allInOut[0].gameObject.GetComponent<Image>().sprite = sprites[1];
            allInOut[1].gameObject.GetComponent<Image>().sprite = sprites[1];
            allInOut[2].gameObject.GetComponent<Image>().sprite = sprites[0];
            RefreshZYYAData();
        });
    }

    void InitAllPath() {
        for (int i = 0; i < before.childCount; i++) {
            if (before.GetChild(i).GetComponent<LinePath>()) {
                linePaths.Add(before.GetChild(i).GetComponent<LinePath>());
            }
        }
        for (int i = 0; i < after.childCount; i++)
        {
            if (after.GetChild(i).GetComponent<LinePath>())
            {
                linePaths.Add(after.GetChild(i).GetComponent<LinePath>());
            }
        }
    }

    // Update is called once per frame
    void Update()
    {
        // 获取当前时间
        DateTime now = DateTime.Now;

        // 格式化时间字符串
        string timeString = now.ToString("yyyy/MM/dd HH:mm");

        // 将格式化的时间字符串设置到UI Text组件上
        timeText.text = timeString;
    }

    private void FixedUpdate()
    {
        if (lineInfo.linePaths.Count > 0)
        {
            lineInfo.gameObject.SetActive(true);
        }
        else 
        {
            lineInfo.gameObject.SetActive(false);
        }
    }
}