package coil.compose;

import E3.v;
import G0.C0260i;
import G0.InterfaceC0262j;
import V4.C;
import V4.D0;
import V4.E;
import V4.N;
import Y4.H;
import Y4.InterfaceC0843i;
import Y4.InterfaceC0844j;
import Y4.O;
import Y4.c0;
import a.AbstractC0872a;
import a5.m;
import android.graphics.drawable.BitmapDrawable;
import android.graphics.drawable.Drawable;
import android.os.Trace;
import androidx.compose.runtime.MutableFloatState;
import androidx.compose.runtime.MutableState;
import androidx.compose.runtime.PrimitiveSnapshotStateKt;
import androidx.compose.runtime.RememberObserver;
import androidx.compose.runtime.SnapshotStateKt__SnapshotStateKt;
import androidx.compose.runtime.Stable;
import androidx.compose.runtime.internal.StabilityInferred;
import coil.ImageLoader;
import coil.compose.AsyncImagePainter;
import coil.request.ErrorResult;
import coil.request.ImageRequest;
import coil.request.ImageResult;
import coil.request.SuccessResult;
import coil.size.Precision;
import coil.size.Size;
import coil.size.SizeResolver;
import coil.target.Target;
import coil.transition.CrossfadeTransition;
import coil.transition.Transition;
import kotlin.jvm.internal.o;
import m3.AbstractC2467b;
import m3.AbstractC2478m;
import n3.C2620b;
import p0.AbstractC2715v;
import p0.C2700f;
import r0.InterfaceC2866e;
import u0.AbstractC2959b;
import w4.C3137A;

/* JADX INFO: loaded from: classes.dex */
@Stable
public final class AsyncImagePainter extends AbstractC2959b implements RememberObserver {
    public static final int $stable = 0;
    public static final Companion Companion = new Companion(null);
    private static final J4.c DefaultTransform = new c(2);
    private AbstractC2959b _painter;
    private State _state;
    private InterfaceC0262j contentScale;
    private int filterQuality;
    private final MutableState imageLoader$delegate;
    private boolean isPreview;
    private J4.c onState;
    private C rememberScope;
    private final MutableState request$delegate;
    private final MutableState state$delegate;
    private J4.c transform;
    private final H drawSize = O.c(new o0.e(0));
    private final MutableState painter$delegate = SnapshotStateKt__SnapshotStateKt.mutableStateOf$default(null, null, 2, null);
    private final MutableFloatState alpha$delegate = PrimitiveSnapshotStateKt.mutableFloatStateOf(1.0f);
    private final MutableState colorFilter$delegate = SnapshotStateKt__SnapshotStateKt.mutableStateOf$default(null, null, 2, null);

    public static final class Companion {
        public /* synthetic */ Companion(kotlin.jvm.internal.h hVar) {
            this();
        }

        public final J4.c getDefaultTransform() {
            return AsyncImagePainter.DefaultTransform;
        }

        private Companion() {
        }
    }

    @StabilityInferred(parameters = 1)
    public static abstract class State {
        public static final int $stable = 0;

        @StabilityInferred(parameters = 1)
        public static final class Empty extends State {
            public static final int $stable = 0;
            public static final Empty INSTANCE = new Empty();

            private Empty() {
                super(null);
            }

            public boolean equals(Object obj) {
                return this == obj || (obj instanceof Empty);
            }

            @Override // coil.compose.AsyncImagePainter.State
            public AbstractC2959b getPainter() {
                return null;
            }

            public int hashCode() {
                return -1515560141;
            }

            public String toString() {
                return "Empty";
            }
        }

        @StabilityInferred(parameters = 0)
        public static final class Error extends State {
            public static final int $stable = 8;
            private final AbstractC2959b painter;
            private final ErrorResult result;

            public Error(AbstractC2959b abstractC2959b, ErrorResult errorResult) {
                super(null);
                this.painter = abstractC2959b;
                this.result = errorResult;
            }

            public static /* synthetic */ Error copy$default(Error error, AbstractC2959b abstractC2959b, ErrorResult errorResult, int i6, Object obj) {
                if ((i6 & 1) != 0) {
                    abstractC2959b = error.painter;
                }
                if ((i6 & 2) != 0) {
                    errorResult = error.result;
                }
                return error.copy(abstractC2959b, errorResult);
            }

            public final AbstractC2959b component1() {
                return this.painter;
            }

            public final ErrorResult component2() {
                return this.result;
            }

            public final Error copy(AbstractC2959b abstractC2959b, ErrorResult errorResult) {
                return new Error(abstractC2959b, errorResult);
            }

            public boolean equals(Object obj) {
                if (this == obj) {
                    return true;
                }
                if (!(obj instanceof Error)) {
                    return false;
                }
                Error error = (Error) obj;
                return o.c(this.painter, error.painter) && o.c(this.result, error.result);
            }

            @Override // coil.compose.AsyncImagePainter.State
            public AbstractC2959b getPainter() {
                return this.painter;
            }

            public final ErrorResult getResult() {
                return this.result;
            }

            public int hashCode() {
                AbstractC2959b abstractC2959b = this.painter;
                return this.result.hashCode() + ((abstractC2959b == null ? 0 : abstractC2959b.hashCode()) * 31);
            }

            public String toString() {
                return "Error(painter=" + this.painter + ", result=" + this.result + ')';
            }
        }

        @StabilityInferred(parameters = 0)
        public static final class Loading extends State {
            public static final int $stable = 8;
            private final AbstractC2959b painter;

            public Loading(AbstractC2959b abstractC2959b) {
                super(null);
                this.painter = abstractC2959b;
            }

            public static /* synthetic */ Loading copy$default(Loading loading, AbstractC2959b abstractC2959b, int i6, Object obj) {
                if ((i6 & 1) != 0) {
                    abstractC2959b = loading.painter;
                }
                return loading.copy(abstractC2959b);
            }

            public final AbstractC2959b component1() {
                return this.painter;
            }

            public final Loading copy(AbstractC2959b abstractC2959b) {
                return new Loading(abstractC2959b);
            }

            public boolean equals(Object obj) {
                if (this == obj) {
                    return true;
                }
                return (obj instanceof Loading) && o.c(this.painter, ((Loading) obj).painter);
            }

            @Override // coil.compose.AsyncImagePainter.State
            public AbstractC2959b getPainter() {
                return this.painter;
            }

            public int hashCode() {
                AbstractC2959b abstractC2959b = this.painter;
                if (abstractC2959b == null) {
                    return 0;
                }
                return abstractC2959b.hashCode();
            }

            public String toString() {
                return "Loading(painter=" + this.painter + ')';
            }
        }

        @StabilityInferred(parameters = 0)
        public static final class Success extends State {
            public static final int $stable = 8;
            private final AbstractC2959b painter;
            private final SuccessResult result;

            public Success(AbstractC2959b abstractC2959b, SuccessResult successResult) {
                super(null);
                this.painter = abstractC2959b;
                this.result = successResult;
            }

            public static /* synthetic */ Success copy$default(Success success, AbstractC2959b abstractC2959b, SuccessResult successResult, int i6, Object obj) {
                if ((i6 & 1) != 0) {
                    abstractC2959b = success.painter;
                }
                if ((i6 & 2) != 0) {
                    successResult = success.result;
                }
                return success.copy(abstractC2959b, successResult);
            }

            public final AbstractC2959b component1() {
                return this.painter;
            }

            public final SuccessResult component2() {
                return this.result;
            }

            public final Success copy(AbstractC2959b abstractC2959b, SuccessResult successResult) {
                return new Success(abstractC2959b, successResult);
            }

            public boolean equals(Object obj) {
                if (this == obj) {
                    return true;
                }
                if (!(obj instanceof Success)) {
                    return false;
                }
                Success success = (Success) obj;
                return o.c(this.painter, success.painter) && o.c(this.result, success.result);
            }

            @Override // coil.compose.AsyncImagePainter.State
            public AbstractC2959b getPainter() {
                return this.painter;
            }

            public final SuccessResult getResult() {
                return this.result;
            }

            public int hashCode() {
                return this.result.hashCode() + (this.painter.hashCode() * 31);
            }

            public String toString() {
                return "Success(painter=" + this.painter + ", result=" + this.result + ')';
            }
        }

        public /* synthetic */ State(kotlin.jvm.internal.h hVar) {
            this();
        }

        public abstract AbstractC2959b getPainter();

        private State() {
        }
    }

    public AsyncImagePainter(ImageRequest imageRequest, ImageLoader imageLoader) {
        State.Empty empty = State.Empty.INSTANCE;
        this._state = empty;
        this.transform = DefaultTransform;
        this.contentScale = C0260i.f1972c;
        this.filterQuality = 1;
        this.state$delegate = SnapshotStateKt__SnapshotStateKt.mutableStateOf$default(empty, null, 2, null);
        this.request$delegate = SnapshotStateKt__SnapshotStateKt.mutableStateOf$default(imageRequest, null, 2, null);
        this.imageLoader$delegate = SnapshotStateKt__SnapshotStateKt.mutableStateOf$default(imageLoader, null, 2, null);
    }

    /* JADX INFO: Access modifiers changed from: private */
    public static final State DefaultTransform$lambda$5(State state) {
        return state;
    }

    private final void clear() {
        C c6 = this.rememberScope;
        if (c6 != null) {
            E.i(c6, null);
        }
        this.rememberScope = null;
    }

    private final float getAlpha() {
        return this.alpha$delegate.getFloatValue();
    }

    /* JADX WARN: Multi-variable type inference failed */
    private final AbstractC2715v getColorFilter() {
        return (AbstractC2715v) this.colorFilter$delegate.getValue();
    }

    /* JADX WARN: Multi-variable type inference failed */
    private final AbstractC2959b getPainter() {
        return (AbstractC2959b) this.painter$delegate.getValue();
    }

    private final CrossfadePainter maybeNewCrossfadePainter(State state, State state2) {
        ImageResult result;
        if (!(state2 instanceof State.Success)) {
            if (state2 instanceof State.Error) {
                result = ((State.Error) state2).getResult();
            }
            return null;
        }
        result = ((State.Success) state2).getResult();
        Transition transitionCreate = result.getRequest().getTransitionFactory().create(AsyncImagePainterKt.fakeTransitionTarget, result);
        if (transitionCreate instanceof CrossfadeTransition) {
            CrossfadeTransition crossfadeTransition = (CrossfadeTransition) transitionCreate;
            return new CrossfadePainter(state instanceof State.Loading ? state.getPainter() : null, state2.getPainter(), this.contentScale, crossfadeTransition.getDurationMillis(), ((result instanceof SuccessResult) && ((SuccessResult) result).isPlaceholderCached()) ? false : true, crossfadeTransition.getPreferExactIntrinsicSize());
        }
        return null;
    }

    private final void setAlpha(float f6) {
        this.alpha$delegate.setFloatValue(f6);
    }

    private final void setColorFilter(AbstractC2715v abstractC2715v) {
        this.colorFilter$delegate.setValue(abstractC2715v);
    }

    private final void setPainter(AbstractC2959b abstractC2959b) {
        this.painter$delegate.setValue(abstractC2959b);
    }

    private final void setState(State state) {
        this.state$delegate.setValue(state);
    }

    private final void set_painter(AbstractC2959b abstractC2959b) {
        this._painter = abstractC2959b;
        setPainter(abstractC2959b);
    }

    private final void set_state(State state) {
        this._state = state;
        setState(state);
    }

    /* JADX INFO: Access modifiers changed from: private */
    public final AbstractC2959b toPainter(Drawable drawable) {
        return drawable instanceof BitmapDrawable ? AbstractC2478m.a(new C2700f(((BitmapDrawable) drawable).getBitmap()), this.filterQuality) : new C2620b(drawable.mutate());
    }

    /* JADX INFO: Access modifiers changed from: private */
    public final State toState(ImageResult imageResult) {
        if (imageResult instanceof SuccessResult) {
            SuccessResult successResult = (SuccessResult) imageResult;
            return new State.Success(toPainter(successResult.getDrawable()), successResult);
        }
        if (!(imageResult instanceof ErrorResult)) {
            throw new v();
        }
        ErrorResult errorResult = (ErrorResult) imageResult;
        Drawable drawable = errorResult.getDrawable();
        return new State.Error(drawable != null ? toPainter(drawable) : null, errorResult);
    }

    /* JADX INFO: Access modifiers changed from: private */
    public final ImageRequest updateRequest(ImageRequest imageRequest) {
        ImageRequest.Builder builderTarget = ImageRequest.newBuilder$default(imageRequest, null, 1, null).target(new Target() { // from class: coil.compose.AsyncImagePainter$updateRequest$$inlined$target$default$1
            @Override // coil.target.Target
            public void onError(Drawable drawable) {
            }

            @Override // coil.target.Target
            public void onStart(Drawable drawable) {
                AsyncImagePainter asyncImagePainter = this.this$0;
                asyncImagePainter.updateState(new AsyncImagePainter.State.Loading(drawable != null ? asyncImagePainter.toPainter(drawable) : null));
            }

            @Override // coil.target.Target
            public void onSuccess(Drawable drawable) {
            }
        });
        if (imageRequest.getDefined().getSizeResolver() == null) {
            builderTarget.size(new SizeResolver() { // from class: coil.compose.AsyncImagePainter$updateRequest$2$1
                @Override // coil.size.SizeResolver
                public final Object size(A4.d dVar) {
                    final H h5 = this.this$0.drawSize;
                    return O.l(new InterfaceC0843i() { // from class: coil.compose.AsyncImagePainter$updateRequest$2$1$size$$inlined$mapNotNull$1

                        /* JADX INFO: renamed from: coil.compose.AsyncImagePainter$updateRequest$2$1$size$$inlined$mapNotNull$1$2, reason: invalid class name */
                        public static final class AnonymousClass2<T> implements InterfaceC0844j {
                            final /* synthetic */ InterfaceC0844j $this_unsafeFlow;

                            /* JADX INFO: renamed from: coil.compose.AsyncImagePainter$updateRequest$2$1$size$$inlined$mapNotNull$1$2$1, reason: invalid class name */
                            @C4.e(c = "coil.compose.AsyncImagePainter$updateRequest$2$1$size$$inlined$mapNotNull$1$2", f = "AsyncImagePainter.kt", l = {221}, m = "emit")
                            public static final class AnonymousClass1 extends C4.c {
                                Object L$0;
                                int label;
                                /* synthetic */ Object result;

                                public AnonymousClass1(A4.d dVar) {
                                    super(dVar);
                                }

                                @Override // C4.a
                                public final Object invokeSuspend(Object obj) {
                                    this.result = obj;
                                    this.label |= Integer.MIN_VALUE;
                                    return AnonymousClass2.this.emit(null, this);
                                }
                            }

                            public AnonymousClass2(InterfaceC0844j interfaceC0844j) {
                                this.$this_unsafeFlow = interfaceC0844j;
                            }

                            /* JADX WARN: Removed duplicated region for block: B:7:0x0013  */
                            @Override // Y4.InterfaceC0844j
                            /*
                                Code decompiled incorrectly, please refer to instructions dump.
                            */
                            public final Object emit(Object obj, A4.d dVar) {
                                AnonymousClass1 anonymousClass1;
                                if (dVar instanceof AnonymousClass1) {
                                    anonymousClass1 = (AnonymousClass1) dVar;
                                    int i6 = anonymousClass1.label;
                                    if ((i6 & Integer.MIN_VALUE) != 0) {
                                        anonymousClass1.label = i6 - Integer.MIN_VALUE;
                                    } else {
                                        anonymousClass1 = new AnonymousClass1(dVar);
                                    }
                                }
                                Object obj2 = anonymousClass1.result;
                                B4.a aVar = B4.a.f492a;
                                int i7 = anonymousClass1.label;
                                if (i7 == 0) {
                                    AbstractC2467b.l(obj2);
                                    InterfaceC0844j interfaceC0844j = this.$this_unsafeFlow;
                                    Size sizeM296toSizeOrNulluvyYCjk = AsyncImagePainterKt.m296toSizeOrNulluvyYCjk(((o0.e) obj).f21799a);
                                    if (sizeM296toSizeOrNulluvyYCjk != null) {
                                        anonymousClass1.label = 1;
                                        if (interfaceC0844j.emit(sizeM296toSizeOrNulluvyYCjk, anonymousClass1) == aVar) {
                                            return aVar;
                                        }
                                    }
                                } else {
                                    if (i7 != 1) {
                                        throw new IllegalStateException("call to 'resume' before 'invoke' with coroutine");
                                    }
                                    AbstractC2467b.l(obj2);
                                }
                                return C3137A.f25453a;
                            }
                        }

                        @Override // Y4.InterfaceC0843i
                        public Object collect(InterfaceC0844j interfaceC0844j, A4.d dVar2) {
                            Object objCollect = h5.collect(new AnonymousClass2(interfaceC0844j), dVar2);
                            return objCollect == B4.a.f492a ? objCollect : C3137A.f25453a;
                        }
                    }, dVar);
                }
            });
        }
        if (imageRequest.getDefined().getScale() == null) {
            builderTarget.scale(UtilsKt.toScale(this.contentScale));
        }
        if (imageRequest.getDefined().getPrecision() != Precision.EXACT) {
            builderTarget.precision(Precision.INEXACT);
        }
        return builderTarget.build();
    }

    /* JADX INFO: Access modifiers changed from: private */
    public final void updateState(State state) {
        State state2 = this._state;
        State state3 = (State) this.transform.invoke(state);
        set_state(state3);
        AbstractC2959b abstractC2959bMaybeNewCrossfadePainter = maybeNewCrossfadePainter(state2, state3);
        if (abstractC2959bMaybeNewCrossfadePainter == null) {
            abstractC2959bMaybeNewCrossfadePainter = state3.getPainter();
        }
        set_painter(abstractC2959bMaybeNewCrossfadePainter);
        if (this.rememberScope != null && state2.getPainter() != state3.getPainter()) {
            Object painter = state2.getPainter();
            RememberObserver rememberObserver = painter instanceof RememberObserver ? (RememberObserver) painter : null;
            if (rememberObserver != null) {
                rememberObserver.onForgotten();
            }
            Object painter2 = state3.getPainter();
            RememberObserver rememberObserver2 = painter2 instanceof RememberObserver ? (RememberObserver) painter2 : null;
            if (rememberObserver2 != null) {
                rememberObserver2.onRemembered();
            }
        }
        J4.c cVar = this.onState;
        if (cVar != null) {
            cVar.invoke(state3);
        }
    }

    @Override // u0.AbstractC2959b
    public boolean applyAlpha(float f6) {
        setAlpha(f6);
        return true;
    }

    @Override // u0.AbstractC2959b
    public boolean applyColorFilter(AbstractC2715v abstractC2715v) {
        setColorFilter(abstractC2715v);
        return true;
    }

    public final InterfaceC0262j getContentScale$coil_compose_base_release() {
        return this.contentScale;
    }

    /* JADX INFO: renamed from: getFilterQuality-f-v9h1I$coil_compose_base_release, reason: not valid java name */
    public final int m287getFilterQualityfv9h1I$coil_compose_base_release() {
        return this.filterQuality;
    }

    public final ImageLoader getImageLoader() {
        return (ImageLoader) this.imageLoader$delegate.getValue();
    }

    @Override // u0.AbstractC2959b
    /* JADX INFO: renamed from: getIntrinsicSize-NH-jbRc, reason: not valid java name */
    public long mo288getIntrinsicSizeNHjbRc() {
        AbstractC2959b painter = getPainter();
        if (painter != null) {
            return painter.mo288getIntrinsicSizeNHjbRc();
        }
        return 9205357640488583168L;
    }

    public final J4.c getOnState$coil_compose_base_release() {
        return this.onState;
    }

    /* JADX WARN: Multi-variable type inference failed */
    public final ImageRequest getRequest() {
        return (ImageRequest) this.request$delegate.getValue();
    }

    /* JADX WARN: Multi-variable type inference failed */
    public final State getState() {
        return (State) this.state$delegate.getValue();
    }

    public final J4.c getTransform$coil_compose_base_release() {
        return this.transform;
    }

    public final boolean isPreview$coil_compose_base_release() {
        return this.isPreview;
    }

    @Override // androidx.compose.runtime.RememberObserver
    public void onAbandoned() {
        clear();
        Object obj = this._painter;
        RememberObserver rememberObserver = obj instanceof RememberObserver ? (RememberObserver) obj : null;
        if (rememberObserver != null) {
            rememberObserver.onAbandoned();
        }
    }

    @Override // u0.AbstractC2959b
    public void onDraw(InterfaceC2866e interfaceC2866e) {
        H h5 = this.drawSize;
        o0.e eVar = new o0.e(interfaceC2866e.c());
        c0 c0Var = (c0) h5;
        c0Var.getClass();
        c0Var.k(null, eVar);
        AbstractC2959b painter = getPainter();
        if (painter != null) {
            painter.m1218drawx_KDEd0(interfaceC2866e, interfaceC2866e.c(), getAlpha(), getColorFilter());
        }
    }

    @Override // androidx.compose.runtime.RememberObserver
    public void onForgotten() {
        clear();
        Object obj = this._painter;
        RememberObserver rememberObserver = obj instanceof RememberObserver ? (RememberObserver) obj : null;
        if (rememberObserver != null) {
            rememberObserver.onForgotten();
        }
    }

    @Override // androidx.compose.runtime.RememberObserver
    public void onRemembered() {
        Trace.beginSection("AsyncImagePainter.onRemembered");
        try {
            if (this.rememberScope == null) {
                D0 d0D = E.d();
                c5.e eVar = N.f8259a;
                a5.c cVarC = E.c(AbstractC0872a.a0(d0D, m.f10845a.f8429e));
                this.rememberScope = cVarC;
                Object obj = this._painter;
                RememberObserver rememberObserver = obj instanceof RememberObserver ? (RememberObserver) obj : null;
                if (rememberObserver != null) {
                    rememberObserver.onRemembered();
                }
                if (this.isPreview) {
                    Drawable placeholder = ImageRequest.newBuilder$default(getRequest(), null, 1, null).defaults(getImageLoader().getDefaults()).build().getPlaceholder();
                    updateState(new State.Loading(placeholder != null ? toPainter(placeholder) : null));
                } else {
                    E.y(cVarC, null, null, new AsyncImagePainter$onRemembered$1$1(this, null), 3);
                }
            }
            Trace.endSection();
        } catch (Throwable th) {
            Trace.endSection();
            throw th;
        }
    }

    public final void setContentScale$coil_compose_base_release(InterfaceC0262j interfaceC0262j) {
        this.contentScale = interfaceC0262j;
    }

    /* JADX INFO: renamed from: setFilterQuality-vDHp3xo$coil_compose_base_release, reason: not valid java name */
    public final void m289setFilterQualityvDHp3xo$coil_compose_base_release(int i6) {
        this.filterQuality = i6;
    }

    public final void setImageLoader$coil_compose_base_release(ImageLoader imageLoader) {
        this.imageLoader$delegate.setValue(imageLoader);
    }

    public final void setOnState$coil_compose_base_release(J4.c cVar) {
        this.onState = cVar;
    }

    public final void setPreview$coil_compose_base_release(boolean z6) {
        this.isPreview = z6;
    }

    public final void setRequest$coil_compose_base_release(ImageRequest imageRequest) {
        this.request$delegate.setValue(imageRequest);
    }

    public final void setTransform$coil_compose_base_release(J4.c cVar) {
        this.transform = cVar;
    }
}