using System.Collections.Generic;
using Snxxz.UI;
using TableConfig;
using UnityEngine;
using UnityEngine.Events;

public class GA_NpcCollect : GA_NpcFunc
{
    private static List<uint> m_ArrivedList = new List<uint>();
    public static event UnityAction<uint, int> OnArrive;
    public static event UnityAction<uint, int> OnLeave;

    private bool m_CanCollect = true;
    private bool m_IsMainWinOpen = false;

    private int m_ReplaceNpcID = -1;

    private FairyCampType belongType = FairyCampType.None;

    public sealed override void InitPerformance(uint clientInstID, int npcID)
    {
        if (m_Model)
        {
            if (m_LoadDefaultRes)
            {
                GameObjectPoolManager.Instance.ReleaseDefaultFuncNPC(m_Model);
            }
            else
            {
                if (m_ReplaceNpcID != -1)
                {
                    GameObject _toDestroy = InstanceResourcesLoader.LoadNpc(m_ReplaceNpcID);
                    if (_toDestroy)
                    {
                        GameObjectPoolManager.Instance.ReleaseGameObject(_toDestroy, m_Model);
                    }
                }
                else
                {
                    Object.Destroy(m_Model);
                }
            }

            m_Model = null;
            m_Animator = null;
        }

        if (npcID == 10404100)
        {
            if (PlayerDatas.Instance.baseData.Job == 2)
            {
                npcID = m_ReplaceNpcID = 10404101;
            }
        }

        if (PlayerDatas.Instance.baseData.MapID == 31220)
        {
            if (npcID >= 30909001 && npcID <= 30909005)
            {
                ModelCenter.Instance.GetModel<FairyLeagueModel>().CrystalBelongChangeEvent += CrystalBelongChangeEvent;

                // 获取归属
                FairyCampType _type = (FairyCampType)ModelCenter.Instance.GetModel<FairyLeagueModel>().fairyLeagueHelp.GetCrystalBelongCamp(npcID);
                int _offset = 0;
                if (_type == FairyCampType.Blue)
                {
                    _offset = 8;
                }
                else if (_type == FairyCampType.Red)
                {
                    _offset = 13;
                }
                npcID = m_ReplaceNpcID = npcID + _offset;

                belongType = _type;
            }
        }

        GameObject _prefab = InstanceResourcesLoader.LoadNpcPrefab(npcID);

        if (_prefab == null)
        {
            _prefab = InstanceResourcesLoader.LoadDefaultFuncNPC();

            if (_prefab)
            {
                m_LoadDefaultRes = true;
            }
        }

        if (_prefab != null)
        {
            if (!_prefab.name.Contains("Cb01"))
            {
                GAMgr.Instance.AddNeedDestroyPrefab(_prefab);
            }

            if (m_LoadDefaultRes)
            {
                m_Model = GameObjectPoolManager.Instance.RequestDefaultFuncNpc();
            }
            else
            {
                m_Model = GameObjectPoolManager.Instance.RequestNpcGameObject(npcID);
            }

            if (m_Model)
            {
                m_Animator = m_Model.GetComponent<Animator>();
                if (m_Animator)
                {
                    m_Animator.enabled = true;
                    m_Animator.SetInteger(GAStaticDefine.Param_ActorInstID, (int)clientInstID);
                }

                SetupBindNode(m_Model.transform);

                if (m_Root)
                {
                    m_Model.transform.SetParent(m_Root.transform);
                    m_Model.transform.localPosition = Vector3.zero;
                    m_Model.transform.localRotation = Quaternion.identity;
                }
            }
        }
    }

    public sealed override void RequestName()
    {
        base.RequestName();

        if (m_ReplaceNpcID != -1)
        {
            m_HeadUpName.SetNPCName(m_ReplaceNpcID);
        }
    }

    protected override void OnInit(GameNetPackBasic package)
    {
        base.OnInit(package);

        if (m_ReplaceNpcID != -1)
        {
            RequestName();
        }

        if (PlayerDatas.Instance.baseData.MapID == 31230)
        {
            DungeonModel _model = ModelCenter.Instance.GetModel<DungeonModel>();
            _model.updateMissionEvent += UpdateMissionEvent;
        }

        CheckCanCollect();

        m_IsMainWinOpen = WindowCenter.Instance.CheckOpen<MainInterfaceWin>();

        WindowCenter.Instance.windowAfterOpenEvent += CheckOpenCollectIcon;
        WindowCenter.Instance.windowAfterCloseEvent += AfterCloseMainWin;

    }

    private void AfterCloseMainWin(Window obj)
    {
        if (obj is MainInterfaceWin)
        {
            m_IsMainWinOpen = false;
            Leave();
        }
    }

    private void CheckOpenCollectIcon(Window obj)
    {
        if (!m_CanCollect)
        {
            return;
        }

        if (obj is MainInterfaceWin)
        {
            m_IsMainWinOpen = true;
            GA_Hero _hero = PlayerDatas.Instance.hero;

            if (_hero != null)
            {
                float _distSqrt = MathUtility.DistanceSqrtXZ(_hero.Pos, Pos);

                if (_distSqrt < Mathf.Pow(NpcConfig.ModelRadius + 0.4f + GeneralConfig.Instance.CloseNpcDist, 2))
                {
                    Arrive();
                }
            }
        }
    }

    private static bool xmlsCollectFinished = false;
    private void UpdateMissionEvent()
    {
        DungeonModel _model = ModelCenter.Instance.GetModel<DungeonModel>();
        _model.updateMissionEvent -= UpdateMissionEvent;
        if (_model.mission.hasCollect == 0)
        {
            PrepareHandler.Instance.OnPrepareEndSuccess += OnPrepareEndSuccess;
        }
        else
        {
            xmlsCollectFinished = true;
        }

        CheckCanCollect();
    }

    protected void OnPrepareEndSuccess()
    {
        PrepareHandler.Instance.OnPrepareEndSuccess -= OnPrepareEndSuccess;
        xmlsCollectFinished = true;
        CheckCanCollect();
    }

    protected override void OnFixedUpdate()
    {
        base.OnFixedUpdate();

        if (!m_IsMainWinOpen)
        {
            m_IsMainWinOpen = WindowCenter.Instance.CheckOpen<MainInterfaceWin>();
            return;
        }

        if (!m_CanCollect)
        {
            return;
        }

        GA_Hero _hero = PlayerDatas.Instance.hero;

        if (_hero != null)
        {
            float _distSqrt = MathUtility.DistanceSqrtXZ(_hero.Pos, Pos);

            if (_distSqrt < Mathf.Pow(NpcConfig.ModelRadius + 0.4f + GeneralConfig.Instance.CloseNpcDist, 2))
            {
                Arrive();
            }
            else
            {
                if (m_ArrivedList.Contains(ServerInstID))
                {
                    if (OnLeave != null)
                    {
                        OnLeave(ServerInstID, NpcConfig.NPCID);
                    }
                    m_ArrivedList.Remove(ServerInstID);
                }
            }
        }
    }

    protected override void OnTaskRefresh(int _nowNPCid, int _nPCLamp, Dictionary<int, int> _dic)
    {
        base.OnTaskRefresh(_nowNPCid, _nPCLamp, _dic);

        CheckCanCollect();
    }

    public override void OnClick()
    {
        base.OnClick();

        if (!GeneralConfig.Instance.SpecialNpcIDs.Contains(NpcConfig.NPCID)// 不是特殊npc
         && !m_CanCollect)
        {
            return;
        }

        if (!m_ArrivedList.Contains(ServerInstID))
        {
            if (OnArrive != null)
            {
                OnArrive(ServerInstID, NpcConfig.NPCID);
            }
            m_ArrivedList.Add(ServerInstID);
        }
    }

    protected override void OnUnit()
    {
        if (m_ReplaceNpcID != -1)
        {
            if (m_LoadDefaultRes)
            {
                GameObjectPoolManager.Instance.ReleaseDefaultFuncNPC(m_Model);
            }
            else
            {
                GameObject _prefab = InstanceResourcesLoader.LoadNpc(m_ReplaceNpcID);
                GameObjectPoolManager.Instance.ReleaseGameObject(_prefab, m_Model);
            }

            m_Model = null;
            m_ReplaceNpcID = -1;
        }

        base.OnUnit();

        DungeonModel _model = ModelCenter.Instance.GetModel<DungeonModel>();
        _model.updateMissionEvent -= UpdateMissionEvent;
        PrepareHandler.Instance.OnPrepareEndSuccess -= OnPrepareEndSuccess;

        if (PlayerDatas.Instance.baseData.MapID == 31220)
        {
            ModelCenter.Instance.GetModel<FairyLeagueModel>().CrystalBelongChangeEvent -= CrystalBelongChangeEvent;
        }

        if (m_ArrivedList.Contains(ServerInstID))
        {
            if (OnLeave != null)
            {
                OnLeave(ServerInstID, NpcConfig.NPCID);
            }
            m_ArrivedList.Remove(ServerInstID);
        }

        WindowCenter.Instance.windowAfterOpenEvent -= CheckOpenCollectIcon;
        WindowCenter.Instance.windowAfterCloseEvent -= AfterCloseMainWin;
    }

    public override bool CanBeSelected()
    {
        if (PlayerDatas.Instance.baseData.MapID == 31230)
        {
            return !xmlsCollectFinished;
        }

        return base.CanBeSelected();
    }

    private void CheckCanCollect()
    {
        if (PlayerDatas.Instance.baseData.MapID == 31230)
        {
            FuncConfigConfig _funcConfig = Config.Instance.Get<FuncConfigConfig>("FamilyPartyDeskNpcID");
            m_CanCollect = int.Parse(_funcConfig.Numerical1) == NpcConfig.NPCID && !xmlsCollectFinished;
        }
        else
        {
            PlayerTaskDatas _model = ModelCenter.Instance.GetModel<PlayerTaskDatas>();
            m_CanCollect = _model.IsGather(NpcConfig.NPCID);
            Debug.LogFormat("Npc: {0} 是否可以采集: {1}", NpcConfig.NPCID, m_CanCollect);
        }

        if (!m_CanCollect)
        {
            if (m_ArrivedList.Contains(ServerInstID))
            {
                if (OnLeave != null)
                {
                    OnLeave(ServerInstID, NpcConfig.NPCID);
                }
                m_ArrivedList.Remove(ServerInstID);
            }
        }
    }

    public override void OnUnSelect()
    {
        base.OnUnSelect();

        if (m_ArrivedList.Contains(ServerInstID))
        {
            if (OnLeave != null)
            {
                OnLeave(ServerInstID, NpcConfig.NPCID);
            }
            m_ArrivedList.Remove(ServerInstID);
        }
    }

    public sealed override void RequestShadow()
    {
        if (NpcConfig.NPCID == 10204200)
        {
            return;
        }

        base.RequestShadow();
    }

    private void CrystalBelongChangeEvent()
    {
        // 获取归属
        FairyCampType _type = (FairyCampType)ModelCenter.Instance.GetModel<FairyLeagueModel>().fairyLeagueHelp.GetCrystalBelongCamp(NpcConfig.NPCID);

        if (belongType != _type)
        {
            if (_type == FairyCampType.Blue)
            {
                SFXPlayUtility.Instance.PlayBattleEffect(3029, this);
            }
            else if (_type == FairyCampType.Red)
            {
                SFXPlayUtility.Instance.PlayBattleEffect(3030, this);
            }

            InitPerformance(ClientInstID, NpcConfig.NPCID);

            RequestName();

            belongType = _type;
        }
    }

    public void Arrive()
    {
        if (!m_CanCollect)
        {
            return;
        }

        if (!m_ArrivedList.Contains(ServerInstID))
        {
            if (OnArrive != null)
            {
                OnArrive(ServerInstID, NpcConfig.NPCID);
            }
            m_ArrivedList.Add(ServerInstID);
        }
    }

    public void Leave()
    {
        if (m_ArrivedList.Contains(ServerInstID))
        {
            if (OnLeave != null)
            {
                OnLeave(ServerInstID, NpcConfig.NPCID);
            }
            m_ArrivedList.Remove(ServerInstID);
        }
    }
}