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

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

namespace Snxxz.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>(); } }
        PlayerPackModel playerPack { get { return ModelCenter.Instance.GetModel<PlayerPackModel>(); } }
        ComposeWinModel composeModel { get { return ModelCenter.Instance.GetModel<ComposeWinModel>(); } }

        #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.rptItem, lackItem.id);
            m_TicketOwn.text = own.ToString();
            m_TicketNeed.text = StringUtility.Contact("/", lackItem.count);
            m_TicketOwn.colorType = own >= lackItem.count ? TextColType.White : TextColType.Red;
            m_TicketCompose.gameObject.SetActive(own < lackItem.count && CanComposeTicket(lackType));

            m_LackContentTip.text = GetLackContentTip(lackType);
            m_LackMoneyTip.gameObject.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.rptItem, lackItem.id);
            if (own < lackItem.count)
            {
                var moneyNeed = GetUnitPrice(lackType) * (lackItem.count - own);
                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
                {
                    if (PlayerDatas.Instance.baseData.GoldPaper < moneyNeed)
                    {
                        ConfirmCancel.ShowPopConfirm(
                            Language.Get("Mail101"),
                            GetBindJadeLackTip(lackType, moneyNeed, (int)PlayerDatas.Instance.baseData.GoldPaper),
                            (bool _ok) =>
                            {
                                if (_ok)
                                {
                                    ConfirmTodo(lackType);
                                }
                            }
                            );
                    }
                    else
                    {
                        ConfirmTodo(lackType);
                    }
                }
            }
            else
            {
                ConfirmTodo(lackType);
            }
        }

        private void TicketCompose()
        {
            switch (lackType)
            {
                case LackType.ElderGodArea:
                    WindowJumpMgr.Instance.WindowJumpTo(JumpUIType.ComposeTicketIce);
                    break;
                case LackType.FairyLand:
                    WindowJumpMgr.Instance.WindowJumpTo(JumpUIType.ComposeTicketFairy);
                    break;
                case LackType.SingleIceCrystal:
                    WindowJumpMgr.Instance.WindowJumpTo(JumpUIType.ComposeTicketGod);
                    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 = Config.Instance.Get<DungeonConfig>(dungeonId1);
                    return config1.TicketPrice;
                case LackType.ElderGodArea:
                    var dungeonId2 = dungeonModel.GetDungeonId(ElderGodAreaModel.ELDERGODAREA_MAPID, 0);
                    var config2 = Config.Instance.Get<DungeonConfig>(dungeonId2);
                    return config2.TicketPrice;
                case LackType.Kylin:
                case LackType.IceCrystal:
                    return GeneralConfig.Instance.autoBuyItemPrices[0];
                case LackType.FairyLand:
                    var dungeonId3 = dungeonModel.GetDungeonId(31080, 0);
                    var config3 = Config.Instance.Get<DungeonConfig>(dungeonId3);
                    return config3.TicketPrice;
                case LackType.SingleIceCrystal:
                    var dungeonId4 = dungeonModel.GetDungeonId(31140, 0);
                    var config4 = Config.Instance.Get<DungeonConfig>(dungeonId4);
                    return config4.TicketPrice;
                default:
                    return 0;
            }
        }

        private string GetLackContentTip(LackType _lackType)
        {
            switch (_lackType)
            {
                case LackType.PersonalBoss:
                    return 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 = Config.Instance.Get<DungeonConfig>(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, _moneyOwn);
                case LackType.Kylin:
                case LackType.IceCrystal:
                    var lackItem = GetLackItem(_lackType);
                    var own = playerPack.GetItemCountByID(PackType.rptItem, 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:
                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)
        {
            var lackItem = GetLackItem(lackType);
            List<ItemCompoundConfig> list;
            if (ItemCompoundConfig.TryGetTicketCompose(lackItem.id, out list))
            {
                return composeModel.IsComposeTicketByType(list[0].secondType);
            }
            return false;
        }

        public enum LackType
        {
            PersonalBoss,
            ElderGodArea,
            Kylin,
            IceCrystal,
            FairyLand,
            SingleIceCrystal,
        }

    }

}