using asap.core;
using cfg;
using game;
using LitJson;
using System;
using System.Collections.Generic;
using tysdk;
using UniRx;
using UnityEngine;
using UnityEngine.AddressableAssets;

namespace GameCore
{
    public class GuideNextEvent
    {

    }
    public class AddIndexEvent
    {
        public bool CompleteGuide;
        public int guideSubIndex;
        public bool isAutoNext;
    }
    /// <summary>
    /// 废弃
    /// </summary>
    public struct OnEventTriggerGuide
    {
        public OnEventTriggerGuide(string panelName)
        {
            this.panelName = panelName;
        }
        public string panelName;
    }
    public class GuideSaveData
    {
        public int guideSubIndex = 0;
        public bool isFinish = false;
        public string groupName;
    }
    public class GuideDataCenter : IDisposable
    {
        Tables _tables;
        PlayerData playerData;
        public GuideDataCenter(cfg.Tables tables, PlayerData playerData)
        {
            this._tables = tables;
            this.playerData = playerData;
        }
        public string CurPanelName;
        public Dictionary<string, GuideSaveData> GuideSaveDataDic = new Dictionary<string, GuideSaveData>();
        public GuideSaveData curSaveData;
        public GuidanceGroupDefine[] guidanceGroupDefines;
        public GuidanceDefine curDefine;
        public string popupPanelNode;
        public GuidanceGroupDefine curGroupDefine;
        public GuidanceDefineSetting guidanceDefineSetting;
        //待释放
        IDisposable disposable;
        IDisposable disposable2;
        IDisposable disposable3;

        public void GMClearGuide()
        {
            foreach (var item in guidanceGroupDefines)
            {
                if (!GuideSaveDataDic.TryGetValue(item.groupName.ToString(), out GuideSaveData _saveData))
                {
                    _saveData = new GuideSaveData();
                    _saveData.groupName = item.groupName.ToString();
                    GuideSaveDataDic.Add(item.groupName.ToString(), _saveData);
                }
                _saveData.isFinish = true;
            }
            GContext.Publish(new ConditionTypeEvent(ConditionType.CompleteGuide, 0));
            curDefine = null;
            curGroupDefine = null;
            Save();
        }
        public async void Init()
        {
            guidanceDefineSetting = (GuidanceDefineSetting)await Addressables.LoadAssetAsync<object>("GuidanceConfig");
            if (guidanceDefineSetting != null)
            {
                guidanceGroupDefines = guidanceDefineSetting.guidanceGroupDefines;
                List<GroupName> Skip = guidanceDefineSetting.SkipGroupNames;
                bool isSkip = playerData.lv >= guidanceDefineSetting.SkipLevel;
                if (GuideSaveDataDic == null)
                {
                    GuideSaveDataDic = new Dictionary<string, GuideSaveData>();
                }
                else
                {
                    GuideSaveData _saveData;
                    GuidanceDefine _define;
                    Dictionary<string, GuideSaveData> keyValuePairs = new Dictionary<string, GuideSaveData>();
                    foreach (var item in guidanceGroupDefines)
                    {

                        if (GuideSaveDataDic.TryGetValue(item.groupName.ToString(), out _saveData))
                        {
                            if (!_saveData.isFinish && _saveData.guideSubIndex > 0)
                            {
                                for (int i = _saveData.guideSubIndex; i < item.guidanceDefines.Length; i++)
                                {
                                    _define = item.guidanceDefines[i];
                                    if (_define.isKey)
                                    {
                                        _saveData.guideSubIndex = _define.JumpIndex;
                                        if (_saveData.guideSubIndex < item.guidanceDefines.Length)
                                        {
                                            _saveData.isFinish = false;
                                            curSaveData = _saveData;
                                            curGroupDefine = item;
                                            curDefine = curGroupDefine.guidanceDefines[_saveData.guideSubIndex];
                                        }
                                        else
                                        {
                                            _saveData.isFinish = true;
                                            GContext.Publish(new ConditionTypeEvent(ConditionType.CompleteGuide, 1));
                                        }
                                        break;
                                    }
                                    else
                                    {
                                        _saveData.isFinish = true;
                                    }
                                }
                            }
                            keyValuePairs[item.groupName.ToString()] = _saveData;
                        }
                        else if (isSkip && Skip.Contains(item.groupName))
                        {
                            _saveData = new GuideSaveData();
                            _saveData.groupName = item.groupName.ToString();
                            _saveData.isFinish = true;
                            keyValuePairs[item.groupName.ToString()] = _saveData;
                        }
                    }
                    GuideSaveDataDic = keyValuePairs;
                    Save();
                }
                if (disposable2 == null)
                {
                    disposable2 = GContext.OnEvent<OnEventTriggerGuide>().Subscribe(TriggerGuideNext);
                }
            }
        }
        public bool GetIsFinish(string groupName)
        {
            return GuideSaveDataDic.ContainsKey(groupName) && GuideSaveDataDic[groupName].isFinish;
        }
        public bool InspectTriggerGuide(string panelName, string prePanelName = "", string curPanelName = "")
        {
            if (prePanelName.Contains("FishingRodPanel"))
            {
                return false;
            }
            if (guidanceDefineSetting == null)
            {
                return false;
            }
            if (curGroupDefine != null
                && GuideSaveDataDic.TryGetValue(curGroupDefine.groupName.ToString(), out var guideSaveData)
                //&& !guideSaveData.isFinish
                && curGroupDefine.guidanceDefines.Length > guideSaveData.guideSubIndex
                && panelName == curGroupDefine.guidanceDefines[guideSaveData.guideSubIndex].panelName)
            {
                TriggerGuideNext(new OnEventTriggerGuide(panelName));
                return true;
            }
            PlayerFishData playerFishData = GContext.container.Resolve<PlayerFishData>();
            GuidanceGroupDefine guidanceGroupDefine;
            for (int i = 0; i < guidanceGroupDefines.Length; i++)
            {
                guidanceGroupDefine = guidanceGroupDefines[i];

                bool isFinish = GetIsFinish(guidanceGroupDefine.groupName.ToString());
                if (isFinish || panelName != guidanceGroupDefine.guidanceDefines[0].panelName)
                {
                    continue;
                }

                if (CheckTriggerGuideFinish(guidanceGroupDefine))
                {
                    continue;
                }

                int count;
                switch (guidanceGroupDefine.TriggerConditionsType)
                {
                    case GuideTriggerConditions.Next:
                        break;
                    case GuideTriggerConditions.First_login:
                        break;
                    case GuideTriggerConditions.OpenSystem_Shop:
                        if (GContext.container.Resolve<PlayerShopData>().IsShopOpen == false)
                        {
                            continue;
                        }
                        break;
                    case GuideTriggerConditions.UnlockSystem_Album:
                        if (GContext.container.Resolve<AlbumData>().theme == null)
                        {
                            continue;
                        }
                        break;
                    case GuideTriggerConditions.Level_2:
                        if (playerData.lv >= 2)
                        {
                            break;
                        }
                        continue;
                    case GuideTriggerConditions.Group_Finish:
                        if (GuideSaveDataDic.TryGetValue(guidanceGroupDefine.TriggerConditionsParameter, out var _data) && _data.isFinish)
                        {
                            break;
                        }
                        continue;
                    case GuideTriggerConditions.GetDiffFishCount:
                        if (int.TryParse(guidanceGroupDefine.TriggerConditionsParameter, out count) && playerFishData.GetDiffFishCount() >= count)
                        {
                            if (playerFishData.GetDiffFishCount() > count)
                            {
                                TriggerGuideFinish(guidanceGroupDefine);
                                continue;
                            }
                            break;
                        }
                        continue;
                    case GuideTriggerConditions.GetFishCount:
                        if (int.TryParse(guidanceGroupDefine.TriggerConditionsParameter, out count) && playerFishData.GetAnglingCount() >= count)
                        {
                            if (playerFishData.GetAnglingCount() > count)
                            {
                                TriggerGuideFinish(guidanceGroupDefine);
                                continue;
                            }
                            break;
                        }
                        continue;
                    case GuideTriggerConditions.FirstClickMap_AtMap2:
                        if (playerData.lastMapId == _tables.TbMapData.DataList[1].ID)
                        {
                            break;
                        }
                        continue;
                    case GuideTriggerConditions.AccountLevel:
                        if (int.TryParse(guidanceGroupDefine.TriggerConditionsParameter, out count) && playerData.lv >= count)
                        {
                            break;
                        }
                        continue;
                    case GuideTriggerConditions.UnlockSystem:
                        if (int.TryParse(guidanceGroupDefine.TriggerConditionsParameter, out count) && GContext.container.Resolve<FishingEventData>().GetSystemOpen(count))
                        {
                            break;
                        }
                        continue;
                    case GuideTriggerConditions.UnlockEvent:
                        string[] str = guidanceGroupDefine.TriggerConditionsParameter.Split('-');
                        if (str.Length == 2)
                        {
                            if (int.TryParse(str[0], out count) && int.TryParse(str[1], out int count2) && GContext.container.Resolve<FishingEventData>().GetEvent(count, count2) > 0)
                            {
                                break;
                            }
                        }
                        else if (str.Length == 3)
                        {
                            if (int.TryParse(str[0], out count) && int.TryParse(str[1], out int count2) && int.TryParse(str[2], out int count3) && GContext.container.Resolve<FishingEventData>().GetEventRedirectID(count, count2) == count3)
                            {

                                break;
                            }
                        }
                        //if (int.TryParse(guidanceGroupDefine.TriggerConditionsParameter, out count) && GContext.container.Resolve<FishingEventData>().GetSystemOpen(count))
                        //{
                        //    break;
                        //}
                        continue;
                    case GuideTriggerConditions.MaxMultiplierCount:
                        if (playerData.IsOpenMagnification &&
                            int.TryParse(guidanceGroupDefine.TriggerConditionsParameter, out count) &&
                            playerData.ContainsOrGreaterRatio(count))
                        {
                            break;
                        }
                        continue;
                    case GuideTriggerConditions.GetSecondRod:
                        if (!prePanelName.Contains("HomePanel") && playerFishData.IsOpenRod && playerFishData.GetRodAllCount() > 1)
                        {
                            break;
                        }
                        continue;
                    case GuideTriggerConditions.RodAscendAvailable:
                        if (!prePanelName.Contains("HomePanel") && playerFishData.IsOpenRod && playerFishData.GetRodCanUp())
                        {
                            break;
                        }
                        continue;
                    case GuideTriggerConditions.RodUpgradeAvailable:
                        if (!prePanelName.Contains("HomePanel") && playerFishData.IsOpenRod && playerFishData.GetRodCanUpLevel())
                        {
                            break;
                        }
                        continue;
                    case GuideTriggerConditions.BuyPack:
                        if (int.TryParse(guidanceGroupDefine.TriggerConditionsParameter, out count) && GContext.container.Resolve<PlayerShopData>().GetAllPackCount(count) > 0)
                        {
                            break;
                        }
                        continue;
                    case GuideTriggerConditions.BoxOpenCondition:
                        FishingBoxDataProvier fishingBoxData = GContext.container.Resolve<FishingBoxDataProvier>();
                        if (fishingBoxData.IsUnclocked && fishingBoxData.GetBoxCount(fishingBoxData.GetIDByQuality(3)) > 0)
                        {
                            break;
                        }
                        continue;
                    case GuideTriggerConditions.GoBuilding:
                        if (GContext.container.Resolve<CampDataMM>().GoBuilding())
                        {
                            break;
                        }
                        continue;
                    case GuideTriggerConditions.GoBuilding02:
                        if (playerData.lv >= 12)
                        {
                            TriggerGuideFinish(guidanceGroupDefine);
                            Debug.Log("TriggerGuideFinish(guidanceGroupDefine);");
                            continue;
                        }
                        if (GContext.container.Resolve<CampDataMM>().GoBuilding02(101012))
                        {
                            Debug.Log("TriggerGuideFinish();");
                            break;
                        }
                        continue;
                    case GuideTriggerConditions.EventWashingStep:
                        if (int.TryParse(guidanceGroupDefine.TriggerConditionsParameter, out count) && GContext.container.Resolve<EventWashingDataManager>().IsCurrentStepID(count))
                        {
                            break;
                        }
                        continue;
                    default:
                        continue;
                }

                if (curGroupDefine == guidanceGroupDefine)
                {
                    return false;
                }
                if (panelName == guidanceGroupDefine.guidanceDefines[0].panelName)
                {
                    TriggerGuide(guidanceGroupDefine, curPanelName);
                    return true;
                }
            }
            return false;
        }

        public void ClearGuide(string groupName)
        {
            if (GuideSaveDataDic.ContainsKey(groupName))
            {
                GuideSaveDataDic.Remove(groupName);
                Save();
            }
        }

        /// <summary>
        /// 特殊屏蔽的新手引导
        /// </summary>
        /// <param name="group"></param>
        bool CheckTriggerGuideFinish(GuidanceGroupDefine group)
        {
            bool isFinishPass = false;
            //判断是否直接完成
            if (group.groupName == GroupName.Chanllenge)
            {
                // isFinishPass = !GContext.container.Resolve<FishingChallengeCenter>().IsFirstOpen;
                isFinishPass = !GContext.container.Resolve<FishingChallengeManager>().IsFirstOpen;
            }

            if (group.groupName == GroupName.BeginnerPack01)
            {
                MMTService mMTService = GContext.container.Resolve<MMTService>();

                if (mMTService.mmt)
                {
                    isFinishPass = true;
                }
            }

            if (isFinishPass)
            {
                TriggerGuideFinish(group);
            }
            return isFinishPass;
        }

        void TriggerGuideFinish(GuidanceGroupDefine group)
        {
            string groupName = group.groupName.ToString();
            if (!GuideSaveDataDic.TryGetValue(groupName, out var guideSaveData))
            {
                guideSaveData = new GuideSaveData();
                guideSaveData.groupName = groupName;
                GuideSaveDataDic.Add(groupName, guideSaveData);
            }
            guideSaveData.guideSubIndex = group.guidanceDefines.Length;
            guideSaveData.isFinish = true;
            Save();
        }
        public bool TriggerGuide(string groupName, string panelName, bool loop = true)
        {
            if (guidanceDefineSetting == null)
            {
                return false;
            }
            GuidanceGroupDefine guidanceGroupDefine;
            if (!loop)
            {
                bool isFinish = GetIsFinish(groupName.ToString());
                if (isFinish)
                {
                    return false;
                }
            }
            for (int i = 0; i < guidanceGroupDefines.Length; i++)
            {
                guidanceGroupDefine = guidanceGroupDefines[i];
                if (guidanceGroupDefine.groupName.ToString() == groupName)
                {
                    if (panelName != guidanceGroupDefine.guidanceDefines[0].panelName)
                    {
                        return false;
                    }
                    TriggerGuide(groupName, guidanceGroupDefine);
                    return true;
                }
            }
            return false;
        }
        async void TriggerGuide(string groupName, GuidanceGroupDefine guidanceGroupDefine)
        {
            await System.Threading.Tasks.Task.Delay(200);
            curSaveData = new GuideSaveData();
            curSaveData.groupName = groupName;
            GuideSaveDataDic[groupName] = curSaveData;
            curGroupDefine = guidanceGroupDefine;
            curDefine = curGroupDefine.guidanceDefines[0];
            ShowPanel("");
            curSaveData.guideSubIndex++;
        }
        void TriggerGuide(GuidanceGroupDefine group, string curPanelName)
        {
            string groupName = group.groupName.ToString();
            if (!GuideSaveDataDic.TryGetValue(groupName, out var guideSaveData))
            {
                guideSaveData = new GuideSaveData();
                guideSaveData.groupName = groupName;
                GuideSaveDataDic.Add(groupName, guideSaveData);
            }
            if (guideSaveData.isFinish)
            {
                return;
            }
            guideSaveData.guideSubIndex = 0;
            curSaveData = guideSaveData;

            curGroupDefine = group;
            curDefine = group.guidanceDefines[0];
            ShowPanel(curPanelName);
            curSaveData.guideSubIndex++;

        }
        public void TriggerGuideNext(OnEventTriggerGuide eventTriggerGuide)
        {
            if (curGroupDefine != null && GuideSaveDataDic.TryGetValue(curGroupDefine.groupName.ToString(), out var guideSaveData))
            {
                if (curGroupDefine.guidanceDefines.Length <= curSaveData.guideSubIndex || eventTriggerGuide.panelName != curGroupDefine.guidanceDefines[guideSaveData.guideSubIndex].panelName)
                {
                    return;
                }
                curDefine = curGroupDefine.guidanceDefines[guideSaveData.guideSubIndex];
                if (curDefine.completeType == CompleteType.PanelOpen)
                {
                    string uIType = curDefine.completeTypeParameter;
                    if (!string.IsNullOrEmpty(uIType) && UIManager.Instance.ContainsUI(uIType))
                    {
                        curSaveData.guideSubIndex++;
                        AddIndex();
                    }
                    else
                    {
                        disposable = GContext.OnEvent<GetUIAsyncEvent>().Subscribe(data =>
                       {
                           if (uIType == data.uIType && data.show)
                           {
                               curSaveData.guideSubIndex++;
                               AddIndex();
                           }
                       });

                    }
                }
                else
                {
                    ShowPanel("");
                    curSaveData.guideSubIndex++;
                }
            }
            else
            {
                InspectTriggerGuide(eventTriggerGuide.panelName);
            }
        }
        public void AddIndex(bool is_pass = false)
        {
            if (curDefine == null)
            {
                return;
            }
            if (disposable != null)
            {
                disposable.Dispose();
                disposable = null;
            }
            if (disposable3 != null)
            {
                disposable3.Dispose();
                disposable3 = null;
            }
            UIManager.Instance.HideUI(UITypes.GuidancePanel);
            bool isAutoNext = curDefine.isAutoNext;
            AddIndexEvent addIndexEvent = new AddIndexEvent();
            addIndexEvent.isAutoNext = isAutoNext;
            if (curGroupDefine.guidanceDefines.Length <= curSaveData.guideSubIndex || is_pass)
            {
#if AGG
                using (var e = GEvent.GameEvent("guide_complete"))
                {
                    e.AddContent("guide_id", curGroupDefine.groupName.ToString())
                     .AddContent("is_pass", is_pass);
                }
#endif
                string panelName = curDefine.panelName;
                curDefine = null;
                curGroupDefine = null;
                curSaveData.isFinish = true;
                Save();
                if (isAutoNext)
                {
                    InspectTriggerGuide(panelName, panelName);
                }
                GContext.Publish(new ConditionTypeEvent(ConditionType.CompleteGuide, 1));
                addIndexEvent.CompleteGuide = true;
                addIndexEvent.guideSubIndex = curSaveData.guideSubIndex;
                GContext.Publish(addIndexEvent);
            }
            else
            {
                Save();
                var define = curGroupDefine.guidanceDefines[curSaveData.guideSubIndex];
                if (isAutoNext && define.panelName == curDefine.panelName)
                {
                    curDefine = define;
                    ShowPanel(CurPanelName);
                    curSaveData.guideSubIndex++;
                }
                else if (!isAutoNext)
                {
                    for (int i = curSaveData.guideSubIndex; i < curGroupDefine.guidanceDefines.Length; i++)
                    {
                        var _define = curGroupDefine.guidanceDefines[i];
                        if (_define.isKey)
                        {
                            curSaveData.isFinish = false;
                            break;
                        }
                        else
                        {
                            curSaveData.isFinish = true;
                        }
                    }
                }
                addIndexEvent.guideSubIndex = curSaveData.guideSubIndex;
                GContext.Publish(addIndexEvent);
            }
        }
        async void ShowPanel(string PanelName)
        {
            if (curDefine.fingerType != FingerType.None)
            {
                disposable3 = GContext.OnEvent<GuideNextEvent>().Subscribe(GuideNextEvent);
            }
            CurPanelName = PanelName;
            await UIManager.Instance.ShowUI(UITypes.GuidancePanel);
        }

        public async void ShowGuidancePopupPanel(string nodeName)
        {
            popupPanelNode = nodeName;
            if (!string.IsNullOrEmpty(popupPanelNode))
            {
                await UIManager.Instance.ShowUI(UITypes.GuidancePopupPanel);
                UIManager.Instance.HideUI(UITypes.GuidancePanel);
            }
        }

        void GuideNextEvent(GuideNextEvent guideLongEvent)
        {
            if (curDefine.fingerType != FingerType.None)
            {
                AddIndex();
            }
        }

        public bool IsGuide(string panelName)
        {
            bool isGuide = curDefine != null;
            if (!isGuide)
            {
                InspectTriggerGuide(panelName);
            }
            return curDefine != null && curDefine.panelName == panelName;
        }

        public bool IsGuide(string panelName, int index, GroupName groupName)
        {
            bool isGuide = curDefine != null;

            if (isGuide && curGroupDefine.groupName == groupName && curSaveData.guideSubIndex == index)
            {
                InspectTriggerGuide(panelName);
                return true;
            }
            return false;// curDefine != null && curDefine.panelName == panelName;
        }
        public void Save()
        {
            PlayFabMgr.Instance.UpdateUserDataValue("GuideSaveData", JsonMapper.ToJson(GuideSaveDataDic));
        }
        public void Dispose()
        {
            disposable?.Dispose();
            disposable = null;
            disposable2?.Dispose();
            disposable2 = null;
            disposable3?.Dispose();
            disposable3 = null;
        }
    }
}