minecraft-modpack-updater/ModpackUpdater.Apps.Manager/Form1.cs

using ModpackUpdater.Apps.Manager.Api.Model;
using ModpackUpdater.Apps.Manager.Api.Plugins.Features;
using ModpackUpdater.Apps.Manager.Api.Plugins.Params;
using ModpackUpdater.Apps.Manager.LangRes;
using ModpackUpdater.Apps.Manager.Settings;
using Pilz.Plugins.Advanced;
using Pilz.Plugins.Advanced.UI.Telerik;
using Pilz.UI.Symbols;
using Pilz.UI.Telerik.Extensions;
using Telerik.WinControls;
using Telerik.WinControls.UI;

namespace ModpackUpdater.Apps.Manager;

public partial class Form1 : RadForm, IMainApi
{
    private IWorkspace? workspace;

    public IWorkspace? Workspace => workspace;

    private record RecentFileItemTag(WorkspaceConfig Config, WorkspaceFeature Feature);

    public Form1()
    {
        InitializeComponent();

        radMenuItem_Workspace.SvgImage = AppGlobals.Symbols.GetSvgImage(AppSymbols.workspace, SymbolSize.Small);
        radMenuItem_WorkspacePreferences.SvgImage = AppGlobals.Symbols.GetSvgImage(AppSymbols.settings, SymbolSize.Small);
        radMenuItem_SaveWorkspace.SvgImage = AppGlobals.Symbols.GetSvgImage(AppSymbols.save, SymbolSize.Small);
        radMenuItem_OpenNewWorkspace.SvgImage = AppGlobals.Symbols.GetSvgImage(AppSymbols.new_window, SymbolSize.Small);
        radMenuItem_RecentWorkspaces.SvgImage = AppGlobals.Symbols.GetSvgImage(AppSymbols.time_machine, SymbolSize.Small);
        radMenuItem_Tools.SvgImage = AppGlobals.Symbols.GetSvgImage(AppSymbols.tools, SymbolSize.Small);

        radMenuItem_SaveWorkspace.Shortcuts.Add(new(Keys.Control, Keys.S));

        PluginFeatureController.Instance.Features.Get(FeatureTypes.Workspace).InsertItemsTo(radMenuItem_OpenNewWorkspace.Items, customClickHandler: RadMenuItem_OpenNewWorkspace_Click);
        PluginFeatureController.Instance.Functions.Get(FeatureTypes.Tools).InsertItemsTo(radMenuItem_OpenNewWorkspace.Items, customClickHandler: RadMenuItem_ToolsItem_Click);
    }

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

        radMenuItem_RecentWorkspaces.Items.Clear();

        foreach (var config in settings.Workspaces.ToArray())
        {
            if (PluginFeatureController.Instance.Features.Get(FeatureTypes.Workspace).OfType<WorkspaceFeature>().FirstOrDefault(n => n.Identifier == config.ProviderId) is not WorkspaceFeature feature)
            {
                settings.Workspaces.Remove(config);
                continue;
            }

            var item = new RadMenuItem
            {
                Text = config.DisplayText,
                Tag = new RecentFileItemTag(config, feature),
                SvgImage = feature.Icon as RadSvgImage,
            };

            item.Click += RadMenuItem_OpenRecentWorkspace_Click;

            radMenuItem_RecentWorkspaces.Items.Add(item);
        }

        if (radMenuItem_RecentWorkspaces.Items.Any())
            radMenuItem_RecentWorkspaces.Visibility = ElementVisibility.Visible;
        else
            radMenuItem_RecentWorkspaces.Visibility = ElementVisibility.Collapsed;
    }

    private 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 async Task LoadNewWorkspace(IWorkspace? workspace)
    {
        if (workspace is null)
            return;

        if (workspace != this.workspace)
            this.workspace = workspace;

        AddToRecentFiles(workspace);
        Invoke(LoadRecentWorkspaces);

        radWaitingBar_Updates.StartWaiting();

        if (!await workspace.Load())
        {
            radWaitingBar_Updates.StopWaiting();
            return;
        }

        Invoke(LoadWorkspace);
    }

    private void LoadWorkspace()
    {
        if (workspace?.Config is null || workspace.InstallInfos is null || workspace.UpdateInfos is null)
            return;

        radWaitingBar_Updates.StartWaiting();
        Text = workspace.Config.DisplayText;
        radTreeView_Updates.BeginUpdate();
        radTreeView_Updates.Nodes.Clear();

        radTreeView_Updates.Nodes.Add(new RadTreeNode
        {
            Text = string.Format(GeneralLangRes.Node_Install, workspace.InstallInfos.Version.ToString()),
            Tag = workspace.InstallInfos,
        });

        foreach (var update in workspace.UpdateInfos.Updates)
        {
            radTreeView_Updates.Nodes.Add(new RadTreeNode
            {
                Text = string.Format(GeneralLangRes.Node_Update, update.Version.ToString()),
                Tag = update,
            });
        }

        radTreeView_Updates.EndUpdate();
        radWaitingBar_Updates.StopWaiting();
    }

    private void LoadActionSet(IActionSetInfos infos)
    {
        radGridView_Actions.BeginUpdate();
        radGridView_Actions.Rows.Clear();
        radGridView_Actions.Columns.Clear();

        // Add columns
        radGridView_Actions.Columns.AddRange([
            new GridViewTextBoxColumn
            {
                Name = "id",
                HeaderText = ActionsListLangRes.Col_Id,
                Width = 150,
                IsVisible = infos is not UpdateInfo,
                IsPinned = true,
            },
            new GridViewTextBoxColumn
            {
                Name = "name",
                HeaderText = ActionsListLangRes.Col_Name,
                Width = 150,
                IsVisible = infos is not UpdateInfo,
            },
            new GridViewTextBoxColumn
            {
                Name = "inherit",
                HeaderText = ActionsListLangRes.Col_InheritFrom,
                Width = 150,
                IsVisible = infos is UpdateInfo,
                IsPinned = true,
            },
            new GridViewComboBoxColumn
            {
                Name = "utype",
                HeaderText = ActionsListLangRes.Col_UpdateType,
                Width = 150,
                DataSource = Enum.GetValues<UpdateActionType>(),
                IsVisible = infos is UpdateInfo,
            },
            new GridViewComboBoxColumn
            {
                Name = "side",
                HeaderText = ActionsListLangRes.Col_Side,
                Width = 150,
                DataSource = Enum.GetValues<Side>(),
            },
            new GridViewCheckBoxColumn
            {
                Name = "isextra",
                HeaderText = ActionsListLangRes.Col_IsExtra,
                Width = 50,
            },
            new GridViewCheckBoxColumn
            {
                Name = "iszip",
                HeaderText = ActionsListLangRes.Col_IsZip,
                Width = 50,
            },
            new GridViewTextBoxColumn
            {
                Name = "zippath",
                HeaderText = ActionsListLangRes.Col_ZipPath,
                Width = 200,
            },
            new GridViewCheckBoxColumn
            {
                Name = "isdir",
                HeaderText = ActionsListLangRes.Col_IsDir,
                Width = 50,
                IsVisible = infos is UpdateInfo,
            },
            new GridViewTextBoxColumn
            {
                Name = "srcpath",
                HeaderText = ActionsListLangRes.Col_SrcPath,
                Width = 250,
                IsVisible = infos is UpdateInfo,
            },
            new GridViewTextBoxColumn
            {
                Name = "destpath",
                HeaderText = ActionsListLangRes.Col_DestPath,
                Width = 250,
            },
            new GridViewComboBoxColumn
            {
                Name = "srctype",
                HeaderText = ActionsListLangRes.Col_SrcType,
                Width = 150,
                DataSource = Enum.GetValues<SourceType>(),
            },
            new GridViewTextBoxColumn
            {
                Name = "srcowner",
                HeaderText = ActionsListLangRes.Col_SrcOwner,
                Width = 150,
            },
            new GridViewTextBoxColumn
            {
                Name = "srcname",
                HeaderText = ActionsListLangRes.Col_SrcName,
                Width = 150,
            },
            new GridViewTextBoxColumn
            {
                Name = "srcregex",
                HeaderText = ActionsListLangRes.Col_SrcRegEx,
                Width = 200,
            },
            new GridViewTextBoxColumn
            {
                Name = "srctag",
                HeaderText = ActionsListLangRes.Col_SrcTag,
                Width = 150,
            },
            new GridViewTextBoxColumn
            {
                Name = "srcurl",
                HeaderText = ActionsListLangRes.Col_SrcUrl,
                Width = 350,
            },
            new GridViewTextBoxColumn
            {
                Name = "website",
                HeaderText = ActionsListLangRes.Col_Website,
                Width = 350,
            },
        ]);

        // Add rows
        foreach (var action in infos.Actions)
        {
            var row = radGridView_Actions.Rows.AddNew();
            row.Tag = action;
            row.Cells["id"].Value = action.Id;
            row.Cells["name"].Value = action.Name;
            row.Cells["iszip"].Value = action.IsZip;
            row.Cells["zippath"].Value = action.ZipPath;
            row.Cells["destpath"].Value = action.DestPath;
            row.Cells["srcurl"].Value = action.SourceUrl;
            row.Cells["srctype"].Value = action.SourceType;
            row.Cells["srcowner"].Value = action.SourceOwner;
            row.Cells["srcname"].Value = action.SourceName;
            row.Cells["srcregex"].Value = action.SourceRegex;
            row.Cells["srctag"].Value = action.SourceTag;
            row.Cells["side"].Value = action.Side;
            row.Cells["isextra"].Value = action.IsExtra;

            if (action is UpdateAction uaction)
            {
                row.Cells["inherit"].Value = uaction.InheritFrom; // TODO: Find inherit action and put it in here!
                row.Cells["utype"].Value = uaction.Type;
                row.Cells["srcpath"].Value = uaction.SrcPath;
                row.Cells["isdir"].Value = uaction.IsDirectory;
            }
        }

        radGridView_Actions.EndUpdate();
    }

    private void Form1_Load(object sender, EventArgs e)
    {
        LoadRecentWorkspaces();
    }

    private async void RadMenuItem_OpenNewWorkspace_Click(object? sender, EventArgs e)
    {
        if (sender is RadMenuItem item && item.Tag is WorkspaceFeature feature && feature.Configure(ref workspace))
            await LoadNewWorkspace(workspace);
    }

    private async void RadMenuItem_OpenRecentWorkspace_Click(object? sender, EventArgs e)
    {
        if (sender is RadMenuItem item && item.Tag is RecentFileItemTag tag && tag.Feature.CreateFromConfig(tag.Config) is IWorkspace workspace)
            await LoadNewWorkspace(workspace);
    }

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

    private void RadTreeView_Updates_SelectedNodeChanged(object sender, RadTreeViewEventArgs e)
    {
        if (e.Node?.Tag is IActionSetInfos infos)
            LoadActionSet(infos);
    }

    private void RadGridView_Actions_CellFormatting(object sender, CellFormattingEventArgs e)
    {
        //var cellElement = e.CellElement;
        //var cellInfo = e.Row.Cells[e.Column.Name];

        //if (e.Column.Name == "srctype" && cellInfo?.Value is string sourceTypeStr && Enum.Parse<SourceType>(sourceTypeStr) is SourceType sourceType)
        //{
        //    cellElement.SvgImage = sourceType switch
        //    {
        //        SourceType.DirectLink => AppGlobals.Symbols.GetSvgImage(AppSymbols.link, SymbolSize.Small),
        //        SourceType.GitHub => AppGlobals.Symbols.GetSvgImage(AppSymbols.github, SymbolSize.Small),
        //        _ => null,
        //    };
        //    cellElement.DrawImage = cellElement.SvgImage != null;
        //    cellElement.TextImageRelation = TextImageRelation.ImageBeforeText;
        //    cellElement.ImageAlignment = ContentAlignment.MiddleLeft;
        //}
        //else
        //{
        //    cellElement.ResetValue(LightVisualElement.SvgImageProperty, ValueResetFlags.Local);
        //    cellElement.ResetValue(LightVisualElement.DrawImageProperty, ValueResetFlags.Local);
        //    cellElement.ResetValue(LightVisualElement.TextImageRelationProperty, ValueResetFlags.Local);
        //    cellElement.ResetValue(LightVisualElement.ImageAlignmentProperty, ValueResetFlags.Local);
        //}
    }

    private void RadGridView_Actions_CellValueChanged(object sender, GridViewCellEventArgs e)
    {
        if (e.Row?.Tag is not InstallAction action)
            return;

        var uaction = action as UpdateAction;
        var newValue = e.Row.Cells[e.Column.Name].Value;
        var colName = e.Column.Name;

        if (newValue is string valueStr)
        {
            var valueNullStr = valueStr.Nullify();

            switch (colName)
            {
                case "id":
                    action.Id = valueNullStr;
                    break;
                case "name":
                    action.Name = valueNullStr;
                    break;
                case "zippath":
                    action.ZipPath = valueNullStr;
                    break;
                case "destpath":
                    action.DestPath = valueNullStr;
                    break;
                case "srcurl":
                    action.SourceUrl = valueNullStr;
                    break;
                case "srctype":
                    action.SourceType = Enum.Parse<SourceType>(valueStr);
                    break;
                case "srcowner":
                    action.SourceOwner = valueNullStr;
                    break;
                case "srcname":
                    action.SourceName = valueNullStr;
                    break;
                case "srcregex":
                    action.SourceTag = valueNullStr;
                    break;
                case "srctag":
                    action.SourceTag = valueNullStr;
                    break;
                case "side":
                    action.Side = Enum.Parse<Side>(valueStr);
                    break;
                case "inherit":
                    if (uaction is not null)
                        uaction.InheritFrom = valueNullStr;
                    break;
                case "utype":
                    if (uaction is not null)
                        uaction.Type = Enum.Parse<UpdateActionType>(valueStr);
                    break;
                case "srcpath":
                    if (uaction is not null)
                        uaction.SrcPath = valueNullStr;
                    break;
            }
        }
        else if (newValue is bool valueBool)
        {
            switch (colName)
            {
                case "iszip":
                    action.IsZip = valueBool;
                    break;
                case "isextra":
                    action.IsExtra = valueBool;
                    break;
                case "isdir":
                    if (uaction is not null)
                        uaction.IsDirectory = valueBool;
                    break;
            }
        }
    }
}