package androidx.core.graphics;

import android.graphics.Point;
import android.graphics.Rect;
import android.graphics.Region;
import android.graphics.RegionIterator;
import java.util.Iterator;
import kotlin.jvm.internal.l;

/* JADX INFO: loaded from: classes.dex */
public final class RegionKt {

    /* JADX INFO: renamed from: androidx.core.graphics.RegionKt$iterator$1, reason: invalid class name */
    public static final class AnonymousClass1 implements Iterator<Rect>, z1.a {
        private boolean hasMore;
        private final RegionIterator iterator;
        private final Rect rect;

        AnonymousClass1(Region region) {
            RegionIterator regionIterator = new RegionIterator(region);
            this.iterator = regionIterator;
            Rect rect = new Rect();
            this.rect = rect;
            this.hasMore = regionIterator.next(rect);
        }

        @Override // java.util.Iterator
        public boolean hasNext() {
            return this.hasMore;
        }

        @Override // java.util.Iterator
        public void remove() {
            throw new UnsupportedOperationException("Operation is not supported for read-only collection");
        }

        /* JADX WARN: Can't rename method to resolve collision */
        @Override // java.util.Iterator
        public Rect next() {
            if (!this.hasMore) {
                throw new IndexOutOfBoundsException();
            }
            Rect rect = new Rect(this.rect);
            this.hasMore = this.iterator.next(this.rect);
            return rect;
        }
    }

    public static final Region and(Region region, Rect r2) {
        l.e(region, "<this>");
        l.e(r2, "r");
        Region region2 = new Region(region);
        region2.op(r2, Region.Op.INTERSECT);
        return region2;
    }

    public static final boolean contains(Region region, Point p2) {
        l.e(region, "<this>");
        l.e(p2, "p");
        return region.contains(p2.x, p2.y);
    }

    public static final void forEach(Region region, y1.l action) {
        l.e(region, "<this>");
        l.e(action, "action");
        RegionIterator regionIterator = new RegionIterator(region);
        while (true) {
            Rect rect = new Rect();
            if (!regionIterator.next(rect)) {
                return;
            } else {
                action.invoke(rect);
            }
        }
    }

    public static final Iterator<Rect> iterator(Region region) {
        l.e(region, "<this>");
        return new AnonymousClass1(region);
    }

    public static final Region minus(Region region, Rect r2) {
        l.e(region, "<this>");
        l.e(r2, "r");
        Region region2 = new Region(region);
        region2.op(r2, Region.Op.DIFFERENCE);
        return region2;
    }

    public static final Region not(Region region) {
        l.e(region, "<this>");
        Region region2 = new Region(region.getBounds());
        region2.op(region, Region.Op.DIFFERENCE);
        return region2;
    }

    public static final Region or(Region region, Rect r2) {
        l.e(region, "<this>");
        l.e(r2, "r");
        Region region2 = new Region(region);
        region2.union(r2);
        return region2;
    }

    public static final Region plus(Region region, Rect r2) {
        l.e(region, "<this>");
        l.e(r2, "r");
        Region region2 = new Region(region);
        region2.union(r2);
        return region2;
    }

    public static final Region unaryMinus(Region region) {
        l.e(region, "<this>");
        Region region2 = new Region(region.getBounds());
        region2.op(region, Region.Op.DIFFERENCE);
        return region2;
    }

    public static final Region xor(Region region, Rect r2) {
        l.e(region, "<this>");
        l.e(r2, "r");
        Region region2 = new Region(region);
        region2.op(r2, Region.Op.XOR);
        return region2;
    }

    public static final Region and(Region region, Region r2) {
        l.e(region, "<this>");
        l.e(r2, "r");
        Region region2 = new Region(region);
        region2.op(r2, Region.Op.INTERSECT);
        return region2;
    }

    public static final Region minus(Region region, Region r2) {
        l.e(region, "<this>");
        l.e(r2, "r");
        Region region2 = new Region(region);
        region2.op(r2, Region.Op.DIFFERENCE);
        return region2;
    }

    public static final Region or(Region region, Region r2) {
        l.e(region, "<this>");
        l.e(r2, "r");
        Region region2 = new Region(region);
        region2.op(r2, Region.Op.UNION);
        return region2;
    }

    public static final Region plus(Region region, Region r2) {
        l.e(region, "<this>");
        l.e(r2, "r");
        Region region2 = new Region(region);
        region2.op(r2, Region.Op.UNION);
        return region2;
    }

    public static final Region xor(Region region, Region r2) {
        l.e(region, "<this>");
        l.e(r2, "r");
        Region region2 = new Region(region);
        region2.op(r2, Region.Op.XOR);
        return region2;
    }
}