using System;
using System.ComponentModel;
using System.Globalization;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Controls.Primitives;
using System.Windows.Media;
using System.Windows.Threading;

namespace Ink_Canvas.Helpers
{
    /// <summary>
    /// Automatically shrinks text to fit available width.
    /// Supports TextBlock and Label.
    /// Only shrinks, never enlarges above MaxFontSize.
    /// </summary>
    public static class AutoFontSizeHelper
    {
        public static readonly DependencyProperty IsEnabledProperty =
            DependencyProperty.RegisterAttached(
                "IsEnabled",
                typeof(bool),
                typeof(AutoFontSizeHelper),
                new PropertyMetadata(false, OnIsEnabledChanged));

        public static void SetIsEnabled(DependencyObject element, bool value) => element.SetValue(IsEnabledProperty, value);
        public static bool GetIsEnabled(DependencyObject element) => (bool)element.GetValue(IsEnabledProperty);

        public static readonly DependencyProperty MinFontSizeProperty =
            DependencyProperty.RegisterAttached(
                "MinFontSize",
                typeof(double),
                typeof(AutoFontSizeHelper),
                new PropertyMetadata(6d, OnSizingPropertyChanged));

        public static void SetMinFontSize(DependencyObject element, double value) => element.SetValue(MinFontSizeProperty, value);
        public static double GetMinFontSize(DependencyObject element) => (double)element.GetValue(MinFontSizeProperty);

        public static readonly DependencyProperty MaxFontSizeProperty =
            DependencyProperty.RegisterAttached(
                "MaxFontSize",
                typeof(double),
                typeof(AutoFontSizeHelper),
                new PropertyMetadata(double.NaN, OnSizingPropertyChanged));

        public static void SetMaxFontSize(DependencyObject element, double value) => element.SetValue(MaxFontSizeProperty, value);
        public static double GetMaxFontSize(DependencyObject element) => (double)element.GetValue(MaxFontSizeProperty);

        public static readonly DependencyProperty StepProperty =
            DependencyProperty.RegisterAttached(
                "Step",
                typeof(double),
                typeof(AutoFontSizeHelper),
                new PropertyMetadata(0.5d, OnSizingPropertyChanged));

        public static void SetStep(DependencyObject element, double value) => element.SetValue(StepProperty, value);
        public static double GetStep(DependencyObject element) => (double)element.GetValue(StepProperty);

        private static readonly DependencyProperty IsAdjustingProperty =
            DependencyProperty.RegisterAttached(
                "IsAdjusting",
                typeof(bool),
                typeof(AutoFontSizeHelper),
                new PropertyMetadata(false));

        private static void SetIsAdjusting(DependencyObject element, bool value) => element.SetValue(IsAdjustingProperty, value);
        private static bool GetIsAdjusting(DependencyObject element) => (bool)element.GetValue(IsAdjustingProperty);

        private static readonly DependencyProperty OriginalFontSizeProperty =
            DependencyProperty.RegisterAttached(
                "OriginalFontSize",
                typeof(double),
                typeof(AutoFontSizeHelper),
                new PropertyMetadata(double.NaN));

        private static void SetOriginalFontSize(DependencyObject element, double value) => element.SetValue(OriginalFontSizeProperty, value);
        private static double GetOriginalFontSize(DependencyObject element) => (double)element.GetValue(OriginalFontSizeProperty);

        private static void OnIsEnabledChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
        {
            if (!(d is FrameworkElement fe)) return;
            if (!(fe is TextBlock) && !(fe is Label)) return;

            if ((bool)e.NewValue)
            {
                var originalFontSize = GetElementFontSize(fe);
                if (!double.IsNaN(originalFontSize) && originalFontSize > 0)
                {
                    SetOriginalFontSize(fe, originalFontSize);
                }

                fe.SizeChanged += Element_OnSizeChanged;
                fe.Loaded += Element_OnLoaded;
                fe.Unloaded += Element_OnUnloaded;
                TryHookContentChanged(fe, true);

                fe.Dispatcher.BeginInvoke(new Action(() => TryAdjust(fe)), DispatcherPriority.Loaded);
            }
            else
            {
                fe.SizeChanged -= Element_OnSizeChanged;
                fe.Loaded -= Element_OnLoaded;
                fe.Unloaded -= Element_OnUnloaded;
                TryHookContentChanged(fe, false);
            }
        }

        private static void OnSizingPropertyChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
        {
            if (d is FrameworkElement fe && GetIsEnabled(fe))
            {
                fe.Dispatcher.BeginInvoke(new Action(() => TryAdjust(fe)), DispatcherPriority.Loaded);
            }
        }

        private static void Element_OnLoaded(object sender, RoutedEventArgs e)
        {
            if (sender is FrameworkElement fe)
            {
                fe.Dispatcher.BeginInvoke(new Action(() => TryAdjust(fe)), DispatcherPriority.Loaded);
            }
        }

        private static void Element_OnUnloaded(object sender, RoutedEventArgs e)
        {
            // No extra cleanup required here.
        }

        private static void Element_OnSizeChanged(object sender, SizeChangedEventArgs e)
        {
            if (sender is FrameworkElement fe) TryAdjust(fe);
        }

        private static void Element_OnTextChanged(object sender, EventArgs e)
        {
            if (sender is FrameworkElement fe)
            {
                fe.Dispatcher.BeginInvoke(new Action(() => TryAdjust(fe)), DispatcherPriority.Loaded);
            }
        }

        private static void TryHookContentChanged(FrameworkElement fe, bool add)
        {
            try
            {
                DependencyPropertyDescriptor dpd = null;
                if (fe is TextBlock)
                {
                    dpd = DependencyPropertyDescriptor.FromProperty(TextBlock.TextProperty, typeof(TextBlock));
                }
                else if (fe is Label)
                {
                    dpd = DependencyPropertyDescriptor.FromProperty(ContentControl.ContentProperty, typeof(ContentControl));
                }

                if (dpd == null) return;
                if (add) dpd.AddValueChanged(fe, Element_OnTextChanged);
                else dpd.RemoveValueChanged(fe, Element_OnTextChanged);
            }
            catch
            {
                // Ignore descriptor issues in rare runtime cases.
            }
        }

        private static void TryAdjust(FrameworkElement fe)
        {
            if (fe == null) return;
            if (!GetIsEnabled(fe)) return;
            if (GetIsAdjusting(fe)) return;

            var text = GetElementText(fe);
            if (string.IsNullOrEmpty(text)) return;

            if (!ShouldAutoScaleForCurrentCulture(text))
            {
                RestoreOriginalFontSize(fe);
                return;
            }

            var availableWidth = GetAvailableWidth(fe);
            if (double.IsNaN(availableWidth) || availableWidth <= 1) return;

            var min = GetMinFontSize(fe);
            if (double.IsNaN(min) || min <= 0) min = 6d;

            var step = GetStep(fe);
            if (double.IsNaN(step) || step < 0.1) step = 0.5d;

            var current = GetElementFontSize(fe);
            if (double.IsNaN(current) || current <= 0) return;

            var max = GetMaxFontSize(fe);
            if (double.IsNaN(max) || max <= 0) max = current;
            // Never enlarge: auto-fit should only reduce font size when needed.
            if (max > current) max = current;

            var startFont = Math.Min(current, max);
            if (startFont < min) startFont = min;

            SetIsAdjusting(fe, true);
            try
            {
                var font = startFont;
                var desired = MeasureTextWidth(fe, text, font);
                if (desired <= 0) return;

                while (font > min && desired > availableWidth + 0.5)
                {
                    font = Math.Max(min, font - step);
                    desired = MeasureTextWidth(fe, text, font);
                    if (desired <= 0) break;
                }

                // Hard-fit fallback: when very narrow slots (e.g., 28px) still overflow at MinFontSize,
                // keep shrinking proportionally so text always fits in the available width.
                if (desired > availableWidth + 0.5)
                {
                    var hardFont = font;
                    for (var i = 0; i < 6 && desired > availableWidth + 0.5; i++)
                    {
                        var ratio = availableWidth / Math.Max(1.0, desired);
                        hardFont = Math.Max(1.0, hardFont * ratio);
                        desired = MeasureTextWidth(fe, text, hardFont);
                        if (desired <= 0) break;
                    }

                    font = hardFont;
                }

                if (!double.IsNaN(font) && font > 0 && Math.Abs(current - font) > 0.01)
                {
                    SetElementFontSize(fe, font);
                }
            }
            finally
            {
                SetIsAdjusting(fe, false);
            }
        }

        private static string GetElementText(FrameworkElement fe)
        {
            if (fe is TextBlock tb) return tb.Text;
            if (fe is Label label) return label.Content as string ?? label.Content?.ToString();
            return null;
        }

        private static bool ShouldAutoScaleForCurrentCulture(string text)
        {
            // Requirement: auto-scale for English UI only, keep Chinese font size unchanged.
            var culture = CultureInfo.CurrentUICulture;
            var name = culture?.Name ?? string.Empty;
            if (name.StartsWith("en", StringComparison.OrdinalIgnoreCase))
            {
                return true;
            }

            // Fallback: if actual rendered text is Latin-heavy, still auto-scale.
            // This avoids clipping when culture detection is out of sync.
            if (string.IsNullOrWhiteSpace(text)) return false;
            foreach (var ch in text)
            {
                if ((ch >= 'A' && ch <= 'Z') || (ch >= 'a' && ch <= 'z'))
                {
                    return true;
                }
            }

            return false;
        }

        private static void RestoreOriginalFontSize(FrameworkElement fe)
        {
            var original = GetOriginalFontSize(fe);
            if (double.IsNaN(original) || original <= 0) return;

            var current = GetElementFontSize(fe);
            if (double.IsNaN(current) || current <= 0) return;

            if (Math.Abs(current - original) > 0.01)
            {
                SetElementFontSize(fe, original);
            }
        }

        private static double GetElementFontSize(FrameworkElement fe)
        {
            if (fe is TextBlock tb) return tb.FontSize;
            if (fe is Label label) return label.FontSize;
            return double.NaN;
        }

        private static void SetElementFontSize(FrameworkElement fe, double value)
        {
            if (fe is TextBlock tb) tb.FontSize = value;
            else if (fe is Label label) label.FontSize = value;
        }

        private static double GetAvailableWidth(FrameworkElement fe)
        {
            double width = double.PositiveInfinity;

            // Explicit width on the element itself should be a hard cap.
            if (!double.IsNaN(fe.Width) && !double.IsInfinity(fe.Width) && fe.Width > 1)
            {
                width = Math.Min(width, fe.Width - fe.Margin.Left - fe.Margin.Right);
            }

            if (!double.IsNaN(fe.MaxWidth) && !double.IsInfinity(fe.MaxWidth) && fe.MaxWidth > 1)
            {
                width = Math.Min(width, fe.MaxWidth - fe.Margin.Left - fe.Margin.Right);
            }

            // Prefer the real layout slot first. This is usually the most accurate
            // "space actually assigned by layout" for the element.
            var slot = LayoutInformation.GetLayoutSlot(fe);
            if (!double.IsNaN(slot.Width) && !double.IsInfinity(slot.Width))
            {
                var slotWidth = slot.Width - fe.Margin.Left - fe.Margin.Right;
                if (slotWidth > 1) width = Math.Min(width, slotWidth);
            }

            if (fe.ActualWidth > 1) width = Math.Min(width, fe.ActualWidth);

            // Immediate parent may be a StackPanel that does not constrain width.
            // Walk a few ancestors and take the tightest finite width as fallback.
            DependencyObject ancestor = fe.Parent ?? VisualTreeHelper.GetParent(fe);
            var depth = 0;
            while (ancestor != null && depth < 8)
            {
                if (ancestor is FrameworkElement af && af.ActualWidth > 1)
                {
                    var candidate = af.ActualWidth;

                    // If ancestor sets explicit width, treat it as a stronger cap.
                    if (!double.IsNaN(af.Width) && !double.IsInfinity(af.Width) && af.Width > 1)
                    {
                        candidate = Math.Min(candidate, af.Width);
                    }

                    if (!double.IsNaN(af.MaxWidth) && !double.IsInfinity(af.MaxWidth) && af.MaxWidth > 1)
                    {
                        candidate = Math.Min(candidate, af.MaxWidth);
                    }

                    if (ancestor is Control ac)
                    {
                        candidate -= ac.Padding.Left + ac.Padding.Right;
                        candidate -= ac.BorderThickness.Left + ac.BorderThickness.Right;
                    }
                    else if (ancestor is Border ab)
                    {
                        candidate -= ab.Padding.Left + ab.Padding.Right;
                        candidate -= ab.BorderThickness.Left + ab.BorderThickness.Right;
                    }

                    if (candidate > 1) width = Math.Min(width, candidate);
                }

                ancestor = (ancestor as FrameworkElement)?.Parent ?? VisualTreeHelper.GetParent(ancestor);
                depth++;
            }

            if (double.IsInfinity(width) || double.IsNaN(width) || width <= 1) return -1;

            // Keep width as inner text area.
            if (fe is Control control)
            {
                width -= control.Padding.Left + control.Padding.Right;
                width -= control.BorderThickness.Left + control.BorderThickness.Right;
            }
            else if (fe is Border border)
            {
                width -= border.Padding.Left + border.Padding.Right;
                width -= border.BorderThickness.Left + border.BorderThickness.Right;
            }

            return width;
        }

        private static double MeasureTextWidth(FrameworkElement fe, string text, double fontSize)
        {
            try
            {
                var dpi = VisualTreeHelper.GetDpi(fe);
                var culture = CultureInfo.CurrentUICulture;

                if (fe.Language != null)
                {
                    try
                    {
                        culture = fe.Language.GetEquivalentCulture();
                    }
                    catch
                    {
                    }
                }

                var fontFamily = SystemFonts.MessageFontFamily;
                var fontStyle = FontStyles.Normal;
                var fontWeight = FontWeights.Normal;
                var fontStretch = FontStretches.Normal;
                Brush foreground = Brushes.Black;
                var flowDirection = FlowDirection.LeftToRight;

                if (fe is TextBlock tb)
                {
                    fontFamily = tb.FontFamily;
                    fontStyle = tb.FontStyle;
                    fontWeight = tb.FontWeight;
                    fontStretch = tb.FontStretch;
                    foreground = tb.Foreground;
                    flowDirection = tb.FlowDirection;
                }
                else if (fe is Label label)
                {
                    fontFamily = label.FontFamily;
                    fontStyle = label.FontStyle;
                    fontWeight = label.FontWeight;
                    fontStretch = label.FontStretch;
                    foreground = label.Foreground;
                    flowDirection = label.FlowDirection;
                }

                var typeface = new Typeface(fontFamily, fontStyle, fontWeight, fontStretch);
                var formatted = new FormattedText(
                    text,
                    culture,
                    flowDirection,
                    typeface,
                    fontSize,
                    foreground,
                    dpi.PixelsPerDip);

                return formatted.WidthIncludingTrailingWhitespace;
            }
            catch
            {
                return -1;
            }
        }
    }
}