//--------------------------------------------------------
//    [Author]:           第二世界
//    [  Date ]:           Thursday, May 03, 2018
//--------------------------------------------------------

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


namespace vnxbqy.UI
{

    public class DungeonSuppliesLackWin : Window
    {

        public static LackType lackType = LackType.PersonalBoss;

        [SerializeField] ItemBehaviour m_Item;
        [SerializeField] TextEx m_TicketOwn;
        [SerializeField] TextEx m_TicketNeed;
        [SerializeField] Text m_LackContentTip;
        [SerializeField] Text m_LackMoneyTip;
        [SerializeField] Text m_ConfirmLabel;
        [SerializeField] Button m_Confirm;
        [SerializeField] Button m_Close;
        [SerializeField] Button m_TicketCompose;

        DungeonModel dungeonModel { get { return ModelCenter.Instance.GetModel<DungeonModel>(); } }
        PackModel playerPack { get { return ModelCenter.Instance.GetModel<PackModel>(); } }
        ComposeWinModel composeModel { get { return ModelCenter.Instance.GetModel<ComposeWinModel>(); } }
        PersonalBossModel personalBossModel { get { return ModelCenter.Instance.GetModel<PersonalBossModel>(); } }

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

        protected override void AddListeners()
        {
            m_Confirm.AddListener(Confirm);
            m_Close.AddListener(CloseClick);
            m_TicketCompose.AddListener(TicketCompose);
        }

        protected override void OnPreOpen()
        {
            var lackItem = GetLackItem(lackType);
            m_Item.showCount = false;
            m_Item.SetItem(lackItem);

            var own = playerPack.GetItemCountByID(PackType.Item, lackItem.id);
            m_TicketOwn.text = own.ToString();
            m_TicketNeed.text = StringUtility.Contact("/", lackItem.count);
            m_TicketOwn.colorType = own >= lackItem.count ? TextColType.White : TextColType.Red;
            if (lackType == LackType.PersonalBoss)
            {
                m_TicketCompose.SetActive(true);
            }
            else
            {
                m_TicketCompose.SetActive(own < lackItem.count && CanComposeTicket(lackType));
            }

            m_LackContentTip.text = GetLackContentTip(lackType);
            m_LackMoneyTip.SetActive(own < lackItem.count);
            m_ConfirmLabel.text = GetConfirmLabel(lackType);

            if (own < lackItem.count)
            {
                var moneyNeed = GetUnitPrice(lackType) * (lackItem.count - own);
                m_LackMoneyTip.text = GetLackMoneyTip(lackType, moneyNeed);
            }

        }

        protected override void OnAfterOpen()
        {
        }

        protected override void OnPreClose()
        {
        }

        protected override void OnAfterClose()
        {
        }
        #endregion

        private void Confirm()
        {
            var lackItem = GetLackItem(lackType);
            var own = playerPack.GetItemCountByID(PackType.Item, lackItem.id);
            if (own < lackItem.count)
            {
                var moneyNeed = GetUnitPrice(lackType) * (lackItem.count - own);
                var moneyOwn = PlayerDatas.Instance.baseData.diamond;
                if (moneyOwn < moneyNeed)
                {
                    if (VersionConfig.Get().isBanShu)
                    {
                        SysNotifyMgr.Instance.ShowTip("GoldErr");
                        return;
                    }

                    WindowCenter.Instance.Open<RechargeTipWin>();
                }
                else
                {
                    ConfirmTodo(lackType);
                }
            }
            else
            {
                ConfirmTodo(lackType);
            }
        }

        private void TicketCompose()
        {
            switch (lackType)
            {
                case LackType.ElderGodArea:
                    WindowJumpMgr.Instance.WindowJumpTo(JumpUIType.ComposeTicketGod);
                    break;
                case LackType.PersonalBoss:
                    WindowJumpMgr.Instance.WindowJumpTo(JumpUIType.VipRechargeFunc5);
                    break;
                case LackType.FairyLand:
                    WindowJumpMgr.Instance.WindowJumpTo(JumpUIType.ComposeTicketFairy);
                    break;
                case LackType.SingleIceCrystal:
                    WindowJumpMgr.Instance.WindowJumpTo(JumpUIType.ComposeTicketIce);
                    break;
            }
        }

        private Dungeon GetDungeon(LackType _lackType)
        {
            switch (_lackType)
            {
                case LackType.PersonalBoss:
                    return new Dungeon(PersonalBossModel.PERSONALBOSS_MAPID, 0);
                case LackType.ElderGodArea:
                    return new Dungeon(ElderGodAreaModel.ELDERGODAREA_MAPID, 0);
                case LackType.Kylin:
                    return dungeonModel.selectedKylinDungeon;
                case LackType.IceCrystal:
                    return new Dungeon(31140, 0);
                case LackType.FairyLand:
                    return new Dungeon(31080, 0);
                case LackType.SingleIceCrystal:
                    return new Dungeon(31140, 0);
                default:
                    return default(Dungeon);
            }
        }

        private Item GetLackItem(LackType _lackType)
        {
            return dungeonModel.GetLackItem(_lackType);
        }

        private int GetUnitPrice(LackType _lackType)
        {
            switch (_lackType)
            {
                case LackType.PersonalBoss:
                    var dungeonId1 = dungeonModel.GetDungeonId(PersonalBossModel.PERSONALBOSS_MAPID, 0);
                    var config1 = DungeonConfig.Get(dungeonId1);
                    return config1.TicketPrice;
                case LackType.ElderGodArea:
                    var dungeonId2 = dungeonModel.GetDungeonId(ElderGodAreaModel.ELDERGODAREA_MAPID, 0);
                    var config2 = DungeonConfig.Get(dungeonId2);
                    return config2.TicketPrice;
                case LackType.Kylin:
                case LackType.IceCrystal:
                    return GeneralDefine.autoBuyItemPrices[0];
                case LackType.FairyLand:
                    var dungeonId3 = dungeonModel.GetDungeonId(31080, 0);
                    var config3 = DungeonConfig.Get(dungeonId3);
                    return config3.TicketPrice;
                case LackType.SingleIceCrystal:
                    var dungeonId4 = dungeonModel.GetDungeonId(31140, 0);
                    var config4 = DungeonConfig.Get(dungeonId4);
                    return config4.TicketPrice;
                default:
                    return 0;
            }
        }

        private string GetLackContentTip(LackType _lackType)
        {
            switch (_lackType)
            {
                case LackType.PersonalBoss:
                    return UIHelper.ReplaceNewLine(Language.Get("W_PersonalBossTickets"));
                case LackType.ElderGodArea:
                    return Language.Get("W_ElderGodTickets");
                case LackType.Kylin:
                case LackType.IceCrystal:
                    var dungeonId = dungeonModel.GetDungeonId(GetDungeon(_lackType));
                    var config = DungeonConfig.Get(dungeonId);
                    return Language.Get("MultipleSweep_Text1", config.FBName, config.SweepCostCnt);
                case LackType.FairyLand:
                    return Language.Get("W_XJMJGodTickets");
                case LackType.SingleIceCrystal:
                    return Language.Get("W_BJKMGodTickets");
                default:
                    return string.Empty;
            }
        }

        private string GetLackMoneyTip(LackType _lackType, int _moneyLack)
        {
            switch (_lackType)
            {
                case LackType.PersonalBoss:
                case LackType.ElderGodArea:
                case LackType.FairyLand:
                case LackType.SingleIceCrystal:
                    return Language.Get("W_TicketJade", _moneyLack);
                case LackType.Kylin:
                case LackType.IceCrystal:
                    return Language.Get("MultipleSweep_Text2", _moneyLack);
                default:
                    return string.Empty;
            }
        }

        private string GetBindJadeLackTip(LackType _lackType, int _moneyNeed, int _moneyOwn)
        {
            switch (_lackType)
            {
                case LackType.PersonalBoss:
                case LackType.ElderGodArea:
                case LackType.FairyLand:
                case LackType.SingleIceCrystal:
                    return Language.Get("JadeChargeAgainst", _moneyNeed);
                case LackType.Kylin:
                case LackType.IceCrystal:
                    var lackItem = GetLackItem(_lackType);
                    var own = playerPack.GetItemCountByID(PackType.Item, lackItem.id);
                    return Language.Get("MultipleSweep_Text3", lackItem.count - own, _moneyNeed);
                default:
                    return string.Empty;
            }
        }

        private void ConfirmTodo(LackType _lackType)
        {
            switch (_lackType)
            {
                case LackType.PersonalBoss:
                    personalBossModel.RequestGotoDungeon(personalBossModel.selectedBoss);
                    break;
                case LackType.ElderGodArea:
                    dungeonModel.SingleChallenge(GetDungeon(_lackType));
                    break;
                case LackType.Kylin:
                case LackType.IceCrystal:
                    dungeonModel.RequestSweep(GetDungeon(_lackType));
                    break;
                case LackType.FairyLand:
                    dungeonModel.SingleChallenge(GetDungeon(_lackType));
                    break;
                case LackType.SingleIceCrystal:
                    dungeonModel.SingleChallenge(GetDungeon(_lackType));
                    break;
                default:
                    break;
            }
        }

        private string GetConfirmLabel(LackType _lackType)
        {
            switch (_lackType)
            {
                case LackType.PersonalBoss:
                case LackType.Kylin:
                case LackType.IceCrystal:
                    return Language.Get("ConfirmTarget");
                case LackType.ElderGodArea:
                case LackType.FairyLand:
                case LackType.SingleIceCrystal:
                    return Language.Get("W_CertainInto");
                default:
                    return Language.Get("ConfirmTarget");
            }
        }

        private bool CanComposeTicket(LackType _lackType)
        {
            if (_lackType == LackType.PersonalBoss)
            {
                return true;
            }
            else
            {
                var lackItem = GetLackItem(lackType);
                ItemCompoundConfig itemCompound = null;
                composeModel.TryGetItemCompoundByMakeId(lackItem.id, out itemCompound);
                if (itemCompound != null)
                {
                    return composeModel.IsComposeTicketByType(itemCompound.secondType);
                }
                return false;
            }
        }

        public enum LackType
        {
            PersonalBoss,
            ElderGodArea,
            Kylin,
            IceCrystal,
            FairyLand,
            SingleIceCrystal,
            //后续IL开发添加预设
            default1,
            default2,
            default3,
            default4,
            default5,
            default6,
            default7,
            default8,
            default9,
            default10,
        }

    }

}