Pilz/Pilz.UI.AvaloniaUI.Features/Extensions.cs

using Avalonia.Controls;
using Avalonia.Interactivity;
using Pilz.Features;

namespace Pilz.UI.AvaloniaUI.Features;

public static class Extensions
{
    public static MenuItem GetAsItem(this PluginModuleBase module)
    {
        return module.GetAsItem(true);
    }

    public static MenuItem GetAsItem(this PluginModuleBase module, bool addDefaultHandler)
    {
        return module.GetAsItem(addDefaultHandler ? RadMenuItem_RMMethod_Click : null);
    }

    public static MenuItem GetAsItem(this PluginFunction function)
    {
        return function.GetAsItem(true);
    }

    public static MenuItem GetAsItem(this PluginFunction function, bool addDefaultHandler)
    {
        return function.GetAsItem(addDefaultHandler ? RadMenuItem_RMFunction_Click : null);
    }

    public static MenuItem GetAsItem(this PluginFeature module, EventHandler<RoutedEventArgs>? clickHandler)
    {
        var item = new MenuItem
        {
            Header = module.Name,
            Icon = module.Icon as Image,
            Tag = module,
            IsVisible = module.Enabled,
            //ToolTipText = module.Description ?? module.Name,
        };

        if (clickHandler is not null)
            item.Click += clickHandler;

        return item;
    }

    /// <summary>
    /// Inserts all items to an item collection.
    /// </summary>
    /// <param name="features"></param>
    /// <param name="itemsCollection"></param>
    /// <param name="addDefaultHandler">Will add a default click handler that executes the feature.<br/>
    /// You usually don't set customClickHandler if you set this parameter to true.</param>
    /// <param name="customClickHandler">Adds a custom click handler. If addDefaultHandler is true, it will only work on <see cref="PluginFeature"/>s.<br/>
    /// You usually don't set addDefaultHandler to true if you set this parameter to something not null.</param>
    /// <param name="insertMode">Defines how and where the items will be inserted.</param>
    /// <param name="customDefault">Defines a custom default position (index).</param>
    /// <param name="customTop">Defines a custom top position (index).</param>
    /// <param name="customBottom">Defines a custom bottom position (index).</param>
    /// <param name="insertPrioSplitters">Defines if splitters should be inserted to seperate the new items by priorization.</param>
    public static IEnumerable<MenuItem> InsertItemsTo(this IEnumerable<PluginFeature> features,
        ItemCollection itemsCollection,
        bool addDefaultHandler = false,
        EventHandler<RoutedEventArgs>? customClickHandler = null,
        FeatureInsertMode insertMode = FeatureInsertMode.Default,
        int? customDefault = null,
        int? customTop = null,
        int? customBottom = null,
        bool insertPrioSplitters = false)
    {
        var insertDefault = customDefault ?? (insertMode.HasFlag(FeatureInsertMode.DefaultStart) ? 0 : itemsCollection.Count);
        var insertTop = customTop ?? (insertMode.HasFlag(FeatureInsertMode.InsertTop) || insertMode.HasFlag(FeatureInsertMode.DefaultStart) ? 0 : insertDefault);
        var insertBottom = customBottom ?? (insertMode.HasFlag(FeatureInsertMode.InsertBottom) || insertMode.HasFlag(FeatureInsertMode.DefaultEnd) ? itemsCollection.Count : insertDefault);
        var insertedItems = new List<MenuItem>();
        FeaturePrioritization? prevPrio = null;

        // Oder by priorization
        features = features.OrderByDescending(n => n.Prioritization);

        foreach (var feature in features)
        {
            MenuItem item;

            if (feature is PluginFunction function)
                item = function.GetAsItem(addDefaultHandler);
            else if (feature is PluginModuleBase module)
                item = module.GetAsItem(addDefaultHandler);
            else
                item = feature.GetAsItem(null);

            if (!addDefaultHandler && customClickHandler != null)
                item.Click += customClickHandler;

            if (insertPrioSplitters && prevPrio > feature.Prioritization)
            {
                if (prevPrio != null)
                    insertItem(new Separator());
                prevPrio = feature.Prioritization;
            }

            insertItem(item);

            void insertItem(object item)
            {
                switch (feature.Prioritization)
                {
                    case >= FeaturePrioritization.High:
                        if (insertDefault >= insertTop) insertDefault++;
                        if (insertBottom >= insertTop) insertBottom++;
                        // ...
                        itemsCollection.Insert(insertTop++, item);
                        break;
                    case FeaturePrioritization.Default:
                        if (insertBottom >= insertDefault) insertBottom++;
                        if (insertTop >= insertDefault) insertTop++;
                        // ...
                        itemsCollection.Insert(insertDefault++, item);
                        break;
                    case <= FeaturePrioritization.Low:
                        if (insertTop >= insertBottom) insertTop++;
                        if (insertDefault >= insertBottom) insertDefault++;
                        // ...
                        itemsCollection.Insert(insertBottom++, item);
                        break;
                }
            }

            if (item.Parent != null)
                insertedItems.Add(item);
        }

        return insertedItems;
    }

    private static void RadMenuItem_RMMethod_Click(object? sender, RoutedEventArgs e)
    {
        //if (sender is MenuItem item && item.IsEnabled && item.Tag is PluginModule module)
        //    await module.ShowUI();
    }

    private static async void RadMenuItem_RMFunction_Click(object? sender, RoutedEventArgs e)
    {
        if (sender is MenuItem item && item.Tag is PluginFunction function && function.Enabled)
            await function.ExecuteAsync();
    }
}