#nullable enable
using UnityEngine.UIElements;

namespace UVC.UIToolkit
{
    /// <summary>
    /// 정수 범위 속성 아이템
    /// Min, Max 두 개의 IntegerField
    /// </summary>
    public class UTKIntRangePropertyItem : UTKPropertyItemBase<UTKIntRange>
    {
        #region Fields
        private IntegerField? _minField;
        private IntegerField? _maxField;
        #endregion

        #region Properties
        public override UTKPropertyType PropertyType => UTKPropertyType.IntRange;
        #endregion

        #region Constructor
        public UTKIntRangePropertyItem(string id, string name, UTKIntRange initialValue = default)
            : base(id, name, initialValue)
        {
        }

        public UTKIntRangePropertyItem(string id, string name, int min, int max)
            : base(id, name, new UTKIntRange(min, max))
        {
        }
        #endregion

        #region Override Methods
        public override VisualElement CreateUI()
        {
            var container = CreateContainer();

            var label = CreateNameLabel();
            container.Add(label);

            var valueContainer = new VisualElement();
            valueContainer.AddToClassList("utk-property-item__value");
            valueContainer.style.flexDirection = FlexDirection.Row;

            _minField = new IntegerField();
            _minField.name = "min-field";
            _minField.value = Value.Min;
            _minField.style.flexGrow = 1;
            valueContainer.Add(_minField);

            var separator = new Label("~");
            separator.AddToClassList("utk-property-item__range-separator");
            valueContainer.Add(separator);

            _maxField = new IntegerField();
            _maxField.name = "max-field";
            _maxField.value = Value.Max;
            _maxField.style.flexGrow = 1;
            valueContainer.Add(_maxField);

            container.Add(valueContainer);

            return container;
        }

        public override void BindUI(VisualElement element)
        {
            base.BindUI(element);

            _minField = element.Q<IntegerField>("min-field");
            _maxField = element.Q<IntegerField>("max-field");

            if (_minField != null)
            {
                _minField.value = Value.Min;
                _minField.SetEnabled(!IsReadOnly);
                _minField.RegisterValueChangedCallback(OnMinChanged);
            }

            if (_maxField != null)
            {
                _maxField.value = Value.Max;
                _maxField.SetEnabled(!IsReadOnly);
                _maxField.RegisterValueChangedCallback(OnMaxChanged);
            }
        }

        public override void UnbindUI(VisualElement element)
        {
            if (_minField != null)
            {
                _minField.UnregisterValueChangedCallback(OnMinChanged);
                _minField = null;
            }

            if (_maxField != null)
            {
                _maxField.UnregisterValueChangedCallback(OnMaxChanged);
                _maxField = null;
            }

            base.UnbindUI(element);
        }

        public override void RefreshUI()
        {
            if (_minField != null && _minField.value != Value.Min)
            {
                _minField.SetValueWithoutNotify(Value.Min);
            }

            if (_maxField != null && _maxField.value != Value.Max)
            {
                _maxField.SetValueWithoutNotify(Value.Max);
            }
        }

        protected override void UpdateReadOnlyState()
        {
            base.UpdateReadOnlyState();

            _minField?.SetEnabled(!IsReadOnly);
            _maxField?.SetEnabled(!IsReadOnly);
        }
        #endregion

        #region Private Methods
        private void OnMinChanged(ChangeEvent<int> evt)
        {
            var newValue = new UTKIntRange(evt.newValue, Value.Max);
            DebounceValueChange(newValue, 100).Forget();
        }

        private void OnMaxChanged(ChangeEvent<int> evt)
        {
            var newValue = new UTKIntRange(Value.Min, evt.newValue);
            DebounceValueChange(newValue, 100).Forget();
        }
        #endregion
    }
}