//--------------------------------------------------------
//    [Author]:           第二世界
//    [  Date ]:           Tuesday, September 12, 2017
//--------------------------------------------------------

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

namespace Snxxz.UI
{
    public class NormalDungeonEntranceWin : Window
    {
        [SerializeField] Image m_EntranceBG;

        [Header("BaseInfo")]
        [SerializeField]
        Text m_DungeonTitle;
        [SerializeField] RawImage m_BossPortrayal;
        [SerializeField] DungeonBreifInfo m_BreifInfo;

        [Header("EnterCD")]
        [SerializeField]
        DungeonEnterInfo m_EnterCdContainer;

        [Header("Sweep")]
        [SerializeField]
        Text m_SweepLevelNeed;
        [SerializeField] ItemBehaviour m_SweepContainer;
        [SerializeField] Text m_SweepCostCount;

        [Header("DungeonTicket")]
        [SerializeField]
        Transform m_TicketContainer;
        [SerializeField]
        ItemBehaviour m_DungeonTicketItem;

        [Header("Button")]
        [SerializeField]
        ButtonEx m_Sweep;
        [SerializeField] RectTransform m_ContainerBtns;
        [SerializeField] ButtonEx m_GroupStart;
        [SerializeField] ButtonEx m_SingleStart;
        [SerializeField] ButtonEx m_AutoGroupStart;
        [SerializeField] ButtonEx m_Group;
        [SerializeField] Button m_CloseWin;

        [SerializeField] RectTransform m_ContainerGroup;

        DungeonModel model { get { return ModelCenter.Instance.GetModel<DungeonModel>(); } }
        TeamModel teamModel { get { return ModelCenter.Instance.GetModel<TeamModel>(); } }
        PlayerPackModel playerPack { get { return ModelCenter.Instance.GetModel<PlayerPackModel>(); } }

        #region Built-in
        protected override void BindController()
        {
        }

        protected override void AddListeners()
        {
            m_GroupStart.AddListener(ChallengeDungeonGroup);
            m_SingleStart.AddListener(ChallengeDungeon);
            m_AutoGroupStart.AddListener(AutoGroupChallenge);
            m_Sweep.AddListener(SweepDungeon);
            m_Group.AddListener(OpenGroup);
            m_CloseWin.AddListener(CloseClick);
        }

        protected override void OnPreOpen()
        {
            DrawDungeonBaseInfo();
            DrawSweepInfo();
            DrawDungeonTicketInfo();
            m_BreifInfo.SetDungeonInfo(model.currentDungeon);
        }

        protected override void OnAfterOpen()
        {
            playerPack.RefreshItemCountAct += OnPackageItemChange;
            model.updateDungeonEnterCD += UpdateDungeonEnterCD;
            m_EnterCdContainer.OnCdComplete += UpdateDungeonEnterCD;
        }

        protected override void OnPreClose()
        {
            playerPack.RefreshItemCountAct -= OnPackageItemChange;
            model.updateDungeonEnterCD -= UpdateDungeonEnterCD;
            m_EnterCdContainer.OnCdComplete -= UpdateDungeonEnterCD;
        }

        protected override void OnAfterClose()
        {

        }

        protected override void LateUpdate()
        {
            base.LateUpdate();
        }
        #endregion

        private void OpenGroup()
        {
            var openGroup = m_ContainerGroup.gameObject.activeSelf;
            m_ContainerGroup.gameObject.SetActive(!openGroup);
        }

        private void UpdateDungeonEnterCD()
        {
            var dungeonId = model.GetDungeonId(model.currentDungeon);
            var dungeonConfig = Config.Instance.Get<DungeonConfig>(dungeonId);
            bool _cd = model.HasEnterCD(dungeonConfig.DataMapID) && model.IsEnterCountDowning(dungeonConfig.DataMapID);
            m_EnterCdContainer.gameObject.SetActive(_cd);
            m_ContainerBtns.gameObject.SetActive(!_cd);
        }

        private void DrawDungeonBaseInfo()
        {
            var dungeonId = model.GetDungeonId(model.currentDungeon);
            var dungeonConfig = Config.Instance.Get<DungeonConfig>(dungeonId);
            var dungeonOpenTimeConfig = Config.Instance.Get<DungeonOpenTimeConfig>(model.currentDungeon.mapId);
            var fbType = dungeonOpenTimeConfig.FBType;
            m_GroupStart.gameObject.SetActive(fbType == 2 || fbType == 3);
            m_SingleStart.gameObject.SetActive(fbType == 1 || fbType == 2);
            m_AutoGroupStart.gameObject.SetActive(fbType == 2 || fbType == 3);

            m_ContainerGroup.gameObject.SetActive(false);
            m_Group.gameObject.SetActive(fbType == 2 || fbType == 3);

            m_EntranceBG.SetSprite(dungeonOpenTimeConfig.PanelImg);

            m_DungeonTitle.text = dungeonConfig.FBName;

            UpdateDungeonEnterCD();

            m_BossPortrayal.gameObject.SetActive(true);
            if (dungeonConfig.BossActorID != null && dungeonConfig.BossActorID.Length > 0)
            {
                if (dungeonConfig.BossActorID[0] == 0)
                {
                    m_BossPortrayal.gameObject.SetActive(false);
                }
                else
                {
                    UI3DModelExhibition.Instance.ShowNPC(dungeonConfig.BossActorID[0], Vector3.zero, m_BossPortrayal);
                }

            }
        }

        private void DrawSweepInfo()
        {
            var dungeonId = model.GetDungeonId(model.currentDungeon);
            var dungeonConfig = Config.Instance.Get<DungeonConfig>(dungeonId);

            var playerLevel = PlayerDatas.Instance.baseData.LV;
            var sweepLevelLimit = dungeonConfig.SweepLVLimit;
            if (model.GetSweepCost(model.currentDungeon).Equals(default(Item)))
            {
                m_Sweep.gameObject.SetActive(false);
                m_SweepContainer.gameObject.SetActive(false);
                m_SweepLevelNeed.gameObject.SetActive(true);
                m_SweepLevelNeed.text = Language.Get("");//补充扫荡需要等级的提示语
            }
            else
            {
                m_SweepLevelNeed.gameObject.SetActive(false);
                m_SweepContainer.gameObject.SetActive(true);
                m_Sweep.gameObject.SetActive(true);

                var sweepCost = model.GetSweepCost(model.currentDungeon);
                var itemConfig = Config.Instance.Get<ItemConfig>(sweepCost.id);
                m_SweepContainer.SetItem(sweepCost);
                //暂时隐藏扫荡券，LC要求
                m_SweepContainer.gameObject.SetActive(false);
                var own = playerPack.GetItemCountByID(PackType.rptItem, sweepCost.id);
                m_SweepCostCount.text = StringUtility.Contact(own, "/", sweepCost.count);
            }

        }

        private void DrawDungeonTicketInfo()
        {
            var config = Config.Instance.Get<DungeonConfig>(model.GetDungeonId(model.currentDungeon));
            if (config == null || config.TicketID == 0)
            {
                m_TicketContainer.gameObject.SetActive(false);
            }
            else
            {
                m_TicketContainer.gameObject.SetActive(true);
                m_DungeonTicketItem.showCount = true;
                DungeonRecord record;
                int _times = 0;
                if (model.TryGetRecord(model.currentDungeon.mapId, out record))
                {
                    _times = record.enterTimes;
                }
                m_DungeonTicketItem.SetItem(model.GetTicketCost(model.currentDungeon.mapId, model.currentDungeon.lineId));
            }
        }

        private void SweepDungeon()
        {
            var sweepError = 0;
            if (TestSweepDungeon(out sweepError))
            {
                WindowCenter.Instance.Open<DungeonSweepWin>();
            }
            else
            {
                ProcessSweepDungeonError(sweepError);
            }
        }

        private void ChallengeDungeon()
        {
            var error = 0;
            if (model.TestChallange(model.currentDungeon, out error))
            {
                if (GeneralConfig.Instance.dungeonCanUseMoneyIds.Contains(model.currentDungeon.mapId))
                {
                    CheckUseMoneyDungeon(model.currentDungeon);
                }
                else
                {
                    model.SingleChallenge(model.currentDungeon);
                }
            }
            else
            {
                if (GeneralConfig.Instance.dungeonCanUseMoneyIds.Contains(model.currentDungeon.mapId)
                    && error == 5)
                {
                    CheckUseMoneyDungeon(model.currentDungeon);
                }
                else
                {
                    ProcessEnterDungeonError(error);
                }
            }
        }

        private void CheckUseMoneyDungeon(Dungeon _dungeon)
        {
            var mapId = _dungeon.mapId;
            var mapConfig = Config.Instance.Get<MapConfig>(mapId);

            if ((MapType)mapConfig.MapFBType == MapType.MultipleFB)
            {
                var teamModel = ModelCenter.Instance.GetModel<TeamModel>();
                if (teamModel.myTeam.inTeam)
                {
                    ConfirmCancel.ShowPopConfirm(
                        Language.Get("Mail101"),
                        Language.Get("PlayerExitTeamSolo"),

                        (bool _ok) =>
                        {
                            if (_ok)
                            {
                                teamModel.RequestExitTeam();
                                Clock.Create(DateTime.Now + new TimeSpan(1 * TimeSpan.TicksPerSecond),
                                    () =>
                                    {
                                        OpenDungeonSuppliesLack(_dungeon);
                                    }
                                    );
                            }
                        }
                        );

                    return;
                }
            }
            OpenDungeonSuppliesLack(_dungeon);
        }

        void OpenDungeonSuppliesLack(Dungeon _dungeon)
        {
            switch (_dungeon.mapId)
            {
                case 31080:
                    DungeonSuppliesLackWin.lackType = DungeonSuppliesLackWin.LackType.FairyLand;
                    WindowCenter.Instance.Open<DungeonSuppliesLackWin>();
                    break;
                case 31140:
                    DungeonSuppliesLackWin.lackType = DungeonSuppliesLackWin.LackType.SingleIceCrystal;
                    WindowCenter.Instance.Open<DungeonSuppliesLackWin>();
                    break;
            }
        }

        private void AutoGroupChallenge()
        {
            var error = 0;
            if (model.TestChallange(model.currentDungeon, out error))
            {
                teamModel.RequestAutoMatchTeam(new TeamMission(model.currentDungeon.mapId, model.currentDungeon.lineId));
                WindowCenter.Instance.Open<TeamFrameWin>(false, 1);
            }
            else
            {
                ProcessEnterDungeonError(error);
            }
        }

        private void ChallengeDungeonGroup()
        {
            var error = 0;
            if (model.TestChallange(model.currentDungeon, out error))
            {
                model.GroupChallenge(model.currentDungeon);
            }
            else
            {
                ProcessEnterDungeonError(error);
            }
        }

        private void ProcessEnterDungeonError(int _error)
        {
            var dungeonId = model.GetDungeonId(model.currentDungeon);
            var dungeonConfig = Config.Instance.Get<DungeonConfig>(dungeonId);

            switch (_error)
            {
                case 1:
                    SysNotifyMgr.Instance.ShowTip("DungeoninCoolTime");
                    break;
                case 2:
                    SysNotifyMgr.Instance.ShowTip("DemonJar_Text2");
                    break;
                case 4:
                    SysNotifyMgr.Instance.ShowTip("GeRen_chenxin_268121", dungeonConfig.MapID);
                    break;
                case 5:
                    ModelCenter.Instance.GetModel<GetItemPathModel>().SetChinItemModel(dungeonConfig.TicketID);
                    break;
            }
        }

        private bool TestSweepDungeon(out int _error)
        {
            var dungeonId = model.GetDungeonId(model.currentDungeon);
            var dungeonConfig = Config.Instance.Get<DungeonConfig>(dungeonId);
            var playerLevel = PlayerDatas.Instance.baseData.LV;
            var dungeonGrade = model.GetGrade(model.currentDungeon);

            if (dungeonGrade <= 0 && playerLevel < dungeonConfig.SweepLVLimit)
            {
                _error = 1;
                return false;
            }

            if (dungeonGrade <= 0)
            {
                _error = 2;
                return false;
            }

            if (playerLevel < dungeonConfig.SweepLVLimit)
            {
                _error = 3;
                return false;
            }

            if (model.IsEnterCountDowning(model.currentDungeon.mapId))
            {
                _error = 4;
                return false;
            }

            _error = 0;
            return true;
        }

        private void ProcessSweepDungeonError(int _error)
        {
            var dungeonId = model.GetDungeonId(model.currentDungeon);
            var dungeonConfig = Config.Instance.Get<DungeonConfig>(dungeonId);

            switch (_error)
            {
                case 1:
                    SysNotifyMgr.Instance.ShowTip("Unlock_BJMopUp2", dungeonConfig.SweepLVLimit);
                    break;
                case 2:
                    SysNotifyMgr.Instance.ShowTip("Unlock_BJMopUp1");
                    break;
                case 3:
                    SysNotifyMgr.Instance.ShowTip("Unlock_BJMopUp3", dungeonConfig.SweepLVLimit);
                    break;
                case 4:
                    SysNotifyMgr.Instance.ShowTip("DungeoninCoolTime");
                    break;
            }
        }

        private void OnPackageItemChange(PackType _type, int _index, int _itemId)
        {
            if (_type != PackType.rptItem)
            {
                return;
            }

            if (_itemId == m_SweepContainer.itemId)
            {
                var sweepCost = model.GetSweepCost(model.currentDungeon);
                var own = playerPack.GetItemCountByID(PackType.rptItem, sweepCost.id);
                m_SweepCostCount.text = StringUtility.Contact(own, "/", sweepCost.count);
            }

            if (_itemId == m_DungeonTicketItem.itemId)
            {
                m_DungeonTicketItem.SetItem(model.GetTicketCost(model.currentDungeon.mapId, model.currentDungeon.lineId));
            }
        }

    }

}