minecraft-modpack-updater/ModpackUpdater.Apps.Manager/Ui/MainWindow.axaml.cs

using Avalonia.Controls;
using Avalonia.Interactivity;
using ModpackUpdater.Apps.Manager.Api;
using ModpackUpdater.Apps.Manager.Api.Model;
using ModpackUpdater.Apps.Manager.Api.Plugins.Features;
using ModpackUpdater.Apps.Manager.Api.Plugins.Params;
using ModpackUpdater.Apps.Manager.Settings;
using ModpackUpdater.Apps.Manager.Ui.Models;
using Pilz.Features;
using Pilz.UI.AvaloniaUI.Features;
using Pilz.UI.Symbols;

namespace ModpackUpdater.Apps.Manager.Ui;

public partial class MainWindow : Window, IMainApi
{
    private WorkspaceFeature? wsFeature;
    
    public MainWindowViewModel Model { get; } = new();
    Window IMainApi.MainWindow => this;
    public IMainApi MainApi => this;
    
    public MainWindow()
    {
        DataContext = Model;
        
        InitializeComponent();
        
        MenuItemWorkspace.Icon = AppGlobals.Symbols.GetImage(AppSymbols.workspace, SymbolSize.Small);
        MenuItemWorkspacePreferences.Icon = AppGlobals.Symbols.GetImage(AppSymbols.settings, SymbolSize.Small);
        MenuItemSaveWorkspace.Icon = AppGlobals.Symbols.GetImage(AppSymbols.save, SymbolSize.Small);
        MenuItemNewWorkspace.Icon = AppGlobals.Symbols.GetImage(AppSymbols.new_window, SymbolSize.Small);
        MenuItemRecentWorkspaces.Icon = AppGlobals.Symbols.GetImage(AppSymbols.time_machine, SymbolSize.Small);
        // MenuItemUpdates.Icon = AppGlobals.Symbols.GetImage(AppSymbols.update_done, SymbolSize.Small);
        MenuItemCreateUpdate.Icon = AppGlobals.Symbols.GetImage(AppSymbols.add, SymbolSize.Small);
        MenuItemRemoveUpdate.Icon = AppGlobals.Symbols.GetImage(AppSymbols.remove, SymbolSize.Small);
        MenuItemTools.Icon = AppGlobals.Symbols.GetImage(AppSymbols.tools, SymbolSize.Small);
        
        PluginFeatureController.Instance.Features.Get(FeatureTypes.Workspace).InsertItemsTo(MenuItemNewWorkspace.Items,
            customClickHandler: MenuItemNewWorkspaceItem_Click,
            insertPrioSplitters: true);
        PluginFeatureController.Instance.Functions.Get(FeatureTypes.Tools).InsertItemsTo(MenuItemTools.Items,
            customClickHandler: MenuItemToolsItem_Click,
            insertPrioSplitters: true);
    }

    private async Task LoadNewWorkspace(IWorkspace? workspace, WorkspaceFeature feature)
    {
        if (workspace is null)
            return;
        
        if (!await workspace.Load())
        {
            // Error
            return;
        }

        if (workspace != Model.CurrentWorkspace)
        {
            wsFeature = feature;
            Model.CurrentWorkspace = workspace;
        }

        AddToRecentFiles(workspace);
        LoadRecentWorkspaces();
    }

    private void LoadRecentWorkspaces()
    {
        var settings = Program.Settings.Get<WorkspaceSettings>();
        MenuItemRecentWorkspaces.Items.Clear();

        settings.Workspaces.ForEach(config =>
        {
            if (PluginFeatureController.Instance.Features.Get(FeatureTypes.Workspace).OfType<WorkspaceFeature>().FirstOrDefault(n => n.Identifier == config.ProviderId) is not WorkspaceFeature feature)
                return;
            
            var item = new MenuItem
            {
                Header = config.DisplayText,
                Icon = feature.Icon,
                DataContext = new MainWindowRecentFilesItem(config, feature),
            };
            item.Click += MenuItemRecentWorkspaceItem_Click;
            MenuItemRecentWorkspaces.Items.Add(item);
        });
    }

    private static void AddToRecentFiles(IWorkspace workspace)
    {
        var settings = Program.Settings.Get<WorkspaceSettings>();

        settings.Workspaces.Remove(workspace.Config);
        settings.Workspaces.Insert(0, workspace.Config);

        while (settings.Workspaces.Count > 20)
            settings.Workspaces.RemoveAt(20);
    }

    private void Window_OnLoaded(object? sender, RoutedEventArgs e)
    {
        LoadRecentWorkspaces();
    }

    private async void MenuItemNewWorkspaceItem_Click(object? sender, RoutedEventArgs e)
    {
        if (sender is not MenuItem item || item.Tag is not WorkspaceFeature feature)
            return;
        
        var context = new WorkspaceContext(MainApi, null);
        await feature.Configure(context);
        if (context.Workspace != null)
            await LoadNewWorkspace(context.Workspace, feature);
    }

    private async void MenuItemRecentWorkspaceItem_Click(object? sender, RoutedEventArgs e)
    {
        if (sender is MenuItem item && item.DataContext is MainWindowRecentFilesItem tag && tag.Feature.CreateFromConfig(tag.Config) is IWorkspace workspace)
            await LoadNewWorkspace(workspace, tag.Feature);
    }

    private void MenuItemToolsItem_Click(object? sender, RoutedEventArgs e)
    {
        if (sender is MenuItem item && item.Tag is PluginFunction func)
            func.Execute(new MainApiParameters(this));
    }

    private void MenuItemCreateUpdate_OnClick(object? sender, RoutedEventArgs e)
    {
        // ...
    }

    private void MenuItemRemoveUpdate_OnClick(object? sender, RoutedEventArgs e)
    {
        // ...
    }

    private void MenuItemEditUpdate_OnClick(object? sender, RoutedEventArgs e)
    {
        // ...
    }

    private void MenuItemAddAction_OnClick(object? sender, RoutedEventArgs e)
    {
        // ...
    }

    private void MenuItemRemoveAction_OnClick(object? sender, RoutedEventArgs e)
    {
        // ...
    }
}