using System.Diagnostics;
using System.Runtime.CompilerServices;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Input;
using System.Windows.Media;
using System.Windows.Threading;
using WPFDark.Internals;


namespace WPFDark.Controls
{
    public enum BiaNumberEditorMode
    {
        Simple,
        WideRange
    }

    public class BiaNumberEditor : FrameworkElement
    {
        #region IsReadOnly

        public bool IsReadOnly
        {
            get => _IsReadOnly;
            set
            {
                if (value != _IsReadOnly)
                    SetValue(IsReadOnlyProperty, value);
            }
        }

        private bool _IsReadOnly;

        public static readonly DependencyProperty IsReadOnlyProperty =
            DependencyProperty.Register(nameof(IsReadOnly), typeof(bool), typeof(BiaNumberEditor),
                new FrameworkPropertyMetadata(
                    false,
                    FrameworkPropertyMetadataOptions.AffectsRender |
                    FrameworkPropertyMetadataOptions.SubPropertiesDoNotAffectRender,
                    (s, e) =>
                    {
                        var self = (BiaNumberEditor) s;
                        self._IsReadOnly = (bool) e.NewValue;
                    }));

        #endregion

        #region BorderColor

        public ByteColor BorderColor
        {
            get => _BorderColor;
            set
            {
                if (value != _BorderColor)
                    SetValue(BorderColorProperty, value);
            }
        }

        private ByteColor _BorderColor = ByteColor.Red;

        public static readonly DependencyProperty BorderColorProperty =
            DependencyProperty.Register(nameof(BorderColor), typeof(ByteColor), typeof(BiaNumberEditor),
                new FrameworkPropertyMetadata(
                    Boxes.ByteColorRed,
                    FrameworkPropertyMetadataOptions.AffectsRender |
                    FrameworkPropertyMetadataOptions.SubPropertiesDoNotAffectRender,
                    (s, e) =>
                    {
                        var self = (BiaNumberEditor) s;
                        self._BorderColor = (ByteColor) e.NewValue;
                    }));

        #endregion

        #region SliderBrush

        public Brush? SliderBrush
        {
            get => _SliderBrush;
            set
            {
                if (value != _SliderBrush)
                    SetValue(SliderBrushProperty, value);
            }
        }

        private Brush? _SliderBrush = Brushes.GreenYellow;

        public static readonly DependencyProperty SliderBrushProperty =
            DependencyProperty.Register(nameof(SliderBrush), typeof(Brush), typeof(BiaNumberEditor),
                new FrameworkPropertyMetadata(
                    Brushes.GreenYellow,
                    FrameworkPropertyMetadataOptions.AffectsRender |
                    FrameworkPropertyMetadataOptions.SubPropertiesDoNotAffectRender,
                    (s, e) =>
                    {
                        var self = (BiaNumberEditor) s;
                        self._SliderBrush = (Brush) e.NewValue;
                    }));

        #endregion

        #region Value

        public double Value
        {
            get => _Value;
            set
            {
                if (NumberHelper.AreClose(value, _Value) == false)
                    SetValue(ValueProperty, value);
            }
        }

        private double _Value;

        public static readonly DependencyProperty ValueProperty =
            DependencyProperty.Register(nameof(Value), typeof(double), typeof(BiaNumberEditor),
                new FrameworkPropertyMetadata(
                    0.0,
                    FrameworkPropertyMetadataOptions.BindsTwoWayByDefault |
                    FrameworkPropertyMetadataOptions.AffectsRender |
                    FrameworkPropertyMetadataOptions.SubPropertiesDoNotAffectRender,
                    (s, e) =>
                    {
                        // 最小値・最大値でクランプして保存する
                        var self = (BiaNumberEditor) s;
                        self._Value = self.ClampValue((double) e.NewValue);

                        self.ValueChanged?.Invoke(self, EventArgs.Empty);
                    }));

        #endregion

        #region Caption

        public string? Caption
        {
            get => _Caption;
            set
            {
                if (value != _Caption)
                    SetValue(CaptionProperty, value);
            }
        }

        private string? _Caption;

        public static readonly DependencyProperty CaptionProperty =
            DependencyProperty.Register(nameof(Caption), typeof(string), typeof(BiaNumberEditor),
                new FrameworkPropertyMetadata(
                    default(string),
                    FrameworkPropertyMetadataOptions.AffectsRender |
                    FrameworkPropertyMetadataOptions.SubPropertiesDoNotAffectRender,
                    (s, e) =>
                    {
                        var self = (BiaNumberEditor) s;
                        self._Caption = e.NewValue?.ToString() ?? "";
                    }));

        #endregion

        #region SliderMinimum

        public double SliderMinimum
        {
            get => _SliderMinimum;
            set
            {
                if (NumberHelper.AreClose(value, _SliderMinimum) == false)
                    SetValue(SliderMinimumProperty, value);
            }
        }

        private double _SliderMinimum = double.MinValue;

        public static readonly DependencyProperty SliderMinimumProperty =
            DependencyProperty.Register(nameof(SliderMinimum), typeof(double), typeof(BiaNumberEditor),
                new FrameworkPropertyMetadata(
                    double.MinValue,
                    FrameworkPropertyMetadataOptions.AffectsRender |
                    FrameworkPropertyMetadataOptions.SubPropertiesDoNotAffectRender,
                    (s, e) =>
                    {
                        var self = (BiaNumberEditor) s;
                        self._SliderMinimum = (double) e.NewValue;
                    }));

        #endregion

        #region SliderMaximum

        public double SliderMaximum
        {
            get => _SliderMaximum;
            set
            {
                if (NumberHelper.AreClose(value, _SliderMaximum) == false)
                    SetValue(SliderMaximumProperty, value);
            }
        }

        private double _SliderMaximum = double.MaxValue;

        public static readonly DependencyProperty SliderMaximumProperty =
            DependencyProperty.Register(nameof(SliderMaximum), typeof(double), typeof(BiaNumberEditor),
                new FrameworkPropertyMetadata(
                    double.MaxValue,
                    FrameworkPropertyMetadataOptions.AffectsRender |
                    FrameworkPropertyMetadataOptions.SubPropertiesDoNotAffectRender,
                    (s, e) =>
                    {
                        var self = (BiaNumberEditor) s;
                        self._SliderMaximum = (double) e.NewValue;
                    }));

        #endregion

        #region Minimum

        public double Minimum
        {
            get => _Minimum;
            set
            {
                if (NumberHelper.AreClose(value, _Minimum) == false)
                    SetValue(MinimumProperty, value);
            }
        }

        private double _Minimum = double.MinValue;

        public static readonly DependencyProperty MinimumProperty =
            DependencyProperty.Register(nameof(Minimum), typeof(double), typeof(BiaNumberEditor),
                new FrameworkPropertyMetadata(
                    double.MinValue,
                    FrameworkPropertyMetadataOptions.AffectsRender |
                    FrameworkPropertyMetadataOptions.SubPropertiesDoNotAffectRender,
                    (s, e) =>
                    {
                        // 変更後の最小値でValueをクランプする

                        var self = (BiaNumberEditor) s;
                        self._Minimum = (double) e.NewValue;

                        self.Value = self.ClampValue(self.Value);
                    }));

        #endregion

        #region Maximum

        public double Maximum
        {
            get => _Maximum;
            set
            {
                if (NumberHelper.AreClose(value, _Maximum) == false)
                    SetValue(MaximumProperty, value);
            }
        }

        private double _Maximum = double.MaxValue;

        public static readonly DependencyProperty MaximumProperty =
            DependencyProperty.Register(nameof(Maximum), typeof(double), typeof(BiaNumberEditor),
                new FrameworkPropertyMetadata(
                    double.MaxValue,
                    FrameworkPropertyMetadataOptions.AffectsRender |
                    FrameworkPropertyMetadataOptions.SubPropertiesDoNotAffectRender,
                    (s, e) =>
                    {
                        // 変更後の最大値でValueをクランプする

                        var self = (BiaNumberEditor) s;
                        self._Maximum = (double) e.NewValue;

                        self.Value = self.ClampValue(self.Value);
                    }));

        #endregion

        #region DisplayFormat

        public string DisplayFormat
        {
            get => _DisplayFormat;
            set
            {
                if (value != _DisplayFormat)
                    SetValue(DisplayFormatProperty, value);
            }
        }

        private string _DisplayFormat = "F3";

        public static readonly DependencyProperty DisplayFormatProperty =
            DependencyProperty.Register(nameof(DisplayFormat), typeof(string), typeof(BiaNumberEditor),
                new FrameworkPropertyMetadata(
                    "F3",
                    FrameworkPropertyMetadataOptions.AffectsRender |
                    FrameworkPropertyMetadataOptions.SubPropertiesDoNotAffectRender,
                    (s, e) =>
                    {
                        var self = (BiaNumberEditor) s;
                        self._DisplayFormat = e.NewValue?.ToString() ?? "";
                    }));

        #endregion

        #region UnitString

        public string UnitString
        {
            get => _UnitString;
            set
            {
                if (value != _UnitString)
                    SetValue(UnitStringProperty, value);
            }
        }

        private string _UnitString = "";

        public static readonly DependencyProperty UnitStringProperty =
            DependencyProperty.Register(nameof(UnitString), typeof(string), typeof(BiaNumberEditor),
                new FrameworkPropertyMetadata(
                    "",
                    FrameworkPropertyMetadataOptions.AffectsRender |
                    FrameworkPropertyMetadataOptions.SubPropertiesDoNotAffectRender,
                    (s, e) =>
                    {
                        var self = (BiaNumberEditor) s;
                        self._UnitString = e.NewValue?.ToString() ?? "";
                    }));

        #endregion

        #region Background

        public Brush? Background
        {
            get => _Background;
            set
            {
                if (value != _Background)
                    SetValue(BackgroundProperty, value);
            }
        }

        private Brush? _Background;

        public static readonly DependencyProperty BackgroundProperty =
            DependencyProperty.Register(nameof(Background), typeof(Brush), typeof(BiaNumberEditor),
                new FrameworkPropertyMetadata(
                    default(Brush),
                    FrameworkPropertyMetadataOptions.AffectsRender |
                    FrameworkPropertyMetadataOptions.SubPropertiesDoNotAffectRender,
                    (s, e) =>
                    {
                        var self = (BiaNumberEditor) s;
                        self._Background = (Brush) e.NewValue;
                    }));

        #endregion

        #region Foreground

        public Brush? Foreground
        {
            get => _Foreground;
            set
            {
                if (value != _Foreground)
                    SetValue(ForegroundProperty, value);
            }
        }

        private Brush? _Foreground;

        public static readonly DependencyProperty ForegroundProperty =
            DependencyProperty.Register(nameof(Foreground), typeof(Brush), typeof(BiaNumberEditor),
                new FrameworkPropertyMetadata(
                    default(Brush),
                    FrameworkPropertyMetadataOptions.AffectsRender |
                    FrameworkPropertyMetadataOptions.SubPropertiesDoNotAffectRender,
                    (s, e) =>
                    {
                        var self = (BiaNumberEditor) s;
                        self._Foreground = (Brush) e.NewValue;
                    }));

        #endregion

        #region CaptionForeground

        public Brush? CaptionForeground
        {
            get => _CaptionForeground;
            set
            {
                if (value != _CaptionForeground)
                    SetValue(CaptionForegroundProperty, value);
            }
        }

        private Brush? _CaptionForeground;

        public static readonly DependencyProperty CaptionForegroundProperty =
            DependencyProperty.Register(nameof(CaptionForeground), typeof(Brush), typeof(BiaNumberEditor),
                new FrameworkPropertyMetadata(
                    default(Brush),
                    FrameworkPropertyMetadataOptions.AffectsRender |
                    FrameworkPropertyMetadataOptions.SubPropertiesDoNotAffectRender,
                    (s, e) =>
                    {
                        var self = (BiaNumberEditor) s;
                        self._CaptionForeground = (Brush) e.NewValue;
                    }));

        #endregion

        #region Padding

        public Thickness Padding
        {
            get => _Padding;
            set
            {
                if (value != _Padding)
                    SetValue(PaddingProperty, value);
            }
        }

        private Thickness _Padding;

        public static readonly DependencyProperty PaddingProperty =
            DependencyProperty.Register(nameof(Padding), typeof(Thickness), typeof(BiaNumberEditor),
                new FrameworkPropertyMetadata(
                    new Thickness(0),
                    FrameworkPropertyMetadataOptions.AffectsRender |
                    FrameworkPropertyMetadataOptions.SubPropertiesDoNotAffectRender,
                    (s, e) =>
                    {
                        var self = (BiaNumberEditor) s;
                        self._Padding = (Thickness) e.NewValue;
                    }));

        #endregion

        #region Mode

        public BiaNumberEditorMode Mode
        {
            get => _Mode;
            set
            {
                if (value != _Mode)
                    SetValue(ModeProperty, value);
            }
        }

        private BiaNumberEditorMode _Mode = BiaNumberEditorMode.Simple;

        public static readonly DependencyProperty ModeProperty =
            DependencyProperty.Register(nameof(Mode), typeof(BiaNumberEditorMode), typeof(BiaNumberEditor),
                new FrameworkPropertyMetadata(
                    BiaNumberEditorMode.Simple,
                    FrameworkPropertyMetadataOptions.AffectsRender |
                    FrameworkPropertyMetadataOptions.SubPropertiesDoNotAffectRender,
                    (s, e) =>
                    {
                        var self = (BiaNumberEditor) s;
                        self._Mode = (BiaNumberEditorMode) e.NewValue;
                    }));

        #endregion

        #region Increment

        public double Increment
        {
            get => _Increment;
            set
            {
                if (NumberHelper.AreClose(value, _Increment) == false)
                    SetValue(IncrementProperty, value);
            }
        }

        private double _Increment = 1.0;

        public static readonly DependencyProperty IncrementProperty =
            DependencyProperty.Register(nameof(Increment), typeof(double), typeof(BiaNumberEditor),
                new FrameworkPropertyMetadata(
                    1.0,
                    FrameworkPropertyMetadataOptions.AffectsRender |
                    FrameworkPropertyMetadataOptions.SubPropertiesDoNotAffectRender,
                    (s, e) =>
                    {
                        var self = (BiaNumberEditor) s;
                        self._Increment = (double) e.NewValue;
                    }));

        #endregion

        #region CornerRadius

        public double CornerRadius
        {
            get => _CornerRadius;
            set
            {
                if (NumberHelper.AreClose(value, _CornerRadius) == false)
                    SetValue(CornerRadiusProperty, value);
            }
        }

        private double _CornerRadius = Constants.BasicCornerRadiusPrim;

        public static readonly DependencyProperty CornerRadiusProperty =
            DependencyProperty.Register(nameof(CornerRadius), typeof(double), typeof(BiaNumberEditor),
                new FrameworkPropertyMetadata(
                    Boxes.BasicCornerRadiusPrim,
                    FrameworkPropertyMetadataOptions.AffectsRender |
                    FrameworkPropertyMetadataOptions.SubPropertiesDoNotAffectRender,
                    (s, e) =>
                    {
                        var self = (BiaNumberEditor) s;
                        self._CornerRadius = (double) e.NewValue;
                    }));

        #endregion

        #region IsVisibleBorder

        public bool IsVisibleBorder
        {
            get => _IsVisibleBorder;
            set
            {
                if (value != _IsVisibleBorder)
                    SetValue(IsVisibleBorderProperty, value);
            }
        }

        private bool _IsVisibleBorder = true;

        public static readonly DependencyProperty IsVisibleBorderProperty =
            DependencyProperty.Register(nameof(IsVisibleBorder), typeof(bool), typeof(BiaNumberEditor),
                new FrameworkPropertyMetadata(
                    true,
                    FrameworkPropertyMetadataOptions.AffectsRender |
                    FrameworkPropertyMetadataOptions.SubPropertiesDoNotAffectRender,
                    (s, e) =>
                    {
                        var self = (BiaNumberEditor) s;
                        self._IsVisibleBorder = (bool) e.NewValue;
                    }));

        #endregion

        #region StartedContinuousEditingCommand

        public ICommand? StartedContinuousEditingCommand
        {
            get => _StartedContinuousEditingCommand;
            set
            {
                if (value != _StartedContinuousEditingCommand)
                    SetValue(StartedContinuousEditingCommandProperty, value);
            }
        }

        private ICommand? _StartedContinuousEditingCommand;

        public static readonly DependencyProperty StartedContinuousEditingCommandProperty =
            DependencyProperty.Register(
                nameof(StartedContinuousEditingCommand),
                typeof(ICommand),
                typeof(BiaNumberEditor),
                new PropertyMetadata(
                    default(ICommand),
                    (s, e) =>
                    {
                        var self = (BiaNumberEditor) s;
                        self._StartedContinuousEditingCommand = (ICommand) e.NewValue;
                    }));

        #endregion

        #region EndContinuousEditingCommand

        public ICommand? EndContinuousEditingCommand
        {
            get => _EndContinuousEditingCommand;
            set
            {
                if (value != _EndContinuousEditingCommand)
                    SetValue(EndContinuousEditingCommandProperty, value);
            }
        }

        private ICommand? _EndContinuousEditingCommand;

        public static readonly DependencyProperty EndContinuousEditingCommandProperty =
            DependencyProperty.Register(
                nameof(EndContinuousEditingCommand),
                typeof(ICommand),
                typeof(BiaNumberEditor),
                new PropertyMetadata(
                    default(ICommand),
                    (s, e) =>
                    {
                        var self = (BiaNumberEditor) s;
                        self._EndContinuousEditingCommand = (ICommand) e.NewValue;
                    }));

        #endregion
        
        #region TextTrimming

        public BiaTextTrimmingMode TextTrimming
        {
            get => _TextTrimming;
            set
            {
                if (value != _TextTrimming)
                    SetValue(TextTrimmingProperty, value);
            }
        }

        private BiaTextTrimmingMode _TextTrimming = BiaTextTrimmingMode.Standard;

        public static readonly DependencyProperty TextTrimmingProperty =
            DependencyProperty.Register(
                nameof(TextTrimming),
                typeof(BiaTextTrimmingMode),
                typeof(BiaNumberEditor),
                new FrameworkPropertyMetadata(
                    BiaTextTrimmingMode.Standard,
                    FrameworkPropertyMetadataOptions.BindsTwoWayByDefault |
                    FrameworkPropertyMetadataOptions.AffectsRender |
                    FrameworkPropertyMetadataOptions.SubPropertiesDoNotAffectRender,
                    (s, e) =>
                    {
                        var self = (BiaNumberEditor) s;
                        self._TextTrimming = (BiaTextTrimmingMode) e.NewValue;
                    }));

        #endregion
        
        #region CaptionAlignment
        
        public TextAlignment CaptionAlignment
        {
            get => _CaptionAlignment;
            set
            {
                if (value != _CaptionAlignment)
                    SetValue(CaptionAlignmentProperty, value);
            }
        }
        
        private TextAlignment _CaptionAlignment = TextAlignment.Left;
        
        public static readonly DependencyProperty CaptionAlignmentProperty =
            DependencyProperty.Register(
                nameof(CaptionAlignment),
                typeof(TextAlignment),
                typeof(BiaNumberEditor),
                new FrameworkPropertyMetadata(
                    TextAlignment.Left,
                    FrameworkPropertyMetadataOptions.BindsTwoWayByDefault |
                    FrameworkPropertyMetadataOptions.AffectsRender |
                    FrameworkPropertyMetadataOptions.SubPropertiesDoNotAffectRender,
                    (s, e) =>
                    {
                        var self = (BiaNumberEditor) s;
                        self._CaptionAlignment = (TextAlignment)e.NewValue;
                    }));
        
        #endregion
        
        #region ValueAlignment
        
        public TextAlignment ValueAlignment
        {
            get => _ValueAlignment;
            set
            {
                if (value != _ValueAlignment)
                    SetValue(CaptionAlignmentProperty,value);
            }
        }
        
        private TextAlignment _ValueAlignment = TextAlignment.Right;
        
        public static readonly DependencyProperty ValueAlignmentProperty =
            DependencyProperty.Register(
                nameof(ValueAlignment),
                typeof(TextAlignment),
                typeof(BiaNumberEditor),
                new FrameworkPropertyMetadata(
                    TextAlignment.Right,
                    FrameworkPropertyMetadataOptions.BindsTwoWayByDefault |
                    FrameworkPropertyMetadataOptions.AffectsRender |
                    FrameworkPropertyMetadataOptions.SubPropertiesDoNotAffectRender,
                    (s, e) =>
                    {
                        var self = (BiaNumberEditor) s;
                        self._ValueAlignment = (TextAlignment)e.NewValue;
                    }));
        
        #endregion

        // ReSharper disable once EventNeverSubscribedTo.Global
        public event EventHandler? ValueChanged;

        static BiaNumberEditor()
        {
            DefaultStyleKeyProperty.OverrideMetadata(typeof(BiaNumberEditor),
                new FrameworkPropertyMetadata(typeof(BiaNumberEditor)));
        }

        public BiaNumberEditor()
        {
            IsEnabledChanged += (_, _) => InvalidateVisual();
        }

        protected override void OnRender(DrawingContext dc)
        {
            if (ActualWidth <= 1 ||
                ActualHeight <= 1)
                return;
            
            var rounder = new LayoutRounder(this);

            DrawBackground(rounder, dc);

            var isCornerRadiusZero = NumberHelper.AreCloseZero(CornerRadius);

            if (isCornerRadiusZero == false)
                dc.PushClip(
                    Caches.GetClipGeom(rounder, ActualWidth, ActualHeight, CornerRadius, IsVisibleBorder));
            {
                if (Mode == BiaNumberEditorMode.Simple)
                    DrawSlider(rounder, dc);

                DrawText(dc);

                if (IsMouseOver &&
                    IsEnabled &&
                    IsReadOnly == false &&
                    NumberHelper.AreCloseZero(Increment) == false)
                    DrawSpin(dc);
            }
            if (isCornerRadiusZero == false)
                dc.Pop();

            if (IsVisibleBorder)
                DrawBorder(rounder, dc);
        }

        private void DrawBackground(in LayoutRounder rounder, DrawingContext dc)
        {
            var brush = isEditing
                ? textBox?.Background
                : Background;

            if (brush is null)
                return;

            if (NumberHelper.AreCloseZero(CornerRadius))
                dc.DrawRectangle(
                    brush,
                    null,
                    rounder.RoundRenderRectangle(IsVisibleBorder));
            else
                dc.DrawRoundedRectangle(
                    brush,
                    null,
                    rounder.RoundRenderRectangle(IsVisibleBorder),
                    CornerRadius,
                    CornerRadius);
        }

        private void DrawBorder(in LayoutRounder rounder, DrawingContext dc)
        {
            if (NumberHelper.AreCloseZero(CornerRadius))
                dc.DrawRectangle(
                    Brushes.Transparent,
                    rounder.GetBorderPen(BorderColor),
                    rounder.RoundRenderRectangle(IsVisibleBorder)
                );
            else
                dc.DrawRoundedRectangle(
                    Brushes.Transparent,
                    rounder.GetBorderPen(BorderColor),
                    rounder.RoundRenderRectangle(IsVisibleBorder),
                    CornerRadius,
                    CornerRadius);
        }

        private void DrawSlider(in LayoutRounder rounder, DrawingContext dc)
        {
            if (SliderWidth <= 0.0f)
                return;

            var brush = isEditing
                ? textBox?.Background
                : SliderBrush;

            if (brush is null)
                return;

            var w = (UiValue - ActualSliderMinimum) * rounder.RoundRenderWidth(IsVisibleBorder) / SliderWidth;
            var r = rounder.RoundRenderRectangle(IsVisibleBorder);
            r.Width = (rounder.RoundLayoutValue(w), 0.0).Max();

            dc.DrawRectangle(brush, null, r);
        }

        private const double SpinWidth = 14.0;

        private void DrawText(DrawingContext dc)
        {
            var offsetY = (ActualHeight - Constants.BasicOneLineHeight) * 0.5;

            var textWidth = ActualWidth - Padding.Left - Padding.Right - SpinWidth * 2;
            var textX = Padding.Left + SpinWidth;
            var textY = Padding.Top + offsetY;
            
            if (Caption != null &&
                CaptionForeground != null)
                DefaultTextRenderer.Instance.Draw(
                    this,
                    Caption,
                    textX,
                    textY,
                    CaptionForeground,
                    dc,
                    textWidth,
                    CaptionAlignment,
                    TextTrimming,
                    false);

            if (UiValueString != null &&
                Foreground != null)
            {
                DefaultTextRenderer.Instance.Draw(
                    this,
                    UiValueString,
                    textX,
                    textY,
                    Foreground,
                    dc,
                    textWidth,
                    ValueAlignment,
                    BiaTextTrimmingMode.None,
                    false);
            }
        }

        private static readonly Brush? _moBrush = ThemeManager.Current.TryFindResource("AccentBrushKey") as Brush;

        private void DrawSpin(DrawingContext dc)
        {
            if (_decSpinGeom is null)
                SetupSpinGeom();
            
            var spinBackground = Caches.GetSolidColorBrush(new ByteColor(0x40, 0x00, 0x00, 0x00));
            
            var offsetY = 8 + (ActualHeight - Constants.BasicOneLineHeight) * 0.5;

            {
                var offsetX = 5.0;

                if (_mouseOverType == MouseOverType.DecSpin)
                    dc.DrawRectangle(spinBackground, null, new Rect(0, 0, SpinWidth, ActualHeight));

                var key = HashCodeMaker.Make(offsetX, offsetY);

                if (TranslateTransformCache.TryGetValue(key, out var tt) == false)
                {
                    tt = new TranslateTransform(offsetX, offsetY);
                    TranslateTransformCache.Add(key, tt);
                }

                dc.PushTransform(tt);
                dc.DrawGeometry(
                    _mouseOverType == MouseOverType.DecSpin
                        ? _moBrush
                        : Foreground, null, _decSpinGeom);
                dc.Pop();
            }

            {
                var offsetX = ActualWidth - 5.0 * 2 + 1;

                if (_mouseOverType == MouseOverType.IncSpin)
                    dc.DrawRectangle(spinBackground, null,
                        new Rect(ActualWidth - SpinWidth, 0, SpinWidth, ActualHeight));

                var key = HashCodeMaker.Make(offsetX, offsetY);

                if (TranslateTransformCache.TryGetValue(key, out var tt) == false)
                {
                    tt = new TranslateTransform(offsetX, offsetY);
                    TranslateTransformCache.Add(key, tt);
                }

                dc.PushTransform(tt);
                dc.DrawGeometry(
                    _mouseOverType == MouseOverType.IncSpin
                        ? _moBrush
                        : Foreground, null, _incSpinGeom);
                dc.Pop();
            }
        }

        private enum MouseOverType
        {
            None,
            DecSpin,
            IncSpin,
            Slider
        }

        private bool _isMouseDown;
        private bool _isMouseMoved;
        private Point _oldPos;
        private Point _mouseDownPos;
        private MouseOverType _mouseOverTypeOnMouseDown;
        private MouseOverType _mouseOverType;

        private bool _isContinuousEdited;
        private double _ContinuousEditingStartValue;

        protected override void OnMouseLeftButtonDown(MouseButtonEventArgs e)
        {
            base.OnMouseLeftButtonDown(e);

            _oldPos = e.GetPosition(this);
            _mouseDownPos = _oldPos;

            if (IsReadOnly)
                return;

            _isMouseDown = true;
            _isMouseMoved = false;
            _mouseOverTypeOnMouseDown = MakeMouseOverType(e);
            _isContinuousEdited = false;
            _ContinuousEditingStartValue = Value;

            if (_mouseOverTypeOnMouseDown == MouseOverType.Slider)
                CaptureMouse();

            e.Handled = true;
        }

        private const double ClickPlayWidth = 4;

        protected override void OnMouseMove(MouseEventArgs e)
        {
            base.OnMouseMove(e);

            var newMouseOverType = MakeMouseOverType(e);

            if (_mouseOverType != newMouseOverType)
            {
                _mouseOverType = newMouseOverType;
                InvalidateVisual();
            }

            if (_isMouseDown == false)
            {
                Cursor = _mouseOverType == MouseOverType.Slider && IsReadOnly == false ? Cursors.SizeWE : Cursors.Arrow;
                return;
            }

            if (IsReadOnly)
                return;

            // Down直後マウス移動ない場合でもOnMouseMoveが呼ばれることがあるため、判定する。
            var currentPos = e.GetPosition(this);
            if (currentPos == _oldPos)
                return;

            if (_isMouseMoved == false)
                if (Math.Abs(currentPos.X - _mouseDownPos.X) <= ClickPlayWidth)
                    return;

            if (_mouseOverTypeOnMouseDown != MouseOverType.Slider)
                return;

            var oldValue = Value;
            var newValue = Value;

            switch (Mode)
            {
                case BiaNumberEditorMode.Simple:
                {
                    // 0から1
                    var xr = (currentPos.X, 0.0, ActualWidth).Clamp() / ActualWidth;
                    newValue = SliderWidth * xr + ActualSliderMinimum;
                    break;
                }

                case BiaNumberEditorMode.WideRange:
                {
                    // Ctrl押下中は５倍速い
                    var s = KeyboardHelper.IsPressControl
                        ? 5.0
                        : 1.0;
                    var w = currentPos.X - _oldPos.X;
                    var v = oldValue + s * w * Increment;

                    newValue = (v, ActualSliderMinimum, ActualSliderMaximum).Clamp();

                    break;
                }
            }

            if (NumberHelper.AreClose(newValue, oldValue) == false)
            {
                if (_isContinuousEdited == false)
                {
                    _isContinuousEdited = true;

                    StartedContinuousEditingCommand?.ExecuteIfCan(null);
                }

                Value = newValue;
            }

            _mouseOverType = MouseOverType.Slider;
            _isMouseMoved = true;
            _oldPos = currentPos;

            Cursor = _mouseOverType == MouseOverType.Slider && IsReadOnly == false ? Cursors.SizeWE : Cursors.Arrow;

            e.Handled = true;
        }

        protected override void OnMouseLeftButtonUp(MouseButtonEventArgs e)
        {
            base.OnMouseLeftButtonUp(e);

            if (IsReadOnly == false)
            {
                if (_mouseOverTypeOnMouseDown == MouseOverType.Slider)
                    ReleaseMouseCapture();
            }

            _isMouseDown = false;

            if (_isMouseMoved)
            {
                if (_isContinuousEdited)
                {
                    if (EndContinuousEditingCommand != null)
                    {
                        if (EndContinuousEditingCommand.CanExecute(null))
                        {
                            var changedValue = Value;
                            Value = _ContinuousEditingStartValue;

                            EndContinuousEditingCommand.Execute(null);

                            Value = changedValue;
                        }
                    }

                    _isContinuousEdited = false;
                }
            }
            else
            {
                var p = e.GetPosition(this);

                if (Math.Abs(p.X - _mouseDownPos.X) <= ClickPlayWidth)
                {
                    // Ctrl押下中は５倍速い
                    var inc = KeyboardHelper.IsPressControl
                        ? Increment * 5
                        : Increment;

                    if (p.X <= SpinWidth && IsReadOnly == false)
                        AddValue(-inc);
                    else if (p.X >= ActualWidth - SpinWidth && IsReadOnly == false)
                        AddValue(inc);
                    else
                        ShowEditBox();
                }
            }

            _mouseOverType = MakeMouseOverType(e);

            e.Handled = true;
        }

        protected override void OnMouseLeave(MouseEventArgs e)
        {
            base.OnMouseLeave(e);

            if (_isMouseDown)
            {
                _isMouseDown = false;
                ReleaseMouseCapture();
                this.ResetMouseClipping();
            }

            _mouseOverType = MouseOverType.None;

            e.Handled = true;
        }

        private MouseOverType MakeMouseOverType(MouseEventArgs e)
        {
            var x = e.GetPosition(this).X;

            if (x < 0 || x >= ActualWidth)
                return MouseOverType.None;

            if (x <= SpinWidth)
                return MouseOverType.DecSpin;

            if (x >= ActualWidth - SpinWidth)
                return MouseOverType.IncSpin;

            return MouseOverType.Slider;
        }

        private TextBox? textBox;
        private bool isEditing;

        private void AddValue(double i)
        {
            var v = Value + i;

            Value = ClampValue(v);
        }

        protected override void OnKeyDown(KeyEventArgs e)
        {
            base.OnKeyDown(e);

            if (IsEnabled == false)
                return;

            if (e.Key == Key.Return)
            {
                ShowEditBox();
                e.Handled = true;
            }
        }

        private void ShowEditBox()
        {
            if (isEditing)
                return;

            if (textBox is null)
            {
                textBox = new TextBox
                {
                    IsTabStop = false,
                    IsUndoEnabled = false,
                    FocusVisualStyle = null,
                    SelectionLength = 0
                };

                textBox.TextChanged += TextBox_OnTextChanged;
                textBox.LostFocus += TextBox_OnLostFocus;
                textBox.PreviewKeyDown += TextBox_OnPreviewKeyDown;
                textBox.PreviewMouseDown += TextBox_OnPreviewMouseDown;
            }

            textBox.Width = ActualWidth;
            textBox.Height = ActualHeight;
            textBox.IsReadOnly = IsReadOnly;
            textBox.Text = FormattedValueString;

            AddVisualChild(textBox);
            InvalidateMeasure();

            textBox.SelectAll();
            textBox.Focus();
            textBox.CaptureMouse();

            isEditing = true;
        }

        private void TextBox_OnPreviewMouseDown(object sender, MouseButtonEventArgs e)
        {
            var rounder = new LayoutRounder(this);
            
            // 自コントロール上であれば、終了させない
            var pos = e.GetPosition(this);
            var rect = rounder.RoundRenderRectangle(false);
            if (rect.Contains(pos))
                return;

            if (isEditing)
                FinishEditing(true);
        }

        private void TextBox_OnTextChanged(object sender, TextChangedEventArgs e)
        {
            InvalidateVisual();
        }

        private void TextBox_OnLostFocus(object sender, RoutedEventArgs e)
        {
            if (isEditing)
                FinishEditing(true);
        }

        private void TextBox_OnPreviewKeyDown(object sender, KeyEventArgs e)
        {
            switch (e.Key)
            {
                case Key.Tab:
                {
                    Debug.Assert(textBox != null);

                    var v = MakeValueFromString(textBox.Text);

                    if (v.Result == MakeValueResult.Continue)
                        textBox.Text = v.Value.ToString(DisplayFormat);
                    else
                        FinishEditing(v.Result == MakeValueResult.Ok);

                    var t = Keyboard.Modifiers == ModifierKeys.Shift
                        ? Caches.PreviousTraversalRequest
                        : Caches.NextTraversalRequest;
                    MoveFocus(t);

                    e.Handled = true;
                    break;
                }

                case Key.Return:
                {
                    Debug.Assert(textBox != null);

                    var v = MakeValueFromString(textBox.Text);

                    if (v.Result == MakeValueResult.Continue)
                        textBox.Text = v.Value.ToString(DisplayFormat);
                    else
                    {
                        FinishEditing(v.Result == MakeValueResult.Ok);
                        Dispatcher?.BeginInvoke(DispatcherPriority.Input, (Action) (() => Focus()));
                    }

                    e.Handled = true;
                    break;
                }

                case Key.Escape:
                {
                    Debug.Assert(textBox != null);

                    textBox.Text = FormattedValueString;
                    FinishEditing(false);

                    Dispatcher?.BeginInvoke(DispatcherPriority.Input, (Action) (() => Focus()));

                    e.Handled = true;
                    break;
                }
            }
        }

        private void FinishEditing(bool isEdit)
        {
            Debug.Assert(textBox != null);

            if (isEdit)
            {
                var v = MakeValueFromString(textBox.Text);
                if (v.Result == MakeValueResult.Ok ||
                    v.Result == MakeValueResult.Continue)
                    Value = v.Value;
            }

            textBox?.ReleaseMouseCapture();

            RemoveVisualChild(textBox);
            isEditing = false;
            InvalidateVisual();
        }

        protected override int VisualChildrenCount
            => isEditing
                ? 1
                : 0;

        protected override Visual GetVisualChild(int index)
            => textBox ?? throw new NullReferenceException();

        protected override Size ArrangeOverride(Size finalSize)
        {
            if (isEditing)
                textBox?.Arrange(new Rect(new Point(0, 0), textBox.DesiredSize));

            return base.ArrangeOverride(finalSize);
        }

        protected override Size MeasureOverride(Size availableSize)
        {
            if (isEditing)
                textBox?.Measure(new Size(ActualWidth, ActualHeight));

            // todo:DPI変更時に再描画が行われないため明示的に指示している。要調査。
            InvalidateVisual();

            return base.MeasureOverride(availableSize);
        }

        private enum MakeValueResult
        {
            Ok,
            Cancel,
            Continue
        }

        private (MakeValueResult Result, double Value) MakeValueFromString(string src)
        {
            if (double.TryParse(src, out var v))
                return (MakeValueResult.Ok, ClampValue(v));

            if (double.TryParse(Evaluator.Eval(src), out v))
                return (MakeValueResult.Continue, ClampValue(v));

            return (MakeValueResult.Cancel, default);
        }

        private static void SetupSpinGeom()
        {
            {
                _decSpinGeom = new StreamGeometry();

                using (var ctx = _decSpinGeom.Open())
                {
                    ctx.DrawTriangle(
                        new Point(0, 4),
                        new Point(4, 0),
                        new Point(4, 8),
                        true,
                        true);
                }
                
                _decSpinGeom.Freeze();
            }
            
            {
                _incSpinGeom = new StreamGeometry();

                using (var ctx = _incSpinGeom.Open())
                {
                    ctx.DrawTriangle(
                        new Point(4, 4),
                        new Point(0, 0),
                        new Point(0, 8),
                        true,
                        true);
                }
                
                _incSpinGeom.Freeze();
            }
        }

        private double ClampValue(double v)
            => (v, ActualMinimum, ActualMaximum).Clamp();

        private string FormattedValueString => Value.ToString(DisplayFormat);

        private double SliderWidth => Math.Abs(SliderMaximum - SliderMinimum);

        private double ActualSliderMinimum => (SliderMinimum, SliderMaximum).Min();

        private double ActualSliderMaximum => (SliderMinimum, SliderMaximum).Max();

        private double ActualMinimum => (Minimum, Maximum).Min();

        private double ActualMaximum => (Minimum, Maximum).Max();

        private string? UiValueString
        {
            get
            {
                if (isEditing == false)
                    return Concat(FormattedValueString, UnitString);

                var v = MakeValueFromString(textBox?.Text ?? "");

                return
                    v.Result == MakeValueResult.Ok || v.Result == MakeValueResult.Continue
                        ? Concat(v.Value.ToString(DisplayFormat), UnitString)
                        : Concat(FormattedValueString, UnitString);
            }
        }

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        private static string Concat(string a, string b)
            => string.IsNullOrEmpty(b)
                ? a
                : a + b;

        private double UiValue
        {
            get
            {
                if (isEditing == false)
                    return Value;

                var v = MakeValueFromString(textBox?.Text ?? "");

                return
                    v.Result == MakeValueResult.Ok || v.Result == MakeValueResult.Continue
                        ? v.Value
                        : Value;
            }
        }

        private static StreamGeometry? _decSpinGeom;
        private static StreamGeometry? _incSpinGeom;

        private static readonly Dictionary<long, TranslateTransform> TranslateTransformCache = new Dictionary<long, TranslateTransform>();
    }
}