/*
 * Decompiled with CFR 0.152.
 */
package net.minecraft.client.gui.layouts;

import com.mojang.math.Divisor;
import java.util.ArrayList;
import java.util.List;
import java.util.function.Consumer;
import net.minecraft.client.gui.layouts.AbstractLayout;
import net.minecraft.client.gui.layouts.LayoutElement;
import net.minecraft.client.gui.layouts.LayoutSettings;
import net.minecraft.util.Mth;
import net.minecraft.util.Util;

public class GridLayout
extends AbstractLayout {
    private final List<LayoutElement> children = new ArrayList<LayoutElement>();
    private final List<CellInhabitant> cellInhabitants = new ArrayList<CellInhabitant>();
    private final LayoutSettings defaultCellSettings = LayoutSettings.defaults();
    private int rowSpacing = 0;
    private int columnSpacing = 0;

    public GridLayout() {
        this(0, 0);
    }

    public GridLayout(int x, int y) {
        super(x, y, 0, 0);
    }

    @Override
    public void arrangeElements() {
        super.arrangeElements();
        int maxRow = 0;
        int maxColumn = 0;
        for (CellInhabitant cellInhabitant : this.cellInhabitants) {
            maxRow = Math.max(cellInhabitant.getLastOccupiedRow(), maxRow);
            maxColumn = Math.max(cellInhabitant.getLastOccupiedColumn(), maxColumn);
        }
        int[] maxColumnWidths = new int[maxColumn + 1];
        int[] maxRowHeights = new int[maxRow + 1];
        for (CellInhabitant cellInhabitant : this.cellInhabitants) {
            int cellInhabitantHeight = cellInhabitant.getHeight() - (cellInhabitant.occupiedRows - 1) * this.rowSpacing;
            Divisor heightDivisor = new Divisor(cellInhabitantHeight, cellInhabitant.occupiedRows);
            for (int row = cellInhabitant.row; row <= cellInhabitant.getLastOccupiedRow(); ++row) {
                maxRowHeights[row] = Math.max(maxRowHeights[row], heightDivisor.nextInt());
            }
            int cellInhabitantWidth = cellInhabitant.getWidth() - (cellInhabitant.occupiedColumns - 1) * this.columnSpacing;
            Divisor widthDivisor = new Divisor(cellInhabitantWidth, cellInhabitant.occupiedColumns);
            for (int column = cellInhabitant.column; column <= cellInhabitant.getLastOccupiedColumn(); ++column) {
                maxColumnWidths[column] = Math.max(maxColumnWidths[column], widthDivisor.nextInt());
            }
        }
        int[] columnXOffsets = new int[maxColumn + 1];
        int[] rowYOffsets = new int[maxRow + 1];
        columnXOffsets[0] = 0;
        for (int column = 1; column <= maxColumn; ++column) {
            columnXOffsets[column] = columnXOffsets[column - 1] + maxColumnWidths[column - 1] + this.columnSpacing;
        }
        rowYOffsets[0] = 0;
        for (int row = 1; row <= maxRow; ++row) {
            rowYOffsets[row] = rowYOffsets[row - 1] + maxRowHeights[row - 1] + this.rowSpacing;
        }
        for (CellInhabitant cellInhabitant : this.cellInhabitants) {
            int availableWidth = 0;
            for (int column = cellInhabitant.column; column <= cellInhabitant.getLastOccupiedColumn(); ++column) {
                availableWidth += maxColumnWidths[column];
            }
            cellInhabitant.setX(this.getX() + columnXOffsets[cellInhabitant.column], availableWidth += this.columnSpacing * (cellInhabitant.occupiedColumns - 1));
            int availableHeight = 0;
            for (int row = cellInhabitant.row; row <= cellInhabitant.getLastOccupiedRow(); ++row) {
                availableHeight += maxRowHeights[row];
            }
            cellInhabitant.setY(this.getY() + rowYOffsets[cellInhabitant.row], availableHeight += this.rowSpacing * (cellInhabitant.occupiedRows - 1));
        }
        this.width = columnXOffsets[maxColumn] + maxColumnWidths[maxColumn];
        this.height = rowYOffsets[maxRow] + maxRowHeights[maxRow];
    }

    public <T extends LayoutElement> T addChild(T child, int row, int column) {
        return this.addChild(child, row, column, this.newCellSettings());
    }

    public <T extends LayoutElement> T addChild(T child, int row, int column, LayoutSettings cellSettings) {
        return this.addChild(child, row, column, 1, 1, cellSettings);
    }

    public <T extends LayoutElement> T addChild(T child, int row, int column, Consumer<LayoutSettings> layoutSettingsAdjustments) {
        return this.addChild(child, row, column, 1, 1, Util.make(this.newCellSettings(), layoutSettingsAdjustments));
    }

    public <T extends LayoutElement> T addChild(T child, int row, int column, int rows, int columns) {
        return this.addChild(child, row, column, rows, columns, this.newCellSettings());
    }

    public <T extends LayoutElement> T addChild(T child, int row, int column, int rows, int columns, LayoutSettings cellSettings) {
        if (rows < 1) {
            throw new IllegalArgumentException("Occupied rows must be at least 1");
        }
        if (columns < 1) {
            throw new IllegalArgumentException("Occupied columns must be at least 1");
        }
        this.cellInhabitants.add(new CellInhabitant(child, row, column, rows, columns, cellSettings));
        this.children.add(child);
        return child;
    }

    public <T extends LayoutElement> T addChild(T child, int row, int column, int rows, int columns, Consumer<LayoutSettings> layoutSettingsAdjustments) {
        return this.addChild(child, row, column, rows, columns, Util.make(this.newCellSettings(), layoutSettingsAdjustments));
    }

    public GridLayout columnSpacing(int columnSpacing) {
        this.columnSpacing = columnSpacing;
        return this;
    }

    public GridLayout rowSpacing(int rowSpacing) {
        this.rowSpacing = rowSpacing;
        return this;
    }

    public GridLayout spacing(int spacing) {
        return this.columnSpacing(spacing).rowSpacing(spacing);
    }

    @Override
    public void visitChildren(Consumer<LayoutElement> layoutElementVisitor) {
        this.children.forEach(layoutElementVisitor);
    }

    public LayoutSettings newCellSettings() {
        return this.defaultCellSettings.copy();
    }

    public LayoutSettings defaultCellSetting() {
        return this.defaultCellSettings;
    }

    public RowHelper createRowHelper(int columns) {
        return new RowHelper(columns);
    }

    private static class CellInhabitant
    extends AbstractLayout.AbstractChildWrapper {
        private final int row;
        private final int column;
        private final int occupiedRows;
        private final int occupiedColumns;

        private CellInhabitant(LayoutElement widget, int row, int column, int occupiedRows, int occupiedColumns, LayoutSettings cellSettings) {
            super(widget, cellSettings.getExposed());
            this.row = row;
            this.column = column;
            this.occupiedRows = occupiedRows;
            this.occupiedColumns = occupiedColumns;
        }

        public int getLastOccupiedRow() {
            return this.row + this.occupiedRows - 1;
        }

        public int getLastOccupiedColumn() {
            return this.column + this.occupiedColumns - 1;
        }
    }

    public final class RowHelper {
        private final int columns;
        private int index;

        private RowHelper(int columns) {
            this.columns = columns;
        }

        public <T extends LayoutElement> T addChild(T widget) {
            return this.addChild(widget, 1);
        }

        public <T extends LayoutElement> T addChild(T widget, int columnWidth) {
            return this.addChild(widget, columnWidth, this.defaultCellSetting());
        }

        public <T extends LayoutElement> T addChild(T widget, LayoutSettings layoutSettings) {
            return this.addChild(widget, 1, layoutSettings);
        }

        public <T extends LayoutElement> T addChild(T widget, int columnWidth, LayoutSettings layoutSettings) {
            int row = this.index / this.columns;
            int columnBegin = this.index % this.columns;
            if (columnBegin + columnWidth > this.columns) {
                ++row;
                columnBegin = 0;
                this.index = Mth.roundToward(this.index, this.columns);
            }
            this.index += columnWidth;
            return GridLayout.this.addChild(widget, row, columnBegin, 1, columnWidth, layoutSettings);
        }

        public GridLayout getGrid() {
            return GridLayout.this;
        }

        public LayoutSettings newCellSettings() {
            return GridLayout.this.newCellSettings();
        }

        public LayoutSettings defaultCellSetting() {
            return GridLayout.this.defaultCellSetting();
        }
    }
}