//--------------------------------------------------------
//    [Author]:           第二世界
//    [  Date ]:           Friday, January 12, 2018
//--------------------------------------------------------

using System;
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using UnityEngine.UI;


namespace Snxxz.UI
{

    public class FindPreciousBossRebornBehaviour : MonoBehaviour
    {
        [SerializeField] RectTransform m_ContainerBossReborn;
        [SerializeField] Text m_BossRebornTimer;
        [SerializeField] Image m_BossIcon;
        [SerializeField] Text m_BossName;
        [SerializeField] Text m_BossLevel;
        [SerializeField] Button m_Goto;
        [SerializeField] Button m_Close;

        float timer = 0f;
        MapModel mapModel { get { return ModelCenter.Instance.GetModel<MapModel>(); } }
        FindPreciousModel model { get { return ModelCenter.Instance.GetModel<FindPreciousModel>(); } }
        DungeonModel dungeonModel { get { return ModelCenter.Instance.GetModel<DungeonModel>(); } }
        DemonJarModel demonJarModel { get { return ModelCenter.Instance.GetModel<DemonJarModel>(); } }
        BossHomeModel bossHomeModel { get { return ModelCenter.Instance.GetModel<BossHomeModel>(); } }
        DogzDungeonModel dogzDungeonModel { get { return ModelCenter.Instance.GetModel<DogzDungeonModel>(); } }
        CrossServerBossModel crossServerBossModel { get { return ModelCenter.Instance.GetModel<CrossServerBossModel>(); } }

        private void OnEnable()
        {
            m_Goto.AddListener(GotoKillBoss);
            m_Close.AddListener(ReportConfirmBossRebornNotify);
            timer = 0f;
            DisplayRebornCountDown();
        }

        private void LateUpdate()
        {
            timer += Time.deltaTime;
            if (timer > 1f)
            {
                timer = 0f;

                var bossId = model.currentBossNotify.bossId;
                if (!model.IsBossAlive(bossId))
                {
                    var type = model.GetBossFindPreciousType(bossId);
                    switch (type)
                    {
                        case FindPreciousType.DemonJar:
                            model.ReportConfirmBossRebornNotify(model.currentBossNotify);
                            break;
                        default:
                            FindPreciousModel.BossInfo bossInfo;
                            if (model.TryGetBossInfo(bossId, out bossInfo))
                            {
                                var rebornCountDown = (int)(bossInfo.refreshTime - TimeUtility.ServerNow).TotalSeconds;
                                if (rebornCountDown > FindPreciousModel.PREPOSE_SECONDS)
                                {
                                    model.ReportConfirmBossRebornNotify(model.currentBossNotify);
                                }
                            }
                            break;
                    }
                }

                DisplayRebornCountDown();
            }
        }

        private void OnDisable()
        {
            m_Goto.RemoveAllListeners();
            m_Close.RemoveAllListeners();
        }

        public void DisplayRebornBoss()
        {
            if (model.currentBossNotify != default(FindPreciousModel.BossNotify))
            {
                var bossId = model.currentBossNotify.bossId;
                var type = model.GetBossFindPreciousType(bossId);

                m_ContainerBossReborn.gameObject.SetActive(true);
                var config = NPCConfig.Get(bossId);
                if (config != null)
                {
                    m_BossIcon.SetSprite(config.HeadPortrait);
                    m_BossName.text = config.charName;
                    m_BossLevel.text = Language.Get("FindPrecious_11", config.NPCLV);
                }
            }
            else
            {
                m_ContainerBossReborn.gameObject.SetActive(false);
            }
        }

        private void GotoKillBoss()
        {
            var mapId = PlayerDatas.Instance.baseData.MapID;
            var bossId = model.currentBossNotify.bossId;
            var type = model.GetBossFindPreciousType(bossId);

            switch (type)
            {
                case FindPreciousType.DemonJar:
                    GotoKillDemonJarBoss(bossId);
                    break;
                case FindPreciousType.WorldBoss:
                    GotoKillWorldBoss(bossId);
                    break;
                case FindPreciousType.BossHome:
                    GotoKillBossHomeBoss(bossId);
                    break;
                case FindPreciousType.ElderGodArea:
                    GotoKillElderGodAreaBoss(bossId);
                    break;
                case FindPreciousType.PersonalBoss:
                    break;
                case FindPreciousType.DogzDungeon:
                    GotoKillDogzDungeonBoss(bossId);
                    break;
                case FindPreciousType.CrossServerBoss:
                    GotoKillCrossServerBoss(bossId);
                    break;
                case FindPreciousType.JadeDynastyBoss:
                    GotoKillStrangleGodBoss(bossId);
                    break;
            }

            ReportConfirmBossRebornNotify();
        }

        private void ReportConfirmBossRebornNotify()
        {
            if (model.currentBossNotify != default(FindPreciousModel.BossNotify))
            {
                model.ReportConfirmBossRebornNotify(model.currentBossNotify);
            }
            else
            {
                m_ContainerBossReborn.gameObject.SetActive(false);
            }
        }

        private void GotoKillDemonJarBoss(int _bossId)
        {
            var mapId = PlayerDatas.Instance.baseData.MapID;
            var mapConfig = MapConfig.Get(mapId);

            if (mapConfig.MapFBType == (int)MapType.OpenCountry)
            {
                WindowCenter.Instance.Close<MainInterfaceWin>();
                var demonJarModel = ModelCenter.Instance.GetModel<DemonJarModel>();
                demonJarModel.selectedBoss = _bossId;
                demonJarModel.lockSelectedBoss = true;
                WindowCenter.Instance.Open<LootPreciousFrameWin>(false, 0);
            }
            else
            {
                SysNotifyMgr.Instance.ShowTip("InDungeon_CantGo");
            }
        }

        private void GotoKillWorldBoss(int _bossId)
        {
            if (CrossServerUtility.IsCrossServer())
            {
                SysNotifyMgr.Instance.ShowTip("CrossMap10");
                return;
            }

            var mapId = PlayerDatas.Instance.baseData.MapID;
            var mapConfig = MapConfig.Get(mapId);
            if (mapConfig.MapFBType != (int)MapType.OpenCountry)
            {
                SysNotifyMgr.Instance.ShowTip("InDungeon_CantGo");
                return;
            }

            MapTransferUtility.Instance.MoveToNPC(_bossId);
        }

        private void GotoKillBossHomeBoss(int _bossId)
        {
            var config = BossHomeConfig.Get(_bossId);
            var dataMapId = dungeonModel.GetDataMapIdByMapId(PlayerDatas.Instance.baseData.MapID);

            if (dataMapId == BossHomeModel.BOSSHOME_MAPID)
            {
                if (PlayerDatas.Instance.baseData.dungeonLineId == config.FloorNum - 1)
                {
                    MapTransferUtility.Instance.MoveToNPC(_bossId);
                }
                else
                {
                    var vipLevel = PlayerDatas.Instance.baseData.VIPLv;
                    var vipNeed = bossHomeModel.GetFloorVipRequirement(PlayerDatas.Instance.baseData.dungeonLineId + 1);

                    if (vipLevel < vipNeed)
                    {
                        var moneyNeed = bossHomeModel.GetVipLackCost(PlayerDatas.Instance.baseData.dungeonLineId + 1);
                        var dungeonId = dungeonModel.GetDungeonId(dataMapId, PlayerDatas.Instance.baseData.dungeonLineId);
                        var dungeonConfig = DungeonConfig.Get(dungeonId);
                        ConfirmCancel.ShowPopConfirm(
                            Language.Get("Mail101"),
                            Language.Get("QuitRemindBossHome", dungeonConfig.FBName, vipNeed, moneyNeed),
                            (bool _ok) =>
                            {
                                if (_ok)
                                {
                                    EnterBossHome(config.FloorNum, _bossId);
                                }
                            }
                            );
                    }
                    else
                    {
                        EnterBossHome(config.FloorNum, _bossId);
                    }
                }
            }
            else
            {
                var mapId = PlayerDatas.Instance.baseData.MapID;
                var mapConfig = MapConfig.Get(mapId);

                if (mapConfig.MapFBType == (int)MapType.OpenCountry)
                {
                    EnterBossHome(config.FloorNum, _bossId);
                }
                else
                {
                    SysNotifyMgr.Instance.ShowTip("InDungeon_CantGo");
                }
            }

        }

        private void GotoKillElderGodAreaBoss(int _bossId)
        {
            var dataMapId = dungeonModel.GetDataMapIdByMapId(PlayerDatas.Instance.baseData.MapID);
            if (dataMapId == ElderGodAreaModel.ELDERGODAREA_MAPID)
            {
                MapTransferUtility.Instance.MoveToNPC(_bossId);
            }
            else
            {
                var mapId = PlayerDatas.Instance.baseData.MapID;
                var mapConfig = MapConfig.Get(mapId);

                if (mapConfig.MapFBType == (int)MapType.OpenCountry)
                {
                    var error = 0;
                    if (TestEnterElderGodAreaDungeon(out error))
                    {
                        var model = ModelCenter.Instance.GetModel<ElderGodAreaModel>();
                        model.selectedBoss = _bossId;
                        DungeonSuppliesLackWin.lackType = DungeonSuppliesLackWin.LackType.ElderGodArea;
                        WindowCenter.Instance.Open<DungeonSuppliesLackWin>();
                    }
                    else
                    {
                        switch (error)
                        {
                            case 1:
                                SysNotifyMgr.Instance.ShowTip("DemonJar_Text2");
                                break;
                        }
                    }
                }
                else
                {
                    SysNotifyMgr.Instance.ShowTip("InDungeon_CantGo");
                }
            }

        }

        private void GotoKillDogzDungeonBoss(int _bossId)
        {
            if (CrossServerUtility.IsCrossServer())
            {
                SysNotifyMgr.Instance.ShowTip("CrossMap10");
                return;
            }

            var mapId = PlayerDatas.Instance.baseData.MapID;
            var mapConfig = MapConfig.Get(mapId);

            if (mapConfig.MapFBType == (int)MapType.OpenCountry)
            {
                MapTransferUtility.Instance.MoveToNPC(_bossId);
            }
            else
            {
                SysNotifyMgr.Instance.ShowTip("InDungeon_CantGo");
            }
        }

        private void GotoKillCrossServerBoss(int _bossId)
        {
            var mapId = PlayerDatas.Instance.baseData.MapID;
            var mapConfig = MapConfig.Get(mapId);

            if (mapConfig.MapFBType == (int)MapType.OpenCountry)
            {
                if (mapId == CrossServerBossModel.DATA_MAPID)
                {
                    var config = CrossServerBossConfig.Get(_bossId);
                    switch (config.MonsterType)
                    {
                        case 1:
                        case 2:
                        case 3:
                            break;
                        case 4:
                            MapTransferUtility.Instance.MoveToNPC(_bossId);
                            break;
                    }
                }
                else
                {
                    crossServerBossModel.RequestEnter();
                }
            }
            else
            {
                SysNotifyMgr.Instance.ShowTip("InDungeon_CantGo");
            }
        }

        private void GotoKillStrangleGodBoss(int _bossId)
        {
            var mapId = PlayerDatas.Instance.baseData.MapID;
            var mapConfig = MapConfig.Get(mapId);

            if (mapConfig.MapFBType == (int)MapType.OpenCountry)
            {
                WindowCenter.Instance.Close<MainInterfaceWin>();
                var jadeDynastyBossModel = ModelCenter.Instance.GetModel<JadeDynastyBossModel>();
                jadeDynastyBossModel.assginSelectBossId = _bossId;
                WindowCenter.Instance.Open<LootPreciousFrameWin>(false, 3);
            }
            else
            {
                SysNotifyMgr.Instance.ShowTip("InDungeon_CantGo");
            }
        }

        private void EnterBossHome(int _floor, int _bossId)
        {
            var error = 0;
            if (TestEnterBossHomeDungeon(_floor, out error))
            {
                bossHomeModel.selectedFloor = _floor;
                bossHomeModel.selectedBoss = _bossId;
                dungeonModel.SingleChallenge(BossHomeModel.BOSSHOME_MAPID, bossHomeModel.selectedFloor - 1);
            }
            else
            {
                ProcessEnterBossHomeDungeonError(_floor, error);
            }
        }

        private bool TestEnterBossHomeDungeon(int _selectedFloor, out int _error)
        {
            var bossHomeModel = ModelCenter.Instance.GetModel<BossHomeModel>();
            var vipLevel = PlayerDatas.Instance.baseData.VIPLv;
            if (vipLevel < bossHomeModel.GetFloorVipRequirement(1))
            {
                _error = 1;
                return false;
            }

            var vipNeed = bossHomeModel.GetFloorVipRequirement(_selectedFloor);
            if (vipLevel < vipNeed)
            {
                _error = 2;
                return false;
            }

            _error = 0;
            return true;
        }

        private void ProcessEnterBossHomeDungeonError(int _floor, int _error)
        {
            var bossHomeModel = ModelCenter.Instance.GetModel<BossHomeModel>();
            switch (_error)
            {
                case 1:
                    WindowCenter.Instance.Open<BossHomeVipLackWin>();
                    break;
                case 2:
                    var moneyNeed = bossHomeModel.GetVipLackCost(_floor);
                    var title = Language.Get("Mail101");
                    var tip = Language.Get("FightTreasure_BossHome", moneyNeed);
                    ConfirmCancel.ShowPopConfirm(
                        title,
                        tip,
                        (bool _ok) =>
                        {
                            if (_ok)
                            {
                                var moneyOwn = PlayerDatas.Instance.baseData.Gold + PlayerDatas.Instance.baseData.GoldPaper;
                                if (moneyOwn < moneyNeed)
                                {
                                    if (VersionConfig.Get().isBanShu)
                                    {
                                        SysNotifyMgr.Instance.ShowTip("GoldErr");
                                        return;
                                    }
                                    WindowCenter.Instance.Open<RechargeTipWin>();
                                }
                                else
                                {
                                    var dungeonModel = ModelCenter.Instance.GetModel<DungeonModel>();
                                    dungeonModel.SingleChallenge(BossHomeModel.BOSSHOME_MAPID, _floor - 1);
                                }
                            }
                        }
                        );
                    break;
            }
        }

        private bool TestEnterElderGodAreaDungeon(out int _error)
        {
            var enterTimes = dungeonModel.GetEnterTimes(ElderGodAreaModel.ELDERGODAREA_MAPID);
            var totalTimes = dungeonModel.GetTotalTimes(ElderGodAreaModel.ELDERGODAREA_MAPID);
            if (enterTimes >= totalTimes)
            {
                _error = 1;
                return false;
            }

            _error = 0;
            return true;
        }

        private void DisplayRebornCountDown()
        {
            var bossId = model.currentBossNotify.bossId;
            if (model.IsBossAlive(bossId))
            {
                m_BossRebornTimer.text = Language.Get("BossAlreadyReborn");
            }
            else
            {
                FindPreciousModel.BossInfo bossInfo;
                if (model.TryGetBossInfo(bossId, out bossInfo))
                {
                    var rebornCountDown = (int)(bossInfo.refreshTime - TimeUtility.ServerNow).TotalSeconds;
                    if (rebornCountDown < 1)
                    {
                        m_BossRebornTimer.text = Language.Get("BossAlreadyReborn");
                    }
                    else
                    {
                        m_BossRebornTimer.text = Language.Get("BossRebornCountDown", rebornCountDown);
                    }
                }
            }
        }


    }

}