using System;
using System.Collections;
using System.Collections.Generic;
using System.Linq;
using UnityEngine;
using UnityEngine.UI;
#if UNITY_EDITOR
using UnityEditor;
using UnityEditorInternal;
#endif
namespace Snxxz.UI
{
    [XLua.Hotfix]
    public class OpenServerActivityWin : Window
    {
        [SerializeField] ScrollerController m_ActivityCtrl;
        [SerializeField] Button m_BtnClose;
        [SerializeField, HideInInspector] List<CustomActivityDisplay> m_CustomActivitys;

        Dictionary<int, bool> m_ActivitySpreadDict = new Dictionary<int, bool>();

        ImpactRankModel m_ImpactRankModel;
        ImpactRankModel impactRankModel
        {
            get
            {
                return m_ImpactRankModel ?? (m_ImpactRankModel = ModelCenter.Instance.GetModel<ImpactRankModel>());
            }
        }

        OSRedEnvelopeModel m_OSRedEnvelopeModel;
        OSRedEnvelopeModel envelopeModel
        {
            get
            {
                return m_OSRedEnvelopeModel ?? (m_OSRedEnvelopeModel = ModelCenter.Instance.GetModel<OSRedEnvelopeModel>());
            }
        }
        FairyLeagueModel fairyLeagueModel { get { return ModelCenter.Instance.GetModel<FairyLeagueModel>(); } }
        FairyGrabBossModel fairyGrabBossModel { get { return ModelCenter.Instance.GetModel<FairyGrabBossModel>(); } }
        OSGiftModel giftModel { get { return ModelCenter.Instance.GetModel<OSGiftModel>(); } }
        FestivalRedpackModel festivalRedpackModel { get { return ModelCenter.Instance.GetModel<FestivalRedpackModel>(); } }

        List<int> openActivitys = new List<int>();
        List<int> priorityActivitys = new List<int>();
        List<int> alreadyOpenActivitys = new List<int>();

        public static event Func<bool> tryCloseEvent;

        protected override void BindController()
        {

        }

        protected override void AddListeners()
        {
            m_ActivityCtrl.OnRefreshCell += OnOpenServerActivityRefresh;
            m_ActivityCtrl.OnGetDynamicSize += OnGetDynamicSize;
            m_ActivityCtrl.lockType = EnhanceLockType.KeepVertical;
            m_BtnClose.onClick.AddListener(TryClose);
        }

        protected override void OnPreOpen()
        {
            TimeUtility.OnServerOpenDayRefresh += OnStepServerDayEvent;
            OperationTimeHepler.Instance.operationTimeUpdateEvent += OperationTimeUpdateEvent;
            OpenServerActivityCenter.Instance.openServerActivityStateChange += OpenServerActivityStateChange;
            for (int i = 0; i < m_CustomActivitys.Count; i++)
            {
                m_ActivitySpreadDict[(int)m_CustomActivitys[i].activityType] = false;
            }
            var impactDefaultType = impactRankModel.GetDefaultSelectType();
            if (impactRankModel.IsLock(impactDefaultType))
            {
                impactDefaultType = impactRankModel.impactRankSorts[0];
            }
            impactRankModel.presentSelectType = impactDefaultType;
            impactRankModel.gotoImpactRankType = 0;
            envelopeModel.selectType = 1;
            festivalRedpackModel.selectType = 1;
            giftModel.SetAreadyOpens();
            GlobalTimeEvent.Instance.secondEvent += SecondEvent;
            CheckAlreadyOpen();
            UpdateFunctionBtns();
        }

        protected override void OnActived()
        {
            bool force = false;
            if (OpenServerActivityCenter.Instance.selectFuncOrder != -1 && !WindowJumpMgr.Instance.IsJumpState)
            {
                functionOrder = OpenServerActivityCenter.Instance.selectFuncOrder;
                force = true;
            }
            OpenServerActivityCenter.Instance.selectFuncOrder = -1;
            if (alreadyOpenActivitys.Count == 0)
            {
                CloseImmediately();
                return;
            }
            if (functionOrder == 0 && !WindowJumpMgr.Instance.IsJumpState && !force)
            {
                functionOrder = GetDefaultSelect();
                //for (int i = 0; i < m_SortArray.Count; i++)
                //{
                //    m_ActivitySpreadDict[m_SortArray[i]] = m_SortArray[i] == functionOrder;
                //}
                UpdateFunctionBtns();
            }
            else
            {
                if (!alreadyOpenActivitys.Contains(functionOrder))
                {
                    functionOrder = GetDefaultSelect();
                }
                //for (int i = 0; i < m_SortArray.Count; i++)
                //{
                //    m_ActivitySpreadDict[m_SortArray[i]] = m_SortArray[i] == functionOrder;
                //}
                if (functionOrder == 2)
                {
                    envelopeModel.selectType = envelopeModel.JumpType != 0 ? envelopeModel.JumpType : 1;
                    envelopeModel.JumpType = 0;
                }
                if (functionOrder == 6)
                {
                    giftModel.selectIndex = giftModel.GetDefaultSelect();
                }
                if (functionOrder == 19)
                {
                    festivalRedpackModel.selectType = festivalRedpackModel.jumpType != 0 ? festivalRedpackModel.jumpType : 1;
                    festivalRedpackModel.jumpType = 0;
                }
                UpdateFunctionBtns();
            }
            OnOpenActivity(functionOrder);

            var index = alreadyOpenActivitys.IndexOf(functionOrder);
            if (alreadyOpenActivitys.Contains(6))
            {
                if (index > alreadyOpenActivitys.IndexOf(6))
                {
                    index = index + giftModel.alreadyOpens.Count - 1;
                }
                else if (index == alreadyOpenActivitys.IndexOf(6))
                {
                    index = index + giftModel.selectIndex;
                }
            }
            m_ActivityCtrl.JumpIndex(index);
        }

        protected override void OnAfterOpen()
        {
            impactRankModel.OSCEffectOpen = false;
        }

        protected override void OnPreClose()
        {
            TimeUtility.OnServerOpenDayRefresh -= OnStepServerDayEvent;
            OperationTimeHepler.Instance.operationTimeUpdateEvent -= OperationTimeUpdateEvent;
            OpenServerActivityCenter.Instance.openServerActivityStateChange -= OpenServerActivityStateChange;
            GlobalTimeEvent.Instance.secondEvent -= SecondEvent;
            CloseOtherWin();
            impactRankModel.gotoImpactRankType = 0;
        }

        protected override void OnAfterClose()
        {
            if (!WindowJumpMgr.Instance.IsJumpState)
            {
                WindowCenter.Instance.Open<MainInterfaceWin>();
            }
        }

        private void TryClose()
        {
            switch ((OpenServerActivityCenter.OSActivityType)functionOrder)
            {
                case OpenServerActivityCenter.OSActivityType.MysticalPurchase:
                    if (tryCloseEvent != null)
                    {
                        if (!tryCloseEvent())
                        {
                            return;
                        }
                    }
                    break;
            }
            CloseClick();
        }

        int GetDefaultSelect()
        {
            openActivitys.Clear();
            priorityActivitys.Clear();

            for (int i = 0; i < m_CustomActivitys.Count; i++)
            {
                if (OpenServerActivityCenter.Instance.IsActivityOpen((int)m_CustomActivitys[i].activityType))
                {
                    openActivitys.Add((int)m_CustomActivitys[i].activityType);
                    if (OpenServerActivityCenter.Instance.IsPriorityOpenOpen((int)m_CustomActivitys[i].activityType))
                    {
                        priorityActivitys.Add((int)m_CustomActivitys[i].activityType);

                        switch (m_CustomActivitys[i].activityType)
                        {
                            case OpenServerActivityCenter.OSActivityType.OSRedpack:
                                envelopeModel.selectType = envelopeModel.m_RedAchieveRedpoint.state == RedPointState.Simple ? 1 : 2;
                                break;
                            case OpenServerActivityCenter.OSActivityType.OSGift:
                                giftModel.selectIndex = giftModel.GetDefaultSelect();
                                break;
                            case OpenServerActivityCenter.OSActivityType.FestivalRedpack:
                                if (festivalRedpackModel.systemRedpoint.state == RedPointState.Simple)
                                {
                                    festivalRedpackModel.selectType = 1;
                                    break;
                                }
                                else if (festivalRedpackModel.taskRedpoint.state == RedPointState.Simple)
                                {
                                    festivalRedpackModel.selectType = 2;
                                    break;
                                }
                                else if (festivalRedpackModel.receiveRedpoint.state == RedPointState.Simple)
                                {
                                    festivalRedpackModel.selectType = 3;
                                    break;
                                }
                                festivalRedpackModel.selectType = 1;
                                break;
                        }
                    }
                }
            }
            if (priorityActivitys.Count > 0)
            {
                priorityActivitys.Sort(Compare);
                return priorityActivitys[0];
            }
            else
            {
                openActivitys.Sort(Compare);
                return openActivitys[0];
            }
        }

        private void SecondEvent()
        {
            var cell = m_ActivityCtrl.GetActiveCellView((int)OpenServerActivityCenter.OSActivityType.FairyLeagueNotice);
            if (cell != null)
            {
                var activityCell = cell as OpenServerActivityCell;
                var seconds = fairyLeagueModel.GetBeforeFirstLeagueTime();
                activityCell.timer.text = TimeUtility.SecondsToHMS(seconds);
                activityCell.containerTimer.gameObject.SetActive(seconds > 0);
            }
            cell = m_ActivityCtrl.GetActiveCellView((int)OpenServerActivityCenter.OSActivityType.FairyGrabBossNotice);
            if (cell != null)
            {
                var activityCell = cell as OpenServerActivityCell;
                var seconds = fairyGrabBossModel.GetNextSessionSeconds();
                bool isOpen = fairyGrabBossModel.IsOpen;
                activityCell.containerTimer.gameObject.SetActive(seconds > 0 || isOpen);
                if (seconds > 0)
                {
                    activityCell.timer.text = TimeUtility.SecondsToHMS(seconds);
                }
                else if (isOpen)
                {
                    activityCell.timer.text = Language.Get("FairyGrabBossOpened");
                }
            }
        }

        void CheckAlreadyOpen()
        {
            alreadyOpenActivitys.Clear();
            for (int i = 0; i < m_CustomActivitys.Count; i++)
            {
                if (OpenServerActivityCenter.Instance.IsActivityOpen((int)m_CustomActivitys[i].activityType))
                {
                    alreadyOpenActivitys.Add((int)m_CustomActivitys[i].activityType);
                }
            }
        }

        private void OnOpenServerActivityRefresh(ScrollerDataType type, CellView cell)
        {
            switch (type)
            {
                case ScrollerDataType.Header:
                    RefreshOpenActivityCell(cell as OpenServerActivityCell);
                    break;
                case ScrollerDataType.Normal:
                    RefreshActivityTypeCell(cell as OpenActivityRankTypeCell);
                    break;
            }
        }

        private bool OnGetDynamicSize(ScrollerDataType type, int index, out float height)
        {
            height = 74;
            var sort = index;
            if (type == ScrollerDataType.Header)
            {
                if (!m_ActivitySpreadDict.ContainsKey(sort) || !m_ActivitySpreadDict[sort]
                    || (sort != 2 && sort != 0 && sort != 19))
                {
                    height = 114;
                    return true;
                }
            }
            return false;
        }

        private void RefreshOpenActivityCell(OpenServerActivityCell _cell)
        {
            var activityType = 0;
            activityType = _cell.index >= 1000 ? _cell.index / 1000 : _cell.index;
            var extraValue = _cell.index % 1000;

            var customActivity = m_CustomActivitys.Find((x) =>
            {
                return (int)x.activityType == activityType;
            });

            switch (activityType)
            {
                case 12:
                    {
                        var seconds = fairyLeagueModel.GetBeforeFirstLeagueTime();
                        _cell.containerTimer.gameObject.SetActive(seconds > 0);
                        if (seconds > 0)
                        {
                            _cell.timer.text = TimeUtility.SecondsToHMS(seconds);
                        }
                    }
                    break;
                case 13:
                    {
                        var seconds = fairyGrabBossModel.GetNextSessionSeconds();
                        bool isOpen = fairyGrabBossModel.IsOpen;
                        _cell.containerTimer.gameObject.SetActive(seconds > 0 || isOpen);
                        if (seconds > 0)
                        {
                            _cell.timer.text = TimeUtility.SecondsToHMS(seconds);
                        }
                        else if (isOpen)
                        {
                            _cell.timer.text = Language.Get("FairyGrabBossOpened");
                        }
                    }
                    break;
                default:
                    _cell.containerTimer.gameObject.SetActive(false);
                    break;
            }

            _cell.activityType = activityType;

            switch (activityType)
            {
                case 6:
                    _cell.redpoint.redpointId = 20906 * 100 + extraValue;
                    _cell.SetSelect(extraValue == giftModel.selectIndex && functionOrder == activityType);
                    _cell.icon.SetSprite(StringUtility.Contact(customActivity.bottomIcon, extraValue));
                    break;
                default:
                    _cell.redpoint.redpointId = MainRedDot.REDPOINT_OPENSERVER * 100 + activityType;
                    _cell.SetSelect(_cell.activityType == functionOrder);
                    _cell.icon.SetSprite(customActivity.bottomIcon);
                    break;
            }

            _cell.downArrow.gameObject.SetActive(false);
            _cell.upArrow.gameObject.SetActive(false);

            if (_cell.activityType == 0 || _cell.activityType == 2 || _cell.activityType == 19)
            {
                _cell.downArrow.gameObject.SetActive(m_ActivitySpreadDict[_cell.activityType]);
                _cell.upArrow.gameObject.SetActive(!m_ActivitySpreadDict[_cell.activityType]);
            }

            _cell.funcBtn.onClick.RemoveAllListeners();
            _cell.funcBtn.onClick.AddListener(() =>
            {
                OnActivityClick(_cell.activityType, extraValue);
            });
        }

        private void OnStepServerDayEvent()
        {
            //m_ActivityCtrl.m_Scorller.RefreshActiveCellViews();
            UpdateFunctionBtns();
        }

        private void RefreshActivityTypeCell(OpenActivityRankTypeCell _cell)
        {
            int _order = _cell.index / 100;
            int _type = _cell.index % 100;
            switch (_order)
            {
                case 0:
                    _cell.redpoint.redpointId = ImpactRankModel.Redpoint_Key_ImpactRank * 100 + _type;
                    _cell.titleTxt.text = Language.Get(StringUtility.Contact("ImpactRankType_", _type));
                    _cell.SetSelect(_type == impactRankModel.presentSelectType);
                    break;
                case 2:
                    _cell.redpoint.redpointId = 20902 * 100 + _type;
                    _cell.titleTxt.text = Language.Get(StringUtility.Contact("OSRedEnvelopeType_", _type));
                    _cell.SetSelect(_type == envelopeModel.selectType);
                    break;
                case 19:
                    _cell.redpoint.redpointId = 20919 * 100 + _type;
                    _cell.titleTxt.text = Language.Get(StringUtility.Contact("FestivalRedpackType_", _type));
                    _cell.SetSelect(_type == festivalRedpackModel.selectType);
                    break;
            }
            _cell.functionBtn.onClick.RemoveAllListeners();
            _cell.functionBtn.onClick.AddListener(() =>
            {
                OnActivityType(_cell.index);
            });
        }

        private void UpdateFunctionBtns()
        {
            m_ActivityCtrl.Refresh();
            for (int i = 0; i < m_CustomActivitys.Count; i++)
            {
                var sort = (int)m_CustomActivitys[i].activityType;
                if (!alreadyOpenActivitys.Contains(sort))
                {
                    continue;
                }
                switch (sort)
                {
                    case 0:
                        m_ActivityCtrl.AddCell(ScrollerDataType.Header, sort);
                        if (functionOrder != sort)
                        {
                            m_ActivitySpreadDict[sort] = false;
                            break;
                        }
                        if (!m_ActivitySpreadDict[sort])
                        {
                            break;
                        }
                        foreach (var _type in impactRankModel.impactRankSorts)
                        {
                            if (impactRankModel.IsLock(_type))
                            {
                                continue;
                            }
                            m_ActivityCtrl.AddCell(ScrollerDataType.Normal, sort * 100 + _type);
                        }
                        break;
                    case 2:
                        m_ActivityCtrl.AddCell(ScrollerDataType.Header, sort);
                        if (!m_ActivitySpreadDict[sort])
                        {
                            m_ActivitySpreadDict[sort] = false;
                            break;
                        }
                        m_ActivityCtrl.AddCell(ScrollerDataType.Normal, sort * 100 + 1);
                        m_ActivityCtrl.AddCell(ScrollerDataType.Normal, sort * 100 + 2);
                        break;
                    case 6:
                        for (int k = 0; k < giftModel.alreadyOpens.Count; k++)
                        {
                            m_ActivityCtrl.AddCell(ScrollerDataType.Header, sort * 1000 + giftModel.alreadyOpens[k]);
                        }
                        break;
                    case 19:
                        m_ActivityCtrl.AddCell(ScrollerDataType.Header, sort);
                        if (!m_ActivitySpreadDict[sort])
                        {
                            m_ActivitySpreadDict[sort] = false;
                            break;
                        }
                        m_ActivityCtrl.AddCell(ScrollerDataType.Normal, sort * 100 + 1);
                        m_ActivityCtrl.AddCell(ScrollerDataType.Normal, sort * 100 + 2);
                        m_ActivityCtrl.AddCell(ScrollerDataType.Normal, sort * 100 + 3);
                        break;
                    default:
                        m_ActivityCtrl.AddCell(ScrollerDataType.Header, sort);
                        break;
                }
            }
            m_ActivityCtrl.Restart();
            m_ActivityCtrl.m_Scorller.RefreshActiveCellViews();
        }

        private void OnActivityClick(int _order, int extra = 0)
        {
            if (functionOrder == _order && _order != 6)
            {
                m_ActivitySpreadDict[_order] = !m_ActivitySpreadDict[_order];
                UpdateFunctionBtns();
                return;
            }
            else
            {
                m_ActivitySpreadDict[functionOrder] = false;
                m_ActivitySpreadDict[_order] = true;
            }

            if (functionOrder != _order)
            {
                functionOrder = _order;
                OnOpenActivity(functionOrder);
            }

            switch (functionOrder)
            {
                case 6:
                    giftModel.selectIndex = extra;
                    break;
            }

            UpdateFunctionBtns();
        }

        private void OnOpenActivity(int _order)
        {
            CloseOtherWin();
            switch (_order)
            {
                case 0:
                    WindowCenter.Instance.Open<ImpactRankWin>(true);
                    break;
                case 1:
                    WindowCenter.Instance.Open<ConsumeRebateWin>(true);
                    break;
                case 2:
                    WindowCenter.Instance.Open<OpenServerRedEnvelopeWin>(true);
                    break;
                case 3:
                    WindowCenter.Instance.Open<OSTimeLimitGiftWin>(true);
                    break;
                case 4:
                    WindowCenter.Instance.Open<FlashSaleWin>(true);
                    break;
                case 5:
                    WindowCenter.Instance.Open<MultipleExpWin>(true);
                    break;
                case 6:
                    WindowCenter.Instance.Open<OpenServerGiftWin>(true);
                    break;
                case 7:
                    WindowCenter.Instance.Open<LimitedTimePackageWin>(true);
                    break;
                case 8:
                    WindowCenter.Instance.Open<NPracticePointWin>(true);
                    break;
                case 9:
                    WindowCenter.Instance.Open<BossRebornWin>(true);
                    break;
                case 10:
                    WindowCenter.Instance.Open<FairyJadeInvestmentWin>(true);
                    break;
                case 11:
                    WindowCenter.Instance.Open<VipInvestWin>(true);
                    break;
                case 12:
                    WindowCenter.Instance.Open<FairyLeagueNoticeWin>(true);
                    break;
                case 13:
                    WindowCenter.Instance.Open<FairyGrabBossNoticeWin>(true);
                    break;
                case 14:
                    WindowCenter.Instance.Open<FlashRushToBuyWin>(true);
                    break;
                case 15:
                    WindowCenter.Instance.Open<WishingPoolWin>(true);
                    break;
                case 16:
                    WindowCenter.Instance.Open<WheelOfFortuneWin>(true);
                    break;
                case 17:
                    WindowCenter.Instance.Open<AccumulateRechargeWin>(true);
                    break;
                case 18:
                    WindowCenter.Instance.Open<MysticalPurchaseWin>(true);
                    break;
                case 19:
                    WindowCenter.Instance.Open<FestivalRedpackWin>(true);
                    break;
                case 20:
                    WindowCenter.Instance.Open<LuckyTreasureWin>(true);
                    break;
                case 21:
                    WindowCenter.Instance.Open<LoginRewardWin>(true);
                    break;
            }
        }

        private void OnActivityType(int _index)
        {
            var _order = _index / 100;
            var _type = _index % 100;
            switch (_order)
            {
                case 0:
                    impactRankModel.presentSelectType = _type;
                    break;
                case 2:
                    envelopeModel.selectType = _type;
                    break;
                case 19:
                    festivalRedpackModel.selectType = _type;
                    break;
            }
            m_ActivityCtrl.m_Scorller.RefreshActiveCellViews();
        }

        private void CloseOtherWin()
        {
            var children = WindowConfig.Get().FindChildWindows("OpenServerActivityWin");
            foreach (var window in children)
            {
                WindowCenter.Instance.Close(window);
            }
        }

        private int Compare(int order_x, int order_y)
        {
            var index_x = m_CustomActivitys.FindIndex((x) =>
            {
                return order_x == (int)x.activityType;
            });
            var index_y = m_CustomActivitys.FindIndex((x) =>
            {
                return order_y == (int)x.activityType;
            });
            return index_x.CompareTo(index_y);
        }

        private void OperationTimeUpdateEvent(Operation type)
        {
            if (type == Operation.MultipleExp || type == Operation.MultipRealmPoint)
            {
                m_ActivityCtrl.m_Scorller.RefreshActiveCellViews();
            }
        }

        private void OpenServerActivityStateChange()
        {
            bool _update = false;
            for (int i = 0; i < m_CustomActivitys.Count; i++)
            {
                if (OpenServerActivityCenter.Instance.IsActivityOpen((int)m_CustomActivitys[i].activityType)
                    && !alreadyOpenActivitys.Contains((int)m_CustomActivitys[i].activityType))
                {
                    alreadyOpenActivitys.Add((int)m_CustomActivitys[i].activityType);
                    _update = true;
                }
            }
            if (_update)
            {
                UpdateFunctionBtns();
            }
        }

        [Serializable]
        public struct CustomActivityDisplay
        {
            public OpenServerActivityCenter.OSActivityType activityType;
            public string bottomIcon;
        }
    }

#if UNITY_EDITOR
    [CustomEditor(typeof(OpenServerActivityWin))]
    public class OpenServerActivityInspector : Editor
    {
        ReorderableList reorderableList;
        private void OnEnable()
        {
            var prop = serializedObject.FindProperty("m_CustomActivitys");
            reorderableList = new ReorderableList(serializedObject, prop, true, true, true, true);

            reorderableList.elementHeight = 50;

            reorderableList.drawElementCallback =
                (rect, index, isActive, isFocused) =>
                {
                    var element = prop.GetArrayElementAtIndex(index);
                    rect.height -= 4;
                    rect.y += 2;
                    EditorGUI.PropertyField(rect, element);
                };

            reorderableList.drawHeaderCallback = (rect) =>
                EditorGUI.LabelField(rect, prop.displayName);
        }

        public override void OnInspectorGUI()
        {
            base.OnInspectorGUI();
            serializedObject.Update();
            reorderableList.DoLayoutList();
            serializedObject.ApplyModifiedProperties();
        }
    }

    [CustomPropertyDrawer(typeof(OpenServerActivityWin.CustomActivityDisplay))]
    public class CustomActivityDrawer : PropertyDrawer
    {
        static string[] enumDisplayNames = null;

        public override void OnGUI(Rect position, SerializedProperty property, GUIContent label)
        {
            using (new EditorGUI.PropertyScope(position, label, property))
            {
                var rect = new Rect(position)
                {
                    height = 20,
                };

                var serializedProperty = property.FindPropertyRelative("activityType");
                if (enumDisplayNames == null ||
                enumDisplayNames.Length != serializedProperty.enumNames.Length)
                {
                    enumDisplayNames = new string[serializedProperty.enumNames.Length];
                    var enumtype = typeof(OpenServerActivityCenter.OSActivityType);
                    var index = 0;
                    foreach (var enumName in serializedProperty.enumNames)
                    {
                        var enumfield = enumtype.GetField(enumName);
                        var customAttributes = enumfield.GetCustomAttributes(typeof(HeaderAttribute), false);
                        enumDisplayNames[index] = customAttributes.Length <= 0 ? enumName : ((HeaderAttribute)customAttributes[0]).header;
                        index++;
                    }
                }

                serializedProperty.enumValueIndex = EditorGUI.Popup(rect, serializedProperty.enumValueIndex, enumDisplayNames);

                rect = new Rect(position)
                {
                    y = position.y + 20,
                    height = 20,
                };

                serializedProperty = property.FindPropertyRelative("bottomIcon");
                serializedProperty.stringValue = EditorGUI.TextField(rect, "IconKey", serializedProperty.stringValue);
            }
        }
    }

#endif
}