using System.Collections.Generic;
using vnxbqy.UI;

using UnityEngine;
using UnityEngine.Events;

public class GA_NpcCollect : GA_NpcFunc
{
    private bool m_CanCollect = true;
    private bool m_IsMainWinOpen = false;

    private int m_ReplaceNpcID = -1;

    private FairyCampType belongType = FairyCampType.None;
    int belongTypeEx = 0;   //当前水晶归属阵营
    protected override void OnPrefabLoadFinished(bool result, Object prefab)
    {
        if (m_ReplaceNpcID != -1)
        {
            var _npcConfig = NPCConfig.Get(m_ReplaceNpcID);
            if (prefab)
            {
                if (_npcConfig.NPCEffect != 0)
                {
                    //npc出现特效需随着模型变化而变化
                    if (m_AppearEffect)
                    {
                        SFXPlayUtility.Instance.Release(m_AppearEffect);
                        m_AppearEffect = null;
                    }
                    m_AppearEffect = SFXPlayUtility.Instance.PlayBattleEffect(_npcConfig.NPCEffect, this);
                }

                if (!prefab.name.Contains(_npcConfig.MODE))
                {
                    return;
                }
            }
        }

        if (m_Model)
        {
            if (m_LoadDefaultRes)
            {
                GameObjectPoolManager.Instance.ReleaseDefaultFuncNPC(m_Model);
            }
            else
            {
                bool _isReleased = false;
                if (m_ReplaceNpcID != -1)
                {
                    var _npcConfig = NPCConfig.Get(m_ReplaceNpcID);
                    if (m_Model.name.Contains(_npcConfig.MODE))
                    {
                        GameObject _toDestroy = InstanceResourcesLoader.LoadNpc(m_ReplaceNpcID);
                        if (_toDestroy)
                        {
                            GameObjectPoolManager.Instance.ReleaseGameObject(_toDestroy, m_Model);
                            _isReleased = true;
                        }
                    }
                }

                if (!_isReleased)
                {
                    if (NpcConfig != null)
                    {
                        GameObject _toDestroy = InstanceResourcesLoader.LoadNpc(NpcConfig.NPCID);
                        if (_toDestroy)
                        {
                            GameObjectPoolManager.Instance.ReleaseGameObject(_toDestroy, m_Model);
                        }
                    }
                    else
                    {
                        Object.Destroy(m_Model);
                    }
                }
            }

            m_Model = null;
            m_Animator = null;
        }

        base.OnPrefabLoadFinished(result, prefab);
    }

    protected sealed override void HandleNpcConfig(int npcID)
    {
        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 = npcID + _offset;

                belongType = _type;
            }
        }
        else if (ModelCenter.Instance.GetModel<DungeonModel>().GetDataMapIdByMapId(PlayerDatas.Instance.baseData.MapID) == GeneralDefine.CrossBattleFieldMapID)
        {
            var crossModel = ModelCenter.Instance.GetModel<CrossServerModel>();
            crossModel.CrystalBelongChangeEvent += CrystalBelongChangeEventEx;
            // 获取归属
            belongTypeEx = crossModel.GetCrystalFaction(npcID);
            npcID = crossModel.GetNewCrystalID(npcID, belongTypeEx);
        }


        NpcConfig = NPCConfig.Get(npcID);
    }

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

        var npcId = this.NpcConfig.NPCID;
        if (npcId == 10404100)
        {
            if (PlayerDatas.Instance.baseData.Job == 2)
            {
                npcId = 10404101;
            }

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

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

        NpcConfig = NPCConfig.Get((int)m_H0406.NPCID);

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

        CheckCanCollect();

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

        if (GeneralDefine.NpcPosOffset.ContainsKey(NpcConfig.NPCID))
        {
            Pos = GeneralDefine.NpcPosOffset[NpcConfig.NPCID];
            //Debug.Log("矫正位置: " + Pos);
        }

        // 执行挖洞逻辑
        if (NpcConfig.Dig == 1)
        {
            m_Dig = SoMap.CreateImpasse.GeneralCircle(Pos, NpcConfig.ModelRadius);
        }

    }

    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.IsOpen<MainInterfaceWin>();
            return;
        }

        if (!m_CanCollect)
        {
            return;
        }

        if (NpcConfig.NPCID != GeneralDefine.GatherSoulDZ)
        {
            GA_Hero _hero = PlayerDatas.Instance.hero;

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

                if (_distSqrt < Mathf.Pow(NpcConfig.ModelRadius + 0.4f + GeneralDefine.CloseNpcDist, 2))
                {
                    PrepareHandler.Instance.Arrive(this);
                }
                else
                {
                    PrepareHandler.Instance.Leave(this);
                }
            }
        }
    }

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

        CheckCanCollect();
    }

    public override void OnClick()
    {
        if (!GeneralDefine.SpecialNpcIDs.Contains(NpcConfig.NPCID)// 不是特殊npc
         && !m_CanCollect)
        {
            return;
        }

        if (NpcConfig.NPCID == GeneralDefine.GatherSoulDZ)
        {
            return;
        }

        GA_Hero _hero = PlayerDatas.Instance.hero;

        if (_hero == null)
        {
            return;
        }

        _hero.LockTarget = this;
        _hero.SelectTarget = this;

        float _chkDistSqrt = MathUtility.DistanceSqrtXZ(_hero.Pos, Pos);

        // 这里判断是否要走向此对象
        if (_chkDistSqrt > 4)
        {
            _hero.MoveToPosition(Pos, 1f);
        }
        
        PrepareHandler.Instance.TriggerOnShowCollect(ServerInstID, NpcConfig.NPCID);
    }

    protected override void HandleOnClick()
    {
        // if (NpcConfig.NPCID != GeneralDefine.GatherSoulDZ)
        // {
        //     base.HandleOnClick();
        // }
    }

    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;
        }
        else if (_model.GetDataMapIdByMapId(PlayerDatas.Instance.baseData.MapID) == GeneralDefine.CrossBattleFieldMapID)
        {
            var crossModel = ModelCenter.Instance.GetModel<CrossServerModel>();
            crossModel.CrystalBelongChangeEvent -= CrystalBelongChangeEventEx;
        }

        PrepareHandler.Instance.Leave(this);

        GA_Hero _hero = PlayerDatas.Instance.hero;
        if (_hero != null)
        {
            if (_hero.SelectTarget != null && ServerInstID == _hero.SelectTarget.ServerInstID)
            {
                SelectionManager.Release(SelectionManager.E_Type.Green);
                _hero.SelectTarget = null;
            }

            if (_hero.LockTarget == this)
            {
                _hero.LockTarget = null;
            }
        }
    }

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

        return base.CanBeSelected();
    }

    public override void OnSelect()
    {

        if (NpcConfig.NPCID != 10204200)
        {
            SelectionManager.Request(SelectionManager.E_Type.Green, this, NpcConfig.ModelRadius * 2);
        }

        GA_Hero _hero = PlayerDatas.Instance.hero;
        Vector3 _forward = MathUtility.ForwardXZ(Pos, _hero.Pos);

        _hero.Forward = _forward;

        if (NpcConfig.AutomaticFace == 1)
        {
            _forward = MathUtility.ForwardXZ(_hero.Pos, Pos);
            Forward = _forward;
        }
    }

    private void CheckCanCollect()
    {
        if (PlayerDatas.Instance.baseData.MapID == 31230)// 仙盟宴会
        {
            FuncConfigConfig _funcConfig = FuncConfigConfig.Get("FamilyPartyDeskNpcID");
            m_CanCollect = int.Parse(_funcConfig.Numerical1) == NpcConfig.NPCID && !xmlsCollectFinished;
        }
        else
        {

            m_CanCollect = true;

            TaskModel _model = ModelCenter.Instance.GetModel<TaskModel>();
            if (!_model.IsGather(NpcConfig.NPCID))
            {
                m_CanCollect = false;
            }

        }

        PrepareHandler.Instance.Leave(this);
    }

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

        PrepareHandler.Instance.Leave(this);

        if (NpcConfig.NPCID == GeneralDefine.GatherSoulDZ)
        {
            SelectionManager.ReleaseJH();
        }
    }

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

        base.RequestShadow();
    }

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

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

            var _npcID = m_ReplaceNpcID = NpcConfig.NPCID + _offset;
            var _npcConfig = NPCConfig.Get(_npcID);
            if (_npcConfig != null)
            {
                InstanceResourcesLoader.AsyncLoadNpc(_npcConfig.NPCID, OnPrefabLoadFinished);
            }

            belongType = _type;
        }
    }

    private void CrystalBelongChangeEventEx()
    {

        // 获取归属
        var crossModel = ModelCenter.Instance.GetModel<CrossServerModel>();
        var _type = crossModel.GetCrystalFaction(NpcConfig.NPCID);

        if (belongTypeEx != _type)
        {
            if (_type == 1)
            {
                SFXPlayUtility.Instance.PlayBattleEffect(3029, this);
            }
            else if (_type == 2)
            {
                SFXPlayUtility.Instance.PlayBattleEffect(3030, this);
            }

            var _npcID = m_ReplaceNpcID = crossModel.GetNewCrystalID(NpcConfig.NPCID, _type);
            var _npcConfig = NPCConfig.Get(_npcID);
            if (_npcConfig != null)
            {
                InstanceResourcesLoader.AsyncLoadNpc(_npcConfig.NPCID, OnPrefabLoadFinished);
            }

            belongTypeEx = _type;
        }
    }
}