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

namespace vnxbqy.UI
{
    public class AlchemyStoveBehaviour : MonoBehaviour
    {
        [SerializeField] Transform m_ContainerMaterials;
        [SerializeField] AlchemyMaterial[] m_AlchemyMaterials;

        [SerializeField] Transform m_ContainerAlcheming;
        [SerializeField] Text m_AlchemyTime;
        [SerializeField] Slider m_TimeSlider;
        [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_ReikiPoint;
        [SerializeField] Transform m_ContainerGrasp;
        [SerializeField] Button m_Func;
        [SerializeField] Text m_FuncLabel;
        [SerializeField] Button m_BatchAlchemy;
        [SerializeField] Text m_BatchAlchemyLabel;
        [SerializeField] Transform m_ContainerUnGrasp;

        [SerializeField] UIEffect m_AlchemingEffect;
        [SerializeField] UIEffect m_AlchemyCompleteEffect;
        [SerializeField] UIEffect[] m_AlchemyFlyEffects;
        [SerializeField] Transform m_ContainerFlyMaterials;
        [SerializeField] Transform[] m_FlyMaterials;
        [SerializeField] Image[] m_FlyIcons;
        [SerializeField] UIEffect m_AlchemyBoomEffect;

        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;

        bool animationStep = false;

        AlchemyModel model { get { return ModelCenter.Instance.GetModel<AlchemyModel>(); } }
        PackModel packModel { get { return ModelCenter.Instance.GetModel<PackModel>(); } }
        ReikiRootModel reikiRootModel { get { return ModelCenter.Instance.GetModel<ReikiRootModel>(); } }
        VipModel vipModel { get { return ModelCenter.Instance.GetModel<VipModel>(); } }
        PackModel playerPack { get { return ModelCenter.Instance.GetModel<PackModel>(); } }

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

            if (m_BatchAlchemy != null)
            {
                m_BatchAlchemy.SetListener(BatchAlchemy);
            }
        }

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

            m_State = model.GetStoveState(model.selectAlchemy);

            DisplayAlchemyMaterials();
            DisplayStove();
            DisplayReikiPoint();
            DisplayBatchState();
        }

        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.SetActive(state == 1);
            m_ContainerNormal.SetActive(state == 0);
            m_ContainerComplete.SetActive(state == 2);

            m_AlchemingEffect.StopImediatly();
            m_AlchemyCompleteEffect.StopImediatly();

            m_ContainerMaterials.SetActive(false);
            m_ContainerFlyMaterials.SetActive(false);

            switch (state)
            {
                case 0:
                    m_ContainerMaterials.SetActive(true);
                    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:
                    m_AlchemingEffect.Play();
                    DisplayAlchemyTime();
                    break;
                case 2:
                    if (model.selectAlchemyType == AlchemyType.Normal && PlayerDatas.Instance.baseData.LV < model.autoFunctionGuideLevel &&
                        !FunctionalGuideCenter.Instance.ExistAnyUnderwayGuide())
                    {
                        NewBieCenter.Instance.ResetGuide(131);
                        StartCoroutine(Co_StartGuied(131));
                    }
                    m_AlchemyCompleteEffect.Play();
                    break;
            }

            if (model.selectAlchemyType == AlchemyType.Normal && PlayerDatas.Instance.baseData.LV < model.autoFunctionGuideLevel
                && !FunctionalGuideCenter.Instance.ExistAnyUnderwayGuide()
                && model.alchemyDrugRedpoint3.state == RedPointState.Simple
                && state != 2)
            {
                NewBieCenter.Instance.ResetGuide(132);
                StartCoroutine(Co_StartGuied(132));
            }

            DisplayViewLength();

            DisplayBatchState();

            var grasp = model.IsGraspRecipe(model.selectAlchemy);
            m_ContainerGrasp.SetActive(grasp);
            m_ContainerUnGrasp.SetActive(!grasp);
            if (grasp)
            {
                m_Func.SetActive(state != 1);
                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;
                }
            }
        }

        IEnumerator Co_StartGuied(int guide)
        {
            yield return null;
            FunctionalGuideCenter.Instance.StartGuide(guide);
        }

        void DisplayReikiPoint()
        {
            m_ReikiPoint.text = reikiRootModel.GetReikiRootTotalPointWithFree().ToString();
        }

        void DisplayViewLength()
        {
            var isMax = !RefineStoveConfig.Has(model.stoveLevel + 1);
            m_ViewSlider.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);
            }
        }

        void DisplayAlchemyTime()
        {
            AlchemyTime alchemyTime;
            if (model.TryGetAlchemyStartTime(model.selectAlchemy, out alchemyTime))
            {
                var config = AlchemyConfig.Get(model.selectAlchemy);
                var startTime = TimeUtility.GetTime(alchemyTime.startTick);
                var seconds = (int)(config.NeedTime * alchemyTime.count
                    - (float)(TimeUtility.ServerNow - startTime).TotalSeconds);
                m_AlchemyTime.text = TimeUtility.SecondsToHMS(seconds);
            }
        }

        void DisplayBatchState()
        {
            if (m_BatchAlchemy != null)
            {
                m_BatchAlchemy.SetActive(state == 0);
                if (state == 0)
                {
                    var vipLevel = vipModel.GetPrivilegeVipLv(VipPrivilegeType.BatchAlchemyFairy);
                    var satisfyBatch = true;
                    if (model.selectAlchemyType == AlchemyType.Fairy
                        && PlayerDatas.Instance.baseData.VIPLv < vipLevel)
                    {
                        satisfyBatch = false;
                    }
                    else if (model.selectAlchemyType == AlchemyType.Normal
                        && PlayerDatas.Instance.baseData.LV < model.normalBatchAlchemyLevel)
                    {
                        satisfyBatch = false;
                    }
                    m_BatchAlchemy.SetColorful(m_BatchAlchemyLabel, model.GetCanAlchemyCount(model.selectAlchemy) > 0
                        && satisfyBatch);
                }
            }
        }

        void DisplayAnimation()
        {
            m_ContainerMaterials.SetActive(false);
            m_ContainerFlyMaterials.SetActive(true);
            List<Item> materials;
            model.TryGetAlchemyMaterials(model.selectAlchemy, out materials);
            for (int i = 0; i < m_FlyMaterials.Length; i++)
            {
                m_FlyMaterials[i].SetActive(i < materials.Count);
                if (i < materials.Count)
                {
                    var itemConfig = ItemConfig.Get(materials[i].id);
                    m_FlyIcons[i].SetSprite(itemConfig.IconKey);
                    m_AlchemyFlyEffects[i].Play();
                    var parent = m_AlchemyFlyEffects[i].target.transform.Find("Animation/GuadianAnimation");
                    if (parent != null)
                    {
                        m_FlyMaterials[i].SetParent(parent);
                        m_FlyMaterials[i].transform.localPosition = Vector3.zero;
                    }
                }
                else
                {
                    m_AlchemyFlyEffects[i].StopImediatly();
                }
            }

            StartCoroutine(Co_DisplayAnimation());
        }

        IEnumerator Co_DisplayAnimation()
        {
            m_AlchemyBoomEffect.Play();
            yield return WaitingForSecondConst.WaitMS700;
            m_ContainerFlyMaterials.SetActive(false);
            for (int i = 0; i < m_FlyMaterials.Length; i++)
            {
                m_FlyMaterials[i].SetParent(m_ContainerFlyMaterials);
            }
            animationStep = false;
            m_State = model.GetStoveState(model.selectAlchemy);
            DisplayStove();
        }

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

        private void AlchemyStateRefresh()
        {
            animationStep = false;

            if (model.isServerPrepare)
            {
                var newState = model.GetStoveState(model.selectAlchemy);
                if (newState == 1 && state == 0)
                {
                    animationStep = true;
                }
            }
            if (!animationStep)
            {
                m_State = model.GetStoveState(model.selectAlchemy);
                DisplayStove();
                DisplayAlchemyMaterials();
            }

            if (animationStep)
            {
                DisplayAnimation();
            }
        }

        private void PlayerDataRefreshEvent(PlayerDataType dataType)
        {
            if (dataType == PlayerDataType.FreePoint)
            {
                DisplayReikiPoint();
            }
            else if (dataType == PlayerDataType.VIPLv
                || dataType == PlayerDataType.LV)
            {
                DisplayBatchState();
            }
        }

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

            if (state == 1)
            {
                AlchemyTime alchemyTime;
                if (model.TryGetAlchemyStartTime(model.selectAlchemy, out alchemyTime))
                {
                    var config = AlchemyConfig.Get(model.selectAlchemy);
                    var startTime = TimeUtility.GetTime(alchemyTime.startTick);
                    var seconds = config.NeedTime * alchemyTime.count
                        - (float)(TimeUtility.ServerNow - startTime).TotalSeconds;
                    m_TimeSlider.value = Mathf.Clamp01(seconds / (config.NeedTime * alchemyTime.count));
                }
            }
        }

        private void PerSecond()
        {
            if (animationStep)
            {
                return;
            }

            var _state = model.GetStoveState(model.selectAlchemy);

            if (_state == state)
            {
                if (state == 1)
                {
                    DisplayAlchemyTime();
                }
            }
            else
            {
                state = _state;
            }
        }
        
        private void BatchAlchemy()
        {
            int alchemyId;
            if (model.IsStoveAlcheming(model.selectAlchemyType, out alchemyId))
            {
                SysNotifyMgr.Instance.ShowTip("AlchemingError");
                return;
            }
            if (model.selectAlchemyType == AlchemyType.Fairy)
            {
                var vipLevel = vipModel.GetPrivilegeVipLv(VipPrivilegeType.BatchAlchemyFairy);
                if (PlayerDatas.Instance.baseData.VIPLv < vipLevel)
                {
                    SysNotifyMgr.Instance.ShowTip("BatchAlchemyError_Vip");
                    return;
                }
            }
            if (model.selectAlchemyType == AlchemyType.Normal)
            {
                if (PlayerDatas.Instance.baseData.LV < model.normalBatchAlchemyLevel)
                {
                    SysNotifyMgr.Instance.ShowTip("BatchAlchemyError_Level", model.normalBatchAlchemyLevel);
                    return;
                }
            }
            Item item;
            if (!model.IsAlchemyEnoughMaterial(model.selectAlchemy, out item))
            {
                SysNotifyMgr.Instance.ShowTip("BatchAlchemyError");
                return;
            }
            List<Item> materials;
            if (model.TryGetAlchemyMaterials(model.selectAlchemy, out materials))
            {
                for (int i = 0; i < materials.Count; i++)
                {
                    var mat = materials[i];
                    var count = packModel.GetItemCountByID(PackType.Item, mat.id);
                    if (model.selectAlchemyType == AlchemyType.Normal)
                        LimitedTimeLuxuryGiftModel.Instance.IsItemIdShow(21, mat.id, mat.count, 1, 0);
                    if (model.selectAlchemyType == AlchemyType.Fairy)
                        LimitedTimeLuxuryGiftModel.Instance.IsItemIdShow(22, mat.id, mat.count, 1, 0);
                }
            }
            AlchemyBatchWin.alchemyId = model.selectAlchemy;
            WindowCenter.Instance.Open<AlchemyBatchWin>();
        }
        
        private void OnFunc()
        {
            switch (state)
            {
                case 0:
                    int alchemyId;
                    if (model.IsStoveAlcheming(model.selectAlchemyType, out alchemyId))
                    {
                        SysNotifyMgr.Instance.ShowTip("AlchemingError");
                        return;
                    }
                    Item item;
                    if (!model.IsAlchemyEnoughMaterial(model.selectAlchemy, out item))
                    {
                        ItemTipUtility.Show(item.id);
                        return;
                    }
                    if (model.selectAlchemyType == AlchemyType.Normal)
                    {
                        AlchemyDrugUseLimit drugUseLimit;
                        var itemId = AlchemyConfig.Get(model.selectAlchemy).AlchemItemID;
                        var itemCount = playerPack.GetItemCountByID(PackType.Item, itemId);
                        if (model.TryGetAlchemyUseLimit(itemId, out drugUseLimit))
                        {
                            var canEatCount = drugUseLimit.GetUseLimit() - drugUseLimit.eatTimes - itemCount;
                            if (canEatCount < 1)
                            {
                                string title = Language.Get("L1003");
                                string info = Language.Get("MaximumMumberOfPills");
                                ConfirmCancel.ShowPopConfirm(title, info, (bool isOk) =>
                                {
                                    if (isOk)
                                    {
                                        SendAlchemyPackage();
                                    }
                                });
                                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;
            }
            Item item1;
            List<Item> materials;
            if (model.TryGetAlchemyMaterials(model.selectAlchemy, out materials))
            {
                for (int i = 0; i < materials.Count; i++)
                {
                    var mat = materials[i];
                    var count = packModel.GetItemCountByID(PackType.Item, mat.id);
                    if (model.selectAlchemyType == AlchemyType.Normal)
                        LimitedTimeLuxuryGiftModel.Instance.IsItemIdShow(21, mat.id, mat.count, 1, 0);
                    if (model.selectAlchemyType == AlchemyType.Fairy)
                        LimitedTimeLuxuryGiftModel.Instance.IsItemIdShow(22, mat.id, mat.count, 1, 0);
                }
            }
            SendAlchemyPackage();
        }

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

                    if (FunctionalGuideCenter.Instance.ExistUnderwayGuide(131))
                    {
                        FunctionalGuideCenter.Instance.RemoveGuide(131);
                    }
                    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();
                        DisplayBatchState();
                    }
                }
            }
        }

        private void OnReikiRootPointRefresh()
        {
            DisplayReikiPoint();
        }

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

            StopAllCoroutines();
            animationStep = false;
        }
    }

    [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.SetActive(_lock);
            m_ContainerItem.SetActive(!_lock);
        }
    }
}