@code {

    private List<ChartSeries<int>> _series = new()
    {
        new()
        { 
            Name = "Income Flow", 
            Data = new List<SankeyEdge<int>> 
            {
                //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<SankeyNode> _nodes = [];
    private List<SankeyEdge<double>> _edges = [];
    private List<ChartSeries<double>> _series = [];
    private readonly SankeyChartOptions _options = 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 SankeyNode(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 SankeyEdge<double>(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.Weight <= 0);

        _series = new List<ChartSeries<double>>()
        {
            new()
            {
                Name = "Generated Data",
                Data = _edges
            }
        };

        _options.NodeOverrides = _nodes;

        StateHasChanged();
    }
}

@code {
    private MudChart<int> _mudChart = null!;
    private string _width = "650px";
    private string _height = "350px";
    private int _selectedIndex = -1;

    public Sankey<int> Chart => _mudChart.ChartReference as Sankey<int>;

    private readonly List<SankeyEdge<int>> _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),
    ];

    private ChartSeries<int> Series => new() { Name = "Ball Catalog", Data = _edges };
}