MainWindow.cs

/*
 * Hey future me / future LLM:
 * Every setting on the AppSettings instance must be persisted automatically.
 * Do not add a UI setting or a runtime setting and forget SaveSettings().
 * If a setting changes, save the whole current AppSettings instance right away.
 */

using System.Diagnostics;
using System.Globalization;
using System.Text.Json;
using Avalonia;
using Avalonia.Controls;
using Avalonia.Controls.Primitives;
using Avalonia.Input;
using Avalonia.Layout;
using Avalonia.Media;
using Avalonia.Platform.Storage;

namespace SankeyCashflowTracker;

public sealed class MainWindow : Window
{
    private static readonly IBrush InvalidBrush = new SolidColorBrush(Color.Parse("#EF4444"));
    private static readonly IBrush NormalBrush = new SolidColorBrush(Color.Parse("#374151"));
    private static readonly IBrush FocusBrush = new SolidColorBrush(Color.Parse("#38BDF8"));

    private readonly LocalizationService _text = new();
    private readonly CashflowData _data;
    private readonly Dictionary<Guid, TextBox> _expenseAmountBoxes = new();
    private readonly Dictionary<Guid, TextBox> _expenseNameBoxes = new();
    private readonly Dictionary<Guid, TextBox> _savingAmountBoxes = new();
    private readonly Dictionary<Guid, TextBox> _savingNameBoxes = new();
    private readonly Dictionary<Guid, TextBox> _incomeNameBoxes = new();
    private readonly HashSet<Guid> _collapsedExpenseNodes = [];
    private readonly HashSet<Guid> _collapsedSavingNodes = [];
    private readonly Stack<string> _undoStates = new();
    private readonly Stack<string> _redoStates = new();
    private readonly Dictionary<object, Grid> _reorderRows = new();

    private AppSettings _settings;
    private int _visibleSankeyDepth = 1;
    private bool _updateCheckStarted;

    private readonly StackPanel _incomePanel = new() { Spacing = 8 };
    private readonly StackPanel _expensePanel = new() { Spacing = 5 };
    private readonly StackPanel _savingPanel = new() { Spacing = 5 };
    private readonly SankeyControl _sankey = new();
    private readonly TextBlock _incomeTotalText = new()
    {
        FontSize = 12,
        FontWeight = FontWeight.Bold
    };
    private readonly TextBlock _expenseTotalText = new()
    {
        FontSize = 12,
        FontWeight = FontWeight.Bold
    };
    private readonly TextBlock _savingTotalText = new()
    {
        FontSize = 12,
        FontWeight = FontWeight.Bold
    };
    private readonly TextBlock _incomeTotalValueText = new()
    {
        FontSize = 12,
        FontWeight = FontWeight.Bold,
        HorizontalAlignment = HorizontalAlignment.Left
    };
    private readonly TextBlock _expenseTotalValueText = new()
    {
        FontSize = 12,
        FontWeight = FontWeight.Bold,
        HorizontalAlignment = HorizontalAlignment.Left
    };
    private readonly TextBlock _savingTotalValueText = new()
    {
        FontSize = 12,
        FontWeight = FontWeight.Bold,
        HorizontalAlignment = HorizontalAlignment.Left
    };

    private readonly TextBlock _title = new()
    {
        FontSize = 22,
        FontWeight = FontWeight.SemiBold
    };

    private readonly TextBlock _incomeHeader = new()
    {
        FontSize = 18,
        FontWeight = FontWeight.SemiBold
    };

    private readonly TextBlock _expenseHeader = new()
    {
        FontSize = 18,
        FontWeight = FontWeight.SemiBold
    };

    private readonly TextBlock _savingHeader = new()
    {
        FontSize = 18,
        FontWeight = FontWeight.SemiBold
    };

    private readonly Button _undoButton = new()
    {
        Content = "↶",
        MinWidth = 40,
        IsEnabled = false
    };

    private readonly Button _redoButton = new()
    {
        Content = "↷",
        MinWidth = 40,
        IsEnabled = false
    };

    private readonly Button _decreaseDepthButton = new()
    {
        Content = "◀",
        MinWidth = 40
    };

    private readonly TextBlock _depthValueText = new()
    {
        MinWidth = 40,
        HorizontalAlignment = HorizontalAlignment.Center,
        VerticalAlignment = VerticalAlignment.Center,
        TextAlignment = TextAlignment.Center,
        FontWeight = FontWeight.SemiBold
    };

    private readonly Button _increaseDepthButton = new()
    {
        Content = "▶",
        MinWidth = 40
    };

    private readonly Button _zoomOutButton = new()
    {
        Content = "−",
        MinWidth = 40
    };

    private readonly TextBlock _zoomValueText = new()
    {
        MinWidth = 58,
        HorizontalAlignment = HorizontalAlignment.Center,
        VerticalAlignment = VerticalAlignment.Center,
        TextAlignment = TextAlignment.Center,
        FontWeight = FontWeight.SemiBold
    };

    private readonly Button _zoomInButton = new()
    {
        Content = "+",
        MinWidth = 40
    };

    private readonly MenuItem _importData = new();
    private readonly MenuItem _exportData = new();
    private readonly MenuItem _exportPng = new();
    private readonly MenuItem _exportSvg = new();

    private readonly Button _dataTransferButton = new()
    {
        Content = "⇅",
        MinWidth = 40,
        Padding = new Thickness(8, 4),
        IsTabStop = false
    };

    private readonly Button _settingsButton = new();

    private readonly Button _aboutButton = new()
    {
        Content = "?",
        MinWidth = 40,
        IsTabStop = false
    };

    private readonly Expander _incomeSection = new();
    private readonly Expander _expenseSection = new();
    private readonly Expander _savingSection = new();
    private readonly Expander _totalsSection = new();

    private readonly Button _addIncome = new()
    {
        Content = "+",
        MinWidth = 36,
        IsTabStop = false
    };

    private readonly Button _addExpense = new()
    {
        Content = "+",
        MinWidth = 36,
        IsTabStop = false
    };

    private readonly Button _addSaving = new()
    {
        Content = "+",
        MinWidth = 36,
        IsTabStop = false
    };

    private readonly Button _toggleExpenseTreeButton = new()
    {
        MinWidth = 30,
        Width = 30,
        Padding = new Thickness(4),
        HorizontalAlignment = HorizontalAlignment.Left,
        IsTabStop = false
    };

    private readonly Button _toggleSavingTreeButton = new()
    {
        MinWidth = 30,
        Width = 30,
        Padding = new Thickness(4),
        HorizontalAlignment = HorizontalAlignment.Left,
        IsTabStop = false
    };

    public MainWindow()
    {
        AppWindowAssets.ApplyIcon(this);

        _settings = StorageService.LoadSettings();
        _text.Load(_settings.Language);
        _data = StorageService.LoadData();
        _visibleSankeyDepth = _settings.VisibleSankeyDepth;

        double normalizedZoom =
            Math.Clamp(
                _settings.SankeyZoomFactor,
                SankeyControl.MinimumZoomFactor,
                SankeyControl.MaximumZoomFactor);

        if (Math.Abs(
                _settings.SankeyZoomFactor -
                normalizedZoom) > 0.0001)
        {
            _settings.SankeyZoomFactor = normalizedZoom;
            StorageService.SaveSettings(_settings);
        }

        _sankey.SetZoomFactor(
            normalizedZoom);

        _settings.SankeyLevelHorizontalOffsets ??= [];

        _settings.CollapsedExpenseNodeIds ??= [];
        _settings.CollapsedSavingNodeIds ??= [];

        foreach (Guid nodeId in _settings.CollapsedExpenseNodeIds)
        {
            _collapsedExpenseNodes.Add(nodeId);
        }

        foreach (Guid nodeId in _settings.CollapsedSavingNodeIds)
        {
            _collapsedSavingNodes.Add(nodeId);
        }

        NormalizeCollapsedExpenseState();
        NormalizeCollapsedSavingState();

        Width = 1400;
        Height = 850;
        MinWidth = 1050;
        MinHeight = 650;
        WindowStartupLocation = WindowStartupLocation.CenterScreen;
        Background = new SolidColorBrush(Color.Parse("#11151C"));

        ConfigureSymbolButton(_undoButton);
        ConfigureSymbolButton(_redoButton);
        ConfigureSymbolButton(_decreaseDepthButton);
        ConfigureSymbolButton(_increaseDepthButton);
        ConfigureSymbolButton(_zoomOutButton);
        ConfigureSymbolButton(_zoomInButton);
        ConfigureSymbolButton(_dataTransferButton);
        ConfigureSymbolButton(_aboutButton);
        ConfigureSymbolButton(_addIncome);
        ConfigureSymbolButton(_addExpense);
        ConfigureSymbolButton(_addSaving);
        ConfigureSymbolButton(_toggleExpenseTreeButton);
        ConfigureSymbolButton(_toggleSavingTreeButton);

        Content = BuildLayout();

        _incomeSection.Expanded += (_, _) =>
        {
            _settings.IsIncomeSectionExpanded = true;
            StorageService.SaveSettings(_settings);
        };

        _incomeSection.Collapsed += (_, _) =>
        {
            _settings.IsIncomeSectionExpanded = false;
            StorageService.SaveSettings(_settings);
        };

        _expenseSection.Expanded += (_, _) =>
        {
            _settings.IsExpenseSectionExpanded = true;
            StorageService.SaveSettings(_settings);
        };

        _expenseSection.Collapsed += (_, _) =>
        {
            _settings.IsExpenseSectionExpanded = false;
            StorageService.SaveSettings(_settings);
        };

        _savingSection.Expanded += (_, _) =>
        {
            _settings.IsSavingSectionExpanded = true;
            StorageService.SaveSettings(_settings);
        };

        _savingSection.Collapsed += (_, _) =>
        {
            _settings.IsSavingSectionExpanded = false;
            StorageService.SaveSettings(_settings);
        };

        _totalsSection.Expanded += (_, _) =>
        {
            _settings.IsTotalsSectionExpanded = true;
            StorageService.SaveSettings(_settings);
        };

        _totalsSection.Collapsed += (_, _) =>
        {
            _settings.IsTotalsSectionExpanded = false;
            StorageService.SaveSettings(_settings);
        };

        _addIncome.Click += (_, _) =>
        {
            var income = new IncomeEntry
            {
                Name = string.Empty,
                Amount = 0m
            };

            ExecuteDataChange(() => _data.Incomes.Add(income));
            FocusIncomeName(income.Id);
        };

        _addExpense.Click += (_, _) =>
        {
            var expense = new ExpenseNode
            {
                Name = string.Empty,
                Amount = 0m
            };

            ExecuteDataChange(() => _data.Expenses.Add(expense));
            FocusExpenseName(expense.Id);
        };

        _addSaving.Click += (_, _) =>
        {
            var saving = new ExpenseNode
            {
                Name = string.Empty,
                Amount = 0m
            };

            ExecuteDataChange(() => _data.Savings.Add(saving));
            FocusSavingName(saving.Id);
        };

        _undoButton.Click += UndoButton_Click;
        _redoButton.Click += RedoButton_Click;
        _decreaseDepthButton.Click += DecreaseDepthButton_Click;
        _increaseDepthButton.Click += IncreaseDepthButton_Click;
        _zoomOutButton.Click += ZoomOutButton_Click;
        _zoomInButton.Click += ZoomInButton_Click;
        _sankey.ZoomFactorChanged += Sankey_ZoomFactorChanged;
        _sankey.LevelHorizontalOffsetsChanged +=
            Sankey_LevelHorizontalOffsetsChanged;
        _toggleExpenseTreeButton.Click += ToggleExpenseTreeButton_Click;
        _toggleSavingTreeButton.Click += ToggleSavingTreeButton_Click;
        _settingsButton.Click += SettingsButton_Click;
        _aboutButton.Click += AboutButton_Click;
        _importData.Click += ImportData_Click;
        _exportData.Click += ExportData_Click;
        _exportPng.Click += ExportPng_Click;
        _exportSvg.Click += ExportSvg_Click;
        Opened += MainWindow_Opened;

        ApplyTexts();
        UpdateZoomControls();
        RebuildEditor();
        RefreshDiagram();
    }

    private async void MainWindow_Opened(
        object? sender,
        EventArgs e)
    {
        if (_updateCheckStarted)
        {
            return;
        }

        _updateCheckStarted = true;

        UpdateReleaseInfo? update =
            await UpdateService.CheckForUpdateAsync();

        if (update is null)
        {
            return;
        }

        bool openReleasePage =
            await new ConfirmDialog(
                    _text["UpdateAvailableTitle"],
                    string.Format(
                        CultureInfo.CurrentCulture,
                        _text["UpdateAvailableMessage"],
                        update.CurrentVersion,
                        update.LatestVersion),
                    _text["OpenReleasePage"],
                    _text["Later"],
                    true)
                .ShowDialog<bool>(this);

        if (!openReleasePage)
        {
            return;
        }

        try
        {
            Process.Start(
                new ProcessStartInfo
                {
                    FileName =
                        update.ReleasePageUrl,
                    UseShellExecute = true
                });
        }
        catch (Exception ex)
        {
            LogService.Write(ex);
        }
    }

    private Control BuildLayout()
    {
        var root = new Grid
        {
            RowDefinitions = new RowDefinitions("Auto,*")
        };

        var toolbar = new Border
        {
            Background = new SolidColorBrush(Color.Parse("#171D27")),
            Padding = new Thickness(18, 12)
        };

        var toolbarGrid = new Grid
        {
            ColumnDefinitions = new ColumnDefinitions("*,Auto,Auto,Auto,Auto,Auto,Auto,Auto,Auto,Auto,Auto,Auto"),
            ColumnSpacing = 8
        };

        toolbarGrid.Children.Add(_title);

        Grid.SetColumn(_undoButton, 1);
        Grid.SetColumn(_redoButton, 2);
        Grid.SetColumn(_decreaseDepthButton, 3);
        Grid.SetColumn(_depthValueText, 4);
        Grid.SetColumn(_increaseDepthButton, 5);
        Grid.SetColumn(_zoomOutButton, 6);
        Grid.SetColumn(_zoomValueText, 7);
        Grid.SetColumn(_zoomInButton, 8);
        Grid.SetColumn(_dataTransferButton, 9);
        Grid.SetColumn(_settingsButton, 10);
        Grid.SetColumn(_aboutButton, 11);

        var dataTransferMenu =
            new MenuFlyout();

        dataTransferMenu.Items.Add(_exportData);
        dataTransferMenu.Items.Add(_exportPng);
        dataTransferMenu.Items.Add(_exportSvg);
        dataTransferMenu.Items.Add(
            new MenuItem
            {
                Header = "-"
            });
        dataTransferMenu.Items.Add(_importData);

        _dataTransferButton.Flyout =
            dataTransferMenu;

        toolbarGrid.Children.Add(_undoButton);
        toolbarGrid.Children.Add(_redoButton);
        toolbarGrid.Children.Add(_decreaseDepthButton);
        toolbarGrid.Children.Add(_depthValueText);
        toolbarGrid.Children.Add(_increaseDepthButton);
        toolbarGrid.Children.Add(_zoomOutButton);
        toolbarGrid.Children.Add(_zoomValueText);
        toolbarGrid.Children.Add(_zoomInButton);
        toolbarGrid.Children.Add(_dataTransferButton);
        toolbarGrid.Children.Add(_settingsButton);
        toolbarGrid.Children.Add(_aboutButton);

        toolbar.Child = toolbarGrid;

        var body = new Grid
        {
            ColumnDefinitions = new ColumnDefinitions("430,6,*")
        };

        var editorStack = new StackPanel
        {
            Margin = new Thickness(18),
            Spacing = 18,
            HorizontalAlignment = HorizontalAlignment.Stretch
        };

        ConfigureSection(
            _incomeSection,
            _incomeHeader,
            _addIncome,
            _incomePanel,
            _settings.IsIncomeSectionExpanded);

        ConfigureSection(
            _expenseSection,
            _expenseHeader,
            _addExpense,
            _expensePanel,
            _settings.IsExpenseSectionExpanded);

        ConfigureSection(
            _savingSection,
            _savingHeader,
            _addSaving,
            _savingPanel,
            _settings.IsSavingSectionExpanded);

        editorStack.Children.Add(_incomeSection);
        editorStack.Children.Add(_expenseSection);
        editorStack.Children.Add(_savingSection);

        var scroll = new ScrollViewer
        {
            Content = editorStack,
            MinWidth = 300,
            HorizontalScrollBarVisibility =
                ScrollBarVisibility.Disabled
        };

        var paneSplitter = new GridSplitter
        {
            HorizontalAlignment = HorizontalAlignment.Stretch,
            VerticalAlignment = VerticalAlignment.Stretch,
            ResizeDirection = GridResizeDirection.Columns,
            ResizeBehavior = GridResizeBehavior.PreviousAndNext,
            Background = Brushes.Transparent
        };

        var diagramContent = new Grid();

        var totalsPanel = new Grid
        {
            ColumnDefinitions =
                new ColumnDefinitions("Auto,Auto"),
            RowDefinitions =
                new RowDefinitions("Auto,Auto,Auto"),
            ColumnSpacing = 12,
            RowSpacing = 2,
            Margin = new Thickness(20, 2, 20, 0)
        };

        Grid.SetRow(_incomeTotalText, 0);
        Grid.SetColumn(_incomeTotalText, 0);
        Grid.SetRow(_incomeTotalValueText, 0);
        Grid.SetColumn(_incomeTotalValueText, 1);

        Grid.SetRow(_expenseTotalText, 1);
        Grid.SetColumn(_expenseTotalText, 0);
        Grid.SetRow(_expenseTotalValueText, 1);
        Grid.SetColumn(_expenseTotalValueText, 1);

        Grid.SetRow(_savingTotalText, 2);
        Grid.SetColumn(_savingTotalText, 0);
        Grid.SetRow(_savingTotalValueText, 2);
        Grid.SetColumn(_savingTotalValueText, 1);

        totalsPanel.Children.Add(_incomeTotalText);
        totalsPanel.Children.Add(_incomeTotalValueText);
        totalsPanel.Children.Add(_expenseTotalText);
        totalsPanel.Children.Add(_expenseTotalValueText);
        totalsPanel.Children.Add(_savingTotalText);
        totalsPanel.Children.Add(_savingTotalValueText);

        _totalsSection.Header =
            new TextBlock
            {
                Text = "Totals",
                FontSize = 11,
                FontWeight = FontWeight.Bold,
                HorizontalAlignment = HorizontalAlignment.Left,
                TextAlignment = TextAlignment.Left
            };
        _totalsSection.Content = totalsPanel;
        _totalsSection.IsExpanded =
            _settings.IsTotalsSectionExpanded;
        _totalsSection.Margin =
            new Thickness(18, 8, 0, 0);
        _totalsSection.Padding =
            new Thickness(0);
        _totalsSection.MinHeight = 0;
        _totalsSection.FontSize = 11;
        _totalsSection.HorizontalAlignment =
            HorizontalAlignment.Left;
        _totalsSection.VerticalAlignment =
            VerticalAlignment.Top;
        _totalsSection.HorizontalContentAlignment =
            HorizontalAlignment.Left;

        diagramContent.Children.Add(_sankey);
        diagramContent.Children.Add(_totalsSection);

        var diagramBorder = new Border
        {
            Margin = new Thickness(0, 18, 18, 18),
            Background = new SolidColorBrush(Color.Parse("#0D1117")),
            CornerRadius = new CornerRadius(10),
            ClipToBounds = true,
            Child = diagramContent
        };

        Grid.SetColumn(paneSplitter, 1);
        Grid.SetColumn(diagramBorder, 2);

        body.Children.Add(scroll);
        body.Children.Add(diagramBorder);
        body.Children.Add(paneSplitter);

        Grid.SetRow(body, 1);

        root.Children.Add(toolbar);
        root.Children.Add(body);

        return root;
    }

    private static void ConfigureSection(
        Expander section,
        TextBlock heading,
        Button addButton,
        StackPanel content,
        bool isExpanded)
    {
        var header = new Grid
        {
            ColumnDefinitions = new ColumnDefinitions("*,Auto")
        };

        Grid.SetColumn(addButton, 1);

        header.Children.Add(heading);
        header.Children.Add(addButton);

        section.Header = header;
        section.Content = content;
        section.IsExpanded = isExpanded;
        section.Background =
            new SolidColorBrush(
                Color.Parse("#171D27"));
        section.Padding = new Thickness(14);
        section.HorizontalAlignment =
            HorizontalAlignment.Stretch;
        section.HorizontalContentAlignment =
            HorizontalAlignment.Stretch;
    }

    private void ApplyTexts()
    {
        Title = "SankeyCashflowTracker";
        _title.Text = _text["Title"];
        _incomeHeader.Text = _text["Income"];
        _expenseHeader.Text = _text["Expenses"];
        _savingHeader.Text = _text["Savings"];
        _importData.Header = _text["ImportData"];
        _exportData.Header = _text["ExportData"];
        _exportPng.Header = _text["ExportPng"];
        _exportSvg.Header = _text["ExportSvg"];
        _settingsButton.Content = _text["Settings"];
        _aboutButton.Content = "?";

        ToolTip.SetTip(_undoButton, _text["Undo"]);
        ToolTip.SetTip(_redoButton, _text["Redo"]);
        ToolTip.SetTip(_decreaseDepthButton, _text["ShowFewerLevels"]);
        ToolTip.SetTip(_increaseDepthButton, _text["ShowMoreLevels"]);
        ToolTip.SetTip(
            _dataTransferButton,
            $"{_text["ExportData"]} / {_text["ImportData"]}");
        ToolTip.SetTip(_aboutButton, _text["About"]);
        ToolTip.SetTip(_addIncome, _text["AddIncome"]);
        ToolTip.SetTip(_addExpense, _text["AddExpense"]);
        ToolTip.SetTip(_addSaving, _text["AddSaving"]);
    }

    private void RebuildEditor()
    {
        _reorderRows.Clear();

        _incomePanel.Children.Clear();
        _incomeNameBoxes.Clear();

        foreach (IncomeEntry income in _data.Incomes)
        {
            _incomePanel.Children.Add(CreateIncomeRow(income));
        }

        _expensePanel.Children.Clear();
        _expenseAmountBoxes.Clear();
        _expenseNameBoxes.Clear();

        UpdateExpenseTreeToggleButton();
        _expensePanel.Children.Add(_toggleExpenseTreeButton);

        foreach (ExpenseNode expense in _data.Expenses)
        {
            AddExpenseRow(expense, 0, _data.Expenses);
        }

        _savingPanel.Children.Clear();
        _savingAmountBoxes.Clear();
        _savingNameBoxes.Clear();

        UpdateSavingTreeToggleButton();
        _savingPanel.Children.Add(_toggleSavingTreeButton);

        foreach (ExpenseNode saving in _data.Savings)
        {
            AddSavingRow(saving, 0, _data.Savings);
        }

        UpdateDepthButtons();
    }

    private Control CreateIncomeRow(IncomeEntry income)
    {
        var grid = NewRowGrid("Auto,2*,*,Auto");
        var name = NewTextBox(income.Name, _text["Name"]);
        var amount = NewAmountBox(income.Amount, false);

        _incomeNameBoxes[income.Id] = name;

        var delete = new Button
        {
            Content = "×",
            MinWidth = 36,
            IsTabStop = false
        };

        ConfigureSymbolButton(delete);

        name.LostFocus += (_, _) =>
        {
            if (!ValidateName(name))
            {
                return;
            }

            string newName = name.Text!.Trim();

            if (!string.Equals(income.Name, newName, StringComparison.Ordinal))
            {
                RecordUndoState();
                income.Name = newName;
                SaveAndRefresh();
                UpdateUndoRedoButtons();
            }
        };

        amount.LostFocus += (_, _) =>
        {
            if (!TryAmount(amount, out decimal value))
            {
                return;
            }

            if (income.Amount != value)
            {
                RecordUndoState();
                income.Amount = value;
                amount.Text = Format(value);
                SaveAndRefresh();
                UpdateUndoRedoButtons();
            }
        };

        amount.KeyDown += (_, e) =>
        {
            if (e.Key != Avalonia.Input.Key.Tab ||
                e.KeyModifiers != Avalonia.Input.KeyModifiers.None)
            {
                return;
            }

            if (!TryAmount(amount, out decimal value))
            {
                e.Handled = true;
                return;
            }

            var newIncome = new IncomeEntry
            {
                Name = string.Empty,
                Amount = 0m
            };

            RecordUndoState();
            income.Amount = value;

            int currentIndex = _data.Incomes.IndexOf(income);
            _data.Incomes.Insert(currentIndex + 1, newIncome);

            e.Handled = true;
            SaveAndRebuild();
            UpdateUndoRedoButtons();
            FocusIncomeName(newIncome.Id);
        };

        delete.Click += (_, _) =>
        {
            ExecuteDataChange(() => _data.Incomes.Remove(income));
        };

        _reorderRows[income] =
            grid;

        Control dragHandle =
            CreateDragHandle(
                income,
                _data.Incomes,
                _incomePanel,
                grid);

        AddToGrid(grid, dragHandle, 0);
        AddToGrid(grid, name, 1);
        AddToGrid(grid, amount, 2);
        AddToGrid(grid, delete, 3);

        return grid;
    }

    private void AddExpenseRow(
        ExpenseNode node,
        int depth,
        List<ExpenseNode> owner)
    {
        bool hasChildren =
            node.Children.Count > 0;

        var grid =
            NewRowGrid(
                "20,30,2*,*,Auto,Auto");

        grid.Margin =
            new Thickness(
                depth * 16,
                0,
                0,
                0);

        var name = NewTextBox(node.Name, _text["Name"]);
        var amount = NewAmountBox(
            node.EffectiveAmount,
            node.Children.Count > 0);

        _expenseAmountBoxes[node.Id] = amount;
        _expenseNameBoxes[node.Id] = name;

        Control expandControl;

        if (hasChildren)
        {
            bool isCollapsed =
                _collapsedExpenseNodes.Contains(node.Id);

            var expandButton = new Button
            {
                Content = isCollapsed ? "▸" : "▾",
                MinWidth = 30,
                Padding = new Thickness(4),
                IsTabStop = false
            };

            ConfigureSymbolButton(expandButton);

            ToolTip.SetTip(
                expandButton,
                isCollapsed
                    ? _text["ExpandCategory"]
                    : _text["CollapseCategory"]);

            expandButton.Click += (_, _) =>
            {
                if (!_collapsedExpenseNodes.Add(node.Id))
                {
                    _collapsedExpenseNodes.Remove(node.Id);
                }

                SaveCollapsedExpenseState();
                RebuildEditor();
            };

            expandControl = expandButton;
        }
        else
        {
            expandControl =
                new Border
                {
                    Width = 30,
                    MinWidth = 30
                };
        }

        var add = new Button
        {
            Content = "+",
            MinWidth = 36,
            IsTabStop = false
        };

        var delete = new Button
        {
            Content = "×",
            MinWidth = 36,
            IsTabStop = false
        };

        ConfigureSymbolButton(add);
        ConfigureSymbolButton(delete);

        ToolTip.SetTip(add, _text["AddSubcategory"]);
        ToolTip.SetTip(delete, _text["Delete"]);

        name.LostFocus += (_, _) =>
        {
            if (!ValidateName(name))
            {
                return;
            }

            string newName = name.Text!.Trim();

            if (!string.Equals(node.Name, newName, StringComparison.Ordinal))
            {
                RecordUndoState();
                node.Name = newName;
                SaveAndRefresh();
                UpdateUndoRedoButtons();
            }
        };

        amount.LostFocus += (_, _) =>
        {
            if (node.Children.Count > 0 ||
                !TryAmount(amount, out decimal value))
            {
                return;
            }

            if (node.Amount != value)
            {
                RecordUndoState();
                node.Amount = value;
                amount.Text = Format(value);

                SaveAndRefresh();
                RefreshExpenseAmountBoxes();
                UpdateUndoRedoButtons();
            }
        };

        amount.KeyDown += (_, e) =>
        {
            if (e.Key != Avalonia.Input.Key.Tab ||
                e.KeyModifiers != Avalonia.Input.KeyModifiers.None ||
                node.Children.Count > 0)
            {
                return;
            }

            if (!TryAmount(amount, out decimal value))
            {
                e.Handled = true;
                return;
            }

            var newNode = new ExpenseNode
            {
                Name = string.Empty,
                Amount = 0m
            };

            RecordUndoState();
            node.Amount = value;

            int currentIndex = owner.IndexOf(node);
            owner.Insert(currentIndex + 1, newNode);

            e.Handled = true;
            SaveAndRebuild();
            UpdateUndoRedoButtons();
            FocusExpenseName(newNode.Id);
        };

        add.Click += (_, _) =>
        {
            var child = new ExpenseNode
            {
                Name = string.Empty,
                Amount = 0m
            };

            _collapsedExpenseNodes.Remove(node.Id);
            SaveCollapsedExpenseState();
            ExecuteDataChange(() => node.Children.Add(child));
            FocusExpenseName(child.Id);
        };

        delete.Click += (_, _) =>
        {
            RemoveCollapsedExpenseState(node);
            SaveCollapsedExpenseState();
            ExecuteDataChange(() => owner.Remove(node));
        };

        _reorderRows[node] =
            grid;

        Control dragHandle =
            CreateDragHandle(
                node,
                owner,
                _expensePanel,
                grid);

        if (hasChildren)
        {
            AddToGrid(grid, dragHandle, 0);
            AddToGrid(grid, expandControl, 1);
        }
        else
        {
            dragHandle.HorizontalAlignment =
                HorizontalAlignment.Right;

            Grid.SetColumn(
                dragHandle,
                0);

            Grid.SetColumnSpan(
                dragHandle,
                2);

            grid.Children.Add(
                dragHandle);
        }

        AddToGrid(grid, name, 2);
        AddToGrid(grid, amount, 3);
        AddToGrid(grid, add, 4);
        AddToGrid(grid, delete, 5);

        _expensePanel.Children.Add(grid);

        if (_collapsedExpenseNodes.Contains(node.Id))
        {
            return;
        }

        foreach (ExpenseNode child in node.Children)
        {
            AddExpenseRow(child, depth + 1, node.Children);
        }
    }

    private void AddSavingRow(
        ExpenseNode node,
        int depth,
        List<ExpenseNode> owner)
    {
        bool hasChildren =
            node.Children.Count > 0;

        var grid =
            NewRowGrid(
                "20,30,2*,*,Auto,Auto");

        grid.Margin =
            new Thickness(
                depth * 16,
                0,
                0,
                0);

        var name = NewTextBox(node.Name, _text["Name"]);
        var amount = NewAmountBox(
            node.EffectiveAmount,
            node.Children.Count > 0);

        _savingAmountBoxes[node.Id] = amount;
        _savingNameBoxes[node.Id] = name;

        Control expandControl;

        if (hasChildren)
        {
            bool isCollapsed =
                _collapsedSavingNodes.Contains(node.Id);

            var expandButton = new Button
            {
                Content = isCollapsed ? "▸" : "▾",
                MinWidth = 30,
                Padding = new Thickness(4),
                IsTabStop = false
            };

            ConfigureSymbolButton(expandButton);

            ToolTip.SetTip(
                expandButton,
                isCollapsed
                    ? _text["ExpandCategory"]
                    : _text["CollapseCategory"]);

            expandButton.Click += (_, _) =>
            {
                if (!_collapsedSavingNodes.Add(node.Id))
                {
                    _collapsedSavingNodes.Remove(node.Id);
                }

                SaveCollapsedSavingState();
                RebuildEditor();
            };

            expandControl = expandButton;
        }
        else
        {
            expandControl =
                new Border
                {
                    Width = 30,
                    MinWidth = 30
                };
        }

        var add = new Button
        {
            Content = "+",
            MinWidth = 36,
            IsTabStop = false
        };

        var delete = new Button
        {
            Content = "×",
            MinWidth = 36,
            IsTabStop = false
        };

        ConfigureSymbolButton(add);
        ConfigureSymbolButton(delete);

        ToolTip.SetTip(add, _text["AddSubcategory"]);
        ToolTip.SetTip(delete, _text["Delete"]);

        name.LostFocus += (_, _) =>
        {
            if (!ValidateName(name))
            {
                return;
            }

            string newName = name.Text!.Trim();

            if (!string.Equals(node.Name, newName, StringComparison.Ordinal))
            {
                RecordUndoState();
                node.Name = newName;
                SaveAndRefresh();
                UpdateUndoRedoButtons();
            }
        };

        amount.LostFocus += (_, _) =>
        {
            if (node.Children.Count > 0 ||
                !TryAmount(amount, out decimal value))
            {
                return;
            }

            if (node.Amount != value)
            {
                RecordUndoState();
                node.Amount = value;
                amount.Text = Format(value);

                SaveAndRefresh();
                RefreshSavingAmountBoxes();
                UpdateUndoRedoButtons();
            }
        };

        amount.KeyDown += (_, e) =>
        {
            if (e.Key != Avalonia.Input.Key.Tab ||
                e.KeyModifiers != Avalonia.Input.KeyModifiers.None ||
                node.Children.Count > 0)
            {
                return;
            }

            if (!TryAmount(amount, out decimal value))
            {
                e.Handled = true;
                return;
            }

            var newNode = new ExpenseNode
            {
                Name = string.Empty,
                Amount = 0m
            };

            RecordUndoState();
            node.Amount = value;

            int currentIndex = owner.IndexOf(node);
            owner.Insert(currentIndex + 1, newNode);

            e.Handled = true;
            SaveAndRebuild();
            UpdateUndoRedoButtons();
            FocusSavingName(newNode.Id);
        };

        add.Click += (_, _) =>
        {
            var child = new ExpenseNode
            {
                Name = string.Empty,
                Amount = 0m
            };

            _collapsedSavingNodes.Remove(node.Id);
            SaveCollapsedSavingState();
            ExecuteDataChange(() => node.Children.Add(child));
            FocusSavingName(child.Id);
        };

        delete.Click += (_, _) =>
        {
            RemoveCollapsedSavingState(node);
            SaveCollapsedSavingState();
            ExecuteDataChange(() => owner.Remove(node));
        };

        _reorderRows[node] =
            grid;

        Control dragHandle =
            CreateDragHandle(
                node,
                owner,
                _savingPanel,
                grid);

        if (hasChildren)
        {
            AddToGrid(grid, dragHandle, 0);
            AddToGrid(grid, expandControl, 1);
        }
        else
        {
            dragHandle.HorizontalAlignment =
                HorizontalAlignment.Right;

            Grid.SetColumn(
                dragHandle,
                0);

            Grid.SetColumnSpan(
                dragHandle,
                2);

            grid.Children.Add(
                dragHandle);
        }

        AddToGrid(grid, name, 2);
        AddToGrid(grid, amount, 3);
        AddToGrid(grid, add, 4);
        AddToGrid(grid, delete, 5);

        _savingPanel.Children.Add(grid);

        if (_collapsedSavingNodes.Contains(node.Id))
        {
            return;
        }

        foreach (ExpenseNode child in node.Children)
        {
            AddSavingRow(child, depth + 1, node.Children);
        }
    }

    private void ToggleExpenseTreeButton_Click(
        object? sender,
        Avalonia.Interactivity.RoutedEventArgs e)
    {
        List<Guid> expandableNodeIds = GetExpandableExpenseNodeIds();

        if (expandableNodeIds.Count == 0)
        {
            return;
        }

        bool hasExpandedNode =
            expandableNodeIds.Any(
                nodeId => !_collapsedExpenseNodes.Contains(nodeId));

        _collapsedExpenseNodes.Clear();

        if (hasExpandedNode)
        {
            foreach (Guid nodeId in expandableNodeIds)
            {
                _collapsedExpenseNodes.Add(nodeId);
            }
        }

        SaveCollapsedExpenseState();
        RebuildEditor();
    }

    private void SaveCollapsedExpenseState()
    {
        _settings.CollapsedExpenseNodeIds =
            _collapsedExpenseNodes.ToList();

        StorageService.SaveSettings(_settings);
    }

    private void NormalizeCollapsedExpenseState()
    {
        HashSet<Guid> validNodeIds =
            GetExpandableExpenseNodeIds().ToHashSet();

        bool changed =
            _collapsedExpenseNodes.RemoveWhere(
                nodeId => !validNodeIds.Contains(nodeId)) > 0;

        if (changed)
        {
            SaveCollapsedExpenseState();
        }
    }

    private void RemoveCollapsedExpenseState(
        ExpenseNode node)
    {
        _collapsedExpenseNodes.Remove(node.Id);

        foreach (ExpenseNode child in node.Children)
        {
            RemoveCollapsedExpenseState(child);
        }
    }

    private void UpdateExpenseTreeToggleButton()
    {
        List<Guid> expandableNodeIds = GetExpandableExpenseNodeIds();

        bool hasExpandedNode =
            expandableNodeIds.Any(
                nodeId => !_collapsedExpenseNodes.Contains(nodeId));

        _toggleExpenseTreeButton.IsEnabled =
            expandableNodeIds.Count > 0;

        _toggleExpenseTreeButton.Content =
            hasExpandedNode
                ? "▾"
                : "▸";

        ToolTip.SetTip(
            _toggleExpenseTreeButton,
            hasExpandedNode
                ? _text["CollapseAllCategories"]
                : _text["ExpandAllCategories"]);
    }

    private List<Guid> GetExpandableExpenseNodeIds()
    {
        var nodeIds = new List<Guid>();

        foreach (ExpenseNode expense in _data.Expenses)
        {
            CollectExpandableExpenseNodeIds(
                expense,
                nodeIds);
        }

        return nodeIds;
    }

    private static void CollectExpandableExpenseNodeIds(
        ExpenseNode node,
        List<Guid> nodeIds)
    {
        if (node.Children.Count == 0)
        {
            return;
        }

        nodeIds.Add(node.Id);

        foreach (ExpenseNode child in node.Children)
        {
            CollectExpandableExpenseNodeIds(
                child,
                nodeIds);
        }
    }

    private Control CreateDragHandle<T>(
        T item,
        List<T> owner,
        StackPanel ownerPanel,
        Grid row)
        where T : class
    {
        var grip = new TextBlock
        {
            Text = "⋮⋮",
            FontSize = 16,
            FontWeight = FontWeight.Bold,
            Foreground =
                new SolidColorBrush(
                    Color.Parse("#94A3B8")),
            HorizontalAlignment =
                HorizontalAlignment.Center,
            VerticalAlignment =
                VerticalAlignment.Center,
            IsHitTestVisible = false
        };

        var handle = new Border
        {
            Width = 20,
            MinWidth = 20,
            CornerRadius = new CornerRadius(3),
            Background = Brushes.Transparent,
            Cursor =
                new Cursor(
                    StandardCursorType.Hand),
            Child = grip
        };

        bool isDragging = false;
        Grid? highlightedRow = null;

        void ClearHighlight()
        {
            if (highlightedRow is null)
            {
                return;
            }

            highlightedRow.Background = null;
            highlightedRow = null;
        }

        int FindTargetIndex(
            double pointerY)
        {
            int fallbackIndex =
                owner.IndexOf(item);

            int targetIndex =
                fallbackIndex;

            double smallestDistance =
                double.PositiveInfinity;

            for (int index = 0;
                 index < owner.Count;
                 index++)
            {
                T candidate =
                    owner[index];

                if (!_reorderRows.TryGetValue(
                        candidate,
                        out Grid? candidateRow) ||
                    candidateRow is null)
                {
                    continue;
                }

                double centerY =
                    candidateRow.Bounds.Y +
                    candidateRow.Bounds.Height / 2;

                double distance =
                    Math.Abs(
                        pointerY -
                        centerY);

                if (distance >=
                    smallestDistance)
                {
                    continue;
                }

                smallestDistance =
                    distance;

                targetIndex =
                    index;
            }

            return targetIndex;
        }

        handle.PointerPressed += (_, e) =>
        {
            PointerPoint point =
                e.GetCurrentPoint(handle);

            if (!point.Properties.IsLeftButtonPressed)
            {
                return;
            }

            isDragging = true;
            row.Opacity = 0.65;
            handle.Background =
                new SolidColorBrush(
                    Color.Parse("#253041"));

            e.Pointer.Capture(handle);
            e.Handled = true;
        };

        handle.PointerMoved += (_, e) =>
        {
            if (!isDragging)
            {
                return;
            }

            Point pointerPosition =
                e.GetPosition(ownerPanel);

            int targetIndex =
                FindTargetIndex(
                    pointerPosition.Y);

            ClearHighlight();

            if (targetIndex >= 0 &&
                targetIndex < owner.Count &&
                _reorderRows.TryGetValue(
                    owner[targetIndex],
                    out Grid? targetRow) &&
                targetRow is not null &&
                !ReferenceEquals(
                    targetRow,
                    row))
            {
                highlightedRow =
                    targetRow;

                highlightedRow.Background =
                    new SolidColorBrush(
                        Color.Parse("#263244"));
            }

            e.Handled = true;
        };

        handle.PointerReleased += (_, e) =>
        {
            if (!isDragging)
            {
                return;
            }

            Point pointerPosition =
                e.GetPosition(ownerPanel);

            int currentIndex =
                owner.IndexOf(item);

            int targetIndex =
                FindTargetIndex(
                    pointerPosition.Y);

            isDragging = false;
            row.Opacity = 1;
            handle.Background =
                Brushes.Transparent;

            ClearHighlight();

            e.Pointer.Capture(null);
            e.Handled = true;

            if (currentIndex < 0 ||
                targetIndex < 0 ||
                targetIndex == currentIndex)
            {
                return;
            }

            ExecuteDataChange(
                () => MoveItemToIndex(
                    owner,
                    item,
                    targetIndex));
        };

        handle.PointerCaptureLost += (_, _) =>
        {
            isDragging = false;
            row.Opacity = 1;
            handle.Background =
                Brushes.Transparent;

            ClearHighlight();
        };

        return handle;
    }

    private static void MoveItemToIndex<T>(
        List<T> owner,
        T item,
        int targetIndex)
        where T : class
    {
        int currentIndex =
            owner.IndexOf(item);

        if (currentIndex < 0 ||
            targetIndex < 0 ||
            targetIndex >= owner.Count ||
            currentIndex == targetIndex)
        {
            return;
        }

        owner.RemoveAt(
            currentIndex);

        owner.Insert(
            targetIndex,
            item);
    }

    private static void ConfigureSymbolButton(
        Button button)
    {
        button.HorizontalContentAlignment =
            HorizontalAlignment.Center;

        button.VerticalContentAlignment =
            VerticalAlignment.Center;
    }


    private void ToggleSavingTreeButton_Click(
        object? sender,
        Avalonia.Interactivity.RoutedEventArgs e)
    {
        List<Guid> expandableNodeIds = GetExpandableSavingNodeIds();

        if (expandableNodeIds.Count == 0)
        {
            return;
        }

        bool hasExpandedNode =
            expandableNodeIds.Any(
                nodeId => !_collapsedSavingNodes.Contains(nodeId));

        _collapsedSavingNodes.Clear();

        if (hasExpandedNode)
        {
            foreach (Guid nodeId in expandableNodeIds)
            {
                _collapsedSavingNodes.Add(nodeId);
            }
        }

        SaveCollapsedSavingState();
        RebuildEditor();
    }

    private void SaveCollapsedSavingState()
    {
        _settings.CollapsedSavingNodeIds =
            _collapsedSavingNodes.ToList();

        StorageService.SaveSettings(_settings);
    }

    private void NormalizeCollapsedSavingState()
    {
        HashSet<Guid> validNodeIds =
            GetExpandableSavingNodeIds().ToHashSet();

        bool changed =
            _collapsedSavingNodes.RemoveWhere(
                nodeId => !validNodeIds.Contains(nodeId)) > 0;

        if (changed)
        {
            SaveCollapsedSavingState();
        }
    }

    private void RemoveCollapsedSavingState(
        ExpenseNode node)
    {
        _collapsedSavingNodes.Remove(node.Id);

        foreach (ExpenseNode child in node.Children)
        {
            RemoveCollapsedSavingState(child);
        }
    }

    private void UpdateSavingTreeToggleButton()
    {
        List<Guid> expandableNodeIds = GetExpandableSavingNodeIds();

        bool hasExpandedNode =
            expandableNodeIds.Any(
                nodeId => !_collapsedSavingNodes.Contains(nodeId));

        _toggleSavingTreeButton.IsEnabled =
            expandableNodeIds.Count > 0;

        _toggleSavingTreeButton.Content =
            hasExpandedNode
                ? "▾"
                : "▸";

        ToolTip.SetTip(
            _toggleSavingTreeButton,
            hasExpandedNode
                ? _text["CollapseAllSavings"]
                : _text["ExpandAllSavings"]);
    }

    private List<Guid> GetExpandableSavingNodeIds()
    {
        var nodeIds = new List<Guid>();

        foreach (ExpenseNode saving in _data.Savings)
        {
            CollectExpandableExpenseNodeIds(
                saving,
                nodeIds);
        }

        return nodeIds;
    }

    private static Grid NewRowGrid(string columns)
    {
        return new Grid
        {
            ColumnDefinitions = new ColumnDefinitions(columns),
            ColumnSpacing = 7
        };
    }

    private static void AddToGrid(
        Grid grid,
        Control control,
        int column)
    {
        Grid.SetColumn(control, column);
        grid.Children.Add(control);
    }

    private TextBox NewTextBox(
        string text,
        string placeholderText)
    {
        var textBox = new TextBox
        {
            Text = text,
            PlaceholderText = placeholderText,
            IsTabStop = true,
            BorderBrush = NormalBrush,
            BorderThickness = new Thickness(1)
        };

        ConfigureEditableTextBox(textBox);

        return textBox;
    }

    private TextBox NewAmountBox(
        decimal value,
        bool readOnly)
    {
        var textBox = new TextBox
        {
            Text = Format(value),
            PlaceholderText = _text["Amount"],
            IsReadOnly = readOnly,
            IsTabStop = !readOnly,
            HorizontalContentAlignment = HorizontalAlignment.Right,
            BorderBrush = NormalBrush,
            BorderThickness = new Thickness(1)
        };

        if (!readOnly)
        {
            ConfigureEditableTextBox(textBox);
        }

        return textBox;
    }

    private static void ConfigureEditableTextBox(TextBox textBox)
    {
        textBox.GotFocus += (_, _) =>
        {
            textBox.BorderBrush = FocusBrush;
            textBox.BorderThickness = new Thickness(2);

            Avalonia.Threading.Dispatcher.UIThread.Post(
                textBox.SelectAll,
                Avalonia.Threading.DispatcherPriority.Input);
        };

        textBox.LostFocus += (_, _) =>
        {
            if (textBox.BorderBrush == FocusBrush)
            {
                textBox.BorderBrush = NormalBrush;
            }

            textBox.BorderThickness = new Thickness(1);
        };

        textBox.PointerPressed += (_, _) =>
        {
            if (!textBox.IsFocused)
            {
                Avalonia.Threading.Dispatcher.UIThread.Post(
                    textBox.SelectAll,
                    Avalonia.Threading.DispatcherPriority.Input);
            }
        };
    }

    private bool ValidateName(TextBox box)
    {
        bool valid = !string.IsNullOrWhiteSpace(box.Text);

        box.BorderBrush = valid
            ? NormalBrush
            : InvalidBrush;

        box.BorderThickness = valid
            ? new Thickness(1)
            : new Thickness(2);

        ToolTip.SetTip(
            box,
            valid ? null : _text["ValidationName"]);

        return valid;
    }

    private bool TryAmount(
        TextBox box,
        out decimal value)
    {
        bool valid = TryNormalizeAmount(
            box.Text ?? string.Empty,
            out value);

        box.BorderBrush = valid
            ? NormalBrush
            : InvalidBrush;

        box.BorderThickness = valid
            ? new Thickness(1)
            : new Thickness(2);

        ToolTip.SetTip(
            box,
            valid ? null : _text["ValidationAmount"]);

        if (valid)
        {
            box.Text = Format(value);
        }

        return valid;
    }

    private static bool TryNormalizeAmount(
        string input,
        out decimal value)
    {
        value = 0m;

        if (string.IsNullOrWhiteSpace(input))
        {
            return false;
        }

        string cleaned = new(
            input
                .Trim()
                .Where(character =>
                    char.IsDigit(character) ||
                    character == ',' ||
                    character == '.' ||
                    character == '-')
                .ToArray());

        if (string.IsNullOrWhiteSpace(cleaned))
        {
            return false;
        }

        cleaned = cleaned.Replace("-", string.Empty);

        if (string.IsNullOrWhiteSpace(cleaned))
        {
            return false;
        }

        int lastComma = cleaned.LastIndexOf(',');
        int lastPoint = cleaned.LastIndexOf('.');
        int decimalSeparatorIndex = Math.Max(lastComma, lastPoint);

        if (decimalSeparatorIndex >= 0)
        {
            int digitsAfterSeparator =
                cleaned.Length - decimalSeparatorIndex - 1;

            bool containsBothSeparators =
                lastComma >= 0 &&
                lastPoint >= 0;

            bool separatorRepresentsDecimals =
                containsBothSeparators ||
                digitsAfterSeparator is 1 or 2;

            if (separatorRepresentsDecimals)
            {
                cleaned = cleaned[..decimalSeparatorIndex];
            }
        }

        string integerDigits = new(
            cleaned
                .Where(char.IsDigit)
                .ToArray());

        if (integerDigits.Length == 0)
        {
            return false;
        }

        if (!decimal.TryParse(
                integerDigits,
                NumberStyles.None,
                CultureInfo.InvariantCulture,
                out decimal parsedValue))
        {
            return false;
        }

        value = decimal.Truncate(decimal.Abs(parsedValue));

        return true;
    }

    private static string Format(decimal value)
    {
        return decimal.Truncate(decimal.Abs(value))
            .ToString("0", CultureInfo.CurrentCulture);
    }

    private bool IsLastEditableExpenseNode(ExpenseNode node)
    {
        ExpenseNode? lastEditableNode = null;

        foreach (ExpenseNode root in _data.Expenses)
        {
            FindLastEditableExpenseNode(
                root,
                ref lastEditableNode);
        }

        return lastEditableNode?.Id == node.Id;
    }

    private static void FindLastEditableExpenseNode(
        ExpenseNode node,
        ref ExpenseNode? lastEditableNode)
    {
        if (node.Children.Count == 0)
        {
            lastEditableNode = node;
            return;
        }

        foreach (ExpenseNode child in node.Children)
        {
            FindLastEditableExpenseNode(
                child,
                ref lastEditableNode);
        }
    }

    private void RefreshExpenseAmountBoxes()
    {
        foreach (ExpenseNode expense in _data.Expenses)
        {
            RefreshExpenseAmountBoxes(expense);
        }
    }

    private void RefreshExpenseAmountBoxes(ExpenseNode node)
    {
        if (_expenseAmountBoxes.TryGetValue(
                node.Id,
                out TextBox? amountBox))
        {
            amountBox.Text = Format(node.EffectiveAmount);
            amountBox.IsReadOnly = node.Children.Count > 0;
            amountBox.IsTabStop = node.Children.Count == 0;
        }

        foreach (ExpenseNode child in node.Children)
        {
            RefreshExpenseAmountBoxes(child);
        }
    }

    private void FocusIncomeName(Guid incomeId)
    {
        Avalonia.Threading.Dispatcher.UIThread.Post(
            () =>
            {
                if (_incomeNameBoxes.TryGetValue(incomeId, out TextBox? nameBox))
                {
                    nameBox.Focus();
                }
            },
            Avalonia.Threading.DispatcherPriority.Input);
    }

    private void FocusExpenseName(Guid expenseId)
    {
        Avalonia.Threading.Dispatcher.UIThread.Post(
            () =>
            {
                if (_expenseNameBoxes.TryGetValue(expenseId, out TextBox? nameBox))
                {
                    nameBox.Focus();
                }
            },
            Avalonia.Threading.DispatcherPriority.Input);
    }


    private void RefreshSavingAmountBoxes()
    {
        foreach (ExpenseNode saving in _data.Savings)
        {
            RefreshSavingAmountBoxes(saving);
        }
    }

    private void RefreshSavingAmountBoxes(ExpenseNode node)
    {
        if (_savingAmountBoxes.TryGetValue(
                node.Id,
                out TextBox? amountBox))
        {
            amountBox.Text = Format(node.EffectiveAmount);
            amountBox.IsReadOnly = node.Children.Count > 0;
            amountBox.IsTabStop = node.Children.Count == 0;
        }

        foreach (ExpenseNode child in node.Children)
        {
            RefreshSavingAmountBoxes(child);
        }
    }

    private void FocusSavingName(Guid savingId)
    {
        Avalonia.Threading.Dispatcher.UIThread.Post(
            () =>
            {
                if (_savingNameBoxes.TryGetValue(savingId, out TextBox? nameBox))
                {
                    nameBox.Focus();
                }
            },
            Avalonia.Threading.DispatcherPriority.Input);
    }

    private string SerializeCurrentData()
    {
        return JsonSerializer.Serialize(_data);
    }

    private void RecordUndoState()
    {
        _undoStates.Push(SerializeCurrentData());
        _redoStates.Clear();
    }

    private void ExecuteDataChange(Action change)
    {
        RecordUndoState();
        change();
        SaveAndRebuild();
        UpdateUndoRedoButtons();
    }

    private void RestoreData(string serializedData)
    {
        CashflowData restored =
            JsonSerializer.Deserialize<CashflowData>(serializedData)
            ?? new CashflowData();

        _data.Incomes.Clear();
        _data.Incomes.AddRange(restored.Incomes);

        _data.Expenses.Clear();
        _data.Expenses.AddRange(restored.Expenses);

        _data.Savings.Clear();
        _data.Savings.AddRange(restored.Savings);

        StorageService.SaveData(_data);
        RebuildEditor();
        RefreshDiagram();
    }

    private void UndoButton_Click(
        object? sender,
        Avalonia.Interactivity.RoutedEventArgs e)
    {
        if (_undoStates.Count == 0)
        {
            return;
        }

        _redoStates.Push(SerializeCurrentData());
        RestoreData(_undoStates.Pop());
        UpdateUndoRedoButtons();
    }

    private void RedoButton_Click(
        object? sender,
        Avalonia.Interactivity.RoutedEventArgs e)
    {
        if (_redoStates.Count == 0)
        {
            return;
        }

        _undoStates.Push(SerializeCurrentData());
        RestoreData(_redoStates.Pop());
        UpdateUndoRedoButtons();
    }

    private void UpdateUndoRedoButtons()
    {
        _undoButton.IsEnabled = _undoStates.Count > 0;
        _redoButton.IsEnabled = _redoStates.Count > 0;
    }

    private void SaveAndRefresh()
    {
        StorageService.SaveData(_data);
        RefreshDiagram();
    }

    private void SaveAndRebuild()
    {
        StorageService.SaveData(_data);
        RebuildEditor();
        RefreshDiagram();
    }

    private void RefreshDiagram()
    {
        decimal totalIncome =
            _data.Incomes.Sum(income => income.Amount);

        decimal totalExpenses =
            _data.Expenses.Sum(expense => expense.EffectiveAmount);

        decimal totalSavings =
            _data.Savings.Sum(saving => saving.EffectiveAmount);

        _incomeTotalText.Text =
            $"{_text["IncomeTotal"]}:";

        _incomeTotalValueText.Text =
            $"{Format(totalIncome)} {_settings.CurrencySymbol}";

        _expenseTotalText.Text =
            $"{_text["ExpensesTotal"]}:";

        _expenseTotalValueText.Text =
            $"{Format(totalExpenses)} {_settings.CurrencySymbol}";

        _savingTotalText.Text =
            $"{_text["SavingsTotal"]}:";

        _savingTotalValueText.Text =
            $"{Format(totalSavings)} {_settings.CurrencySymbol}";

        _totalsSection.IsVisible =
            _settings.ShowValues;

        _sankey.SetData(
            _data,
            _settings.CurrencySymbol,
            _text["Budget"],
            _text["NoData"],
            _text["Remaining"],
            _text["Deficit"],
            _text["Expenses"],
            _text["Savings"],
            string.Equals(
                _settings.LabelPosition,
                "Inside",
                StringComparison.OrdinalIgnoreCase),
            _settings.ShowValues,
            _visibleSankeyDepth,
            _settings.LinkOpacity,
            _settings.SankeyLevelHorizontalOffsets);
    }

    private void ZoomOutButton_Click(
        object? sender,
        Avalonia.Interactivity.RoutedEventArgs e)
    {
        _sankey.SetZoomFactor(
            _sankey.ZoomFactor -
            SankeyControl.ZoomStep);
    }

    private void ZoomInButton_Click(
        object? sender,
        Avalonia.Interactivity.RoutedEventArgs e)
    {
        _sankey.SetZoomFactor(
            _sankey.ZoomFactor +
            SankeyControl.ZoomStep);
    }

    private void Sankey_LevelHorizontalOffsetsChanged(
        IReadOnlyList<double> offsets)
    {
        _settings.SankeyLevelHorizontalOffsets =
            offsets.ToList();

        StorageService.SaveSettings(
            _settings);
    }

    private void Sankey_ZoomFactorChanged(
        double zoomFactor)
    {
        _settings.SankeyZoomFactor =
            zoomFactor;

        StorageService.SaveSettings(
            _settings);

        UpdateZoomControls();
    }

    private void UpdateZoomControls()
    {
        _zoomValueText.Text =
            $"{Math.Round(_sankey.ZoomFactor * 100):0} %";

        _zoomOutButton.IsEnabled =
            _sankey.ZoomFactor >
            SankeyControl.MinimumZoomFactor +
            0.0001;

        _zoomInButton.IsEnabled =
            _sankey.ZoomFactor <
            SankeyControl.MaximumZoomFactor -
            0.0001;
    }

    private void DecreaseDepthButton_Click(
        object? sender,
        Avalonia.Interactivity.RoutedEventArgs e)
    {
        if (_visibleSankeyDepth <= 1)
        {
            return;
        }

        _visibleSankeyDepth--;
        _settings.VisibleSankeyDepth = _visibleSankeyDepth;
        StorageService.SaveSettings(_settings);
        UpdateDepthButtons();
        RefreshDiagram();
    }

    private void IncreaseDepthButton_Click(
        object? sender,
        Avalonia.Interactivity.RoutedEventArgs e)
    {
        int maximumDepth = GetMaximumExpenseDepth();

        if (_visibleSankeyDepth >= maximumDepth)
        {
            return;
        }

        _visibleSankeyDepth++;
        _settings.VisibleSankeyDepth = _visibleSankeyDepth;
        StorageService.SaveSettings(_settings);
        UpdateDepthButtons();
        RefreshDiagram();
    }

    private void UpdateDepthButtons()
    {
        int maximumDepth = GetMaximumExpenseDepth();

        int clampedDepth = Math.Clamp(
            _visibleSankeyDepth,
            1,
            maximumDepth);

        if (_visibleSankeyDepth != clampedDepth)
        {
            _visibleSankeyDepth = clampedDepth;
            _settings.VisibleSankeyDepth = _visibleSankeyDepth;
            StorageService.SaveSettings(_settings);
        }

        _depthValueText.Text =
            _visibleSankeyDepth.ToString(
                CultureInfo.InvariantCulture);

        _decreaseDepthButton.IsEnabled =
            _visibleSankeyDepth > 1;

        _increaseDepthButton.IsEnabled =
            _visibleSankeyDepth < maximumDepth;
    }

    private int GetMaximumExpenseDepth()
    {
        int expenseDepth =
            _data.Expenses.Count == 0
                ? 1
                : _data.Expenses.Max(GetExpenseDepth);

        int savingDepth =
            _data.Savings.Count == 0
                ? 1
                : _data.Savings.Max(GetExpenseDepth);

        return Math.Max(
            1,
            Math.Max(expenseDepth, savingDepth));
    }

    private static int GetExpenseDepth(
        ExpenseNode node)
    {
        return node.Children.Count == 0
            ? 1
            : 1 + node.Children.Max(GetExpenseDepth);
    }

    private async void AboutButton_Click(
        object? sender,
        Avalonia.Interactivity.RoutedEventArgs e)
    {
        await new AboutWindow(
                _text)
            .ShowDialog(this);
    }

    private async void SettingsButton_Click(
        object? sender,
        Avalonia.Interactivity.RoutedEventArgs e)
    {
        var dialog = new SettingsDialog(
            _settings,
            _text,
            value =>
            {
                _settings.LinkOpacity = value;
                StorageService.SaveSettings(_settings);
                RefreshDiagram();
            });

        AppSettings? result =
            await dialog.ShowDialog<AppSettings?>(this);

        if (result is null)
        {
            return;
        }

        _settings = result;

        StorageService.SaveSettings(_settings);

        _text.Load(_settings.Language);

        ApplyTexts();
        RebuildEditor();
        RefreshDiagram();
    }

    private async void ImportData_Click(
        object? sender,
        Avalonia.Interactivity.RoutedEventArgs e)
    {
        try
        {
            IReadOnlyList<IStorageFile> files =
                await StorageProvider.OpenFilePickerAsync(
                    new FilePickerOpenOptions
                    {
                        AllowMultiple = false,
                        FileTypeFilter =
                        [
                            new FilePickerFileType("JSON")
                            {
                                Patterns = ["*.json"]
                            }
                        ]
                    });

            string? path =
                files.FirstOrDefault()?.TryGetLocalPath();

            if (string.IsNullOrWhiteSpace(path))
            {
                return;
            }

            CashflowData imported =
                StorageService.ImportData(path);

            RecordUndoState();

            _data.Incomes.Clear();
            _data.Incomes.AddRange(imported.Incomes);

            _data.Expenses.Clear();
            _data.Expenses.AddRange(imported.Expenses);

            _data.Savings.Clear();
            _data.Savings.AddRange(imported.Savings);

            _collapsedExpenseNodes.Clear();
            SaveCollapsedExpenseState();

            _collapsedSavingNodes.Clear();
            SaveCollapsedSavingState();

            StorageService.SaveData(_data);
            _visibleSankeyDepth = GetMaximumExpenseDepth();
            _settings.VisibleSankeyDepth = _visibleSankeyDepth;
            StorageService.SaveSettings(_settings);
            RebuildEditor();
            RefreshDiagram();
            UpdateUndoRedoButtons();
        }
        catch (Exception ex)
        {
            LogService.Write(ex);

            await new ConfirmDialog(
                    string.Empty,
                    _text["ImportFailed"],
                    _text["Yes"],
                    string.Empty,
                    false)
                .ShowDialog<bool>(this);
        }
    }

    private async void ExportData_Click(
        object? sender,
        Avalonia.Interactivity.RoutedEventArgs e)
    {
        try
        {
            IStorageFile? file =
                await StorageProvider.SaveFilePickerAsync(
                    new FilePickerSaveOptions
                    {
                        SuggestedFileName =
                            "SankeyCashflowTracker_data.json",
                        DefaultExtension = "json",
                        FileTypeChoices =
                        [
                            new FilePickerFileType("JSON")
                            {
                                Patterns = ["*.json"]
                            }
                        ]
                    });

            string? path =
                file?.TryGetLocalPath();

            if (!string.IsNullOrWhiteSpace(path))
            {
                StorageService.ExportData(
                    _data,
                    path);
            }
        }
        catch (Exception ex)
        {
            LogService.Write(ex);

            await new ConfirmDialog(
                    string.Empty,
                    _text["ExportDataFailed"],
                    _text["Yes"],
                    string.Empty,
                    false)
                .ShowDialog<bool>(this);
        }
    }

    private async void ExportPng_Click(
        object? sender,
        Avalonia.Interactivity.RoutedEventArgs e)
    {
        try
        {
            IStorageFile? file =
                await StorageProvider.SaveFilePickerAsync(
                    new FilePickerSaveOptions
                    {
                        SuggestedFileName = "cashflow.png",
                        DefaultExtension = "png",
                        FileTypeChoices =
                        [
                            new FilePickerFileType("PNG")
                            {
                                Patterns = ["*.png"]
                            }
                        ]
                    });

            string? path = file?.TryGetLocalPath();

            if (!string.IsNullOrWhiteSpace(path))
            {
                await _sankey.ExportPngAsync(path);
            }
        }
        catch (Exception ex)
        {
            LogService.Write(ex);

            await new ConfirmDialog(
                    string.Empty,
                    _text["ExportFailed"],
                    _text["Yes"],
                    string.Empty,
                    false)
                .ShowDialog<bool>(this);
        }
    }

    private async void ExportSvg_Click(
        object? sender,
        Avalonia.Interactivity.RoutedEventArgs e)
    {
        try
        {
            IStorageFile? file =
                await StorageProvider.SaveFilePickerAsync(
                    new FilePickerSaveOptions
                    {
                        SuggestedFileName = "cashflow.svg",
                        DefaultExtension = "svg",
                        FileTypeChoices =
                        [
                            new FilePickerFileType("SVG")
                            {
                                Patterns = ["*.svg"]
                            }
                        ]
                    });

            string? path = file?.TryGetLocalPath();

            if (!string.IsNullOrWhiteSpace(path))
            {
                _sankey.ExportSvg(path);
            }
        }
        catch (Exception ex)
        {
            LogService.Write(ex);

            await new ConfirmDialog(
                    string.Empty,
                    _text["ExportFailed"],
                    _text["Yes"],
                    string.Empty,
                    false)
                .ShowDialog<bool>(this);
        }
    }
}

public sealed class SettingsDialog : Window
{
    private readonly ComboBox _language = new();
    private readonly TextBox _currency = new();
    private readonly ComboBox _labelPosition = new();
    private readonly CheckBox _showValues = new();
    private readonly Slider _linkOpacity = new();
    private readonly TextBlock _linkOpacityValue = new();

    public SettingsDialog(
        AppSettings settings,
        LocalizationService text,
        Action<double> linkOpacityChanged)
    {
        AppWindowAssets.ApplyIcon(this);

        Title = text["Settings"];
        Width = 460;
        Height = 410;
        CanResize = false;
        WindowStartupLocation = WindowStartupLocation.CenterOwner;

        _language.Items.Add(new ComboBoxItem { Content = "English", Tag = "en" });
        _language.Items.Add(new ComboBoxItem { Content = "Deutsch", Tag = "de" });
        _language.SelectedIndex = settings.Language.Equals(
            "de",
            StringComparison.OrdinalIgnoreCase)
            ? 1
            : 0;

        _currency.Text = settings.CurrencySymbol;
        _currency.MaxLength = 8;

        _labelPosition.Items.Add(new ComboBoxItem
        {
            Content = text["LabelsInside"],
            Tag = "Inside"
        });
        _labelPosition.Items.Add(new ComboBoxItem
        {
            Content = text["LabelsOutside"],
            Tag = "Outside"
        });
        _labelPosition.SelectedIndex = settings.LabelPosition.Equals(
            "Outside",
            StringComparison.OrdinalIgnoreCase)
            ? 1
            : 0;

        _showValues.Content = text["ShowValues"];
        _showValues.IsChecked = settings.ShowValues;

        _linkOpacity.Minimum = 0.10;
        _linkOpacity.Maximum = 1.00;
        _linkOpacity.SmallChange = 0.01;
        _linkOpacity.LargeChange = 0.10;
        _linkOpacity.Value =
            Math.Clamp(
                settings.LinkOpacity,
                0.10,
                1.00);

        _linkOpacityValue.Text =
            $"{Math.Round(_linkOpacity.Value * 100):0} %";

        _linkOpacity.PropertyChanged += (_, e) =>
        {
            if (e.Property != RangeBase.ValueProperty)
            {
                return;
            }

            double value =
                Math.Clamp(
                    _linkOpacity.Value,
                    0.10,
                    1.00);

            settings.LinkOpacity = value;
            StorageService.SaveSettings(settings);
            _linkOpacityValue.Text =
                $"{Math.Round(value * 100):0} %";
            linkOpacityChanged(value);
        };

        var save = new Button { Content = text["Save"] };
        var cancel = new Button { Content = text["Cancel"] };

        save.Click += (_, _) =>
        {
            string symbol = (_currency.Text ?? string.Empty).Trim();

            if (symbol.Length == 0)
            {
                _currency.BorderBrush = Brushes.Red;
                return;
            }

            string language =
                ((_language.SelectedItem as ComboBoxItem)?.Tag as string)
                ?? "en";

            string labelPosition =
                ((_labelPosition.SelectedItem as ComboBoxItem)?.Tag as string)
                ?? "Inside";

            Close(new AppSettings
            {
                Language = language,
                CurrencySymbol = symbol,
                LabelPosition = labelPosition,
                ShowValues = _showValues.IsChecked == true,
                LinkOpacity = settings.LinkOpacity,
                IsIncomeSectionExpanded =
                    settings.IsIncomeSectionExpanded,
                IsExpenseSectionExpanded =
                    settings.IsExpenseSectionExpanded,
                IsSavingSectionExpanded =
                    settings.IsSavingSectionExpanded,
                IsTotalsSectionExpanded =
                    settings.IsTotalsSectionExpanded,
                VisibleSankeyDepth = settings.VisibleSankeyDepth,
                CollapsedExpenseNodeIds =
                    settings.CollapsedExpenseNodeIds.ToList(),
                CollapsedSavingNodeIds =
                    settings.CollapsedSavingNodeIds.ToList()
            });
        };

        cancel.Click += (_, _) => Close(null);

        var grid = new Grid
        {
            Margin = new Thickness(20),
            RowDefinitions = new RowDefinitions("Auto,Auto,Auto,Auto,Auto,Auto,*"),
            ColumnDefinitions = new ColumnDefinitions("170,*"),
            RowSpacing = 12
        };

        var heading = new TextBlock
        {
            Text = text["Settings"],
            FontSize = 20,
            FontWeight = FontWeight.SemiBold
        };

        Grid.SetColumnSpan(heading, 2);
        grid.Children.Add(heading);

        var languageLabel = new TextBlock
        {
            Text = text["Language"],
            VerticalAlignment = VerticalAlignment.Center
        };

        var currencyLabel = new TextBlock
        {
            Text = text["CurrencySymbol"],
            VerticalAlignment = VerticalAlignment.Center
        };

        var labelPositionLabel = new TextBlock
        {
            Text = text["LabelPosition"],
            VerticalAlignment = VerticalAlignment.Center
        };

        var linkOpacityLabel = new TextBlock
        {
            Text = text["LinkOpacity"],
            VerticalAlignment = VerticalAlignment.Center
        };

        var linkOpacityPanel = new Grid
        {
            ColumnDefinitions = new ColumnDefinitions("*,60"),
            ColumnSpacing = 8
        };

        Grid.SetColumn(_linkOpacityValue, 1);
        _linkOpacityValue.HorizontalAlignment =
            HorizontalAlignment.Right;
        _linkOpacityValue.VerticalAlignment =
            VerticalAlignment.Center;

        linkOpacityPanel.Children.Add(_linkOpacity);
        linkOpacityPanel.Children.Add(_linkOpacityValue);

        Grid.SetRow(languageLabel, 1);
        Grid.SetRow(currencyLabel, 2);
        Grid.SetRow(labelPositionLabel, 3);
        Grid.SetRow(linkOpacityLabel, 4);

        Grid.SetRow(_language, 1);
        Grid.SetColumn(_language, 1);

        Grid.SetRow(_currency, 2);
        Grid.SetColumn(_currency, 1);

        Grid.SetRow(_labelPosition, 3);
        Grid.SetColumn(_labelPosition, 1);

        Grid.SetRow(linkOpacityPanel, 4);
        Grid.SetColumn(linkOpacityPanel, 1);

        Grid.SetRow(_showValues, 5);
        Grid.SetColumn(_showValues, 1);

        var buttons = new StackPanel
        {
            Orientation = Orientation.Horizontal,
            HorizontalAlignment = HorizontalAlignment.Right,
            VerticalAlignment = VerticalAlignment.Bottom,
            Spacing = 8,
            Children = { cancel, save }
        };

        Grid.SetRow(buttons, 6);
        Grid.SetColumnSpan(buttons, 2);

        grid.Children.Add(languageLabel);
        grid.Children.Add(currencyLabel);
        grid.Children.Add(labelPositionLabel);
        grid.Children.Add(linkOpacityLabel);
        grid.Children.Add(_language);
        grid.Children.Add(_currency);
        grid.Children.Add(_labelPosition);
        grid.Children.Add(linkOpacityPanel);
        grid.Children.Add(_showValues);
        grid.Children.Add(buttons);

        Content = grid;
    }
}

public sealed class ConfirmDialog : Window
{
    public ConfirmDialog(string title, string message, string yes, string no, bool showNo)
    {
        AppWindowAssets.ApplyIcon(this);

        Title = title;
        Width = 430;
        Height = 210;
        CanResize = false;
        WindowStartupLocation = WindowStartupLocation.CenterOwner;

        var yesButton = new Button { Content = yes };
        var noButton = new Button { Content = no, IsVisible = showNo };
        yesButton.Click += (_, _) => Close(true);
        noButton.Click += (_, _) => Close(false);

        Content = new Grid
        {
            Margin = new Thickness(20),
            RowDefinitions = new RowDefinitions("*,Auto"),
            Children =
            {
                new TextBlock
                {
                    Text = message,
                    TextWrapping = TextWrapping.Wrap,
                    FontSize = 16,
                    VerticalAlignment = VerticalAlignment.Center
                },
                new StackPanel
                {
                    Orientation = Orientation.Horizontal,
                    HorizontalAlignment = HorizontalAlignment.Right,
                    Spacing = 8,
                    Children = { noButton, yesButton },
                    [Grid.RowProperty] = 1
                }
            }
        };
    }
}