using System;
using System.Collections.Generic;
using System.Linq;
using asap.core;
using cfg;
using game;
using GameCore;
using UniRx;
using UnityEngine;
using Random = UnityEngine.Random;

namespace EventMowForTreasure
{
    public class EventMowForTreasureManager : AEventDataManager<EventMowForTreasureData>
    {
        public EventMowForTreasureManager(PlayerItemData playerItemData)
        {
            _playerItemData = playerItemData;
            GContext.OnEvent<EventMowForTreasureData>().Subscribe(_ =>
            {
                SaveData();
                SetRedPoint();
                SetRedPoint_chainPack();
            }).AddTo(Disposables);
        }

        #region event

        protected override int EventType => 7;
        protected override int EventSubType => 6;

        #endregion event

        #region data

        private readonly PlayerItemData _playerItemData;
        private readonly List<ItemData> _itemDatas = new List<ItemData>();
        protected override void RefreshData(int eventId)
        {
            base.RefreshData(eventId);
            RefreshToolToken();
        }

        protected override void InitData(int eventId)
        {
            base.InitData(eventId);
            Data.SetChainPackID();
            Data.RefreshCache();
            InitToolAmount();
            var welcomeGift = GContext.container.Resolve<FishingEventData>().GetInitWelcomeGift(eventId);
            AddToken(welcomeGift);
            SaveData();
        }

        protected override void SaveData()
        {
            base.SaveData();
            GContext.Publish(new EventMowForTreasureGuideRefresh());
        }
        #endregion data

        #region Stage

        public List<ItemData> GetItemDataForCell()
        {
            var dropID = GetCurrentStage()?.BreakDropID ?? 0;
            if (dropID <= 0) return null;

            var dropItems = _playerItemData.GetItemDataByDropIdAndTypeLureInflation(Data.InflationRate, dropID);
            if (dropItems == null || dropItems.Count == 0) return null;

            return dropItems.Where(x => x.count > 0).ToList();
        }
        public List<ItemData> AddItemDataForCell()
        {
            var dropID = GetCurrentStage()?.BreakDropID ?? 0;
            if (dropID <= 0) return null;
            ChangeSource changeSource = new ChangeSource(Data.EventId, "Event_Minigame2", "Event_Minigame2_Mow", "DirectReward");

            var dropItems = _playerItemData.AddItemByDropLureInflation(Data.InflationRate, dropID, changeSource, false);
            if (dropItems == null || dropItems.Count == 0) return null;

            _itemDatas.AddRange(dropItems);

            return dropItems.Where(x => x.count > 0).ToList();
        }

        public void ShowAllBrokeDropItems()
        {
            if (_itemDatas is { Count: <= 0 }) return;
            //// 合并重复物品ID，避免显示多个相同物品
            var mergedItems = _itemDatas
                                .GroupBy(item => item.id)
                                .Select(group => new ItemData
                                {
                                    id = group.Key,
                                    count = group.Sum(item => item.count)
                                }).ToList();
            GContext.Publish(new ShowData(mergedItems));
            GContext.Publish(new ShowData());
            _itemDatas.Clear();
        }
        public EventMowForTreasureObstacleData GetObstacleData(Vector2Int coordinate, int columnAmount)
        {
            var index = columnAmount * (coordinate.y - 1) + coordinate.x;
            if (index < 0 || index >= Data.ObstacleList.Count)
                return null;
            return Data.ObstacleList[index];
        }

        private int GetFixedStageID()
        {
            if (Data.FixedStageList.Count == Data.EventMain.FixedStageList.Count) return -1;
            return Data.EventMain.FixedStageList[Data.FixedStageList.Count];
        }

        private EventMowForTreasureStage GetFixedStageConfig()
        {
            var id = GetFixedStageID();
            return Tables.TbEventMowForTreasureStage.GetOrDefault(id);
        }

        private EventMowForTreasureStage GetRelevantLoopStageByFixed()
        {
            if (Data.IsCompletedFixedStage) return null;
            var id = Data.EventMain.LoopStageList.ElementAt(Data.FixedStageList.Count);
            return Tables.TbEventMowForTreasureStage.GetOrDefault(id);
        }

        private int GetLoopStageID()
        {
            var loopProgress = Data.CompletedStageAmount - Data.FixedStageList.Count;
            var targetIndex = loopProgress % Data.EventMain.LoopStageList.Count;
            return Data.EventMain.LoopStageList.ElementAt(targetIndex);
        }

        private EventMowForTreasureStage GetLoopStageConfig()
        {
            var id = GetLoopStageID();
            return Tables.TbEventMowForTreasureStage.GetOrDefault(id);
        }

        private EventMowForTreasureStage GetCurrentStage()
        {
            return Data.IsCompletedFixedStage ? GetLoopStageConfig() : GetFixedStageConfig();
        }

        public string GetCurrentStageAct()
        {
            return Data.IsCompletedFixedStage
                ? GetCurrentStage()?.StageBgPrefab
                : GetRelevantLoopStageByFixed()?.StageBgPrefab;
        }

        public Dictionary<int, int> GetCurrentStageItemDir()
        {
            return Data.IsCompletedFixedStage
                ? GetLoopStageConfig()?.StageItemList
                : GetRelevantLoopStageByFixed()?.StageItemList;
        }

        private Dictionary<int, float> GetCurrentStageItemDrop()
        {
            return Data.IsCompletedFixedStage
                ? GetLoopStageConfig()?.StageItemProb
                : GetRelevantLoopStageByFixed()?.StageItemProb;
        }

        public void InitStageAllObstacle(Vector2Int startCoordinate, Vector2Int endCoordinate)
        {
            InitDataStarAndEndData(startCoordinate, endCoordinate);
            InitStageObstacleListDatas();
        }

        private void InitStageObstacleListDatas()
        {
            if (Data.ObstacleList is { Count: > 0 }) return;
            var stageConfig = GetCurrentStage();
            var randomStageIndex = Random.Range(0, stageConfig.StageConfig.Count);
            var randomStageObstacles = stageConfig.StageConfig[randomStageIndex];
            var currentItemDrop = GetCurrentStageItemDrop();
            var datas = new List<EventMowForTreasureObstacleData>();
            foreach (var t in randomStageObstacles)
            {
                var type = t;
                if (currentItemDrop.TryGetValue(type, out var probability))
                {
                    var random = Random.value;
                    if (random > probability)
                        type = (int)EEventMowForTreasureObstacleType.CommonObstacle;
                }

                var data = new EventMowForTreasureObstacleData
                {
                    Type = (EEventMowForTreasureObstacleType)type
                };
                datas.Add(data);
            }

            Data.ObstacleList = datas;
            SaveData();
        }

        private void InitDataStarAndEndData(Vector2Int startCoordinate, Vector2Int endCoordinate)
        {
            if (Data.StartObstacle != null)
            {
                Data.StartObstacle.Coordinate = startCoordinate;
            }
            else
            {
                Data.StartObstacle = new EventMowForTreasureObstacleData
                {
                    Type = EEventMowForTreasureObstacleType.None,
                    Coordinate = startCoordinate,
                    IsBroke = true
                };
            }

            if (Data.EndObstacle != null)
            {
                Data.EndObstacle.Coordinate = endCoordinate;
            }
            else
            {
                Data.EndObstacle = new EventMowForTreasureObstacleData
                {
                    Coordinate = endCoordinate,
                    Type = EEventMowForTreasureObstacleType.FinalReward
                };
            }
        }

        public List<ItemData> GetCurrentStageFinalReward()
        {
            var stageConfig = GetCurrentStage();
            return   GContext.container.Resolve<PlayerItemData>()
                .GetItemDataByDropIdAndTypeLureInflation(Data.InflationRate, stageConfig.FinalRewardDropID); 
        }

        public void SetCompleteStageAndSendReward()
        {
            var stageConfig = GetCurrentStage();
            if (!Data.IsCompletedFixedStage) Data.FixedStageList.Add(stageConfig.ID);
            Data.CompletedStageAmount += 1;
            Data.ObstacleList?.Clear();
            Data.ObstacleList = null;
            Data.EndObstacle = null;
            Data.StartObstacle = null;
            AggStageComplete(GetCurrentStage().ID);
            SaveData();
            ChangeSource changeSource = new ChangeSource(Data.EventId, "Event_Minigame2", "Event_Minigame2_Mow", "StageReward");

            GContext.container.Resolve<PlayerItemData>()
                .AddItemByDropLureInflation(Data.InflationRate, stageConfig.FinalRewardDropID, changeSource);
            GContext.Publish(new ShowData());
        }
        public void ProcessSingleCellBreak(EventMowForTreasureObstacleCell cell,
            Func<EventMowForTreasureObstacleCell, List<EventMowForTreasureObstacleCell>> getSpecialRewardBreakCells,
            ref int specialRewardBrokeCount)
        {
            if (!cell) return;
            var data = cell.GetData();
            if (data == null) return;
            if (data.IsBroke) return;

            if (data.IsCollectionReward)
                TryCollectCollection(data, out _);
            else if (data.IsSpecialReward)
            {
                var cells = getSpecialRewardBreakCells?.Invoke(cell);
                if (cells == null) return;
                specialRewardBrokeCount += cells.Count(c => !c.GetData().IsBroke);
                int brokeCount = 0;
                foreach (var c in cells)
                    ProcessSingleCellBreak(c, getSpecialRewardBreakCells, ref specialRewardBrokeCount);
            }
            else if (data.IsObstacleCell)
                ObstacleBreakItemDrop(data);

            data.IsBroke = true;
            SaveData();
        }
        private void ObstacleBreakItemDrop(EventMowForTreasureObstacleData data)
        {
            var itemDatas = AddItemDataForCell();
            if (itemDatas is not { Count: > 0 }) return;
            data.ItemData = itemDatas.First();
        }
        #endregion

        #region Tool

        private void InitToolAmount()
        {
            if (Data.EventMain.ToolConfigList.Count != Data.EventMain.ToolInitCount.Count)
            {
                Debug.LogError($"InitToolAmount 数量不一致 ToolConfigList {Data.EventMain.ToolConfigList.Count} ToolInitCount {Data.EventMain.ToolInitCount.Count}");
                return;
            }

            for (int i = 0; i < Data.EventMain.ToolConfigList.Count; i++)
            {
                var toolID = Data.EventMain.ToolConfigList[i];
                var amount = Data.EventMain.ToolInitCount[i];
                if (IsDefaultTool(toolID))
                {
                    AddToken(amount);
                    continue;
                }
                if (!Data.ToolAmountPairs.TryAdd(toolID, amount))
                {
                    Debug.LogWarning($" InitToolAmount 添加失败 toolID {toolID} amount {amount}");
                }
            }

            SetRedPoint();
        }

        public EEventMowForTreasureToolType GetToolTypeByConfig(EventMowForTreasureTool tool)
        {
            return (EEventMowForTreasureToolType)Data.EventMain.ToolConfigList.IndexOf(tool.ID);
        }

        public EventMowForTreasureTool GetToolConfigByIndex(int index)
        {
            var isValidIndex = index >= 0 && index < Data.EventMain.ToolConfigList.Count;
            return !isValidIndex ? null : Tables.TbEventMowForTreasureTool.GetOrDefault(Data.EventMain.ToolConfigList[index]);
        }

        public bool TryGetToolAmount(int toolID, out int toolAmount)
        {
            return Data.ToolAmountPairs.TryGetValue(toolID, out toolAmount);
        }

        private int GetDefaultToolID()
        {
            return Data.EventMain.ToolConfigList.FirstOrDefault();
        }
        public bool IsDefaultTool(int toolID)
        {
            return toolID == GetDefaultToolID();
        }
        public EventMowForTreasureTool GetDefaultToolConfig()
        {
            return Data.Tables.TbEventMowForTreasureTool.GetOrDefault(GetDefaultToolID());
        }

        public bool GetCanUseDefaultTool()
        {
            return GetCanUseTool(GetDefaultToolID());
        }

        public bool GetCanUseTool(int toolID)
        {
            if (!Data.ToolAmountPairs.TryGetValue(toolID, out var toolAmount))
                return false;
            return toolAmount > 0;
        }

        public void ConsumeTool(int toolID)
        {
            var isDefault = IsDefaultTool(toolID);
            if (isDefault)
                RemoveToken(1);
            else
                Data.ToolAmountPairs[toolID]--;
            GContext.Publish(new EventMowForTreasureToolAmountChange());
            SetRedPoint();
            SaveData();
        }

        public bool TryExchangeTool(int exchangeNum, int exchangeRate, int toolConfigID)
        {
            var defaultToolID = GetDefaultToolID();
            if (defaultToolID == 0) return false;
            Data.ToolAmountPairs.TryGetValue(defaultToolID, out var ownAmount);
            var needAmount = exchangeNum * exchangeRate;
            if (needAmount > ownAmount)
            {
                ShowFestPackPanel();
                return false;
            }

            RemoveToken(needAmount);
            if (!Data.ToolAmountPairs.TryAdd(toolConfigID, exchangeNum))
                Data.ToolAmountPairs[toolConfigID] += exchangeNum;
            SaveData();
            SetRedPoint();
            GContext.Publish(new EventMowForTreasureToolAmountChange());
            return true;
        }

        #endregion

        #region Collection

        public bool IsCanObtainCollectionReward(EventMowForTreasureCollectionData collectionData, int collectionAmount)
        {
            if (collectionData?.CollectionConfig == null) return false;
            if (collectionAmount < collectionData.CollectionConfig.CollectingRequirement) return false;
            ChangeSource changeSource = new ChangeSource(Data.EventId, "Event_Minigame2", "Event_Minigame2_Mow", "TaskReward");

            GContext.container.Resolve<PlayerItemData>()
                .AddItemByDropLureInflation(Data.InflationRate, collectionData.GerRewardDropID(), changeSource);
            collectionData.Amount = collectionAmount - collectionData.CollectionConfig.CollectingRequirement;
            collectionData.Round++;
            SaveData();
            return true;
        }

        private List<ItemData> GetCollectionReward(EventMowForTreasureCollectionData collectionData)
        {
            return GContext.container.Resolve<PlayerItemData>()
                .GetItemDataByDropIdAndTypeLureInflation(Data.InflationRate,
                    collectionData.GerRewardDropID());
        }
        public EventMowForTreasureCollectionData GetCollectionDataByType(int type)
        {
            return TryGetCollectionIDByType(type, out var collectionID) ? GetCollectionData(collectionID) : null;
        }
        public bool TryCollectCollection(EventMowForTreasureObstacleData cellData,
            out EventMowForTreasureCollectionData collectionData)
        {
            collectionData = null;
            if (!TryGetCollectionIDByType((int)cellData.Type, out var collectionID)) return false;
            collectionData = GetCollectionData(collectionID);
            if (collectionData != null)
                collectionData.Amount += 1;
            else
                Data.CollectionProgressPairs.Add(collectionID, new EventMowForTreasureCollectionData(Tables, collectionID, 1));

            cellData.IsBroke = true;
            SaveData();
            AggCollection((int)cellData.Type, GetCurrentStage().ID);
            return true;
        }

        private bool TryGetCollectionIDByType(int type, out int collectionID)
        {
            return GetCurrentStageItemDir().TryGetValue(type, out collectionID);
        }

        private EventMowForTreasureCollectionData GetCollectionData(int collectionID)
        {
            if (Data.CollectionProgressPairs.TryGetValue(collectionID, out var collectionData))
            {
                if (collectionData.CollectionID == 0)
                    collectionData.CollectionID = collectionID;
                return collectionData;
            }

            collectionData = new EventMowForTreasureCollectionData(Tables, collectionID, 0);
            Data.CollectionProgressPairs.Add(collectionID, collectionData);
            SaveData();
            return collectionData;
        }

        public EventMowForTreasureCollectionData GetCollectionDataAndRewardByIndex(int index,
            out List<ItemData> rewards)
        {
            rewards = null;
            var isValidIndex = index >= 0 && index < Data.EventMain.CollectionID.Count;
            if (!isValidIndex) return null;
            var collectionID = Data.EventMain.CollectionID[index];
            var collectionData = GetCollectionData(collectionID);
            rewards = GetCollectionReward(collectionData);
            return collectionData;
        }

        #endregion

        #region FestPack

        public async void ShowFestPackPanel()
        {
            try
            {
                if (Data?.EventMain == null) return;

                GameObject go;
                var chainPackData = GenericChainPackData<EventMowForTreasureData>.Create(Data, GetPackData());
                if (chainPackData.ChainProgress >= chainPackData.ChainListCount)
                {
                    var packManagerConfig = Data.Tables.TbEventPackManager.GetOrDefault(Data.EventMain.PackPackID);
                    UITypes.EventMowForTreasureFestPackPanle.SetType(Data.EventMain.PackPanel);
                    go = await UIManager.Instance.ShowUILoad(UITypes.EventMowForTreasureFestPackPanle);
                    var vipLevel = GContext.container.Resolve<PlayerData>().PriceLv;
                    var packManager = Tables.TbEventPackManager.GetOrDefault(Data.EventMain.PackPackID);
                    var packIDs = packManager.VIPPackList[vipLevel];
                    if (packIDs.Count != 2)
                    {
                        Debug.LogError($"配置错误 packIDs.Count not 2 packManager id {packManager.ID} vipLevel{vipLevel}");
                        return;
                    }

                    var packLeft = Tables.TbPack.GetOrDefault(packIDs[0]);
                    var packRight = Tables.TbPack.GetOrDefault(packIDs[1]);
                    go.GetOrAddComponent<GeneralEventNormalPackPanel>()?
                        .Init(new GeneralEventNormalPackInfo()
                        {
                            EventId = Data.EventID,
                            PackLeft = packLeft,
                            PackRight = packRight,
                            ExpireTime = ZZTimeHelper.UtcNow().Add(Data.RemainingTime),
                            InflationRate = Data.InflationRate
                        });
                    return;
                }


                UITypes.EventMowForTreasureFestPackChainPanle.SetType(Data.EventMain.ChainPackPanel);
                go = await UIManager.Instance.ShowUILoad(UITypes.EventMowForTreasureFestPackChainPanle);
                var panel = go.GetComponent<ChainPackPanel>();
                panel.Init(chainPackData);
            }
            catch (Exception e)
            {
                Debug.LogError($"jsd {e}");
            }
        }

        public async void ShowExchangeToolPanel(int toolID)
        {
            try
            {
                var toolIndex = Data.EventMain.ToolConfigList.IndexOf(toolID);
                var rateCount = Data.EventMain.ToolExchangeRate.Count;
                if (toolIndex >= rateCount)
                {
                    Debug.LogError($"参数错误 _toolConfig.ID {toolID} toolIndex {toolIndex} RateCount {rateCount}");
                    return;
                }

                var toolRate = Data.EventMain.ToolExchangeRate[toolIndex];
                var go = await UIManager.Instance.ShowUILoad(UITypes.EventMowForTreasureExchangePanel);
                go.GetOrAddComponent<EventMowForTreasureExchangePanel>()?
                    .SetData(toolID, toolRate);
            }
            catch (Exception e)
            {
                Debug.LogError(e);
            }
        }

        private EventChainPackInfo GetPackData()
        {
            var chainList = GetChainPackManager().GetPackIDsByCurrentVipLevel();
            var packs = Tables.TbPack.DataList.Where(p => chainList.ToHashSet().Contains(p.ID)).ToArray();
            return new EventChainPackInfo
            {
                ChainList = chainList,
                ExpireTime =ZZTimeHelper.UtcNow().Add(Data.RemainingTime),
                Packs = packs,
                RedPointKey = GetRedPointKey_chainPack()
            };
        }

        private EventPackManager GetChainPackManager()
        {
            return Tables.TbEventPackManager[Data.ChainPackID];
        }

        public void AddChainPackProgress(int count = 1)
        {
            if (Data == null) return;
            var currentCount = Data.GetChainProgress();
            var totalCount = currentCount + count;
            Data.SetChainProgress(totalCount);
            SaveData();
        }

        #endregion

        #region Token

        public override void AddToken(int count)
        {
            base.AddToken(count);
            RefreshToolToken();
            GContext.Publish(new EventMowForTreasureToolAmountChange());
        }

        protected override void RemoveToken(int count)
        {
            base.RemoveToken(count);
            RefreshToolToken();
            GContext.Publish(new EventMowForTreasureToolAmountChange());
        }
        private void RefreshToolToken()
        {
            var defaultConfigID = GetDefaultToolID();
            if (!Data.ToolAmountPairs.TryAdd(defaultConfigID, GetTokenCount()))
                Data.ToolAmountPairs[defaultConfigID] = GetTokenCount();
            SetRedPoint();
            SaveData();
        }

        #endregion

        #region Guide
        public void AddGuideStep(int step = 1)
        {
            Data.GuideStep += step;
            SaveData();
        }
        public void TryShowGuide()
        {
            if (Data.IsCompleteGuide)
                return;
            switch (Data.GuideStep)
            {
                case 1:
                    UITypes.EventMowForTreasureInfoPopup.SetType(Data.EventMain.InfoPanel);
                    _ = UIManager.Instance.ShowUILoad(UITypes.EventMowForTreasureInfoPopup);
                    Data.GuideStep++;
                    break;
                case >= 2 and <= 4:
                    UITypes.EventMowForTreasureGuidePopup.SetType(Data.EventMain.GuidePanel);
                    _ = UIManager.Instance.ShowUILoad(UITypes.EventMowForTreasureGuidePopup);
                    break;
                default:
                    GContext.container.Resolve<GuideDataCenter>().InspectTriggerGuide("EventMowForTreasurePanel");
                    Data.IsCompleteGuide = true;
                    break;
            }
            SaveData();
        }

        public void ClearGuide()
        {
            Data.IsCompleteGuide = false;
            Data.GuideStep = 1;
            SaveData();
        }

        #endregion

        #region Red

        private string GetRedPointKey_chainPack()
        {
            return "eventMowForTreasureChainPack.red";
        }

        private bool GetRedPointState_chainPack()
        {
            return GetRedPointCount_chainPack()>0;
        }

        private int GetRedPointCount_chainPack()
        {
            return GenericChainPackData<EventMowForTreasureData>.Create(Data, GetPackData())?.RedPointIndex??0;;
        }

        public void SetRedPoint_chainPack()
        {
            RedPointManager.Instance?.SetRedPointState(GetRedPointKey_chainPack(), GetRedPointState_chainPack(),GetRedPointCount_chainPack());
        }
        private string GetRedPointKey()
        {
            return "eventMowForTreasure.red";
        }
        private bool GetRedPointState()
        {
            return GetRedPointCount()>0;
        }

        private int GetRedPointCount()
        {
            var chainPackData = GenericChainPackData<EventMowForTreasureData>.Create(Data, GetPackData());
            return Data.ToolAmountPairs.Values.Sum()+chainPackData?.RedPointIndex??0;
        }

        private void SetRedPoint()
        {
            RedPointManager.Instance?.SetRedPointState(GetRedPointKey(), GetRedPointState(),GetRedPointCount());
        }
        #endregion

        #region Agg

        private void AggCollection(int collection_type, int stage_id)
        {
#if UNITY_EDITOR
            Debug.Log($"event_mowfortreasure_collection collection_type {collection_type} stage_id {stage_id}");
#endif
#if AGG
            using (var e = GEvent.GameEvent("event_mowfortreasure_collection"))
            {
                e.AddContent(nameof(collection_type),collection_type)
                    .AddContent(nameof(stage_id), stage_id);
            }
#endif
        }
        private void AggStageComplete(int stage_id)
        {
#if UNITY_EDITOR
            Debug.Log($"event_mowfortreasure_complete  stage_id {stage_id}");
#endif
#if AGG
            using (var e = GEvent.GameEvent("event_mowfortreasure_complete"))
            {
                e.AddContent(nameof(stage_id), stage_id);
            }
#endif
        }

        public void AggItem(int item_type, bool is_knife, int block_break_count)
        {
            var stage_id = GetCurrentStage().ID;
#if UNITY_EDITOR
            Debug.Log($"event_mowfortreasure_item item_type {item_type} is_knife {is_knife} block_break_count {block_break_count} stage_id {stage_id}");
#endif
#if AGG
            using (var e = GEvent.GameEvent("event_mowfortreasure_item"))
            {
                e.AddContent(nameof(item_type), item_type)
                    .AddContent(nameof(is_knife), is_knife)
                    .AddContent(nameof(block_break_count), block_break_count)
                    .AddContent(nameof(stage_id), stage_id);
            }
#endif
        }
        #endregion
    }
}