using System;
using asap.core;
using cfg;
using GameCore;
using Newtonsoft.Json;
using System.Collections.Generic;
using System.Linq;
using UniRx;
using UnityEngine;

namespace Assets.Scripts.UI.JigsawPuzzle
{
    public class JigsawPuzzleManager:IDisposable
    {
        public const string PriceImgName = "separate_icon_eventjigsawpuzzle_piece_";

        public JigsawPuzzleManager()
        {
            GContext.OnEvent<TargetEvent>().Subscribe(OnEvent_TargetEvent).AddTo(Disposables);
        }

        public void Dispose()
        {
            Disposables?.Dispose();
            _rewards?.Clear();
        }

        private CompositeDisposable _disposable;
        private CompositeDisposable Disposables => _disposable ??= new CompositeDisposable();

        #region event

        private void OnEvent_TargetEvent(TargetEvent targetEvent)
        {
            if (targetEvent.type == 4 && targetEvent.subType == 9)
            {
                RefreshData(targetEvent.id);
            }
        }

        #endregion event

        #region data

        [Inject]
        public Tables Tables { get; set; }

        private JigsawPuzzleData _jigsawPuzzleData;
        public JigsawPuzzleData Data => _jigsawPuzzleData ??= new JigsawPuzzleData(Tables);

        private void RefreshData(int eventId)
        {
            //判断周开启时间
            FishingEvent fishingEvent = Tables.TbFishingEvent.GetOrDefault(eventId);
            if (fishingEvent == null) return;
            var CacheData = GetCacheData();
            if (CacheData != null && CacheData.EventID == eventId)
            {
                this.Data.SetData(CacheData);
                SetRedPoint();
                return;
            }
            InitData(eventId);
            SaveData();
        }
        private void InitData(int eventId)
        {
            this.Data.EventID = eventId;
            Data.CompletedRoundCount = 0;
            Data.PieceRepeatAmount = 0;
            this.Data.RefreshCache();
            Data.FixedInitList?.Clear();
            this.Data.InflationRate = GContext.container.Resolve<PlayerData>().InflationRate;
            var welcomeGift= GContext.container.Resolve<FishingEventData>().GetInitWelcomeGift(eventId);
            Debug.Log($"jsd InitData {welcomeGift}");
            AddToken(welcomeGift);
        }
        private JigsawPuzzleData GetCacheData()
        {
            string dataStr = PlayFabMgr.Instance.GetLocalData(nameof(JigsawPuzzleData));
#if UNITY_EDITOR
            Debug.Log($"jsd JigsawPuzzleData LoadData sData {dataStr}");
#endif
            if (string.IsNullOrEmpty(dataStr))
                return null;
                
            return JsonConvert.DeserializeObject<JigsawPuzzleData>(dataStr);
        }
        public void SaveData()
        {
#if UNITY_EDITOR
            Debug.Log($"jsd JigsawPuzzleData SaveData {JsonConvert.SerializeObject(Data)}");
#endif
            PlayFabMgr.Instance.UpdateUserDataValue(nameof(JigsawPuzzleData), JsonConvert.SerializeObject(Data));
        }

        private List<EventJigsawPuzzleReward> _rewards = new List<EventJigsawPuzzleReward>();

        public List<EventJigsawPuzzleReward> GetEventRewards()
        {
            if (Data == null) return null;

            if (_rewards == null)
                _rewards = new List<EventJigsawPuzzleReward>();
            else
                _rewards.Clear();

            var round = Data.RoundConfig;
            if (round == null) return null;
            
            foreach (var id in round.PuzzleRewardList)
            {
                var rewardConfig = Tables.TbEventJigsawPuzzleReward.Get(id);
                if (rewardConfig == null) continue;
                if (_rewards.Contains(rewardConfig)) continue;
                _rewards.Add(rewardConfig);
            }
            return _rewards;
        }

        public EventJigsawPuzzleReward GetRandomReward()
        {
            if (Data.FixedInitList.Count < Data.EventMain.FixedInitList.Count)
            {
                var rewardID = Data.EventMain.FixedInitList[Data.FixedInitList.Count];
                if (rewardID != 0)
                {
                    Data.FixedInitList.Add(rewardID);
                    SaveData();
                    var reward = _rewards.Find(x => x.Index == rewardID);
                    if(reward==null)
                        Debug.LogError($"get fixed reward rewardID:{rewardID} reward is null");
                    return reward;
                }
            }

            var progressConfig = GetProgressConfig(Data.CompletedPicCount);
            if (progressConfig == null)
            {
                Debug.LogError("progressConfig error");
                return null;
            }

            bool isPuzzlePiece = UnityEngine.Random.Range(0, 101) < progressConfig.NotPieceProb * 100;

            if (isPuzzlePiece)
                return GetRandomItemRewardIndex();

            bool isRepeatPuzzle = UnityEngine.Random.Range(0, 101) < progressConfig.RepeatProb * 100;
            if (isRepeatPuzzle)
                return GetRandomRepeatPuzzleRewardIndex();
            return GetRandomNewPuzzleRewardIndex();
        }

        private EventJigsawPuzzleExProb GetProgressConfig(int completedCount)
        {
            foreach (var probId in Data.RoundConfig.ProbList)
            {
                var config = Tables.TbEventJigsawPuzzleExProb.GetOrDefault(probId);
                if (config == null)
                {
                    Debug.LogError($"配置错误 probId:{probId} 没有对应的config ");
                    continue;
                }

                if (config.CompletedPicCount == completedCount)
                    return config;
            }
            Debug.LogError($"RoundConfig {Data.RoundConfig.ID} 没有完成这个 {completedCount}数量 的奖励 配置错误");
            return null;
        }

        private EventJigsawPuzzleReward GetRandomRepeatPuzzleRewardIndex()
        {
            var puzzleRewards = _rewards.Where(x => x.ItemDropID == 0).ToList();
            var ownedPuzzles = puzzleRewards.Where(r => Data.ProgressPairs.ContainsKey(r.PictureID)
                && Data.ProgressPairs[r.PictureID].Count == 6)
                .ToList();

            if (ownedPuzzles.Count == 0)
                return GetWeightedRandomReward(puzzleRewards);

            return GetWeightedRandomReward(ownedPuzzles);
        }

        private EventJigsawPuzzleReward GetRandomNewPuzzleRewardIndex()
        {
            var puzzleRewards = _rewards.Where(x => x.ItemDropID == 0).ToList();
            var newPuzzles = puzzleRewards.Where(r => Data.ProgressPairs.ContainsKey(r.PictureID)
                && Data.ProgressPairs[r.PictureID].Count < 6).ToList();

            if (newPuzzles.Count == 0)
                return GetRandomRepeatPuzzleRewardIndex();

            return GetWeightedRandomReward(newPuzzles);
        }

        private EventJigsawPuzzleReward GetRandomItemRewardIndex()
        {
            var itemRewards = _rewards.Where(r => r.ItemDropID > 0).ToList();

            if (itemRewards.Count == 0)
                return GetWeightedRandomReward(_rewards);

            return GetWeightedRandomReward(itemRewards);
        }

        private EventJigsawPuzzleReward GetWeightedRandomReward(List<EventJigsawPuzzleReward> availableRewards)
        {
            if (availableRewards.Count == 0)
            {
                Debug.LogError($"get random reward error {availableRewards.Count} ");
                return null;
            }

            int totalWeight = availableRewards.Sum(r => r.Weight);

            if (totalWeight <= 0)
            {
                Debug.LogError("总权重为0");
                return null;
            }

            int randomValue = UnityEngine.Random.Range(0, totalWeight);
            int currentWeight = 0;

            for (int i = 0; i < availableRewards.Count; i++)
            {
                currentWeight += availableRewards[i].Weight;
                if (randomValue < currentWeight)
                {
                    return availableRewards[i];
                }
            }

            return availableRewards.LastOrDefault();
        }

        #endregion data

        #region config

        public int GetRewardDropID(int pictureID)
        {
            var index = Data.RoundConfig.PictureList.IndexOf(pictureID);
            if (index >= 0 && index < Data.RoundConfig.PictureRewardList.Count)
                return Data.RoundConfig.PictureRewardList[index];
            Debug.LogError($"{this.GetType().Name} 配置错误 puzzlePicture is null PictureID {pictureID}");
            return 0;
        }
        public int GetPictureIDByQuality(int quality)
        {
            var index = quality - 1;
            if(index >= Data.RoundConfig.PictureList.Count|| index < 0)
                return -1;
            return Data.RoundConfig.PictureList[index];
        }
        public string GetPictureNameByQuality(int quality)
        {
            return Tables.TbEventJigsawPuzzlePicture.GetOrDefault(GetPictureIDByQuality(quality))?.PictureName;
        }

        #endregion
        #region token

        public void AddToken(int count)
        {
            var currentCount = GetTokenCount();
            if (Data == null) return;
            var totalCount = currentCount + count;
            GContext.container.Resolve<FishingEventData>().SaveTransitionData(Data.EventID, totalCount);
            SetRedPoint();
        }

        public void RemoveToken(int count)
        {
            if (Data == null) return;
            var eventData = GContext.container.Resolve<FishingEventData>();
            if (eventData == null) return;
            var current = eventData.GetTransitionDataCount(Data.EventID);
            var resCount = Mathf.Max(0, current - count);
            eventData.SaveTransitionData(Data.EventID, resCount);
            SetRedPoint();
        }

        public int GetTokenCount()
        {
            if (Data == null) return 0;
            var eventData = GContext.container.Resolve<FishingEventData>();
            return eventData?.GetTransitionDataCount(Data.EventID) ?? 0;
        }

        public bool IsCompleteAllPuzzle()
        {
            return Data.CompletedPicCount >= Data.RoundConfig.PictureList.Count;
        }

        #endregion
        #region Red

        private string GetRedPointKey()
        {
            return "eventJigsawPuzzle.red";
        }
        private bool GetRedPointState()
        {
            return GetTokenCount()>0;
        }
        private void SetRedPoint()
        {
            RedPointManager.Instance?.SetRedPointState(GetRedPointKey(), GetRedPointState(),GetTokenCount());
        }
        #endregion
    }
}