DreamineControl.cs

이 파일의 문서화 페이지로 가기

// ============================================================================
// \file DreamineTabHost.SingleFile.cs
// \brief DreamineTabHost + DreamineTabHostItem (single-file copy/paste version)
// \details
//  - Allows XAML usage like:
//      <vs:DreamineTabHost>
//          <vs:DreamineTabHostItem Content="UiComponentDashboard"/>
//          <vs:DreamineTabHostItem Content="LocalizationDashboard"/>
//      </vs:DreamineTabHost>
//  - Achieved via [ContentProperty(nameof(Items))] so children go into Items,
//    not into Content (avoids "Content set more than once").
//  - Still supports ContentList / ContentTypeList DP-based inputs.
//  - Runtime view loading uses ViewLoader.LoadViewWithViewModel(...).
//  - Popup naming convention: "*_Popup".
//  - Visibility notification to root DataContext via IVisibilityAware.
// \date 2026-02-12
// ============================================================================
 
using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.ComponentModel;
using System.Linq;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Markup;
using System.Windows.Threading;
using Dreamine.MVVM.Core;
using Dreamine.MVVM.Interfaces;
using Dreamine.UI.Wpf.Controls.ViewRegion;
 
namespace Dreamine.UI.Wpf.Controls
{
    [ContentProperty(nameof(Items))]
    public class DreamineTabHost : ContentControl
    {
        public ObservableCollection<DreamineTabHostItem> Items { get; } = new ObservableCollection<DreamineTabHostItem>();

        private FrameworkElement? _currentView;

        private readonly Dictionary<string, FrameworkElement> _views = new Dictionary<string, FrameworkElement>();

        private readonly List<string> _order = new List<string>();

        private readonly PopupWindowManager _popupManager = PopupWindowManager.Instance;

        private ViewSwitcher? _viewSwitcher;

        private Grid _containerGrid = null!;

        private bool _isSwitchScheduled;

        private int _designLastIndex = -1;

        private readonly Dictionary<FrameworkElement, bool> _lastVisibilityState = new Dictionary<FrameworkElement, bool>();
 
        #region ===== Popup awareness: Flag DP & Readonly DP =====

        public static readonly DependencyProperty TargetAnalyzedProperty =
            DependencyProperty.Register(
                nameof(TargetAnalyzed),
                typeof(bool),
                typeof(DreamineTabHost),
                new PropertyMetadata(false));

        public bool TargetAnalyzed
        {
            get => (bool)GetValue(TargetAnalyzedProperty);
            set => SetValue(TargetAnalyzedProperty, value);
        }

        private static readonly DependencyPropertyKey IsCurrentTargetPopupPropertyKey =
            DependencyProperty.RegisterReadOnly(
                nameof(IsCurrentTargetPopup),
                typeof(bool),
                typeof(DreamineTabHost),
                new PropertyMetadata(false));

        public static readonly DependencyProperty IsCurrentTargetPopupProperty =
            IsCurrentTargetPopupPropertyKey.DependencyProperty;

        public bool IsCurrentTargetPopup
        {
            get => (bool)GetValue(IsCurrentTargetPopupProperty);
            private set => SetValue(IsCurrentTargetPopupPropertyKey, value);
        }
 
        #endregion

        public DreamineTabHost()
        {
            // \brief Keep default DP collections alive
            ContentList = new ObservableCollection<string>();
 
            // \brief When XAML children change, re-init
            Items.CollectionChanged += (_, __) => TryInitViews();
        }
 
        // =====================================================================
        // Dependency Properties (Public)
        // =====================================================================

        public static readonly DependencyProperty ContentListProperty =
            DependencyProperty.Register(
                nameof(ContentList),
                typeof(ObservableCollection<string>),
                typeof(DreamineTabHost),
                new PropertyMetadata(new ObservableCollection<string>(), OnContentInputsChanged));

        public ObservableCollection<string> ContentList
        {
            get => (ObservableCollection<string>)GetValue(ContentListProperty);
            set => SetValue(ContentListProperty, value);
        }

        public static readonly DependencyProperty ContentTypeListProperty =
            DependencyProperty.Register(
                nameof(ContentTypeList),
                typeof(ObservableCollection<string>),
                typeof(DreamineTabHost),
                new PropertyMetadata(null, OnContentInputsChanged));

        public ObservableCollection<string> ContentTypeList
        {
            get => (ObservableCollection<string>)GetValue(ContentTypeListProperty);
            set => SetValue(ContentTypeListProperty, value);
        }

        public static readonly DependencyProperty CurrentViewProperty =
            DependencyProperty.Register(
                nameof(CurrentView),
                typeof(string),
                typeof(DreamineTabHost),
                new PropertyMetadata(string.Empty, OnCurrentViewChanged));

        public string CurrentView
        {
            get => (string)GetValue(CurrentViewProperty);
            set => SetValue(CurrentViewProperty, value);
        }

        public static readonly DependencyProperty SelectViewProperty =
            DependencyProperty.Register(
                nameof(SelectView),
                typeof(int),
                typeof(DreamineTabHost),
                new PropertyMetadata(0, OnSelectViewChanged));

        public int SelectView
        {
            get => (int)GetValue(SelectViewProperty);
            set => SetValue(SelectViewProperty, value);
        }

        public static readonly DependencyProperty UseSingletonViewProperty =
            DependencyProperty.Register(
                nameof(UseSingletonView),
                typeof(bool),
                typeof(DreamineTabHost),
                new PropertyMetadata(true, OnContentInputsChanged));

        public bool UseSingletonView
        {
            get => (bool)GetValue(UseSingletonViewProperty);
            set => SetValue(UseSingletonViewProperty, value);
        }
 
        // ----- Design hints -----

        public static readonly DependencyProperty DesignBaseNamespaceHintProperty =
            DependencyProperty.Register(
                nameof(DesignBaseNamespaceHint),
                typeof(string),
                typeof(DreamineTabHost),
                new PropertyMetadata(string.Empty, OnDesignHintChanged));

        public string DesignBaseNamespaceHint
        {
            get => (string)GetValue(DesignBaseNamespaceHintProperty);
            set => SetValue(DesignBaseNamespaceHintProperty, value);
        }

        public static readonly DependencyProperty DesignAssemblyHintProperty =
            DependencyProperty.Register(
                nameof(DesignAssemblyHint),
                typeof(string),
                typeof(DreamineTabHost),
                new PropertyMetadata(string.Empty, OnDesignHintChanged));

        public string DesignAssemblyHint
        {
            get => (string)GetValue(DesignAssemblyHintProperty);
            set => SetValue(DesignAssemblyHintProperty, value);
        }

        public static readonly DependencyProperty AutoWireDesignViewModelProperty =
            DependencyProperty.Register(
                nameof(AutoWireDesignViewModel),
                typeof(bool),
                typeof(DreamineTabHost),
                new PropertyMetadata(true, OnDesignHintChanged));

        public bool AutoWireDesignViewModel
        {
            get => (bool)GetValue(AutoWireDesignViewModelProperty);
            set => SetValue(AutoWireDesignViewModelProperty, value);
        }
 
        // =====================================================================
        // DP Callbacks
        // =====================================================================

        private static void OnContentInputsChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
        {
            if (d is DreamineTabHost c)
            {
                c.TryInitViews();
            }
        }

        private static void OnDesignHintChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
        {
            if (d is DreamineTabHost c && c.IsInDesignMode())
            {
                c.TryInitViews();
            }
        }

        private static void OnCurrentViewChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
        {
            if (d is DreamineTabHost ctrl && e.NewValue is string viewName)
            {
                ctrl.Dispatcher.BeginInvoke(new Action(() =>
                {
                    ctrl.SwitchToViewInternal(viewName);
                }), DispatcherPriority.Background);
            }
        }

        private static void OnSelectViewChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
        {
            if (d is DreamineTabHost c)
            {
                c.ScheduleSwitch();
            }
        }
 
        // =====================================================================
        // Lifecycle
        // =====================================================================

        protected override void OnInitialized(EventArgs e)
        {
            base.OnInitialized(e);
 
            // \brief Ensure initialization after XAML children (Items) are populated.
            Dispatcher.InvokeAsync(() =>
            {
                TryInitViews();
            }, DispatcherPriority.ContextIdle);
        }
 
        // =====================================================================
        // Switching
        // =====================================================================

        private void ScheduleSwitch()
        {
            if (_isSwitchScheduled)
            {
                return;
            }
 
            _isSwitchScheduled = true;
 
            Dispatcher.BeginInvoke(new Action(() =>
            {
                try
                {
                    if (IsInDesignMode())
                    {
                        UpdateVisibleViewDesign();
                    }
                    else
                    {
                        UpdateVisibleView();
                    }
                }
                finally
                {
                    _isSwitchScheduled = false;
                }
            }), DispatcherPriority.Input);
        }

        private void SwitchToViewInternal(string? targetKey)
        {
            if (_viewSwitcher == null)
            {
                return;
            }
 
            if (string.IsNullOrWhiteSpace(targetKey))
            {
                return;
            }
 
            bool isPopup = _viewSwitcher.IsPopupName(targetKey);
 
            if (TargetAnalyzed)
            {
                IsCurrentTargetPopup = isPopup;
            }
 
            // \note IMPORTANT:
            //  - We intentionally call Switch(key) WITHOUT extra named parameters,
            //    because your ViewSwitcher signature currently does not accept targetAnalyzed (CS1739).
            _viewSwitcher.Switch(targetKey, isPopup);
 
            if (!isPopup && _views.TryGetValue(targetKey, out var nextView))
            {
                _currentView = nextView;
            }
        }

        private void UpdateVisibleView()
        {
            if (_viewSwitcher == null)
            {
                return;
            }
 
            // \brief Prefer ordered keys (stable), not Dictionary iteration.
            string? targetKey = _order.ElementAtOrDefault(SelectView);
 
            // \brief If missing, fallback: if the original declared entry is "*_Popup", map it.
            if (string.IsNullOrWhiteSpace(targetKey))
            {
                var raw = GetDeclaredRawEntryAt(SelectView);
                if (!string.IsNullOrWhiteSpace(raw) &&
                    raw.EndsWith("_Popup", StringComparison.OrdinalIgnoreCase))
                {
                    string withoutSuffix = raw[..^6];
                    targetKey = DeriveSimpleKeyFromType(withoutSuffix);
                }
            }
 
            if (string.IsNullOrWhiteSpace(targetKey))
            {
                return;
            }
 
            SwitchToViewInternal(targetKey);
        }

        private void UpdateVisibleViewDesign()
        {
            if (_containerGrid == null || _views.Count == 0)
            {
                return;
            }
 
            int newIndex = SelectView;
            if (newIndex < 0) newIndex = 0;
            if (newIndex >= _order.Count) newIndex = _order.Count - 1;
 
            if (newIndex == _designLastIndex && _containerGrid.Children.Count == 1)
            {
                return;
            }
 
            var newKey = _order.ElementAtOrDefault(newIndex);
            if (string.IsNullOrWhiteSpace(newKey))
            {
                return;
            }
 
            var newView = _views[newKey];
 
            _containerGrid.Children.Clear();
            _containerGrid.Children.Add(newView);
 
            _designLastIndex = newIndex;
        }
 
        // =====================================================================
        // Visibility aware
        // =====================================================================

        private void OnRootIsVisibleChanged(object sender, DependencyPropertyChangedEventArgs e)
        {
            if (sender is not FrameworkElement fe)
            {
                return;
            }
 
            if (fe.DataContext is not IVisibilityAware vm)
            {
                return;
            }
 
            bool isVisible = (bool)e.NewValue;
 
            if (_lastVisibilityState.TryGetValue(fe, out bool last) && last == isVisible)
            {
                return;
            }
 
            _lastVisibilityState[fe] = isVisible;
 
            if (isVisible)
            {
                vm.OnShown();
            }
            else
            {
                vm.OnHidden();
            }
        }
 
        // =====================================================================
        // Initialization
        // =====================================================================

        private void TryInitViews()
        {
            // \brief Prepare container
            _containerGrid ??= new Grid();
            Content = _containerGrid;
 
            _containerGrid.Children.Clear();
            _views.Clear();
            _order.Clear();
            _currentView = null;
            _lastVisibilityState.Clear();
 
            // \brief Build pairs from:
            //  1) Items (XAML children) if present
            //  2) otherwise DP collections (ContentList/ContentTypeList)
            var pairs = BuildPairsFromItemsOrDps();
 
            if (pairs.Count == 0)
            {
                return;
            }
 
            if (IsInDesignMode())
            {
                InitDesignViews(pairs);
                UpdateVisibleViewDesign();
                return;
            }
 
            // \brief Runtime initialization
            foreach (var (name, typeName) in pairs)
            {
                var result = ViewLoader.LoadViewWithViewModel(typeName, UseSingletonView);
 
                if (result.IsPopup)
                {
                    string actualTypeName = typeName.EndsWith("_Popup", StringComparison.OrdinalIgnoreCase)
                        ? typeName[..^6]
                        : typeName;
 
                    _popupManager.CreatePopup(actualTypeName, result);
                    continue;
                }
 
                if (result.View is null)
                {
                    continue;
                }
 
                _views[name] = result.View;
                _order.Add(name);
 
                // \brief Visibility hook attach (dedupe)
                result.View.IsVisibleChanged -= OnRootIsVisibleChanged;
                result.View.IsVisibleChanged += OnRootIsVisibleChanged;
 
                _containerGrid.Children.Add(result.View);
 
                // \brief Default visibility
                result.View.Visibility = UseSingletonView ? Visibility.Collapsed : Visibility.Visible;
            }
 
            _viewSwitcher = new ViewSwitcher(_popupManager.Windows, _views, UseSingletonView);
 
            // \brief Initial switch
            if (!string.IsNullOrWhiteSpace(CurrentView) && _views.ContainsKey(CurrentView))
            {
                SwitchToViewInternal(CurrentView);
            }
            else
            {
                UpdateVisibleView();
            }
        }

        private List<(string name, string typeName)> BuildPairsFromItemsOrDps()
        {
            // \brief 1) Items (XAML children)
            var fromItems = BuildPairsFromItems();
            if (fromItems.Count > 0)
            {
                return EnsureUniqueNames(fromItems);
            }
 
            // \brief 2) DPs (ContentList / ContentTypeList)
            var fromDps = BuildNameTypePairs_NoMutation(ContentList, ContentTypeList);
            return EnsureUniqueNames(fromDps);
        }

        private List<(string name, string typeName)> BuildPairsFromItems()
        {
            var result = new List<(string name, string typeName)>();
 
            if (Items == null || Items.Count == 0)
            {
                return result;
            }
 
            foreach (var it in Items)
            {
                var raw = it?.Content?.ToString() ?? string.Empty;
                if (string.IsNullOrWhiteSpace(raw))
                {
                    continue;
                }
 
                // \brief If Popup flag is set, normalize to "*_Popup" convention.
                string typeName = it!.Popup && !raw.EndsWith("_Popup", StringComparison.OrdinalIgnoreCase)
                    ? raw + "_Popup"
                    : raw;
 
                string name = !string.IsNullOrWhiteSpace(it.Key)
                    ? it.Key
                    : DeriveSimpleKeyFromType(typeName.EndsWith("_Popup", StringComparison.OrdinalIgnoreCase) ? typeName[..^6] : typeName);
 
                // \brief If a separate Type is provided, use it as concrete type.
                if (!string.IsNullOrWhiteSpace(it.Type))
                {
                    typeName = it.Type;
                    if (it.Popup && !typeName.EndsWith("_Popup", StringComparison.OrdinalIgnoreCase))
                    {
                        typeName += "_Popup";
                    }
                }
 
                result.Add((name, typeName));
            }
 
            return result;
        }

        private string? GetDeclaredRawEntryAt(int index)
        {
            if (Items != null && Items.Count > 0)
            {
                var it = Items.ElementAtOrDefault(index);
                return it?.Content?.ToString();
            }
 
            return ContentList?.ElementAtOrDefault(index);
        }

        private void InitDesignViews(List<(string name, string typeName)> pairs)
        {
            foreach (var (name, typeName) in pairs)
            {
                var candidates = BuildDesignTypeCandidates(typeName, DesignBaseNamespaceHint, DesignAssemblyHint);
 
                UserControl? view = null;
                foreach (var cand in candidates)
                {
                    view = TryCreateDesignView(cand);
                    if (view != null) break;
                }
 
                view ??= MakeDesignPlaceholder(name);
 
                if (AutoWireDesignViewModel && view.DataContext == null)
                {
                    AttachDesignViewModelIfEmpty(view);
                }
 
                _views[name] = view;
                _order.Add(name);
            }
 
            _containerGrid.Children.Clear();
 
            var idx = Math.Clamp(SelectView, 0, Math.Max(0, _order.Count - 1));
            if (_order.Count > 0)
            {
                var key = _order[idx];
                _containerGrid.Children.Add(_views[key]);
                _designLastIndex = idx;
            }
        }
 
        // =====================================================================
        // Helpers
        // =====================================================================

        private bool IsInDesignMode()
            => DesignerProperties.GetIsInDesignMode(this);

        private static List<(string name, string typeName)> EnsureUniqueNames(List<(string name, string typeName)> pairs)
        {
            var result = new List<(string name, string typeName)>(pairs);
            var seen = new HashSet<string>(StringComparer.Ordinal);
 
            for (int i = 0; i < result.Count; i++)
            {
                var (n, t) = result[i];
                if (string.IsNullOrWhiteSpace(n))
                {
                    n = DeriveSimpleKeyFromType(t);
                }
 
                if (seen.Add(n))
                {
                    result[i] = (n, t);
                    continue;
                }
 
                int k = 2;
                string c;
                do
                {
                    c = $"{n}_{k++}";
                }
                while (!seen.Add(c));
 
                result[i] = (c, t);
            }
 
            return result;
        }

        private static List<(string name, string typeName)> BuildNameTypePairs_NoMutation(
            ObservableCollection<string>? names,
            ObservableCollection<string>? types)
        {
            var result = new List<(string name, string typeName)>();
 
            var hasNames = names is { Count: > 0 };
            var hasTypes = types is { Count: > 0 };
 
            if (!hasNames && !hasTypes)
            {
                return result;
            }
 
            if (hasNames && hasTypes)
            {
                var count = Math.Min(names!.Count, types!.Count);
                for (int i = 0; i < count; i++)
                {
                    var typeName = types[i] ?? string.Empty;
                    var name = string.IsNullOrWhiteSpace(names[i])
                        ? DeriveSimpleKeyFromType(typeName)
                        : names[i];
 
                    result.Add((name, typeName));
                }
            }
            else if (hasTypes)
            {
                foreach (var t in types!)
                {
                    var typeName = t ?? string.Empty;
                    var name = DeriveSimpleKeyFromType(typeName);
                    result.Add((name, typeName));
                }
            }
            else
            {
                foreach (var n in names!)
                {
                    var typeName = n ?? string.Empty;
                    var name = DeriveSimpleKeyFromType(typeName);
                    result.Add((name, typeName));
                }
            }
 
            return result;
        }

        private static string DeriveSimpleKeyFromType(string raw)
            => string.IsNullOrWhiteSpace(raw)
                ? string.Empty
                : (raw.Contains('.') ? raw.Split('.').Last() : raw);

        private static string[] BuildDesignTypeCandidates(string raw, string baseNs, string asmHint)
        {
            var list = new List<string> { raw };
 
            if (!string.IsNullOrWhiteSpace(asmHint) && !raw.Contains(","))
            {
                list.Add($"{raw}, {asmHint}");
            }
 
            if (!raw.Contains('.') && !string.IsNullOrWhiteSpace(baseNs))
            {
                var full = $"{baseNs}.{raw}";
                list.Add(full);
 
                if (!string.IsNullOrWhiteSpace(asmHint))
                {
                    list.Add($"{full}, {asmHint}");
                }
            }
 
            return list.Distinct().ToArray();
        }

        private static UserControl? TryCreateDesignView(string typeName)
        {
            try
            {
                Type? t = null;
 
                if (typeName.Contains(","))
                {
                    t = Type.GetType(typeName, throwOnError: false, ignoreCase: false);
                }
 
                if (t == null)
                {
                    t = FindTypeByName(typeName);
                }
 
                if (t == null || !typeof(UserControl).IsAssignableFrom(t))
                {
                    return null;
                }
 
                try
                {
                    return Activator.CreateInstance(t) as UserControl;
                }
                catch
                {
                    return Activator.CreateInstance(t, nonPublic: true) as UserControl;
                }
            }
            catch
            {
                return null;
            }
        }

        private static Type? FindTypeByName(string name)
        {
            var asms = AppDomain.CurrentDomain.GetAssemblies();
 
            if (name.Contains('.'))
            {
                foreach (var asm in asms)
                {
                    var t = asm.GetType(name, throwOnError: false, ignoreCase: false);
                    if (t != null)
                    {
                        return t;
                    }
                }
            }
 
            foreach (var asm in asms)
            {
                try
                {
                    var t = asm.GetTypes().FirstOrDefault(x => x.Name == name);
                    if (t != null)
                    {
                        return t;
                    }
                }
                catch
                {
                    // ignore reflection errors
                }
            }
 
            return null;
        }

        private static UserControl MakeDesignPlaceholder(string title)
        {
            return new UserControl
            {
                Content = new Border
                {
                    Background = System.Windows.Media.Brushes.White,
                    BorderBrush = System.Windows.Media.Brushes.LightSteelBlue,
                    BorderThickness = new Thickness(2),
                    CornerRadius = new CornerRadius(6),
                    Padding = new Thickness(8),
                    Child = new TextBlock
                    {
                        Text = $"[design] {title}",
                        FontSize = 16,
                        Foreground = System.Windows.Media.Brushes.Black
                    }
                }
            };
        }

        private static void AttachDesignViewModelIfEmpty(UserControl view)
        {
            if (view.DataContext != null)
            {
                return;
            }
 
            var vmType = ResolveDesignViewModelType(view.GetType());
            if (vmType == null)
            {
                return;
            }
 
            try
            {
                var vm = DMContainer.Resolve(vmType);
                if (vm != null)
                {
                    view.DataContext = vm;
                }
            }
            catch
            {
                // keep design resilient
            }
        }

        private static Type? ResolveDesignViewModelType(Type viewType)
        {
            var fullCandidate = viewType.FullName + "ViewModel";
            var nsCandidate = $"{viewType.Namespace}.{viewType.Name}ViewModel";
            var shortCandidate = viewType.Name + "ViewModel";
 
            var t = FindTypeByName(fullCandidate);
            if (t != null) return t;
 
            t = FindTypeByName(nsCandidate);
            if (t != null) return t;
 
            return FindTypeByName(shortCandidate);
        }
    }

    public class DreamineTabHostItem : ContentControl
    {
        public static readonly DependencyProperty PopupProperty =
            DependencyProperty.Register(
                nameof(Popup),
                typeof(bool),
                typeof(DreamineTabHostItem),
                new PropertyMetadata(false));

        public bool Popup
        {
            get => (bool)GetValue(PopupProperty);
            set => SetValue(PopupProperty, value);
        }

        public static readonly DependencyProperty KeyProperty =
            DependencyProperty.Register(
                nameof(Key),
                typeof(string),
                typeof(DreamineTabHostItem),
                new PropertyMetadata(string.Empty));

        public string Key
        {
            get => (string)GetValue(KeyProperty);
            set => SetValue(KeyProperty, value);
        }

        public static readonly DependencyProperty TypeProperty =
            DependencyProperty.Register(
                nameof(Type),
                typeof(string),
                typeof(DreamineTabHostItem),
                new PropertyMetadata(string.Empty));

        public string Type
        {
            get => (string)GetValue(TypeProperty);
            set => SetValue(TypeProperty, value);
        }
    }
}