XiuXianGame/Assets/Scripts/GameUI/UI/XianTuLogPanel/XianTuLogPanel.cs

using System.Collections.Generic;
using System.Linq;
using Core.Language;
using Excel2Json;
using Fort23.Core;
using Fort23.UTool;
using OfficeOpenXml.FormulaParsing.Excel.Functions.Logical;
using UnityEngine;
using Utility;

namespace Fort23.Mono
{
    public class XianTuData
    {
        public int type;
        public string name;
        public XianTuLogConfig xianTuLogConfig;
        public XianTuData fatherXianTuData;
    }

    [UIBinding(prefab = "XianTuLogPanel")]
    public partial class XianTuLogPanel : UIPanel, IScrollListContent
    {
        private int type = 0;

        private int bigMaoXaiXuan = 0;
        private int placesXaiXuan = 0;

        List<XianTuLogConfig> xianTuLogConfigs = new List<XianTuLogConfig>();
        List<XianTuLogConfig> shoeXianTuLogConfigs = new List<XianTuLogConfig>();

        List<XianTuSaiXuanWidget> bigMapXianTuSaiWidgets = new List<XianTuSaiXuanWidget>();
        List<XianTuSaiXuanWidget> placesXianTuSaiWidgets = new List<XianTuSaiXuanWidget>();

        List<XianTuData> xianTuDatas = new List<XianTuData>();


        List<int> places = new List<int>();

        private EventLogTitleWidget eventLogTitleWidget;

        Map<int, List<int>> xianTuMapConfigd = new Map<int, List<int>>();

        List<UIComponent> components = new List<UIComponent>();

        private void Init()
        {
            isAddStack = true;
            IsShowAppBar = false;
        }

        protected override void AddEvent()
        {
        }

        protected override void DelEvent()
        {
        }

        public override void AddButtonEvent()
        {
            Btn_Close.onClick.AddListener(() => { UIManager.Instance.HideUIUIPanel(this); });

            Btn_Main.onClick.AddListener(() => { Btn_Main_OnClick(); });

            Btn_Event.onClick.AddListener(() => { Btn_Event_OnClick(); });

            Btn_XaiXuan.onClick.AddListener(() => { Btn_XaiXuanClose.gameObject.SetActive(true); });
            Btn_XaiXuanClose.onClick.AddListener(() => { Btn_XaiXuanClose.gameObject.SetActive(false); });
        }

        private void Btn_Main_OnClick()
        {
            if (this.type == 1)
                return;
            Sv.transform.SetParent(MarskRoot1, false);
            eventLogTitleWidget.own.gameObject.SetActive(false);
            ChangeList.ShowTargetIndex(0);
            Btn_XaiXuanClose.gameObject.SetActive(false);
            Btn_XaiXuan.gameObject.SetActive(false);
            bigMaoXaiXuan = 0;
            placesXaiXuan = 0;
            places.Clear();
            UIManager.Instance.DormancyAllGComponent<MainEventLogWidget>();
            UIManager.Instance.DormancyAllGComponent<EventLogWidget>();
            UIManager.Instance.DormancyAllGComponent<EventLogTitleWidget>();

            type = 1;
            shoeXianTuLogConfigs = GetTypeXiantuLogConfigs(type);
            XaiXuanMap(shoeXianTuLogConfigs);
            Content.Init(this, xianTuDatas.Count);
        }

        private void Btn_Event_OnClick()
        {
            if (this.type == 2)
                return;
            Sv.transform.SetParent(MarskRoot, false);
            eventLogTitleWidget.own.gameObject.SetActive(true);
            ChangeList.ShowTargetIndex(1);
            Btn_XaiXuanClose.gameObject.SetActive(false);
            Btn_XaiXuan.gameObject.SetActive(true);
            bigMaoXaiXuan = 0;
            placesXaiXuan = 0;
            places.Clear();
            UIManager.Instance.DormancyAllGComponent<MainEventLogWidget>();
            UIManager.Instance.DormancyAllGComponent<EventLogWidget>();
            UIManager.Instance.DormancyAllGComponent<EventLogTitleWidget>();
            components.Clear();
            type = 2;
            shoeXianTuLogConfigs = GetTypeXiantuLogConfigs(type);
            XaiXuanMap(shoeXianTuLogConfigs);
            if (xianTuDatas.Count > 0)
            {
                eventLogTitleWidget.own.SetActive(true);
                eventLogTitleWidget.CustomInit(xianTuDatas[0].name);
            }
            else
            {
                eventLogTitleWidget.own.SetActive(false);
            }

            Content.Init(this, xianTuDatas.Count);
        }

        private void XaiXuanMap(List<XianTuLogConfig> configs)
        {
            xianTuDatas.Clear();
            // List<XianTuLogConfig> showConfigs = new List<XianTuLogConfig>();
            Map<int, List<XianTuLogConfig>> xiantuMap = new Map<int, List<XianTuLogConfig>>();
            //全部 不筛选
            if (bigMaoXaiXuan == 0)
            {
                if (type == 1)
                {
                    foreach (var xianTuLogConfig in configs)
                    {
                        XianTuData xianTuData2 = new XianTuData();
                        xianTuData2.type = 2;
                        xianTuData2.xianTuLogConfig = xianTuLogConfig;
                        xianTuDatas.Add(xianTuData2);
                    }

                    return;
                }
                else
                {
                    foreach (var xianTuLogConfig in configs)
                    {
                        if (xianTuMapConfigd.ContainsKey(xianTuLogConfig.ID))
                        {
                            foreach (var i in xianTuMapConfigd[xianTuLogConfig.ID])
                            {
                                if (!xiantuMap.ContainsKey(i))
                                {
                                    xiantuMap.Add(i, new List<XianTuLogConfig>());
                                }

                                xiantuMap[i].Add(xianTuLogConfig);
                            }
                        }
                    }
                }
            }
            else
            {
                List<EventConfig> eventConfigs;
                foreach (var xianTuLogConfig in configs)
                {
                    if (EventSystemManager.Instance.eventConfigsMap.ContainsKey(xianTuLogConfig.ID))
                    {
                        eventConfigs = EventSystemManager.Instance.eventConfigsMap[xianTuLogConfig.ID];
                        foreach (var eventConfig in eventConfigs)
                        {
                            if (places.Contains(eventConfig.placeID))
                            {
                                PlacesConfig placesConfig = ConfigComponent.Instance.Get<PlacesConfig>(eventConfig.placeID);
                                if (!xiantuMap.ContainsKey(placesConfig.bigMapID))
                                {
                                    xiantuMap.Add(placesConfig.bigMapID, new List<XianTuLogConfig>());
                                }

                                xiantuMap[placesConfig.bigMapID].Add(xianTuLogConfig);

                                break;
                            }
                        }
                    }
                }
            }


            foreach (var keyValuePair in xiantuMap)
            {
                XianTuData xianTuData = new XianTuData();
                xianTuData.type = 1;
                BigMapConfig bigMapConfig = ConfigComponent.Instance.Get<BigMapConfig>(keyValuePair.Key);
                int count = 0;
                int allCount = 0;

                xianTuDatas.Add(xianTuData);
                foreach (var xianTuLogConfig in keyValuePair.Value)
                {
                    if (EventSystemManager.Instance.eventConfigsMap.ContainsKey(xianTuLogConfig.ID))
                    {
                        var eventConfigs1 = EventSystemManager.Instance.eventConfigsMap[xianTuLogConfig.ID];
                        foreach (var eventConfig in eventConfigs1)
                        {
                            if (places.Contains(eventConfig.placeID) || places.Count <= 0)
                            {
                                AccountFileInfo.EventList eventList = AccountFileInfo.Instance.playerData.completeEvents.FirstOrDefault(cl => cl.eventID == eventConfig.ID);
                                if (eventList != null)
                                {
                                    count++;
                                }

                                allCount++;
                            }
                        }
                    }

                    XianTuData xianTuData2 = new XianTuData();
                    xianTuData2.type = 2;
                    xianTuData2.xianTuLogConfig = xianTuLogConfig;
                    xianTuData2.fatherXianTuData = xianTuData;
                    xianTuDatas.Add(xianTuData2);
                }

                xianTuData.name = LanguageManager.Instance.Text(bigMapConfig.mapName) + " (" + count + "/" + allCount + ")";
            }
        }

        public async override CTask<bool> AsyncInit(object[] uiData)
        {
            xianTuLogConfigs = ConfigComponent.Instance.GetAll<XianTuLogConfig>().ToList();


            List<EventConfig> eventConfigs = ConfigComponent.Instance.GetAll<EventConfig>().ToList();
            foreach (var xianTuLogConfig in xianTuLogConfigs)
            {
                List<EventConfig> configs = eventConfigs.Where(ec => ec.XiantuID == xianTuLogConfig.ID).ToList();
                foreach (var eventConfig in configs)
                {
                    PlacesConfig placesConfig = ConfigComponent.Instance.Get<PlacesConfig>(eventConfig.placeID);
                    if (!xianTuMapConfigd.ContainsKey(xianTuLogConfig.ID))
                    {
                        xianTuMapConfigd.Add(xianTuLogConfig.ID, new List<int>());
                    }

                    if (!xianTuMapConfigd[xianTuLogConfig.ID].Contains(placesConfig.bigMapID))
                    {
                        xianTuMapConfigd[xianTuLogConfig.ID].Add(placesConfig.bigMapID);
                    }
                }
            }


            XianTuSaiXuanWidget xianTuSaiXuanWidget1 = await UIManager.Instance.CreateGComponentForObject<XianTuSaiXuanWidget>(XianTuSaiXuanWidget1, null);
            xianTuSaiXuanWidget1.CustomInit(1, 0);
            xianTuSaiXuanWidget1.OnClick = OnClick;

            xianTuSaiXuanWidget1 = await UIManager.Instance.CreateGComponentForObject<XianTuSaiXuanWidget>(XianTuSaiXuanWidget2, null);
            xianTuSaiXuanWidget1.CustomInit(2, 0);
            xianTuSaiXuanWidget1.OnClick = OnClick;

            BigMapConfig[] bigMapConfigs = ConfigComponent.Instance.GetAll<BigMapConfig>();
            foreach (var bigMapConfig in bigMapConfigs)
            {
                XianTuSaiXuanWidget xianTuSaiXuanWidget = await UIManager.Instance.CreateGComponent<XianTuSaiXuanWidget>(null, BigMapConnect);
                xianTuSaiXuanWidget.CustomInit(1, bigMapConfig.ID);
                xianTuSaiXuanWidget.OnClick = OnClick;
                bigMapXianTuSaiWidgets.Add(xianTuSaiXuanWidget);
            }

            eventLogTitleWidget = await UIManager.Instance.CreateGComponentForObject<EventLogTitleWidget>(EventLogTitleWidgetGam, null);


            BigMapList.GetChildObj();
            BigMapList.ShowTargetIndex(0);

            Btn_Main_OnClick();
            return await base.AsyncInit(uiData);
        }

        private async void OnClick(ItemWidgetBasic obj)
        {
            XianTuSaiXuanWidget xianTuSaiXuanWidge = obj as XianTuSaiXuanWidget;
            if (xianTuSaiXuanWidge.type == 1)
            {
                bigMaoXaiXuan = xianTuSaiXuanWidge._bigMapConfig.ID;
                placesXaiXuan = 0;
                foreach (var placesXianTuSaiWidget in placesXianTuSaiWidgets)
                {
                    UIManager.Instance.DormancyGComponent(placesXianTuSaiWidget);
                }

                placesXianTuSaiWidgets.Clear();
                if (bigMaoXaiXuan == 0)
                {
                    PlacesRoot.gameObject.SetActive(false);
                    BigMapList.ShowTargetIndex(0);
                }
                else
                {
                    PlacesRoot.gameObject.SetActive(true);
                    foreach (var place in xianTuSaiXuanWidge._bigMapConfig.places)
                    {
                        XianTuSaiXuanWidget xianTuSaiXuanWidget = await UIManager.Instance.CreateGComponent<XianTuSaiXuanWidget>(null, PlacesConnect);
                        xianTuSaiXuanWidget.CustomInit(2, place);
                        xianTuSaiXuanWidget.OnClick = OnClick;
                        placesXianTuSaiWidgets.Add(xianTuSaiXuanWidget);
                    }

                    BigMapList.ClickWidget(xianTuSaiXuanWidge.own.GetComponent<UIToggleWidgetBasic>());

                    PlacesRootList.GetChildObj();
                    PlacesRootList.ShowTargetIndex(0);
                }
            }
            else if (xianTuSaiXuanWidge.type == 2)
            {
                placesXaiXuan = xianTuSaiXuanWidge._placesConfig.ID;
                if (placesXaiXuan == 0)
                {
                    PlacesRootList.ShowTargetIndex(0);
                }
                else
                {
                    PlacesRootList.ClickWidget(xianTuSaiXuanWidge.own.GetComponent<UIToggleWidgetBasic>());
                }
            }

            BigMapConfig bigMapConfig = ConfigComponent.Instance.Get<BigMapConfig>(bigMaoXaiXuan);
            PlacesConfig placesConfig = ConfigComponent.Instance.Get<PlacesConfig>(placesXaiXuan);

            places.Clear();
            if (bigMaoXaiXuan == 0)
            {
            }
            else if (bigMaoXaiXuan != 0 && placesXaiXuan == 0)
            {
                places.AddRange(bigMapConfig.places);
            }
            else if (bigMaoXaiXuan != 0 && placesXaiXuan != 0)
            {
                places.Add(placesConfig.ID);
            }

            UIManager.Instance.DormancyAllGComponent<MainEventLogWidget>();
            UIManager.Instance.DormancyAllGComponent<EventLogWidget>();
            shoeXianTuLogConfigs = GetTypeXiantuLogConfigs(type);
            XaiXuanMap(shoeXianTuLogConfigs);
            components.Clear();
            if (xianTuDatas.Count > 0)
            {
                eventLogTitleWidget.own.SetActive(true);
                eventLogTitleWidget.CustomInit(xianTuDatas[0].name);
            }
            else
            {
                eventLogTitleWidget.own.SetActive(false);
            }


            Content.Init(this, xianTuDatas.Count);
        }


        private List<XianTuLogConfig> GetTypeXiantuLogConfigs(int type)
        {
            List<XianTuLogConfig> xianTuLogConfiges = new List<XianTuLogConfig>();
            foreach (var xianTuLogConfig in xianTuLogConfigs)
            {
                if (xianTuLogConfig.EventType == type)
                {
                    xianTuLogConfiges.Add(xianTuLogConfig);
                }
            }

            return xianTuLogConfiges;
        }

        public async CTask<IScorllListWidget> GetIScorllListWidget(int index, RectTransform root)
        {
            if (index < 0 || index >= xianTuDatas.Count)
            {
                return null;
            }

            if (type == 1)
            {
                MainEventLogWidget mainEventLogWidget = await UIManager.Instance.CreateGComponent<MainEventLogWidget>(null, Content.GetComponent<RectTransform>());
                mainEventLogWidget.CustomInit(xianTuDatas[index].xianTuLogConfig);

                return mainEventLogWidget;
            }
            else
            {
                XianTuData xianTuData = xianTuDatas[index];
                if (xianTuData.type == 1)
                {
                    EventLogTitleWidget eventLogTitleWidget = await UIManager.Instance.CreateGComponent<EventLogTitleWidget>(null, Content.GetComponent<RectTransform>());
                    eventLogTitleWidget.CustomInit(xianTuData);
                    components.Add(eventLogTitleWidget);
                    // xianTuTitleWidgets.Add(eventLogTitleWidget);
                    return eventLogTitleWidget;
                }
                else
                {
                    EventLogWidget EventLogWidget = await UIManager.Instance.CreateGComponent<EventLogWidget>(null, Content.GetComponent<RectTransform>());
                    await EventLogWidget.CustomInit(xianTuData, places);
                    components.Add(EventLogWidget);
                    return EventLogWidget;
                }
            }
        }

        public void HindIScorllListWidget(IScorllListWidget widget)
        {
            UIManager.Instance.DormancyGComponent(widget as UIComponent);
            if (components.Contains(widget as UIComponent))
            {
                components.Remove(widget as EventLogTitleWidget);
            }
        }

        public async static CTask OpenPanel()
        {
            XianTuLogPanel xianTuLogPanel = await UIManager.Instance.LoadAndOpenPanel<XianTuLogPanel>(null);
        }

        List<UIComponent> _components = new List<UIComponent>();
        private float maxY;
        private float minY;

        [CustomMethod(CustomMethodType.Update)]
        public void Update()
        {
            if (type != 2)
                return;


            UIComponent highestItem = null;
            maxY = float.MinValue;
            minY = float.MaxValue;
            _components.Clear();


            foreach (var xianTuTitleWidget in components)
            {
                float itemY = xianTuTitleWidget.own.transform.position.y; // 使用世界坐标的 Y 值
                if (itemY > eventLogTitleWidget.own.transform.position.y)
                {
                    maxY = itemY;

                    _components.Add(xianTuTitleWidget);
                }
            }

            foreach (var uiComponent in _components)
            {
                float itemY = uiComponent.own.transform.position.y; // 使用世界坐标的 Y 值
                if (itemY < minY)
                {
                    minY = itemY;
                    highestItem = uiComponent;
                }
            }


            if (highestItem != null)
            {
                float outsideY = eventLogTitleWidget.own.transform.position.y;
                if (maxY > outsideY)
                {
                    XianTuData xianTuData = default;
                    if (highestItem is EventLogTitleWidget)
                    {
                        EventLogTitleWidget eventLogTitleWidget = highestItem as EventLogTitleWidget;
                        xianTuData = eventLogTitleWidget.xiantuData;
                    }
                    else if (highestItem is EventLogWidget)
                    {
                        EventLogWidget eventLogWidget = highestItem as EventLogWidget;
                        xianTuData = eventLogWidget.XianTuData.fatherXianTuData;
                    }

                    eventLogTitleWidget.CustomInit(xianTuData.name);
                }
            }
        }

        public override void Close()
        {
            UIManager.Instance.DormancyAllGComponent<MainEventLogWidget>();
            UIManager.Instance.DormancyAllGComponent<EventLogWidget>();
            UIManager.Instance.DormancyAllGComponent<EventLogTitleWidget>();
            components.Clear();
            type = 0;
            foreach (var bigMapXianTuSaiWidget in bigMapXianTuSaiWidgets)
            {
                UIManager.Instance.DormancyGComponent(bigMapXianTuSaiWidget);
            }

            bigMapXianTuSaiWidgets.Clear();

            foreach (var placesXianTuSaiWidget in placesXianTuSaiWidgets)
            {
                UIManager.Instance.DormancyGComponent(placesXianTuSaiWidget);
            }

            placesXianTuSaiWidgets.Clear();

            Btn_XaiXuanClose.gameObject.SetActive(false);
            Btn_XaiXuan.gameObject.SetActive(false);

            bigMaoXaiXuan = 0;
            placesXaiXuan = 0;
            places.Clear();

            base.Close();
        }
    }
}