//--------------------------------------------------------
//    [Author]:           第二世界
//    [  Date ]:           Thursday, November 01, 2018
//--------------------------------------------------------

using System;
using System.Collections;
using System.Collections.Generic;

using UnityEngine;
using UnityEngine.UI;

namespace vnxbqy.UI {

    public class TeamDungeonTicketLackWin : Window
    {
        public static LackType lackType = LackType.FairyLand;

        [SerializeField] ItemBehaviour m_Item;
        [SerializeField] TextEx m_TicketOwn;
        [SerializeField] TextEx m_TicketNeed;
        [SerializeField] Text m_LackContentTip;
        [SerializeField] Text m_LackMoneyTip;
        [SerializeField] Button m_Buy;
        [SerializeField] Button m_Close;
        [SerializeField] Button m_TicketCompose;
        [SerializeField] Toggle m_RemindToggle;

        DungeonModel dungeonModel { get { return ModelCenter.Instance.GetModel<DungeonModel>(); } }
        PackModel packModel { get { return ModelCenter.Instance.GetModel<PackModel>(); } }
        ComposeWinModel composeModel { get { return ModelCenter.Instance.GetModel<ComposeWinModel>(); } }
        StoreModel storeModel { get { return ModelCenter.Instance.GetModel<StoreModel>(); } }
        #region Built-in
        protected override void BindController()
        {
        }

        protected override void AddListeners()
        {
            m_Buy.onClick.AddListener(Buy);
            m_Close.onClick.AddListener(CloseClick);
            m_TicketCompose.onClick.AddListener(TicketCompose);
        }

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

            var own = packModel.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;
            m_TicketCompose.SetActive(own < lackItem.count && SatisfyComposeTicket(lackItem));

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

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

            m_RemindToggle.isOn = false;
        }

        protected override void OnAfterOpen()
        {
        }

        protected override void OnPreClose()
        {
            DayRemind.Instance.SetDayRemind(GetDayRemindKey(lackType), m_RemindToggle.isOn);
        }

        protected override void OnAfterClose()
        {
        }
        #endregion

        private Item GetLackItem(LackType _lackType)
        {
            switch (_lackType)
            {
                case LackType.FairyLand:
                    return dungeonModel.GetLackItem(DungeonSuppliesLackWin.LackType.FairyLand);
                default:
                    return default(Item);
            }
        }

        private string GetLackContentTip(LackType _lackType)
        {
            switch (_lackType)
            {
                case LackType.FairyLand:
                    return Language.Get("TeamLostItem1");
                default:
                    return string.Empty;
            }
        }

        private bool SatisfyComposeTicket(Item lackItem)
        {
            ItemCompoundConfig itemCompound = null;
            composeModel.TryGetItemCompoundByMakeId(lackItem.id,out itemCompound);
            if(itemCompound != null)
            {
                return composeModel.IsComposeTicketByType(itemCompound.secondType);
            }
            return false;
        }

        private int GetUnitPrice(LackType _lackType)
        {
            switch (_lackType)
            {
                case LackType.FairyLand:
                    var dungeonId3 = dungeonModel.GetDungeonId(31080, 0);
                    var config3 = DungeonConfig.Get(dungeonId3);
                    return config3.TicketPrice;
                default:
                    return 0;
            }
        }

        private void TicketCompose()
        {
            switch (lackType)
            {
                case LackType.FairyLand:
                    CloseImmediately();
                    WindowJumpMgr.Instance.WindowJumpTo(JumpUIType.ComposeTicketFairy);
                    break;
            }
        }

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

        private string GetBindJadeLackTip(LackType _lackType, int _moneyNeed, int _moneyOwn)
        {
            switch (_lackType)
            {
                case LackType.FairyLand:
                    return Language.Get("JadeChargeAgainst", _moneyNeed);
                default:
                    return string.Empty;
            }
        }

        private StoreConfig GetStoreConfig(Item lackItem, int moneyType)
        {
            var config = StoreConfig.GetStoreCfg(lackItem.id, moneyType);
            return config;
        }

        private void Buy()
        {
            var lackItem = GetLackItem(lackType);
            var own = packModel.GetItemCountByID(PackType.Item, lackItem.id);
            if (own < lackItem.count)
            {
                var moneyNeed = GetUnitPrice(lackType) * (lackItem.count - own);
                if (PlayerDatas.Instance.baseData.diamond < moneyNeed)
                {
                    if (VersionConfig.Get().isBanShu)
                    {
                        SysNotifyMgr.Instance.ShowTip("GoldErr");
                        return;
                    }
                    WindowCenter.Instance.Open<RechargeTipWin>();
                }
                else
                {
                    ConfirmTodo(lackType, 1);
                }
            }
        }

        private void ConfirmTodo(LackType _lackType,int moneyType)
        {
            switch (_lackType)
            {
                case LackType.FairyLand:
                    var lackItem = GetLackItem(_lackType);
                    var config = GetStoreConfig(lackItem, moneyType);
                    if (config != null)
                    {
                        var own = packModel.GetItemCountByID(PackType.Item, lackItem.id);
                        if (moneyType == 1)
                        {
                            ConfirmCancel.ShowPopConfirm(Language.Get("Mail101"), GetConfirmLabel(_lackType), (bool isOk) =>
                              {
                                  if (isOk)
                                  {
                                      storeModel.SendBuyShopItem(config, lackItem.count - own);
                                      CloseImmediately();
                                  }
                              });
                            return;
                        }
                        else
                        {
                            storeModel.SendBuyShopItem(config, lackItem.count - own);
                        }
                    }
                    CloseImmediately();
                    break;
                default:
                    break;
            }
        }

        string GetConfirmLabel(LackType _lackType)
        {
            switch (_lackType)
            {
                case LackType.FairyLand:
                    return Language.Get("TeamLostItem2", GetUnitPrice(_lackType));
                default:
                    return string.Empty;
            }
        }

        public static string GetDayRemindKey(LackType _lackType)
        {
            switch (_lackType)
            {
                case LackType.FairyLand:
                    return DayRemind.TEAM_TICKET_FAIRYLAND;
                default:
                    return string.Empty;
            }
        }

        public enum LackType
        {
            FairyLand,
        }
    }

}