Refactor application structure and add unit tests

Added:
- New `ProgressService` class for managing progress indicators.
- New `AssetDatabase`, `AssetOpenHandlerAttribute`, and `AsyncAssetOpenHandlerAttribute` classes for asset handling.
- `Ghost.UnitTest` project for unit testing with associated files and configurations.

Changed:
- `ActivationHandler` class to ensure correct handling of `LaunchActivatedEventArgs`.
- `App.xaml.cs` to register `INotificationService` and `IProgressService`, replacing `StackedNotificationService`.
- `OnLaunched` method in `App.xaml.cs` to correctly call `ActivationHandler.Handle(args)` and start the host.
- `INavigationAware` interface from internal to public for broader access.
- `EditorState.cs` to activate `EditorApplication` with the current service provider.
- Property names in `AssetItem` and `ExplorerItem` structs to `Name` and `FullName`.
- `NotificationService` class to implement `INotificationService` and refactor notification handling.
- `AssetPathToGlyphConverter` to handle file extensions consistently.
- Bindings in `ProjectPage.xaml` and `ProjectPage.xaml.cs` to use `FullName` instead of `Path`.
- `EngineEditorWindow` and `LandingWindow` classes to utilize new notification and progress services.
- `Logger` class to include a new method for logging errors with exceptions.

Updated:
- Manifest files and project files to reflect new structure and dependencies.
- Solution file `GhostEngine.sln` to include the new unit test project.
- Added several new test classes and methods in `UnitTests.cs`.

Ghost.App/ViewModels/Pages/EngineEditor/ConsoleViewModel.cs

@@ -0,0 +1,92 @@
+using CommunityToolkit.Mvvm.ComponentModel;
+using CommunityToolkit.Mvvm.Input;
+using Ghost.Engine.Models;
+using Ghost.Engine.Services;
+using System.Collections.ObjectModel;
+
+namespace Ghost.Editor.ViewModels.Pages.EngineEditor;
+
+internal partial class ConsoleViewModel : ObservableObject
+{
+    [ObservableProperty]
+    public partial ObservableCollection<LogMessage> Logs
+    {
+        get; set;
+    } = new();
+
+    [ObservableProperty]
+    public partial bool ShowInfo
+    {
+        get; set;
+    } = true;
+
+    [ObservableProperty]
+    public partial bool ShowWarning
+    {
+        get; set;
+    } = true;
+
+    [ObservableProperty]
+    public partial bool ShowError
+    {
+        get; set;
+    } = true;
+
+    [ObservableProperty]
+    public partial bool ShowStackTrace
+    {
+        get; set;
+    } = false;
+
+    [ObservableProperty]
+    public partial LogMessage? SelectedLog
+    {
+        get; set;
+    }
+
+    public ConsoleViewModel()
+    {
+        foreach (var log in Logger.Logs)
+        {
+            Logs.Add(log);
+        }
+
+        Logger.OnLogsUpdate += UpdateLogs;
+    }
+
+    ~ConsoleViewModel()
+    {
+        Logger.OnLogsUpdate -= UpdateLogs;
+    }
+
+    private void UpdateLogs(LogChangeType updateType)
+    {
+        switch (updateType)
+        {
+            case LogChangeType.LogAdded:
+                Logs.Add(Logger.Logs[^1]);
+                break;
+            case LogChangeType.LogRemoved:
+                if (Logs.Count > 0)
+                {
+                    Logs.RemoveAt(0);
+                }
+                break;
+            case LogChangeType.LogsCleared:
+                Logs.Clear();
+                break;
+        }
+    }
+
+    partial void OnShowStackTraceChanged(bool value)
+    {
+        Logger.HasStackTrace = value;
+        Logger.LogInfo($"Stack trace visibility set to {value}.");
+    }
+
+    [RelayCommand]
+    private void ClearLogs()
+    {
+        Logger.Clear();
+    }
+}

Ghost.App/ViewModels/Pages/EngineEditor/HierarchyViewModel.cs

@@ -0,0 +1,38 @@
+using CommunityToolkit.Mvvm.ComponentModel;
+using Ghost.Editor.SceneGraph;
+using System;
+using System.Collections.ObjectModel;
+
+namespace Ghost.Editor.ViewModels.Pages.EngineEditor;
+
+internal partial class HierarchyViewModel : ObservableObject, IDisposable
+{
+    [ObservableProperty]
+    public partial ObservableCollection<WorldNode> SceneList
+    {
+        get;
+        private set;
+    } = new(EditorWorldManager.LoadedWorlds);
+
+    public HierarchyViewModel()
+    {
+        EditorWorldManager.OnWorldLoaded += OnWorldLoaded;
+        EditorWorldManager.OnWorldUnloaded += OnWorldUnloaded;
+    }
+
+    private void OnWorldLoaded(WorldNode node)
+    {
+        SceneList.Add(node);
+    }
+
+    private void OnWorldUnloaded(WorldNode node)
+    {
+        SceneList.Remove(node);
+    }
+
+    public void Dispose()
+    {
+        EditorWorldManager.OnWorldLoaded -= OnWorldLoaded;
+        EditorWorldManager.OnWorldUnloaded -= OnWorldUnloaded;
+    }
+}

Ghost.App/ViewModels/Pages/EngineEditor/ProjectViewModel.cs

@@ -0,0 +1,151 @@
+using CommunityToolkit.Mvvm.ComponentModel;
+using Ghost.App;
+using Ghost.App.Models;
+using Ghost.Data.Services;
+using Ghost.Editor.AssetHandle;
+using System;
+using System.Collections.Generic;
+using System.Collections.ObjectModel;
+using System.IO;
+using System.Threading.Tasks;
+
+namespace Ghost.Editor.ViewModels.Pages.EngineEditor;
+
+internal partial class ProjectViewModel : ObservableObject
+{
+    public ObservableCollection<ExplorerItem> SubDirectories
+    {
+        get;
+    } = new();
+
+    [ObservableProperty]
+    public partial ObservableCollection<ExplorerItem> DirectoryAssets
+    {
+        get;
+        set;
+    } = new();
+
+    [ObservableProperty]
+    public partial ExplorerItem? SelectedDirectory
+    {
+        get;
+        set;
+    }
+
+    [ObservableProperty]
+    public partial ExplorerItem? SelectedAsset
+    {
+        get;
+        set;
+    }
+
+    public ProjectViewModel()
+    {
+        if (ProjectService.CurrentProject.Metadata == null)
+        {
+            throw new InvalidOperationException("Current project is not set.");
+        }
+
+        var assetsRootItem = new ExplorerItem("Assets", Path.Combine(Path.GetDirectoryName(ProjectService.CurrentProject.Path)!, ProjectService.ASSETS_FOLDER), true);
+        LoadSubFolderRecursive(ref assetsRootItem);
+
+        SubDirectories.Add(assetsRootItem);
+    }
+
+    private static void LoadSubFolderRecursive(ref ExplorerItem parentItem)
+    {
+        foreach (var directory in Directory.EnumerateDirectories(parentItem.FullName))
+        {
+            var item = new ExplorerItem(Path.GetFileName(directory), directory, true);
+            LoadSubFolderRecursive(ref item);
+
+            parentItem.Children ??= new();
+            parentItem.Children.Add(item);
+        }
+    }
+
+    public static Task<ExplorerItem?> FindNodeIterative(ExplorerItem root, Func<ExplorerItem, bool> predicate)
+    {
+        var stack = new Stack<ExplorerItem>();
+        stack.Push(root);
+
+        return Task.Run(() =>
+        {
+            while (stack.Count > 0)
+            {
+                var node = stack.Pop();
+                if (predicate(node))
+                {
+                    return node;
+                }
+
+                if (node.Children == null || node.Children.Count == 0)
+                {
+                    continue;
+                }
+
+                for (var i = node.Children.Count - 1; i >= 0; i--)
+                {
+                    stack.Push(node.Children[i]);
+                }
+            }
+
+            return null;
+        });
+    }
+
+    private void NavigateToDirectory(string? path)
+    {
+        GhostApplication.Window?.DispatcherQueue.TryEnqueue(async () =>
+        {
+            DirectoryAssets.Clear();
+
+            if (!Directory.Exists(path))
+            {
+                return;
+            }
+
+            foreach (var directory in Directory.EnumerateDirectories(path))
+            {
+                var directoryItem = new ExplorerItem(Path.GetFileName(directory), directory, true);
+                DirectoryAssets.Add(directoryItem);
+            }
+
+            foreach (var file in Directory.EnumerateFiles(path))
+            {
+                var fileItem = new ExplorerItem(Path.GetFileName(file), file, false);
+                DirectoryAssets.Add(fileItem);
+            }
+
+            SelectedDirectory = await FindNodeIterative(SubDirectories[0], x => x.FullName == path);
+        });
+    }
+
+    public async Task OpenSelected()
+    {
+        if (SelectedAsset == null)
+        {
+            return;
+        }
+
+        if (SelectedAsset.IsDirectory)
+        {
+            NavigateToDirectory(SelectedAsset.FullName);
+        }
+        else
+        {
+            await AssetDatabase.OpenAsset(SelectedAsset.FullName);
+        }
+    }
+
+    partial void OnSelectedDirectoryChanged(ExplorerItem? value)
+    {
+        if (value == null)
+        {
+            return;
+        }
+
+        DirectoryAssets.Clear();
+        NavigateToDirectory(value.FullName);
+    }
+}

Ghost.App/ViewModels/Pages/Landing/CreateProjectViewModel.cs

@@ -0,0 +1,95 @@
+using CommunityToolkit.Mvvm.ComponentModel;
+using CommunityToolkit.Mvvm.Input;
+using Ghost.App.Contracts;
+using Ghost.App.Infrastructures.AppState;
+using Ghost.App.Services;
+using Ghost.App.Utilities;
+using Ghost.Data.Models;
+using Ghost.Data.Services;
+using Ghost.Editor.Models;
+using Ghost.Engine.Resources;
+using System.Collections.ObjectModel;
+using System.IO;
+using System.Linq;
+using System.Threading.Tasks;
+
+namespace Ghost.Editor.ViewModels.Pages.Landing;
+
+internal partial class CreateProjectViewModel(NotificationService notificationService, ProjectService projectService, AppStateMachine stateService) : ObservableObject, INavigationAware
+{
+    public ObservableCollection<TemplateData> templates = new();
+
+    [ObservableProperty]
+    public partial TemplateData? SelectedTemplate
+    {
+        get;
+        set;
+    }
+
+    [ObservableProperty]
+    public partial string? ProjectName
+    {
+        get;
+        set;
+    }
+
+    [ObservableProperty]
+    public partial string? ProjectLocation
+    {
+        get;
+        set;
+    }
+
+    public async void OnNavigatedTo(object? parameter)
+    {
+        templates.Clear();
+        await foreach (var (path, info) in ProjectService.GetProjectTemplatesAsync())
+        {
+            templates.Add(new(path, info));
+        }
+
+        SelectedTemplate = templates.FirstOrDefault();
+    }
+
+    public void OnNavigatedFrom()
+    {
+    }
+
+    [RelayCommand]
+    private async Task SelectionProjectLocation()
+    {
+        var folder = await SystemUtilities.OpenFolderPickerAsync();
+        if (folder != null)
+        {
+            ProjectLocation = folder.Path;
+        }
+    }
+
+    [RelayCommand]
+    private async Task CreateProject()
+    {
+        if (string.IsNullOrWhiteSpace(ProjectName)
+            || !Directory.Exists(ProjectLocation)
+            || !SelectedTemplate.HasValue)
+        {
+            notificationService.ShowNotification("Incorrect project info", MessageType.Error);
+            return;
+        }
+
+        var result = await projectService.CreateProjectAsync(ProjectName, ProjectLocation, EngineData.s_engineVersion, SelectedTemplate.Value.directory);
+        if (!result.success)
+        {
+            notificationService.ShowNotification(result.message, MessageType.Error);
+            return;
+        }
+
+        try
+        {
+            await stateService.TransitionToAsync(StateKey.EngineEditor, result.data);
+        }
+        catch (System.Exception e)
+        {
+            notificationService.ShowNotification($"Failed to load project: {e.Message}", MessageType.Error);
+        }
+    }
+}

Ghost.App/ViewModels/Pages/Landing/OpenProjectViewModel.cs

@@ -0,0 +1,110 @@
+using CommunityToolkit.Mvvm.ComponentModel;
+using Ghost.App.Contracts;
+using Ghost.App.Infrastructures.AppState;
+using Ghost.Data.Models;
+using Ghost.Data.Services;
+using Ghost.Editor.Models;
+using Ghost.Editor.Services.Contracts;
+using Microsoft.UI.Xaml;
+using System;
+using System.Collections.ObjectModel;
+using System.Linq;
+using System.Threading.Tasks;
+using Windows.ApplicationModel.DataTransfer;
+using Windows.Storage;
+
+namespace Ghost.Editor.ViewModels.Pages.Landing;
+
+internal partial class OpenProjectViewModel(ProjectService projectService, INotificationService _notificationService, AppStateMachine _stateService) : ObservableObject, INavigationAware
+{
+    public readonly ObservableCollection<ProjectMetadataInfo> projects = new();
+
+    [ObservableProperty]
+    public partial Visibility EmptyVisibility
+    {
+        get;
+        set;
+    }
+
+    [ObservableProperty]
+    public partial Visibility DragVisibility
+    {
+        get;
+        set;
+    }
+
+    public void UpdateEmptyPlaceHolderVisibility()
+    {
+        EmptyVisibility = projects.Count == 0 ? Visibility.Visible : Visibility.Collapsed;
+    }
+
+    public async void OnNavigatedTo(object? parameter)
+    {
+        projects.Clear();
+        await foreach (var projectInfo in projectService.GetAllProjectAsync())
+        {
+            var metadata = await ProjectService.LoadMetadataAsync(projectInfo.MetadataPath);
+            if (metadata == null)
+            {
+                continue;
+            }
+
+            projects.Add(new(projectInfo.MetadataPath, metadata));
+        }
+
+        UpdateEmptyPlaceHolderVisibility();
+        DragVisibility = Visibility.Collapsed;
+    }
+
+    public void OnNavigatedFrom()
+    {
+    }
+
+    public async Task ContentDrop(DataPackageView dataView)
+    {
+        var errorMessage = string.Empty;
+        if (dataView.Contains(StandardDataFormats.StorageItems))
+        {
+            var items = await dataView.GetStorageItemsAsync();
+            var rootFolder = items.OfType<StorageFolder>().FirstOrDefault();
+            if (rootFolder != null)
+            {
+                var result = await projectService.AddProjectFromDirectoryAsync(rootFolder.Path);
+                if (result.success)
+                {
+                    projects.Add(result.data);
+                    goto CloseDropPanel;
+                }
+                else
+                {
+                    errorMessage = result.message;
+                }
+            }
+        }
+        else
+        {
+            errorMessage = "Unsupported data format. Please drop a folder containing a project.";
+        }
+
+        _notificationService.ShowNotification(errorMessage, MessageType.Error);
+
+    CloseDropPanel:
+        DragVisibility = Visibility.Collapsed;
+        UpdateEmptyPlaceHolderVisibility();
+    }
+
+    public async Task LoadProject(ProjectMetadataInfo project)
+    {
+        try
+        {
+            project.Metadata.LastOpened = DateTime.Now;
+            await ProjectService.CreateMetadataFileAsync(project.Path, project.Metadata);
+
+            await _stateService.TransitionToAsync(StateKey.EngineEditor, project);
+        }
+        catch (Exception e)
+        {
+            _notificationService.ShowNotification($"Failed to load project: {e.Message}", MessageType.Error);
+        }
+    }
+}

Ghost.App/ViewModels/Windows/EngineEditorViewModel.cs

@@ -0,0 +1,13 @@
+using CommunityToolkit.Mvvm.ComponentModel;
+using Ghost.Data.Models;
+using Ghost.Data.Services;
+using Ghost.Engine.Resources;
+
+namespace Ghost.Editor.ViewModels.Windows;
+
+internal partial class EngineEditorViewModel : ObservableRecipient
+{
+    public string engineVersionDescriptor = $"{EngineData.ENGINE_NAME} - {EngineData.s_engineVersion}";
+
+    public ProjectMetadataInfo CurrentProject => ProjectService.CurrentProject;
+}