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


namespace Snxxz.UI
{
    public class ItemInfoWin : Window
    {
        [SerializeField] RectTransform bgObj;

        [SerializeField]
        Text titleText;
        [SerializeField]
        ItemCell itemCell;
        [SerializeField]
        Button closeBtn;
        [SerializeField]
        Text dateText;
     
        [SerializeField]
        Text conditionText;
        [SerializeField] Text needLvText;

        [SerializeField]
        Text realmTitleText;
        [SerializeField] Image realmImg;

        [SerializeField]
        Text itemTypeText;

        [SerializeField]
        Text itemDesText;
        [SerializeField]
        RectTransform itemDesContent;
        [SerializeField]
        ScrollRect scrollRect;
        [SerializeField]
        LayoutElement scrollLayout;

        [SerializeField]
        GameObject bottomPart;

        [SerializeField]
        Text promptText;

        [SerializeField]
        RectTransform btnGroup;
        [SerializeField]
        GameObject operateBtn;
        [SerializeField]
        CanvasGroup tipAlpha;

        [SerializeField] ModelShowPerfab modelShow;

        private List<GameObject> tempObjlist = new List<GameObject>();

        ItemTipsModel _itemTipsModel;
        ItemTipsModel itemTipsModel
        {
            get
            {
                return _itemTipsModel ?? (_itemTipsModel = ModelCenter.Instance.GetModel<ItemTipsModel>());
            }
        }

        PackModel _playerPack;
        PackModel playerPack
        {
            get { return _playerPack ?? (_playerPack = ModelCenter.Instance.GetModel<PackModel>()); }
        }

        Color32 conditionColor = new Color32(255, 244, 205, 255);
        Color32 conditionRedColor = new Color32(255, 1, 1, 255);

        protected override void BindController()
        {
           
        }

        protected override void AddListeners()
        {
            closeBtn.AddListener(CloseWin);
        }
        protected override void OnPreOpen()
        {
            KnapsackTimeCDMgr.Instance.RefreshItemOverdueTimeAct += RefreshRemainTime;
            playerPack.refreshItemDayUseCountEvent += RefreshUseCnt;
            this.transform.localPosition = Vector3.zero;
            tipAlpha.alpha = 0;
            bottomPart.SetActive(false);
            tempObjlist.Clear();
            InitUI();
        }

        protected override void OnActived()
        {
            StartCoroutine(SetScrollSize());
        }

        protected override void OnAfterOpen()
        {
            this.transform.SetAsLastSibling();
          
        }

        protected override void OnPreClose()
        {
            KnapsackTimeCDMgr.Instance.RefreshItemOverdueTimeAct -= RefreshRemainTime;
            playerPack.refreshItemDayUseCountEvent -= RefreshUseCnt;
            for (int i = 0; i < tempObjlist.Count; i++)
            {
                Destroy(tempObjlist[i]);
            }
        }

        protected override void OnAfterClose()
        {

        }

        private void InitUI()
        {
            if (itemTipsModel.curAttrData == null)
                return;

            itemTypeText.text = itemTipsModel.curAttrData.itemConfig.ItemTypeName;
            titleText.text = itemTipsModel.curAttrData.itemConfig.ItemName;
            titleText.color = UIHelper.GetUIColor(itemTipsModel.curAttrData.itemConfig.ItemColor);
            ItemCellModel cellModel = new ItemCellModel(itemTipsModel.curAttrData.itemId, itemTipsModel.curAttrData.isPreview, (ulong)itemTipsModel.curAttrData.count, itemTipsModel.curAttrData.isBind,
                itemTipsModel.curAttrData.guid, itemTipsModel.curAttrData.packType, false);
            itemCell.Init(cellModel);

            CheckUselimit();

            string infoDes = itemTipsModel.curAttrData.GetAllInfoDes();
            if(infoDes.Contains("{Exp}"))
            {
                ulong expValue = itemTipsModel.GetAddExpValue(itemTipsModel.curAttrData.itemConfig.EffectValueA1, itemTipsModel.curAttrData.itemConfig.EffectValueB1);
                infoDes = infoDes.Replace("{Exp}", UIHelper.ReplaceLargeNum(expValue));
            }
             if(infoDes.Contains("{FightPower}"))
            {
                int fightPower = 0;
                itemTipsModel.TryGetFightPowerByItemId(itemTipsModel.curAttrData.itemId, out fightPower);
                infoDes = infoDes.Replace("{FightPower}", fightPower.ToString());
            }
            if (infoDes.Contains("{ShareNum}"))
            {
                string shareNumDes = itemTipsModel.GetShareNumItemDes(itemTipsModel.curAttrData.itemId);
                infoDes = infoDes.Replace("{ShareNum}", shareNumDes);
            }

            itemDesText.text = infoDes;
            operateBtn.SetActive(false);

            CreateFuncBtn();

            RefreshRemainTime(itemTipsModel.curAttrData.guid);
            bool isShowModel = itemTipsModel.IsShowModel(itemTipsModel.curAttrData.itemId,modelShow);
            if(isShowModel)
            {
                bgObj.anchoredPosition3D = new Vector3(197, 0, 0);
                modelShow.gameObject.SetActive(true);
            }
            else
            {
                modelShow.gameObject.SetActive(false);
                bgObj.anchoredPosition3D = Vector3.zero;
            }
        }

        private void CheckUselimit()
        {
            int[] uselimits = itemTipsModel.curAttrData.itemConfig.UseCondiType;
            if (uselimits == null) return;

            conditionText.gameObject.SetActive(false);
            needLvText.gameObject.SetActive(false);
            realmTitleText.gameObject.SetActive(false);
            realmImg.gameObject.SetActive(false);

            for (int i = 0; i < uselimits.Length; i++)
            {
                switch(uselimits[i])
                {
                    case 0:
                        if (itemTipsModel.curAttrData.itemConfig.UseLV > 1)
                        {
                            conditionText.gameObject.SetActive(true);
                            needLvText.gameObject.SetActive(true);
                        }
                        conditionText.text = Language.Get("KnapS110");
                        needLvText.text = itemTipsModel.curAttrData.itemConfig.UseLV.ToString();

                        if (PlayerDatas.Instance.baseData.LV >= itemTipsModel.curAttrData.itemConfig.UseLV)
                        {
                            conditionText.color = conditionColor;
                            needLvText.color = conditionColor;
                        }
                        else
                        {
                            conditionText.color = conditionRedColor;
                            needLvText.color = conditionRedColor;
                        }

                        break;
                    case 1:
                        realmTitleText.gameObject.SetActive(true);
                        realmImg.gameObject.SetActive(true);
                        realmTitleText.text = Language.Get("RealmLimit1");
                        RealmConfig realmConfig = RealmConfig.Get(itemTipsModel.curAttrData.itemConfig.RealmLimit);
                        if(itemTipsModel.curAttrData.itemConfig.RealmLimit <= 0)
                        {
                            realmImg.SetSprite("NoRealm");
                        }
                        else
                        {
                          if(realmConfig != null)
                            {
                                realmImg.SetSprite(realmConfig.Img);
                            }
                        }
                        realmImg.SetNativeSize();
                        if (PlayerDatas.Instance.baseData.realmLevel >= itemTipsModel.curAttrData.itemConfig.RealmLimit)
                        {
                            realmTitleText.color = conditionColor;
                        }
                        else
                        {
                            realmTitleText.color = conditionRedColor;
                        }
                        break;
                    case 2:
                        break;
                }
            }

        }

        private void RefreshUseCnt(int id)
        {
            if (itemTipsModel.curAttrData == null || id != itemTipsModel.curAttrData.itemId)
                return;

            int useCnt = playerPack.GetItemUsedTimesToday(itemTipsModel.curAttrData.itemId);
            if (itemTipsModel.curAttrData.itemConfig.MaxSkillCnt > 0)
            {
                promptText.text = Language.Get("BoxUseCntTip", StringUtility.Contact(useCnt, "/", itemTipsModel.curAttrData.itemConfig.MaxSkillCnt));
            }
        }

        private void RefreshRemainTime(string guid)
        {
            if (UIHelper.ServerStringTrim(guid) != itemTipsModel.curAttrData.guid)
            {
                return;
            }
            double remainTime = 0;
            bool isRemain = itemTipsModel.curAttrData.TryGetItemRemainTime(out remainTime);
            dateText.gameObject.SetActive(isRemain);
            if (isRemain)
            {
                SetDateLimitUI(remainTime);
            }
        }

        private void SetDateLimitUI(double time)
        {
            dateText.gameObject.SetActive(true);
            TimeSpan t = TimeSpan.FromSeconds(time);
            if (t.TotalDays > 1)
            {
                dateText.text = Language.Get("EquipInfo_OverdueDay", (int)t.TotalDays);
            }
            else if (t.TotalHours > 1)
            {
                dateText.text = Language.Get("EquipInfo_OverdueHour", (int)t.TotalHours);
            }
            else if (t.TotalMinutes > 1)
            {
                dateText.text = Language.Get("EquipInfo_OverdueMin", (int)t.TotalMinutes);
            }
            else if (t.TotalMinutes > 0)
            {
                dateText.text = Language.Get("EquipInfo_OverdueMin", 1);
            }
            else if (t.TotalSeconds <= 0)
            {
                dateText.text = Language.Get("EquipInfo_Overdued");
            }
        }

        IEnumerator SetScrollSize()
        {
            yield return null;
            yield return null;
            itemDesContent.anchoredPosition3D = new Vector3(itemDesContent.anchoredPosition3D.x, 0, 0);
            SetMidUIHeight(itemDesContent.rect.height);
            StartCoroutine(ShowBottomPart());
        }

        IEnumerator ShowBottomPart()
        {
            yield return null;
            int useCnt = playerPack.GetItemUsedTimesToday(itemTipsModel.curAttrData.itemId);
            if (itemTipsModel.curAttrData.itemConfig.MaxSkillCnt > 0)
            {
                promptText.gameObject.SetActive(true);
                promptText.text = Language.Get("BoxUseCntTip", StringUtility.Contact(useCnt, "/", itemTipsModel.curAttrData.itemConfig.MaxSkillCnt));
                if (useCnt < itemTipsModel.curAttrData.itemConfig.MaxSkillCnt)
                {
                    promptText.color = UIHelper.s_DarkGreenColor;
                }
                else
                {
                    promptText.color = UIHelper.s_DarkRedColor;
                }
            }
            else
            {
                promptText.gameObject.SetActive(false);
            }
            bottomPart.gameObject.SetActive(true);
            StartCoroutine(SetPanelScale());
        }

        IEnumerator SetPanelScale()
        {
            yield return null;
            bottomPart.gameObject.SetActive(false);
            bottomPart.gameObject.SetActive(true);
            //itemTipsModel.SetCommonTipPos(bgObj);
            //this.transform.localScale = Vector3.one;
            tipAlpha.alpha = 1;
        }

        private void SetMidUIHeight(float midHeight)
        {
            scrollRect.enabled = false;

            if (midHeight < itemTipsModel.equipMidHeights[0])
            {
                scrollLayout.preferredHeight = itemTipsModel.equipMidHeights[0];
            }
            else if (midHeight > itemTipsModel.equipMidHeights[1])
            {
                scrollRect.enabled = true;
                scrollLayout.preferredHeight = itemTipsModel.equipMidHeights[1];
            }
            else
            {
                scrollLayout.preferredHeight = midHeight;
            }
        }

        private void CreateFuncBtn()
        {
            btnGroup.anchoredPosition3D = Vector3.zero;
            if (itemTipsModel.curAttrData.tipsFuncBtnDic.Count > 0)
            {
                foreach (ItemOperateType key in itemTipsModel.curAttrData.tipsFuncBtnDic.Keys)
                {
                    Button btn = OnGUIButton(btnGroup.gameObject, operateBtn, key.ToString(), Language.Get(StringUtility.Contact("ItemHandle_", key.ToString())));
                    btn.RemoveAllListeners();
                    btn.onClick.AddListener(() =>
                    {
                        CloseWin();
                        itemTipsModel.curAttrData.tipsFuncBtnDic[key](key, "");
                    });
                }
            }
        }

        private Button OnGUIButton(GameObject parent, GameObject sourceBtn, string btnName, string textName)
        {
            GameObject go = Instantiate(sourceBtn);
            go.name = btnName;
            go.transform.SetParent(parent.transform);
            go.transform.Find("BtnText").GetComponent<Text>().text = textName;
            go.transform.localPosition = Vector3.zero;
            go.transform.localScale = Vector3.one;
            Button btn = go.GetComponent<Button>();
            go.SetActive(true);
            tempObjlist.Add(go);
            return btn;
        }

        private void CloseWin()
        {
            CloseImmediately();
        }
    }
}