package jxl.write.biff;

import common.Assert;
import common.Logger;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Iterator;
import jxl.Cell;
import jxl.CellType;
import jxl.Range;
import jxl.biff.SheetRangeImpl;
import jxl.write.Blank;
import jxl.write.WritableSheet;
import jxl.write.WriteException;

/* JADX INFO: loaded from: classes.dex */
class MergedCells {
    static /* synthetic */ Class class$jxl$write$biff$MergedCells = null;
    private static Logger logger = null;
    private static final int maxRangesPerSheet = 1020;
    private ArrayList ranges = new ArrayList();
    private WritableSheet sheet;

    static {
        Class clsClass$ = class$jxl$write$biff$MergedCells;
        if (clsClass$ == null) {
            clsClass$ = class$("jxl.write.biff.MergedCells");
            class$jxl$write$biff$MergedCells = clsClass$;
        }
        logger = Logger.getLogger(clsClass$);
    }

    public MergedCells(WritableSheet writableSheet) {
        this.sheet = writableSheet;
    }

    private void checkIntersections() {
        ArrayList arrayList = new ArrayList(this.ranges.size());
        for (SheetRangeImpl sheetRangeImpl : this.ranges) {
            Iterator it = arrayList.iterator();
            boolean z = false;
            while (it.hasNext() && !z) {
                if (((SheetRangeImpl) it.next()).intersects(sheetRangeImpl)) {
                    Logger logger2 = logger;
                    StringBuffer stringBuffer = new StringBuffer();
                    stringBuffer.append("Could not merge cells ");
                    stringBuffer.append(sheetRangeImpl);
                    stringBuffer.append(" as they clash with an existing set of merged cells.");
                    logger2.warn(stringBuffer.toString());
                    z = true;
                }
            }
            if (!z) {
                arrayList.add(sheetRangeImpl);
            }
        }
        this.ranges = arrayList;
    }

    private void checkRanges() {
        for (int i2 = 0; i2 < this.ranges.size(); i2++) {
            try {
                SheetRangeImpl sheetRangeImpl = (SheetRangeImpl) this.ranges.get(i2);
                Cell topLeft = sheetRangeImpl.getTopLeft();
                Cell bottomRight = sheetRangeImpl.getBottomRight();
                boolean z = false;
                for (int column = topLeft.getColumn(); column <= bottomRight.getColumn(); column++) {
                    for (int row = topLeft.getRow(); row <= bottomRight.getRow(); row++) {
                        if (this.sheet.getCell(column, row).getType() != CellType.EMPTY) {
                            if (z) {
                                Logger logger2 = logger;
                                StringBuffer stringBuffer = new StringBuffer();
                                stringBuffer.append("Range ");
                                stringBuffer.append(sheetRangeImpl);
                                stringBuffer.append(" contains more than one data cell.  ");
                                stringBuffer.append("Setting the other cells to blank.");
                                logger2.warn(stringBuffer.toString());
                                this.sheet.addCell(new Blank(column, row));
                            } else {
                                z = true;
                            }
                        }
                    }
                }
            } catch (WriteException unused) {
                Assert.verify(false);
                return;
            }
        }
    }

    static /* synthetic */ Class class$(String str) {
        try {
            return Class.forName(str);
        } catch (ClassNotFoundException e) {
            throw new NoClassDefFoundError(e.getMessage());
        }
    }

    void add(Range range) {
        this.ranges.add(range);
    }

    Range[] getMergedCells() {
        int size = this.ranges.size();
        Range[] rangeArr = new Range[size];
        for (int i2 = 0; i2 < size; i2++) {
            rangeArr[i2] = (Range) this.ranges.get(i2);
        }
        return rangeArr;
    }

    void insertColumn(int i2) {
        Iterator it = this.ranges.iterator();
        while (it.hasNext()) {
            ((SheetRangeImpl) it.next()).insertColumn(i2);
        }
    }

    void insertRow(int i2) {
        Iterator it = this.ranges.iterator();
        while (it.hasNext()) {
            ((SheetRangeImpl) it.next()).insertRow(i2);
        }
    }

    void removeColumn(int i2) {
        for (SheetRangeImpl sheetRangeImpl : this.ranges) {
            if (sheetRangeImpl.getTopLeft().getColumn() == i2 && sheetRangeImpl.getBottomRight().getColumn() == i2) {
                ArrayList arrayList = this.ranges;
                arrayList.remove(arrayList.indexOf(sheetRangeImpl));
            } else {
                sheetRangeImpl.removeColumn(i2);
            }
        }
    }

    void removeRow(int i2) {
        Iterator it = this.ranges.iterator();
        while (it.hasNext()) {
            SheetRangeImpl sheetRangeImpl = (SheetRangeImpl) it.next();
            if (sheetRangeImpl.getTopLeft().getRow() == i2 && sheetRangeImpl.getBottomRight().getRow() == i2) {
                it.remove();
            } else {
                sheetRangeImpl.removeRow(i2);
            }
        }
    }

    void unmergeCells(Range range) {
        int iIndexOf = this.ranges.indexOf(range);
        if (iIndexOf != -1) {
            this.ranges.remove(iIndexOf);
        }
    }

    void write(File file) throws IOException {
        if (this.ranges.size() == 0) {
            return;
        }
        if (!((WritableSheetImpl) this.sheet).getWorkbookSettings().getMergedCellCheckingDisabled()) {
            checkIntersections();
            checkRanges();
        }
        if (this.ranges.size() < maxRangesPerSheet) {
            file.write(new MergedCellsRecord(this.ranges));
            return;
        }
        int size = (this.ranges.size() / maxRangesPerSheet) + 1;
        int i2 = 0;
        for (int i3 = 0; i3 < size; i3++) {
            int iMin = Math.min(maxRangesPerSheet, this.ranges.size() - i2);
            ArrayList arrayList = new ArrayList(iMin);
            for (int i4 = 0; i4 < iMin; i4++) {
                arrayList.add(this.ranges.get(i2 + i4));
            }
            file.write(new MergedCellsRecord(arrayList));
            i2 += iMin;
        }
    }
}