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

namespace Snxxz.UI
{
    public class AlchemyStoveBehaviour : MonoBehaviour
    {
        [SerializeField] AlchemyMaterial[] m_AlchemyMaterials;

        [SerializeField] Transform m_ContainerAlcheming;
        [SerializeField] Text m_AlchemyTime;
        [SerializeField] Transform m_ContainerComplete;
        [SerializeField] Transform m_ContainerNormal;
        [SerializeField] Text m_StoveLevel;
        [SerializeField] Text m_StoveExp;
        [SerializeField] Slider m_StoveExpSlider;
        [SerializeField] Image m_ViewSlider;
        [SerializeField] float m_SliderLength;

        [SerializeField] Text m_LuckValue;
        [SerializeField] Transform m_ContainerGrasp;
        [SerializeField] Button m_Func;
        [SerializeField] Text m_FuncLabel;
        [SerializeField] Transform m_ContainerUnGrasp;

        int m_State = 0; //0-正常状态 1-炼丹中 2-炼丹结束
        int state
        {
            get { return m_State; }
            set
            {
                if (m_State != value)
                {
                    m_State = value;
                    DisplayStove();
                }
            }
        }

        float timer = 0f;

        AlchemyModel model { get { return ModelCenter.Instance.GetModel<AlchemyModel>(); } }
        PackModel packModel { get { return ModelCenter.Instance.GetModel<PackModel>(); } }

        private void Awake()
        {
            m_Func.SetListener(OnFunc);
        }

        public void Display()
        {
            model.selectAlchemyRefresh += SelectAlchemyRefresh;
            model.alchemyStateRefresh += AlchemyStateRefresh;
            PlayerDatas.Instance.playerDataRefreshEvent += PlayerDataRefreshEvent;
            packModel.refreshItemCountEvent += RefreshItemCountEvent;

            m_State = model.GetStoveState(model.selectAlchemy);

            DisplayAlchemyMaterials();
            DisplayStove();
            DisplayLuckValue();
        }

        void DisplayAlchemyMaterials()
        {
            var grasp = model.IsGraspRecipe(model.selectAlchemy);

            List<Item> materials;
            model.TryGetAlchemyMaterials(model.selectAlchemy, out materials);

            for (int i = 0; i < m_AlchemyMaterials.Length; i++)
            {
                if (grasp && materials != null && i < materials.Count)
                {
                    m_AlchemyMaterials[i].SetLock(false);
                    m_AlchemyMaterials[i].Display(materials[i]);
                }
                else
                {
                    m_AlchemyMaterials[i].SetLock(true);
                }
            }
        }

        void DisplayStove()
        {
            m_ContainerAlcheming.gameObject.SetActive(state == 1);
            m_ContainerNormal.gameObject.SetActive(state == 0);
            m_ContainerComplete.gameObject.SetActive(state == 2);

            switch (state)
            {
                case 0:
                    m_StoveLevel.text = StringUtility.Contact("Lv.", model.stoveLevel);
                    var isMax = !RefineStoveConfig.Has(model.stoveLevel + 1);
                    var stoveConfig = RefineStoveConfig.Get(model.stoveLevel);
                    if (isMax)
                    {
                        m_StoveExp.text = Language.Get("L1055");
                        m_StoveExpSlider.value = 1;
                    }
                    else
                    {
                        m_StoveExp.text = StringUtility.Contact(model.stoveExp, "/", stoveConfig.Exp);
                        var progress = Mathf.Clamp01((float)model.stoveExp / stoveConfig.Exp);
                        m_StoveExpSlider.value = progress;
                    }
                    break;
                case 1:
                    uint tick = 0;
                    if (model.TryGetAlchemyStartTime(model.selectAlchemy, out tick))
                    {
                        var config = AlchemyConfig.Get(model.selectAlchemy);
                        var startTime = TimeUtility.GetTime(tick);
                        var seconds = (int)(config.NeedTime - (float)(TimeUtility.ServerNow - startTime).TotalSeconds);
                        m_AlchemyTime.text = TimeUtility.SecondsToHMS(seconds);
                    }
                    break;
                case 2:
                    break;
            }

            DisplayViewLength();

            var grasp = model.IsGraspRecipe(model.selectAlchemy);
            m_ContainerGrasp.gameObject.SetActive(grasp);
            m_ContainerUnGrasp.gameObject.SetActive(!grasp);
            if (grasp)
            {
                switch (state)
                {
                    case 0:
                        m_FuncLabel.text = Language.Get("AlchemyStoveStart");
                        break;
                    case 1:
                        m_FuncLabel.text = Language.Get("AlchemyStoveStop");
                        break;
                    case 2:
                        m_FuncLabel.text = Language.Get("AlchemyStoveGet");
                        break;
                }
            }
        }

        void DisplayLuckValue()
        {
            m_LuckValue.text = PlayerDatas.Instance.extersion.luckValue.ToString();
        }

        void DisplayViewLength()
        {
            var isMax = !RefineStoveConfig.Has(model.stoveLevel + 1);
            m_ViewSlider.gameObject.SetActive(!isMax);
            if (!isMax)
            {
                var stoveConfig = RefineStoveConfig.Get(model.stoveLevel);
                var config = AlchemyConfig.Get(model.selectAlchemy);
                var exp = config.AlchemyExp + model.stoveExp;
                var progress = Mathf.Clamp01((float)exp / stoveConfig.Exp);
                m_ViewSlider.rectTransform.sizeDelta = m_ViewSlider.rectTransform.sizeDelta.SetX(progress * m_SliderLength);
            }
        }

        private void SelectAlchemyRefresh()
        {
            m_State = model.GetStoveState(model.selectAlchemy);
            DisplayStove();
            DisplayAlchemyMaterials();
        }

        private void AlchemyStateRefresh()
        {
            m_State = model.GetStoveState(model.selectAlchemy);
            DisplayStove();
            DisplayAlchemyMaterials();
        }

        private void PlayerDataRefreshEvent(PlayerDataType dataType)
        {
            if (dataType == PlayerDataType.LuckValue)
            {
                DisplayLuckValue();
            }
        }

        private void LateUpdate()
        {
            timer += Time.deltaTime;
            if (timer >= 0.5f)
            {
                timer = 0f;
                PerSecond();
            }
        }

        private void PerSecond()
        {
            var _state = model.GetStoveState(model.selectAlchemy);

            if (_state == state)
            {
                if (state == 1)
                {
                    DisplayStove();
                }
            }
            else
            {
                state = _state;
            }
        }

        private void OnFunc()
        {
            switch (state)
            {
                case 0:
                    Int2 alchemyPosition;
                    if (model.IsStoveAlcheming(model.selectAlchemyType, out alchemyPosition))
                    {
                        SysNotifyMgr.Instance.ShowTip("AlchemingError");
                        return;
                    }
                    Item item;
                    if (!model.IsAlchemyEnoughMaterial(model.selectAlchemy, out item))
                    {
                        ItemTipUtility.Show(item.id);
                        return;
                    }
                    var succRate = model.GetAlchemySuccRate(model.selectAlchemy);
                    if (succRate / 100 < 100)
                    {
                        ConfirmCancel.ShowPopConfirm(Language.Get("Mail101"), Language.Get("AlchemyLowRateRemind"), (bool isOk) =>
                          {
                              if (isOk)
                              {
                                  SendAlchemyPackage();
                              }
                          });
                        return;
                    }
                    break;
                case 1:
                    ConfirmCancel.ShowPopConfirm(Language.Get("Mail101"), Language.Get("StopAlchemyDrugRemind"), (bool isOk) =>
                    {
                        if (isOk)
                        {
                            SendAlchemyPackage();
                        }
                    });
                    return;
            }

            SendAlchemyPackage();
        }

        void SendAlchemyPackage()
        {
            var pak = new CA576_tagCMPlayerRefine();
            pak.AlchemyID = (uint)model.selectAlchemy;
            switch (state)
            {
                case 0:
                    pak.DoType = 1;
                    break;
                case 1:
                    pak.DoType = 2;
                    break;
                case 2:
                    pak.DoType = 3;
                    break;
            }
            GameNetSystem.Instance.SendInfo(pak);
        }

        private void RefreshItemCountEvent(PackType packType, int index, int itemId)
        {
            if (packType == PackType.Item)
            {
                List<Item> items;
                if (model.TryGetAlchemyMaterials(model.selectAlchemy, out items))
                {
                    if (items.FindIndex((x) =>
                     {
                         return x.id == itemId;
                     }) != -1)
                    {
                        DisplayAlchemyMaterials();
                    }
                }
            }
        }

        public void Dispose()
        {
            model.selectAlchemyRefresh -= SelectAlchemyRefresh;
            model.alchemyStateRefresh -= AlchemyStateRefresh;
            PlayerDatas.Instance.playerDataRefreshEvent -= PlayerDataRefreshEvent;
            packModel.refreshItemCountEvent -= RefreshItemCountEvent;
        }
    }

    [Serializable]
    public class AlchemyMaterial
    {
        [SerializeField] Transform m_ContainerItem;
        [SerializeField] Image m_Icon;
        [SerializeField] Text m_Count;
        [SerializeField] Transform m_ContainerLock;
        [SerializeField] Button m_Func;

        PackModel packModel { get { return ModelCenter.Instance.GetModel<PackModel>(); } }

        public void Display(Item item)
        {
            Display(item.id, item.count);
        }

        public void Display(int id, int count)
        {
            var itemConfig = ItemConfig.Get(id);
            m_Icon.SetSprite(itemConfig.IconKey);

            var packCount = packModel.GetItemCountByID(PackType.Item, id);
            var enough = packCount >= count;
            var label = UIHelper.AppendColor(enough ? TextColType.Green : TextColType.Red, packCount.ToString());
            m_Count.text = StringUtility.Contact(label, "/", count);

            m_Func.SetListener(() =>
            {
                ItemTipUtility.Show(id);
            });
        }

        public void SetLock(bool _lock)
        {
            m_ContainerLock.gameObject.SetActive(_lock);
            m_ContainerItem.gameObject.SetActive(!_lock);
        }
    }
}