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

using UnityEngine;
using UnityEngine.UI;

namespace vnxbqy.UI
{
    
    public class FestivalRedpackBehaviour : MonoBehaviour
    {
        [SerializeField] Transform m_NormalBottom;
        [SerializeField] Transform m_BigBottom;
        [SerializeField] Text m_RedpackName;
        [SerializeField] Text m_Wish;
        [SerializeField] Transform m_ContainerPreview;
        [SerializeField] Text m_Time;
        [SerializeField] Transform m_ContainerOpen;
        [SerializeField] Button m_Open;
        [SerializeField] Transform m_ContainerGot;
        [SerializeField] Transform m_ContainerEnd;
        [SerializeField] Transform m_ContainerOverdue;
        [SerializeField] UIEffect m_Effect;

        int redpackId = 0;
        int redpackServerId = 0;

        FestivalRedpackModel model { get { return ModelCenter.Instance.GetModel<FestivalRedpackModel>(); } }

        RedEnvelopeModel envelopeModel { get { return ModelCenter.Instance.GetModel<RedEnvelopeModel>(); } }

        private void Awake()
        {
            m_Open.onClick.AddListener(Open);
        }

        public void DisplaySystemRedpack(int id)
        {
            redpackId = id;
            var existServerRedpack = model.IsExistSystemRedpack(id, out redpackServerId);
            var overdue = model.IsSystemRedpackOverdue(id);
            m_ContainerPreview.SetActive(!existServerRedpack);
            m_ContainerOpen.SetActive(false);
            m_ContainerGot.SetActive(false);
            m_ContainerEnd.SetActive(false);
            m_ContainerOverdue.SetActive(false);


            m_Effect.StopImediatly();
            var config = RedPackConfig.Get(id);
            if (config != null)
            {
                m_RedpackName.text = config.content;

                bool requireEffect = false;
                if (config.RedEnvelopeType == FestivalRedpackModel.FESTIVALSYSTEMREDPACK1)
                {
                    requireEffect = true;
                }

                if (requireEffect)
                {
                    m_Effect.Play();
                }

                m_NormalBottom.SetActive(config.RedEnvelopeType != FestivalRedpackModel.FESTIVALSYSTEMREDPACK1);
                m_BigBottom.SetActive(config.RedEnvelopeType == FestivalRedpackModel.FESTIVALSYSTEMREDPACK1);
            }

            FestivalRedpack festivalRedpack;
            if (model.TryGetRedpack(id, out festivalRedpack))
            {
                m_Time.text = StringUtility.Contact(festivalRedpack.openTime.ToString("HH:mm"), Language.Get("FestivalOpenGrab"));
            }

            if (existServerRedpack)
            {
                DisplayBase(redpackServerId);
            }
            else
            {
                redpackServerId = 0;
                m_ContainerOverdue.SetActive(overdue);
                m_ContainerPreview.SetActive(!overdue);
            }
        }

        void DisplayBase(int id)
        {
            redpackServerId = id;
            RedEnvelopeModel.RedEnvelope envelope;
            if (envelopeModel.TryGetEnvelope(redpackServerId, out envelope))
            {
                var overdue = model.IsSystemRedpackOverdue(redpackId);
                m_ContainerOverdue.SetActive(overdue && envelope.state == 1);
                m_ContainerOpen.SetActive(envelope.state == 1 && !overdue);
                m_ContainerGot.SetActive(envelope.state == 2);
                m_ContainerEnd.SetActive(envelope.state == 3);
            }
        }

        private void Open()
        {
            if (model.IsSystemRedpackOverdue(redpackId))
            {
                SysNotifyMgr.Instance.ShowTip("FestivalSystemOpenOverude");
                return;
            }
            if (redpackServerId == 0)
            {
                SysNotifyMgr.Instance.ShowTip("FestivalSystemOpenError");
            }
            else
            {
                RedEnvelopeModel.RedEnvelope envelope;
                if (envelopeModel.TryGetEnvelope(redpackServerId, out envelope))
                {
                    switch (envelope.state)
                    {
                        case 1:
                            RedpackSystemOpenWin.redpackId = redpackId;
                            RedpackSystemOpenWin.redpackServerId = redpackServerId;
                            WindowCenter.Instance.Open<RedpackSystemOpenWin>();
                            break;
                        case 2:
                        case 3:
                            envelopeModel.SendOpenRedpackPackage(redpackServerId, envelope.type);
                            break;
                    }
                }
            }
        }

    }
}