@code {
    private readonly List<SankeyChartNode> _nodes =
    [
        new("Income", 0),

        // Income
        new("Expenses", 1),
        new("Savings", 1),

        // Expenses
        new("Housing", 2),
        new("Food", 2),
        new("Insurance", 2),
        new("Mobility", 2),
        new("Travel", 2),
        new("Leisure", 2),
        // Savings
        new("Interest", 2),
        new("Stocks", 2),

        // Housing
        new("Rent", 3),
        new("Other", 3),
        // Insurance
        new("Home insurance", 3),
        new("Car insurance", 3),
        new("Health insurance", 3),
        // Travel
        new("Car", 3),
        new("Public transport", 3),
    ];

    private readonly List<SankeyChartEdge> _edges =
    [
        // Income
        new("Income", "Expenses", 2800),
        new("Income", "Savings", 400),

        // Expenses
        new("Expenses", "Housing", 1200),
        new("Expenses", "Food", 500),
        new("Expenses", "Insurance", 250),
        new("Expenses", "Mobility", 125),
        new("Expenses", "Travel", 425),
        new("Expenses", "Leisure", 300),
        // Savings
        new("Savings", "Interest", 10),
        new("Savings", "Stocks", 390),

        // Housing
        new("Housing", "Rent", 950),
        new("Housing", "Other", 250),
        // Insurance
        new("Insurance", "Home insurance", 50),
        new("Insurance", "Car insurance", 75),
        new("Insurance", "Health insurance", 125),
        // Travel
        new("Travel", "Car", 300),
        new("Travel", "Public transport", 125),
    ];
}

@code {
    private List<SankeyChartNode> _nodes = [];
    private List<SankeyChartEdge> _edges = [];
    private readonly ChartOptions _options = new();
    private readonly NodeChartOptions _nodeChartOptions = new()
    {
        NodeWidth = 5,
        MinVerticalSpacing = 5,
        LabelFontSize = "0.33rem",
        LabelPadding = 2,
        OrderNodesByValue = true,
        HideNodesSmallerThan = 1
    };

    private int _width = 650;
    private int _height = 650;
    private int _nodeCount = 50;
    private int _columnCount = 3;

    protected override void OnAfterRender(bool firstRender)
    {
        base.OnAfterRender(firstRender);
        if (firstRender) GenerateData();
    }

    private void GenerateData(double minEdgePercentage = 0.15, double maxEdgePercentage = 0.7)
    {
        var rnd = new Random();
        _nodes = [];
        _edges = [];

        var nodesPerColumn = (int)Math.Ceiling((double)_nodeCount / _columnCount);
        for (var col = 0; col < _columnCount; col++)
        {
            var nodesInCurrentColumn = Math.Min(nodesPerColumn, _nodeCount - _nodes.Count);
            for (var i = 0; i < nodesInCurrentColumn; i++)
            {
                var nodeName = $"Node_{col}_{i}";
                _nodes.Add(new SankeyChartNode(nodeName, col));
            }
        }

        var nodesByColumn = _nodes.GroupBy(n => n.Column)
            .OrderBy(g => g.Key)
            .Select(g => g.ToList())
            .ToList();
        var nodeOutputs = new Dictionary<string, double>();
        var nodeInputs = new Dictionary<string, double>();
        foreach (var node in _nodes)
        {
            nodeOutputs[node.Name] = 0;
            nodeInputs[node.Name] = 0;
        }

        for (var colI = 0; colI < nodesByColumn.Count - 1; colI++)
        {
            var sourceNodes = nodesByColumn[colI];
            var targetNodes = nodesByColumn[colI + 1];

            if (colI == 0)
            {
                foreach (var sourceNode in sourceNodes)
                {
                    nodeOutputs[sourceNode.Name] = rnd.Next(1, 1000);
                }
            }

            foreach (var sourceNode in sourceNodes)
            {
                var remainingEdgeValue = nodeOutputs[sourceNode.Name];
                var edgeCount = rnd.Next(1, Math.Min(targetNodes.Count, 3) + 1);
                var selectedTargets = targetNodes.OrderBy(_ => rnd.Next()).Take(edgeCount).ToList();

                for (var i = 0; i < selectedTargets.Count; i++)
                {
                    var targetNode = selectedTargets[i];
                    double edgeValue;

                    if (i == selectedTargets.Count - 1)
                    {
                        edgeValue = remainingEdgeValue;
                    }
                    else
                    {
                        var maxEdgeValue = remainingEdgeValue - (selectedTargets.Count - i - 1) * 10;
                        edgeValue = rnd.NextDouble() * maxEdgeValue * maxEdgePercentage + maxEdgeValue * minEdgePercentage;
                        remainingEdgeValue -= edgeValue;
                    }

                    _edges.Add(new SankeyChartEdge(sourceNode.Name, targetNode.Name, Math.Round(edgeValue)));
                    nodeInputs[targetNode.Name] += edgeValue;
                }
            }

            foreach (var targetNode in targetNodes)
            {
                nodeOutputs[targetNode.Name] = nodeInputs[targetNode.Name];
            }
        }

        _edges.RemoveAll(e => e.Value <= 0);

        StateHasChanged();
    }
}

@code {
    private string _width = "650px";
    private string _height = "350px";
    private int _SelectedIndex = -1;

    private readonly List<SankeyChartNode> _nodes =
    [
        new("Balls", 0),

        new("Soccer ball", 1),
        new("Football", 1),
        new("Tennis ball", 1),

        new("Good condition", 2),
        new("Bad condition", 2),
    ];

    private readonly List<SankeyChartEdge> _edges =
    [
        new("Balls", "Soccer ball", 20),
        new("Balls", "Football", 10),
        new("Balls", "Tennis ball", 30),
        
        new("Soccer ball", "Good condition", 17),
        new("Soccer ball", "Bad condition", 3),
        new("Football", "Good condition", 5),
        new("Football", "Bad condition", 5),
        new("Tennis ball", "Good condition", 10),
        new("Tennis ball", "Bad condition", 20),
    ];
}