ViewLoader.cs

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

using System;
using System.Diagnostics;
using System.Linq;
using System.Reflection;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Navigation;
using Dreamine.MVVM.Core;
using Dreamine.MVVM.ViewModels;
 
namespace Dreamine.UI.Wpf.Controls.ViewRegion
{
    public static class ViewLoader
    {
        public class LoadedViewInfo
        {
            public UserControl? View { get; set; }

            public FrameworkElement? FrameworkView { get; set; }

            public Type? ViewModelType { get; set; }

            public bool IsPopup { get; set; }

            public string? UniqueKey { get; set; }
        }

        public static LoadedViewInfo LoadViewWithViewModel(string typeName, bool useSingletonView)
        {
            // \brief Parse popup suffix
            bool isPopup = typeName.EndsWith("_Popup", StringComparison.OrdinalIgnoreCase);
            string actualTypeName = isPopup ? typeName[..^6] : typeName;
 
            // \brief 1) Resolve View type
            var viewType =
                Type.GetType(actualTypeName, throwOnError: false, ignoreCase: true)
                ?? AppDomain.CurrentDomain.GetAssemblies()
                    .SelectManySafe(a => a.GetTypesSafe())
                    .FirstOrDefault(t =>
                        t.FullName?.Equals(actualTypeName, StringComparison.OrdinalIgnoreCase) == true ||
                        t.Name.Equals(actualTypeName.Split('.').Last(), StringComparison.OrdinalIgnoreCase));
 
            // \brief 2) Resolve ViewModel type (FIXED)
            Type? viewModelType = ResolveViewModelType_Strict(actualTypeName, viewType);
 
            // \brief ViewModel exists => reset DataContext strategy may differ
            bool resetDataContext = viewModelType != null;
 
            object? vmInstance = null;
            string? uniqueKey = null;
 
            // \brief 3) Create/Resolve ViewModel instance
            if (viewModelType != null)
            {
                if (useSingletonView)
                {
                    vmInstance = DMContainer.Resolve(viewModelType) ?? Activator.CreateInstance(viewModelType);
                }
                else
                {
                    // \brief Multi instance unique key
                    long typeIndex = ViewModelKeyCache.GetOrIncrement(typeName);
                    uniqueKey = $"{typeName}_{typeIndex:D2}";
 
                    vmInstance = Activator.CreateInstance(viewModelType);
                }
            }
 
            // \brief 4) Create FrameworkElement
            FrameworkElement framework = ResolveFrameworkElement(viewType, actualTypeName, resetDataContext);
 
            // \brief 5) Apply DataContext when VM exists
            if (vmInstance != null)
            {
                ApplyDataContext(framework, vmInstance);
            }
 
            // \brief 6) Ensure wrapper as UserControl
            UserControl wrapper;
            if (framework is UserControl uc)
            {
                wrapper = uc;
            }
            else
            {
                wrapper = new EmbeddedHostControl(framework);
 
                // \note Ensure wrapper has same DataContext as the hosted framework
                if (wrapper.DataContext == null)
                {
                    wrapper.DataContext = framework.DataContext;
                }
            }
 
            return new LoadedViewInfo
            {
                View = wrapper,
                FrameworkView = framework,
                ViewModelType = viewModelType,
                IsPopup = isPopup,
                UniqueKey = uniqueKey
            };
        }

        private static string StripViewSuffix(string name)
        {
            const string suffix = "View";
            if (name.Length > suffix.Length && name.EndsWith(suffix, StringComparison.OrdinalIgnoreCase))
                return name[..^suffix.Length];
            return name;
        }

        private static Type? ResolveViewModelType_Strict(string actualTypeName, Type? viewType)
        {
            // \brief Candidate full names
            var candidates = new List<string>();
 
            // \brief Common: same namespace + ViewModel suffix
            candidates.Add(actualTypeName + "ViewModel");
            candidates.Add(StripViewSuffix(actualTypeName) + "ViewModel");
 
            // \brief Pages -> ViewModels convention
            if (actualTypeName.Contains(".Pages.", StringComparison.OrdinalIgnoreCase))
            {
                var pagesToVm = actualTypeName.Replace(".Pages.", ".ViewModels.", StringComparison.OrdinalIgnoreCase);
                candidates.Add(pagesToVm + "ViewModel");
                candidates.Add(StripViewSuffix(pagesToVm) + "ViewModel");
            }
 
            // \brief Views -> ViewModels convention (optional, but common)
            if (actualTypeName.Contains(".Views.", StringComparison.OrdinalIgnoreCase))
            {
                var viewsToVm = actualTypeName.Replace(".Views.", ".ViewModels.", StringComparison.OrdinalIgnoreCase);
                candidates.Add(viewsToVm + "ViewModel");
                candidates.Add(StripViewSuffix(viewsToVm) + "ViewModel");
            }
 
            // \brief If viewType is known, add "Namespace.ViewModels.{ViewName}ViewModel"
            if (viewType != null)
            {
                string viewNs = viewType.Namespace ?? string.Empty;
                string viewName = viewType.Name;
                string viewNameNoSuffix = StripViewSuffix(viewName);
                if (!string.IsNullOrWhiteSpace(viewNs))
                {
                    candidates.Add($"{viewNs}.ViewModels.{viewName}ViewModel");
                    candidates.Add($"{viewNs}.ViewModels.{viewNameNoSuffix}ViewModel");
                    candidates.Add($"{viewNs}.{viewName}ViewModel");
                    candidates.Add($"{viewNs}.{viewNameNoSuffix}ViewModel");
 
                    // \brief Sibling "Views" -> "ViewModels" namespace swap
                    if (viewNs.Contains(".Views", StringComparison.OrdinalIgnoreCase))
                    {
                        string swappedNs = viewNs.Replace(".Views", ".ViewModels", StringComparison.OrdinalIgnoreCase);
                        candidates.Add($"{swappedNs}.{viewName}ViewModel");
                        candidates.Add($"{swappedNs}.{viewNameNoSuffix}ViewModel");
                    }
                }
 
                // \brief Short name candidates
                candidates.Add(viewName + "ViewModel");
                candidates.Add(viewNameNoSuffix + "ViewModel");
            }
 
            // \brief De-duplicate
            candidates = candidates
                .Where(x => !string.IsNullOrWhiteSpace(x))
                .Distinct(StringComparer.OrdinalIgnoreCase)
                .ToList();
 
            // \brief Search with strict filtering
            foreach (var cand in candidates)
            {
                var t = AppDomain.CurrentDomain.GetAssemblies()
                    .SelectManySafe(a => a.GetTypesSafe())
                    .FirstOrDefault(x =>
                        x.FullName?.Equals(cand, StringComparison.OrdinalIgnoreCase) == true ||
                        x.Name.Equals(cand.Split('.').Last(), StringComparison.OrdinalIgnoreCase));
 
                if (t == null)
                {
                    continue;
                }
 
                // \brief Must be a concrete class
                if (!t.IsClass || t.IsAbstract)
                {
                    continue;
                }
 
                // \brief Prevent selecting View type as ViewModel
                if (typeof(FrameworkElement).IsAssignableFrom(t))
                {
                    continue;
                }
 
                // \brief Strong filter: must be ViewModelBase (your framework)
                if (!typeof(ViewModelBase).IsAssignableFrom(t))
                {
                    continue;
                }
 
                return t;
            }
 
            return null;
        }

        private static FrameworkElement ResolveFrameworkElement(Type? viewType, string typeName, bool resetDataContext) 
        {
            if (viewType == null || viewType.IsAbstract)
            {
                return new TextBlock
                {
                    Text = $"[No View Type: {typeName}]",
                    Margin = new Thickness(8)
                };
            }
 
            object? instance = null;
 
            // 1차: VsControls를 통한 생성 시도 (항상 새 인스턴스)
            try
            {
                instance = DMContainer.Resolve(viewType);
            }
            catch (Exception ex)
            {
                System.Diagnostics.Debug.WriteLine($"[ViewLoader] VsContainer.Resolve 실패: {typeName} - {ex.Message}");
            }
 
            // 2차: 컨테이너 생성 실패 시 Activator.CreateInstance로 폴백
            if (instance == null)
            {
                try
                {
                    instance = Activator.CreateInstance(viewType);
                }
                catch (Exception ex)
                {
                    return new TextBlock
                    {
                        Text = $"[CreateInstance Failed: {typeName}] {ex.Message}",
                        Margin = new Thickness(8)
                    };
                }
            }
 
            switch (instance)
            {
                // --- UserControl 그대로 사용 ---
                case UserControl uc:
                    {
                        if (resetDataContext)
                        {
                            uc.DataContext = null;
                        }
                        return uc;
                    }
 
                // --- Page → Frame 호스팅 ---
                case Page page:
                    {
                        if (resetDataContext)
                        {
                            page.DataContext = null;
                        }
 
                        var frame = new Frame
                        {
                            Content = page,
                            NavigationUIVisibility = NavigationUIVisibility.Hidden,
                            JournalOwnership = JournalOwnership.OwnsJournal
                        };
 
                        if (resetDataContext)
                        {
                            frame.DataContext = null;
                        }
 
                        return frame;
                    }
 
                // --- Window → ContentControl 호스팅 ---
                case Window win:
                    {
                        if (win.Content is FrameworkElement content)
                        {
                            if (resetDataContext)
                            {
                                content.DataContext = null;
                                win.DataContext = null;
                            }
 
                            win.Content = null;
                            var host = new ContentControl
                            {
                                Content = content
                            };
 
                            if (resetDataContext)
                            {
                                host.DataContext = null;
                            }
 
                            MergeResources(host.Resources, win.Resources);
                            return host;
                        }
 
                        return new TextBlock
                        {
                            Text = $"[Window has no Content: {typeName}]",
                            Margin = new Thickness(8)
                        };
                    }
 
                // --- 기타 FrameworkElement ---
                case FrameworkElement fe:
                    {
                        if (resetDataContext)
                        {
                            fe.DataContext = null;
                        }
                        return fe;
                    }
 
                default:
                    {
                        return new TextBlock
                        {
                            Text = $"[Unknown View Type: {viewType.FullName}]",
                            Margin = new Thickness(8)
                        };
                    }
            }
        }

        private static void ApplyDataContext(FrameworkElement root, object vm)
        {
            if (root == null || vm == null)
            {
                return;
            }
 
            // --- Frame 전용 처리: Page 로드 타이밍 보장 ---
            if (root is Frame fr)
            {
                // Frame 자신에도 ViewModel 설정
                fr.DataContext = vm;
 
                // 로컬: 실제 컨텐츠에 주입
#pragma warning disable CS1587 // Doxygen documents local functions; the C# compiler does not attach XML docs to them.
                void TrySet(FrameworkElement fe)
                {
                    if (fe != null)
                    {
                        fe.DataContext = vm;
                    }
                }
#pragma warning restore CS1587
 
                // 로컬: Loaded 이후 1회성 주입
#pragma warning disable CS1587 // Doxygen documents local functions; the C# compiler does not attach XML docs to them.
                void OnLoaded(object? s, RoutedEventArgs e)
                {
                    if (s is FrameworkElement fe)
                    {
                        fe.Loaded -= OnLoaded;
                        TrySet(fe);
                    }
                }
#pragma warning restore CS1587
 
                // 로컬: 네비게이션 직후 1회성 주입
#pragma warning disable CS1587 // Doxygen documents local functions; the C# compiler does not attach XML docs to them.
                void OnNavigated(object? s, NavigationEventArgs e)
                {
                    fr.Navigated -= OnNavigated;
 
                    if (fr.Content is FrameworkElement fe)
                    {
                        if (!fe.IsLoaded)
                        {
                            fe.Loaded += OnLoaded;
                        }
 
                        TrySet(fe);
                    }
                }
#pragma warning restore CS1587
 
                // 현재 시점에 컨텐츠가 있으면 즉시/Loaded에서 주입
                if (fr.Content is FrameworkElement current)
                {
                    if (!current.IsLoaded)
                    {
                        current.Loaded += OnLoaded;
                    }
 
                    TrySet(current);
                }
                else
                {
                    // 아직 Page가 없음 → 다음 네비게이션에서 주입
                    fr.Navigated += OnNavigated;
                }
 
                return;
            }
 
            // --- ContentControl 호스트 처리 ---
            if (root is ContentControl cc && cc.Content is FrameworkElement innerCc)
            {
                cc.DataContext = vm;
                innerCc.DataContext = vm;
                return;
            }
 
            // --- 일반 FrameworkElement 처리 ---
            root.DataContext = vm;
        }
 

        private static void MergeResources(ResourceDictionary target, ResourceDictionary source)
        {
            foreach (var rd in source.MergedDictionaries)
                target.MergedDictionaries.Add(rd);
 
            foreach (var key in source.Keys)
                if (!target.Contains(key))
                    target.Add(key, source[key]);
        }

        private static Type[] GetTypesSafe(this Assembly asm)
        {
            try { return asm.GetTypes(); }
            catch (ReflectionTypeLoadException ex) { return ex.Types.Where(t => t != null).ToArray()!; }
        }

        private static IEnumerable<T> SelectManySafe<T>(this IEnumerable<Assembly> assemblies, Func<Assembly, IEnumerable<T>> selector)
        {
            foreach (var a in assemblies)
            {
                if (a.IsDynamic) continue;
                IEnumerable<T>? res = null;
                try { res = selector(a); }
                catch (Exception ex) { Debug.WriteLine($"[ViewLoader] Assembly scan 실패 ({a.FullName}): {ex.Message}"); }
                if (res != null) foreach (var x in res) yield return x;
            }
        }

        private sealed class EmbeddedHostControl : UserControl
        {
            public EmbeddedHostControl(FrameworkElement inner)
            {
                Content = inner;
            }
        }
    }
}