using vnxbqy.UI;
using System;
using System.Collections.Generic;
using UnityEngine.UI;
using System.Linq;
using LitJson;
using UnityEngine;

public class CrossServerMHBossModel : ILModel<CrossServerMHBossModel>
{
    public const int DATA_MAPID = 32080;
    public const int REDPOINT = 21303;

    List<int> sortedBossIds = new List<int>();
    Dictionary<int, CrossServerBossData> bosses = new Dictionary<int, CrossServerBossData>();

    public List<int> AddBossTimesCosts = new List<int>();

    CrossServerBossModel crossBossModel { get { return ModelCenter.Instance.GetModelEx<CrossServerBossModel>(); } }


    int m_SelectedBoss = 0;
    public int selectedBoss
    {
        get
        {
            return this.m_SelectedBoss;
        }
        set
        {
            if (this.m_SelectedBoss != value)
            {
                this.m_SelectedBoss = value;
                if (bossSelectedEvent != null)
                {
                    bossSelectedEvent(value);
                }
            }
        }
    }

    int m_WearyValue = 0;
    public int wearyValue
    {
        get { return m_WearyValue; }
        set
        {
            if (m_WearyValue != value)
            {
                m_WearyValue = value;
                UpdateRedpoint();
                if (bossWearyValueChangeEvent != null)
                {
                    bossWearyValueChangeEvent();
                }
            }
        }
    }

    int m_BuyCnt = 0;
    public int buyCnt
    {
        get { return m_BuyCnt; }
        set
        {
            if (m_BuyCnt != value)
            {
                m_BuyCnt = value;
                UpdateRedpoint();
                if (bossWearyValueChangeEvent != null)
                {
                    bossWearyValueChangeEvent();
                }
            }
        }
    }


    public event Action bossWearyValueChangeEvent;
    public event Action<int> bossSelectedEvent;

    public Redpoint redpoint = new Redpoint(FindPreciousModel.LOOTPRECIOUs_REDPOINTID, REDPOINT);

    FindPreciousModel findPreciousModel { get { return ModelCenter.Instance.GetModel<FindPreciousModel>(); } }
    TeamModel teamModel { get { return ModelCenter.Instance.GetModel<TeamModel>(); } }

    protected override void Init()
    {
        ParseConfig();
        FuncOpen.Instance.OnFuncStateChangeEvent += OnFunctionStateChange;
        crossBossModel.bossSelectedEvent += CrossBossSelectedEvent;
        GameEvent.playerLoginOkEvent += OnPlayerLoginOk;
        GameEvent.mapInitOkEvent += OnMapInitOk;
    }

    protected override void UnInit()
    {
        FuncOpen.Instance.OnFuncStateChangeEvent -= OnFunctionStateChange;
        crossBossModel.bossSelectedEvent -= CrossBossSelectedEvent;
    }


    void CrossBossSelectedEvent(int bossID)
    {
        if (bosses.ContainsKey(bossID))
            selectedBoss = bossID;
    }

    public void OnMapInitOk()
    {
        if (PlayerDatas.Instance.baseData.MapID == DATA_MAPID)
        {
            if (selectedBoss != 0)
            {
                MapTransferUtility.Instance.MoveToNPC(selectedBoss);
            }
        }
    }

    public void RequestEnter()
    {
        if (PlayerDatas.Instance.extersion.bossState == 1)
        {
            SysNotifyMgr.Instance.ShowTip("CrossMap11");
            return;
        }

        if (!AssetVersionUtility.IsUnpriorAssetDownLoadOk())
        {
            InGameDownLoad.Instance.TryDownLoad(InGameDownLoad.Dominant.Whole);
            return;
        }

        var sendInfo = new CC105_tagCMEnterCrossServer();
        sendInfo.DataMapID = DATA_MAPID;
        GameNetSystem.Instance.SendInfo(sendInfo);
    }

    public bool CanEnter(out int error)
    {
        var mapId = PlayerDatas.Instance.baseData.MapID;
        var mapConfig = MapConfig.Get(mapId);
        if (mapConfig.MapFBType != (int)MapType.OpenCountry)
        {
            error = 1;
            return false;
        }

        if (teamModel.isMatching)
        {
            error = 2;
            return false;
        }

        if (teamModel.teamPrepare.isPreparing)
        {
            error = 3;
            return false;
        }

        if (CrossServerLogin.Instance.IsEnterCrossServerPreparing())
        {
            error = 4;
            return false;
        }

        var deadModel = ModelCenter.Instance.GetModel<PlayerDeadModel>();
        if (deadModel.playerIsDie)
        {
            error = 5;
            return false;
        }

        var config = CrossServerBossConfig.Get(selectedBoss);
        if (config.MonsterType == 4 && !findPreciousModel.IsBossUnlock(selectedBoss))
        {
            error = 6;
            return false;
        }
        if (PlayerDatas.Instance.baseData.FightPoint < (ulong)NPCExConfig.Get(selectedBoss).SuppressFightPower)
        {
            error = 7;
            return false;
        }

        error = 0;
        return true;
    }

    public void ProcessEnterError(int error)
    {
        switch (error)
        {
            case 1:
                SysNotifyMgr.Instance.ShowTip("InDungeon_CantGo");
                break;
            case 2:
                SysNotifyMgr.Instance.ShowTip("CrossMap1");
                break;
            case 3:
                SysNotifyMgr.Instance.ShowTip("CrossMap2");
                break;
            case 4:
                SysNotifyMgr.Instance.ShowTip("CrossMap3");
                break;
            case 5:
                SysNotifyMgr.Instance.ShowTip("CrossMap4");
                break;
            case 6:
                SysNotifyMgr.Instance.ShowTip("BossRealmHint2", RealmConfig.Get(NPCConfig.Get(selectedBoss).Realm).LvLarge);
                break;
            case 7:
                SysNotifyMgr.Instance.ShowTip("TaskFeedback4");
                break;
        }
    }

    public void RequestExit()
    {
        var match = new CC104_tagCMExitCrossRealm();
        GameNetSystem.Instance.SendToCrossServer(match);
    }

    public bool TryGetBossData(int bossId, out CrossServerBossData data)
    {
        return bosses.TryGetValue(bossId, out data);
    }

    public List<int> GetNpcIds()
    {
        var npcIds = new List<int>();

        var lockedCount = 0;
        var keyList = bosses.Keys.ToList();
        for (var i = 0; i < keyList.Count; i++)
        {
            var bossId = keyList[i];
            if (findPreciousModel.IsBossUnlock(bossId))
            {
                npcIds.Add(bossId);
            }
            else
            {
                if (lockedCount < FindPreciousModel.ShowLockBossCnt)
                {
                    lockedCount++;
                    npcIds.Add(bossId);
                }
            }
        }

        return npcIds;
    }

    public List<int> GetShowBosses()
    {
        return new List<int>(sortedBossIds);
    }

    public int GetRecommendNpc()
    {

        var preferBoss = 0;
        for (int i = sortedBossIds.Count - 1; i >= 0; i--)
        {
            var bossId = sortedBossIds[i];
            if (IsBossUnLocked(bossId) && findPreciousModel.IsPlayerLevelLargerOrBiggerThanBoss(bossId))
            {
                if (preferBoss == 0)
                {
                    preferBoss = bossId;
                }

                if (findPreciousModel.IsBossAlive(bossId) && findPreciousModel.IsSameBigRealmStageBoss(bossId))
                {
                    return bossId;
                }
            }
        }

        if (preferBoss == 0)
        {
            preferBoss = sortedBossIds[0];
        }

        return preferBoss;

    }


    public bool IsBossUnLocked(int bossId)
    {
        if (!bosses.ContainsKey(bossId))
        {
            return false;
        }
        if (!findPreciousModel.IsBossUnlock(bossId))
        {
            return false;
        }
        if (PlayerDatas.Instance.baseData.FightPoint < (ulong)NPCExConfig.Get(bossId).SuppressFightPower)
        {
            return false;
        }
        return true;
    }



    public void OnPlayerLoginOk()
    {
        UpdateRedpoint();
    }

    private void OnFunctionStateChange(int id)
    {
        if (id == 202)
        {
            UpdateRedpoint();
        }
    }

    public void UpdateRedpoint()
    {
        if (FuncOpen.Instance.IsFuncOpen(202))
        {
            var wearyValueLimit = GeneralDefine.bossWearyValues[3];
            var count = wearyValueLimit - wearyValue;
            redpoint.count = count;
        }
        else
        {
            redpoint.count = 0;
        }

        redpoint.state = redpoint.count > 0 ? RedPointState.Quantity : RedPointState.None;
        CrossServerUtility.UpdateCrossServerRedpoint();
    }

    private void ParseConfig()
    {
        var keyList = CrossServerBossConfig.GetKeys();
        for (var i = 0; i < keyList.Count; i++)
        {
            var config = CrossServerBossConfig.Get(keyList[i]);
            if (config.MonsterType != 5)
                continue;
            bosses[config.NPCID] = new CrossServerBossData(config.NPCID);
            sortedBossIds.Add(config.NPCID);

        }

        sortedBossIds.Sort(FindPreciousModel.BossCompare);

        AddBossTimesCosts.Clear();
        var addTimes = JsonMapper.ToObject(FuncConfigConfig.Get("KillBossCntLimit1").Numerical3);
        var keyList1 = addTimes.Keys.ToList();
        for (int i = 0; i < keyList1.Count; i++)
        {
            var key = keyList1[i];
            if (key != "3")
            {
                continue;
            }
            var awards = addTimes[key];
            for (int j = 0; j < awards.Count; j++)
            {
                AddBossTimesCosts.Add(int.Parse(awards[j].ToString()));
            }
            break;

        }
    }

    public void GotoKillBoss()
    {
        if (!FuncOpen.Instance.IsFuncOpen(202))
        {
            FuncOpen.Instance.ProcessorFuncErrorTip(202);
            return;
        }
        selectedBoss = GetRecommendNpc();

        if (PlayerDatas.Instance.baseData.MapID == DATA_MAPID)
        {
            MapTransferUtility.Instance.MoveToNPC(selectedBoss);
            return;
        }

        var error = 0;
        if (!CanEnter(out error))
        {
            ProcessEnterError(error);
            return;
        }
        RequestEnter();
    }

    public void GotoKillBossByBossID(int bossID)
    {
        if (!FuncOpen.Instance.IsFuncOpen(202))
        {
            FuncOpen.Instance.ProcessorFuncErrorTip(202);
            return;
        }
        selectedBoss = bossID;

        if (PlayerDatas.Instance.baseData.MapID == DATA_MAPID)
        {
            MapTransferUtility.Instance.MoveToNPC(selectedBoss);
            return;
        }

        var error = 0;
        if (!CanEnter(out error))
        {
            ProcessEnterError(error);
            return;
        }
        RequestEnter();
    }

    public ulong GetBossFightPower(int bossId)
    {
        if (!bosses.ContainsKey(bossId))
        {
            return 0;
        }

        return (ulong)NPCExConfig.Get(bossId).SuppressFightPower;
    }

    public void SetSelectBoss(int bossID)
    {
        selectedBoss = bossID;
    }

    //今日已击杀数
    public int GetBossKilledCnt()
    {
        return wearyValue;
    }
}