ClassExplorer.razor

@inject IDialogService DialogService

<MudStack Row="false" Class="wh100" data-test-id="classExplorer">
    <MudText>@Class.Name</MudText>

    <MudTreeView T="TreeItem" Items="Items" SelectedValueChanged="OnSelectedItemChanged" Dense="true" Class="w100">
        <ItemTemplate>
            @if (context.Value == null)
            { }
            else if (context.Value == CurrentlyEditingItem)
            {
                <MudTreeViewItem @bind-Expanded="@context.Expanded" Items="@context.Children" Value="@context.Value" Text="@context.Text" EndTextTypo="@Typo.caption">
                    <BodyContent Context="Item">
                        <MudTextField T="string" Typo="Typo.caption" @bind-Value="Text" Variant="Variant.Text" OnKeyUp="OnEditTextKeyUp" AutoFocus="true"></MudTextField>
                    </BodyContent>
                </MudTreeViewItem>
            }
            else if (context.Value.Type == TreeItemType.MethodsFolder || context.Value.Type == TreeItemType.PropertiesFolder)
            {
                <MudTreeViewItem @bind-Expanded="@context.Expanded" Items="@context.Children" Value="@context.Value" Text="@context.Value!.Name" EndTextTypo="@Typo.caption">
                    <BodyContent Context="Item">
                        <div style="display: grid; grid-template-columns: 1fr auto; align-items: center; width: 100%" @onmouseover="() => Hovered = Item.Value" @onmouseout="() => Hovered = null" data-test-id="@context.Value.Type">
                            <MudText Style="justify-self: start;">@Item.Text</MudText>
                            <div style="@($"justify-self: end; visibility: {(Hovered == Item.Value ? "visible" : "hidden")}")">
                                <MudIconButton Icon="@Icons.Material.Filled.Add" Size="Size.Medium" Color="Color.Inherit" OnClick="context.Value.Type == TreeItemType.MethodsFolder ? ShowAddMethodMenu : ShowNewProperty" />
                            </div>
                        </div>
                    </BodyContent>
                </MudTreeViewItem>
            }
            else if (context.Value.Type == TreeItemType.Method)
            {
                <MudTreeViewItem @bind-Expanded="@context.Expanded" Value="@context.Value" Text="@context.Value!.Name" EndTextTypo="@Typo.caption">
                    <BodyContent Context="Item">
                        <div style="display: grid; grid-template-columns: 1fr auto; align-items: center; width: 100%" @onmouseover="() => Hovered = Item.Value" @onmouseout="() => Hovered = null" data-test-id="Method" data-test-method="@Item.Text">
                            <MudText Typo="Typo.caption" Style="justify-self: start;">@Item.Value!.Method!.ReturnType.FriendlyName @Item.Text (@string.Join(',', Item.Value.Method!.Parameters.Select(x => $"{x.ParameterType.FriendlyName} {x.Name}")))</MudText>
                            <div style="@($"justify-self: end; visibility: {(Hovered == Item.Value ? "visible" : "hidden")}")">
                                <MudIconButton Icon="@Icons.Material.Filled.Edit" Size="Size.Medium" Color="Color.Inherit" OnClick="() => ShowMethodEdit(Item.Value!)" />
                                <MudIconButton Icon="@Icons.Material.Filled.Add" Size="Size.Medium" Color="Color.Inherit" OnClick="() => ShowRenameMenu(Item.Value!)" />
                            </div>
                        </div>
                    </BodyContent>
                </MudTreeViewItem>
            }
            else if (context.Value.Type == TreeItemType.Property && context.Value.Property != null)
            {
                <MudTreeViewItem @bind-Expanded="@context.Expanded" Value="@context.Value" Text="@context.Value.Name" EndTextTypo="@Typo.caption">
                    <BodyContent Context="Item">
                        <div style="display: grid; grid-template-columns: 1fr auto; align-items: center; width: 100%" @onmouseover="() => Hovered = Item.Value" @onmouseout="() => Hovered = null" data-test-id="Property">
                            <MudText Typo="Typo.caption" Style="justify-self: start;">@Item.Value!.Property!.PropertyType.FriendlyName @Item.Value!.Name</MudText>
                            <div style="@($"justify-self: end; visibility: {(Hovered == Item.Value ? "visible" : "hidden")}")">
                                <MudIconButton Icon="@Icons.Material.Filled.ShapeLine" Size="Size.Medium" Color="Color.Inherit" OnClick="() => ShowPropertyTypeEdit(Item.Value!)" />
                                <MudIconButton Icon="@Icons.Material.Filled.Edit" Size="Size.Medium" Color="Color.Inherit" OnClick="() => ShowRenameMenu(Item.Value!)" />
                                <MudIconButton Icon="@Icons.Material.Filled.Delete" Size="Size.Medium" Color="Color.Inherit" />
                            </div>
                        </div>
                    </BodyContent>
                </MudTreeViewItem>
            }
        </ItemTemplate>
    </MudTreeView>
</MudStack>


@code {

    private enum TreeItemType
    {
        PropertiesFolder,
        Property,
        MethodsFolder,
        Method
    }
    private record class TreeItem(TreeItemType Type, NodeDev.Core.Class.NodeClassMethod? Method, NodeDev.Core.Class.NodeClassProperty? Property)
    {
        public string Name { get; set; } = "";
        public bool IsExpanded { get; set; } = true;
    }

    [Parameter]
    public NodeDev.Core.Class.NodeClass Class { get; set; } = null!;

    [Parameter]
    public NodeDev.Core.Class.NodeClassMethod? SelectedMethod { get; set; }

    [Parameter]
    public EventCallback<NodeDev.Core.Class.NodeClassMethod?> SelectedMethodChanged { get; set; }

    private TreeItem? SelectedTreeItem;

    private List<TreeItemData<TreeItem>> Items { get; } = [];

    private TreeItem? Hovered = null;

    private TreeItem? CurrentlyEditingItem = null;
    private string? Text = null;
    public bool IsNew = false;

    protected override void OnInitialized()
    {
        base.OnInitialized();

        TreeItemData<TreeItem> methodsFolder;
        TreeItemData<TreeItem> propertiesFolder;

        Items.Add(methodsFolder = new()
            {
                Value = new(TreeItemType.MethodsFolder, null, null)
                {
                    Name = "Methods"
                },
                Expanded = true,
                Children = []
            });

        Items.Add(propertiesFolder = new()
            {
                Value = new(TreeItemType.PropertiesFolder, null, null)
                {
                    Name = "Properties"
                },
                Expanded = true,
                Children = []
            });

        foreach (var method in Class.Methods)
        {
            methodsFolder.Children.Add(new()
                {
                    Value = new(TreeItemType.Method, method, null)
                    {
                        Name = method.Name
                    }
                });
        }

        foreach (var property in Class.Properties)
        {
            propertiesFolder.Children.Add(new()
                {
                    Value = new(TreeItemType.Property, null, property)
                    {
                        Name = property.Name
                    }
                });
        }
    }

    private void ShowAddMethodMenu()
    {
        var newItem = new TreeItemData<TreeItem>()
            {
                Value = new TreeItem(TreeItemType.Method, null, null)
                {
                    Name = "NewMethod"
                }
            };
        Items.First(x => x.Value?.Type == TreeItemType.MethodsFolder).Children!.Add(newItem);

        CurrentlyEditingItem = newItem.Value;
        IsNew = true;
        Text = CurrentlyEditingItem.Name;

    }

    private void ShowNewProperty()
    {
        var newItem = new TreeItemData<TreeItem>()
            {
                Value = new(TreeItemType.Property, null, null)
                {
                    Name = "NewProperty"
                }
            };
        Items.First(x => x.Value!.Type == TreeItemType.PropertiesFolder).Children!.Add(newItem);

        CurrentlyEditingItem = newItem.Value;
        IsNew = true;
        Text = CurrentlyEditingItem.Name;

    }

    private void ShowRenameMenu(TreeItem item)
    {
        if (item == null)
            return;

        Text = item.Name;
        CurrentlyEditingItem = item;
        IsNew = false;
    }

    private async Task ShowPropertyTypeEdit(TreeItem item)
    {
        var result = await DialogService.Show<TypeSelectorDialog>("", new()
            {
                [nameof(TypeSelectorDialog.TypeFactory)] = Class.TypeFactory
            }, new DialogOptions()
            {
                FullScreen = true,
                FullWidth = true
            }).Result;

        NodeDev.Core.Types.TypeBase typeBase;
        if (result?.Data is Type type)
            typeBase = Class.TypeFactory.Get(type, null);
        else if (result?.Data is NodeDev.Core.Types.TypeBase t)
            typeBase = t;
        else
            return;

        item.Property!.ChangeType(typeBase);
    }

    private async Task ShowMethodEdit(TreeItem item)
    {
        var result = await DialogService.Show<EditMethodMenu>("", new()
            {
                [nameof(EditMethodMenu.Method)] = item.Method
            }, new DialogOptions()
            {
                FullScreen = false,
                FullWidth = true,
                MaxWidth = MaxWidth.Large
            }).Result;
    }

    private void OnEditTextKeyUp(KeyboardEventArgs args)
    {
        if (args.Key != "Enter" || string.IsNullOrWhiteSpace(Text) || CurrentlyEditingItem == null)
            return;

        if (IsNew)
        {
            if (CurrentlyEditingItem!.Type == TreeItemType.Method)
            {
                var method = new Core.Class.NodeClassMethod(Class, Text, Class.TypeFactory.Get(typeof(void), null));
                Class.AddMethod(method, createEntryAndReturn: true);

                Items.First(x => x.Value!.Type == TreeItemType.MethodsFolder).Children!.RemoveAll(x => x.Value == CurrentlyEditingItem);
                Items.First(x => x.Value!.Type == TreeItemType.MethodsFolder).Children!.Add(new()
                    {
                        Value = new(TreeItemType.Method, method, null)
                        {
                            Name = method.Name
                        }
                    });
            }
            else if (CurrentlyEditingItem.Type == TreeItemType.Property)
            {
                var property = new Core.Class.NodeClassProperty(Class, Text, Class.TypeFactory.Get<double>());
                Class.Properties.Add(property);

                Items.First(x => x.Value!.Type == TreeItemType.PropertiesFolder).Children!.RemoveAll(x => x.Value == CurrentlyEditingItem);
                Items.First(x => x.Value!.Type == TreeItemType.PropertiesFolder).Children!.Add(new()
                    {
                        Value = new(TreeItemType.Property, null, property)
                        {
                            Name = property.Name
                        }
                    });
            }
        }
        else if (CurrentlyEditingItem.Method != null)
        {
            CurrentlyEditingItem.Method.Rename(Text);
            CurrentlyEditingItem.Name = Text;
        }
        else if (CurrentlyEditingItem.Property != null)
        {
            CurrentlyEditingItem.Property.Rename(Text);
            CurrentlyEditingItem.Name = Text;
        }

        CurrentlyEditingItem = null;
        Text = null;
    }

    private void OnSelectedItemChanged(TreeItem? tree)
    {
        if (CurrentlyEditingItem != null)
        {
            // remove the textbox
            if (IsNew)
                Items.First().Children!.RemoveAll(x => x.Value == CurrentlyEditingItem);

            CurrentlyEditingItem = null;
            Text = null;
        }

        SelectedTreeItem = tree;

        if (tree?.Type == TreeItemType.Method)
        {
            SelectedMethod = tree.Method;
            _ = SelectedMethodChanged.InvokeAsync(SelectedMethod);
        }
        else
        {
            SelectedMethod = null;
            _ = SelectedMethodChanged.InvokeAsync(SelectedMethod);
        }

    }

}