#nullable enable
using System;
using UnityEngine;
using UnityEngine.UIElements;

namespace UVC.UIToolkit
{
    /// <summary>
    /// 실수 입력 필드에 위/아래 스테퍼 버튼이 붙은 컴포넌트.
    /// TextInput 오른쪽에 위, 아래 버튼이 세로로 배치됩니다.
    /// 키보드 화살표, 마우스 휠, 버튼 클릭으로 값을 조절할 수 있습니다.
    /// </summary>
    /// <remarks>
    /// <para><b>UTKFloatStepper란?</b></para>
    /// <para>실수를 편리하게 증감할 수 있는 입력 컴포넌트입니다.</para>
    /// <list type="bullet">
    ///   <item><description><b>버튼 클릭</b>: ▲/▼ 버튼으로 값 증감</description></item>
    ///   <item><description><b>키보드</b>: ↑/↓ 화살표 키로 값 증감</description></item>
    ///   <item><description><b>마우스 휠</b>: 호버 상태에서 휠로 값 조절</description></item>
    ///   <item><description><b>직접 입력</b>: 텍스트 필드에 숫자 직접 입력</description></item>
    /// </list>
    /// <para><b>주요 기능:</b></para>
    /// <list type="bullet">
    ///   <item><description>최소/최대값 제한 (MinValue, MaxValue)</description></item>
    ///   <item><description>증감 단위 설정 (Step)</description></item>
    ///   <item><description>순환 모드 (WrapAround) - 최대에서 최소로, 최소에서 최대로</description></item>
    /// </list>
    /// </remarks>
    /// <example>
    /// <para><b>C# 코드에서 사용:</b></para>
    /// <code>
    /// // 기본 스테퍼 생성
    /// var stepper = new UTKFloatStepper();
    /// stepper.MinValue = 0f;
    /// stepper.MaxValue = 10f;
    /// stepper.Value = 5.5f;
    /// stepper.Step = 0.5f;  // 0.5씩 증감
    ///
    /// // 값 변경 이벤트
    /// stepper.OnValueChanged += (value) => {
    ///     Debug.Log($"현재 값: {value}");
    /// };
    ///
    /// // 범위와 초기값을 지정하는 생성자
    /// var volumeStepper = new UTKFloatStepper(0f, 1f, 0.8f, 0.1f);  // min, max, initial, step
    ///
    /// // 순환 모드 활성화 (10.0 → 0.0, 0.0 → 10.0)
    /// stepper.WrapAround = true;
    ///
    /// // 프로그래밍 방식으로 값 변경
    /// stepper.Increment();  // Step만큼 증가
    /// stepper.Decrement();  // Step만큼 감소
    /// stepper.SetValue(7.5f);  // 직접 설정
    ///
    /// // 읽기 전용 (사용자가 수정할 수 없음)
    /// var readOnlyStepper = new UTKFloatStepper(0f, 10f, 5f, 0.1f);
    /// readOnlyStepper.IsReadOnly = true;
    /// </code>
    /// <para><b>UXML에서 사용:</b></para>
    /// <code><![CDATA[
    /// <!-- 기본 스테퍼 -->
    /// <utk:UTKFloatStepper value="5.5" min-value="0" max-value="10" />
    ///
    /// <!-- 증감 단위 설정 -->
    /// <utk:UTKFloatStepper value="1.0" step="0.5" />
    ///
    /// <!-- 순환 모드 -->
    /// <utk:UTKFloatStepper value="0.5" min-value="0" max-value="1" wrap-around="true" />
    ///
    /// <!-- 읽기 전용 -->
    /// <utk:UTKFloatStepper value="5.0" is-readonly="true" />
    /// ]]></code>
    /// <para><b>실제 활용 예시 (볼륨 조절):</b></para>
    /// <code>
    /// // 볼륨 스테퍼 (0.0~1.0)
    /// var volumeStepper = new UTKFloatStepper(0f, 1f, 0.8f, 0.1f);
    /// volumeStepper.OnValueChanged += (volume) => {
    ///     AudioListener.volume = volume;
    /// };
    /// </code>
    /// </example>
    [UxmlElement]
    public partial class UTKFloatStepper : VisualElement, IDisposable
    {
        #region Constants
        private const string USS_PATH = "UIToolkit/Input/UTKFloatStepper";
        #endregion

        #region UXML Attributes
        [UxmlAttribute("value")]
        public float Value
        {
            get => _value;
            set => SetValue(value);
        }

        [UxmlAttribute("min-value")]
        public float MinValue
        {
            get => _minValue;
            set
            {
                _minValue = value;
                ClampValue();
            }
        }

        [UxmlAttribute("max-value")]
        public float MaxValue
        {
            get => _maxValue;
            set
            {
                _maxValue = value;
                ClampValue();
            }
        }

        [UxmlAttribute("step")]
        public float Step
        {
            get => _step;
            set => _step = value > 0 ? value : 0.1f;
        }

        [UxmlAttribute("wrap-around")]
        public bool WrapAround
        {
            get => _wrapAround;
            set => _wrapAround = value;
        }

        /// <summary>읽기 전용 상태. true일 때 사용자가 값을 수정할 수 없음</summary>
        [UxmlAttribute("is-readonly")]
        public bool IsReadOnly
        {
            get => _isReadOnly;
            set
            {
                _isReadOnly = value;
                UpdateReadOnlyState();
                EnableInClassList("utk-number-stepper--readonly", value);
            }
        }
        #endregion

        #region Fields
        private bool _disposed;
        private bool _isReadOnly;
        private float _value;
        private float _minValue = float.MinValue;
        private float _maxValue = float.MaxValue;
        private float _step = 1.0f;
        private bool _wrapAround;
        private bool _isUpdating;
        private bool _isHovered;

        private TextField? _textField;
        private Button? _upButton;
        private Button? _downButton;
        #endregion

        #region Events
        /// <summary>값이 변경될 때 발생</summary>
        public event Action<float>? OnValueChanged;

        /// <summary>Tab 키가 눌렸을 때 발생 (다음 요소로 포커스 이동용)</summary>
        public event Action? OnTabPressed;

        /// <summary>Shift+Tab 키가 눌렸을 때 발생 (이전 요소로 포커스 이동용)</summary>
        public event Action? OnShiftTabPressed;
        #endregion

        #region Constructor

        public UTKFloatStepper()
        {
            UTKThemeManager.Instance.ApplyThemeToElement(this);
            LoadStyleSheet();
            CreateUI();
            SetupEvents();
            SubscribeToThemeChanges();
        }

        public UTKFloatStepper(bool isReadOnly = false): this()
        {
            _isReadOnly = isReadOnly;
        }

        public UTKFloatStepper(float minValue, float maxValue, float initialValue = 0f, float step = 0.1f, bool isReadOnly = false): this()
        {
            _isReadOnly = isReadOnly;
            _minValue = minValue;
            _maxValue = maxValue;
            _step = step > 0 ? step : 1.0f;
            _value = Mathf.Clamp(initialValue, minValue, maxValue);
        }

        private void LoadStyleSheet()
        {
            var uss = Resources.Load<StyleSheet>(USS_PATH);
            if (uss != null)
            {
                styleSheets.Add(uss);
            }
        }

        private void SubscribeToThemeChanges()
        {
            UTKThemeManager.Instance.OnThemeChanged += OnThemeChanged;

            // 패널에서 분리될 때 이벤트 구독 해제
            RegisterCallback<DetachFromPanelEvent>(_ =>
            {
                UTKThemeManager.Instance.OnThemeChanged -= OnThemeChanged;
            });
        }

        private void OnThemeChanged(UTKTheme theme)
        {
            UTKThemeManager.Instance.ApplyThemeToElement(this);
        }
        #endregion

        #region Public Methods
        public void SetValue(float newValue, bool notify = true)
        {
            float clampedValue = ClampValueInternal(newValue);
            if (!Mathf.Approximately(_value, clampedValue))
            {
                _value = clampedValue;
                UpdateDisplay();
                if (notify)
                {
                    OnValueChanged?.Invoke(_value);
                }
            }
        }

        public void Increment()
        {
            if (_wrapAround && _value + _step > _maxValue)
            {
                SetValue(_minValue);
            }
            else
            {
                SetValue(_value + _step);
            }
        }

        public void Decrement()
        {
            if (_wrapAround && _value - _step < _minValue)
            {
                SetValue(_maxValue);
            }
            else
            {
                SetValue(_value - _step);
            }
        }

        public void SetRange(float min, float max)
        {
            _minValue = min;
            _maxValue = max;
            ClampValue();
        }

        /// <summary>컴포넌트의 활성화 상태를 설정합니다.</summary>
        public new void SetEnabled(bool enabled)
        {
            base.SetEnabled(enabled);
            EnableInClassList("utk-number-stepper--disabled", !enabled);
        }

        /// <summary>텍스트 필드에 포커스를 설정합니다.</summary>
        public new void Focus()
        {
            _textField?.Focus();
        }
        #endregion

        #region Private Methods - UI Creation
        private void CreateUI()
        {
            AddToClassList("utk-number-stepper");

            // Text Field
            _textField = new TextField { name = "stepper-input" };
            _textField.AddToClassList("utk-number-stepper__input");
            _textField.isReadOnly = _isReadOnly;

            // TextField 내부 input 스타일링
            _textField.RegisterCallback<AttachToPanelEvent>(_ =>
            {
                var input = _textField.Q<VisualElement>("unity-text-input");
                if (input != null)
                {
                    input.AddToClassList("utk-number-stepper__text-input");
                }
            });

            Add(_textField);

            // Button Container (위/아래 버튼을 세로로 배치)
            var buttonContainer = new VisualElement { name = "stepper-buttons" };
            buttonContainer.AddToClassList("utk-number-stepper__buttons");

            // Up Button
            _upButton = new Button { name = "stepper-up", text = UTKMaterialIcons.KeyboardArrowUp };
            _upButton.AddToClassList("utk-number-stepper__btn");
            _upButton.AddToClassList("utk-number-stepper__btn--up");
            _upButton.SetEnabled(!_isReadOnly);
            UTKMaterialIcons.ApplyIconStyle(_upButton, 14);
            buttonContainer.Add(_upButton);

            // Down Button
            _downButton = new Button { name = "stepper-down", text = UTKMaterialIcons.KeyboardArrowDown };
            _downButton.AddToClassList("utk-number-stepper__btn");
            _downButton.AddToClassList("utk-number-stepper__btn--down");
            _downButton.SetEnabled(!_isReadOnly);
            UTKMaterialIcons.ApplyIconStyle(_downButton, 14);
            buttonContainer.Add(_downButton);

            Add(buttonContainer);

            UpdateDisplay();
        }

        private void SetupEvents()
        {
            _upButton?.RegisterCallback<ClickEvent>(OnUpButtonClick);
            _downButton?.RegisterCallback<ClickEvent>(OnDownButtonClick);

            _textField?.RegisterCallback<ChangeEvent<string>>(OnTextFieldChanged);
            _textField?.RegisterCallback<KeyDownEvent>(OnTextFieldKeyDown, TrickleDown.TrickleDown);

            RegisterCallback<MouseEnterEvent>(OnMouseEnter);
            RegisterCallback<MouseLeaveEvent>(OnMouseLeave);
            RegisterCallback<WheelEvent>(OnWheelEvent);
        }
        #endregion

        #region Event Handlers
        private void OnUpButtonClick(ClickEvent evt) => Increment();
        private void OnDownButtonClick(ClickEvent evt) => Decrement();

        private void OnTextFieldChanged(ChangeEvent<string> evt)
        {
            if (_isUpdating) return;

            if (float.TryParse(evt.newValue, out float parsed))
            {
                SetValue(parsed);
            }
            else
            {
                // 유효하지 않은 입력이면 이전 값으로 복원
                UpdateDisplay();
            }
        }

        private void OnTextFieldKeyDown(KeyDownEvent evt)
        {
            if (evt.keyCode == KeyCode.UpArrow)
            {
                Increment();
                evt.StopPropagation();
            }
            else if (evt.keyCode == KeyCode.DownArrow)
            {
                Decrement();
                evt.StopPropagation();
            }
            else if (evt.keyCode == KeyCode.Tab)
            {
                if (evt.shiftKey && OnShiftTabPressed != null)
                {
                    OnShiftTabPressed.Invoke();
                    evt.StopImmediatePropagation();
                }
                else if (!evt.shiftKey && OnTabPressed != null)
                {
                    OnTabPressed.Invoke();
                    evt.StopImmediatePropagation();
                }
            }
        }

        private void OnMouseEnter(MouseEnterEvent evt) => _isHovered = true;
        private void OnMouseLeave(MouseLeaveEvent evt) => _isHovered = false;

        private void OnWheelEvent(WheelEvent evt)
        {
            if (!_isHovered) return;

            if (evt.delta.y < 0)
            {
                Increment();
            }
            else if (evt.delta.y > 0)
            {
                Decrement();
            }
            evt.StopPropagation();
        }
        #endregion

        #region Private Methods - Logic
        private void UpdateDisplay()
        {
            if (_textField == null) return;

            _isUpdating = true;
            _textField.value = _value.ToString();//.ToString("F2");
            _isUpdating = false;
        }

        private void ClampValue()
        {
            SetValue(_value, notify: false);
        }

        private float ClampValueInternal(float value)
        {
            return Mathf.Clamp(value, _minValue, _maxValue);
        }

        private void UpdateReadOnlyState()
        {
            if (_textField != null)
            {
                _textField.isReadOnly = _isReadOnly;
            }

            if (_upButton != null)
            {
                _upButton.SetEnabled(!_isReadOnly);
            }

            if (_downButton != null)
            {
                _downButton.SetEnabled(!_isReadOnly);
            }
        }
        #endregion

        #region IDisposable
        public void Dispose()
        {
            if (_disposed) return;
            _disposed = true;

            UTKThemeManager.Instance.OnThemeChanged -= OnThemeChanged;

            // 이벤트 콜백 해제
            _upButton?.UnregisterCallback<ClickEvent>(OnUpButtonClick);
            _downButton?.UnregisterCallback<ClickEvent>(OnDownButtonClick);

            _textField?.UnregisterCallback<ChangeEvent<string>>(OnTextFieldChanged);
            _textField?.UnregisterCallback<KeyDownEvent>(OnTextFieldKeyDown, TrickleDown.TrickleDown);

            UnregisterCallback<MouseEnterEvent>(OnMouseEnter);
            UnregisterCallback<MouseLeaveEvent>(OnMouseLeave);
            UnregisterCallback<WheelEvent>(OnWheelEvent);

            // 이벤트 null 처리
            OnValueChanged = null;
            OnTabPressed = null;
            OnShiftTabPressed = null;

            // UI 참조 정리
            _textField = null;
            _upButton = null;
            _downButton = null;
        }
        #endregion
    }
}