//--------------------------------------------------------
//    [Author]:           第二世界
//    [  Date ]:           Friday, January 18, 2019
//--------------------------------------------------------

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


namespace vnxbqy.UI
{
    
    public class RealmTowerWin : Window
    {
        [SerializeField] ScrollerController m_TowerBehaviour;
        [SerializeField] List<ItemCell> items;
        [SerializeField] TextEx m_LevelLimit;
        [SerializeField] Button m_Challenge;
        [SerializeField] TextEx m_TopNow;
        [SerializeField] TextEx m_TowerName;
        [SerializeField] Button m_Close;
        [SerializeField] Button m_FlashKill;
        [SerializeField] Text m_FlashKillCount;

        RealmModel realmModel { get { return ModelCenter.Instance.GetModel<RealmModel>(); } }
        DungeonModel dungeonModel { get { return ModelCenter.Instance.GetModel<DungeonModel>(); } }

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

        protected override void AddListeners()
        {
            m_Challenge.SetListener(Challenge);
            m_Close.AddListener(CloseClick);
        }

        protected override void OnPreOpen()
        {
            m_TowerBehaviour.OnRefreshCell += RefreshCell;
            //realmModel.OnTowerPassEvent += OnTowerPassEvent;
            realmModel.OnFlashOverEvent += OnFlashOverEvent;
            Display();
            OnCreateScroller();
        }

        protected override void OnAfterOpen()
        {
        }

        protected override void OnPreClose()
        {
            m_TowerBehaviour.OnRefreshCell -= RefreshCell;
            //realmModel.OnTowerPassEvent -= OnTowerPassEvent;
            realmModel.OnFlashOverEvent -= OnFlashOverEvent;
        }

        protected override void OnAfterClose()
        {
        }

        protected override void OnActived()
        {
        }

        #endregion

        void OnFlashOverEvent(int state)
        {
            var floors = RealmTowerConfig.GetFloorsByFloorID(realmModel.currentFloor);
            m_TowerBehaviour.MoveToIndex(floors.Count - floors.IndexOf(realmModel.currentFloor) - 3, 0.2f, EnhancedScroller.TweenType.easeInQuad);
            
            Clock.AlarmAfter(0.3f, () => { 
                OnTowerPassEvent();
                if (dungeonModel.dungeonResult.quickPass == 1 && dungeonModel.dungeonResult.dataMapID == RealmModel.Tower_MapId)
                {
                    var serveritems = dungeonModel.dungeonResult.itemInfo;
                    if (serveritems != null)
                    {
                        List<Item> items = new List<Item>();
                        foreach (var item in serveritems)
                        {
                            items.Add(new Item(item.ItemID, (ulong)item.Count));
                        }
                        ItemLogicUtility.Instance.ShowGetItem(items, seconds: 0);
                    }
                }
            });
        }


        void Display()
        {
            var config = RealmTowerConfig.Get(realmModel.selectFloorID);
            var awards = config.RewardItemList;
            for (int i = 0; i < items.Count; i++)
            {
                if (i < awards.Length)
                {
                    items[i].SetActive(true);
                    int itemID = awards[i][0];
                    items[i].Init(new ItemCellModel(itemID, false, (ulong)awards[i][1]));
                    items[i].button.AddListener(() => {
                        ItemTipUtility.Show(itemID);
                    });
                }
                else
                {
                    items[i].SetActive(false);
                }
            }

            m_LevelLimit.text = UIHelper.GetRealmName(config.NeedRealmLV, false, true);
            m_Challenge.SetActive(realmModel.currentFloor == realmModel.selectFloorID);
            m_TopNow.SetActive(realmModel.currentFloor != realmModel.selectFloorID);
            m_TowerName.text = Language.Get("RealmTower4", RealmConfig.Get(RealmConfig.Get(RealmTowerConfig.Get(realmModel.selectFloorID).NeedRealmLV).LvLarge).Name);
            
            ShowBtns();
        }

        void ShowBtns()
        {
            int count = GetFlashKillCount();
            if (count == 0)
            { 
                m_Challenge.SetActive(realmModel.currentFloor == realmModel.selectFloorID);
                m_FlashKill.SetActive(false);
            }
            else
            {
                m_Challenge.SetActive(false);
                m_FlashKill.SetActive(true);
                m_FlashKillCount.text = count == 1 ? string.Empty : count.ToString();

                m_FlashKill.AddListener(() => {

                    if (!dungeonModel.CanFlashKill())
                    {
                        SysNotifyMgr.Instance.ShowTip("InFBCanotDo");
                        return;
                    }

                    var pack = new CB108_tagCMFBQuickPass();
                    pack.MapID = RealmModel.Tower_MapId;
                    pack.LineID = (ushort)(realmModel.currentFloor + count - 1);
                    GameNetSystem.Instance.SendInfo(pack);
                });
            }
        }

        // 前20层不用雷诛
        int GetFlashKillCount()
        {
            int count = 0;
            if (realmModel.currentFloor <= 20)
                return count;

            for (int i = 0; i < GeneralDefine.flashKillMaxCount; i++)
            {
                var config = RealmTowerConfig.Get(realmModel.currentFloor + i);
                if (config == null)
                    break;

                if (PlayerDatas.Instance.baseData.realmLevel < config.NeedRealmLV)
                    break;

                var fightPower = NPCExConfig.Get(config.BossID).SuppressFightPower;
                if (PlayerDatas.Instance.baseData.FightPoint >= (ulong)fightPower * GeneralDefine.fightPowerMore)
                {
                    count++;
                }
                else
                {
                    //遇到第一个卡点就停止
                    break;
                }
            }
            return count;
        }


        void OnCreateScroller()
        {   
            var floors = RealmTowerConfig.GetFloorsByFloorID(realmModel.selectFloorID);
            if (floors == null) return;
            m_TowerBehaviour.Refresh();

            for (int i = floors.Count - 1; i >= 0; i--)
            {
                if (i == floors.Count - 1)
                {
                    m_TowerBehaviour.AddCell(ScrollerDataType.Header, floors[i]);
                }
                else
                {
                    m_TowerBehaviour.AddCell(ScrollerDataType.Normal, floors[i]);
                }
            }

            m_TowerBehaviour.AddCell(ScrollerDataType.Tail, 0);

            m_TowerBehaviour.Restart();
            m_TowerBehaviour.JumpIndex(floors.Count - floors.IndexOf(realmModel.selectFloorID) - 3);
        }


        void Challenge()
        {
            realmModel.RequestChallenge();
        }

        void RefreshCell(ScrollerDataType type, CellView cell)
        { 
            if (type == ScrollerDataType.Header || type == ScrollerDataType.Normal)
            {
                var floorCell = cell as RealmTowerFloorCell;
                floorCell.Display(cell.index);
            }
        }

        void OnTowerPassEvent()
        {
            Display();
            m_TowerBehaviour.m_Scorller.RefreshActiveCellViews();
        }
    }

}