package coil.intercept;

import A4.d;
import B4.a;
import C4.c;
import C4.e;
import C4.j;
import E3.v;
import V4.AbstractC0786y;
import V4.C;
import V4.E;
import android.graphics.Bitmap;
import android.graphics.drawable.BitmapDrawable;
import android.graphics.drawable.Drawable;
import androidx.compose.runtime.ComposerKt;
import androidx.media3.extractor.ts.TsExtractor;
import coil.ComponentRegistry;
import coil.EventListener;
import coil.ImageLoader;
import coil.decode.DataSource;
import coil.decode.DecodeResult;
import coil.decode.Decoder;
import coil.decode.FileImageSource;
import coil.decode.ImageSource;
import coil.fetch.DrawableResult;
import coil.fetch.FetchResult;
import coil.fetch.Fetcher;
import coil.fetch.SourceResult;
import coil.intercept.Interceptor;
import coil.memory.MemoryCache;
import coil.memory.MemoryCacheService;
import coil.request.ImageRequest;
import coil.request.Options;
import coil.request.RequestService;
import coil.request.SuccessResult;
import coil.size.Scale;
import coil.size.Size;
import coil.transform.Transformation;
import coil.util.Bitmaps;
import coil.util.DrawableUtils;
import coil.util.Logger;
import coil.util.SystemCallbacks;
import coil.util.Utils;
import java.util.List;
import java.util.concurrent.CancellationException;
import kotlin.jvm.internal.h;
import m3.AbstractC2467b;
import w4.C3137A;
import w4.k;
import x4.AbstractC3250p;

/* JADX INFO: loaded from: classes.dex */
public final class EngineInterceptor implements Interceptor {
    public static final Companion Companion = new Companion(null);
    private static final String TAG = "EngineInterceptor";
    private final ImageLoader imageLoader;
    private final Logger logger;
    private final MemoryCacheService memoryCacheService;
    private final RequestService requestService;
    private final SystemCallbacks systemCallbacks;

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

        private Companion() {
        }
    }

    public static final class ExecuteResult {
        private final DataSource dataSource;
        private final String diskCacheKey;
        private final Drawable drawable;
        private final boolean isSampled;

        public ExecuteResult(Drawable drawable, boolean z6, DataSource dataSource, String str) {
            this.drawable = drawable;
            this.isSampled = z6;
            this.dataSource = dataSource;
            this.diskCacheKey = str;
        }

        public static /* synthetic */ ExecuteResult copy$default(ExecuteResult executeResult, Drawable drawable, boolean z6, DataSource dataSource, String str, int i6, Object obj) {
            if ((i6 & 1) != 0) {
                drawable = executeResult.drawable;
            }
            if ((i6 & 2) != 0) {
                z6 = executeResult.isSampled;
            }
            if ((i6 & 4) != 0) {
                dataSource = executeResult.dataSource;
            }
            if ((i6 & 8) != 0) {
                str = executeResult.diskCacheKey;
            }
            return executeResult.copy(drawable, z6, dataSource, str);
        }

        public final ExecuteResult copy(Drawable drawable, boolean z6, DataSource dataSource, String str) {
            return new ExecuteResult(drawable, z6, dataSource, str);
        }

        public final DataSource getDataSource() {
            return this.dataSource;
        }

        public final String getDiskCacheKey() {
            return this.diskCacheKey;
        }

        public final Drawable getDrawable() {
            return this.drawable;
        }

        public final boolean isSampled() {
            return this.isSampled;
        }
    }

    /* JADX INFO: renamed from: coil.intercept.EngineInterceptor$decode$1, reason: invalid class name */
    @e(c = "coil.intercept.EngineInterceptor", f = "EngineInterceptor.kt", l = {ComposerKt.providerValuesKey}, m = "decode")
    public static final class AnonymousClass1 extends c {
        int I$0;
        Object L$0;
        Object L$1;
        Object L$2;
        Object L$3;
        Object L$4;
        Object L$5;
        Object L$6;
        Object L$7;
        int label;
        /* synthetic */ Object result;

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

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

    /* JADX INFO: renamed from: coil.intercept.EngineInterceptor$execute$1, reason: invalid class name and case insensitive filesystem */
    @e(c = "coil.intercept.EngineInterceptor", f = "EngineInterceptor.kt", l = {126, TsExtractor.TS_STREAM_TYPE_HDMV_DTS, 148}, m = "execute")
    public static final class C12501 extends c {
        Object L$0;
        Object L$1;
        Object L$2;
        Object L$3;
        Object L$4;
        Object L$5;
        Object L$6;
        Object L$7;
        int label;
        /* synthetic */ Object result;

        public C12501(d dVar) {
            super(dVar);
        }

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

    /* JADX INFO: renamed from: coil.intercept.EngineInterceptor$fetch$1, reason: invalid class name and case insensitive filesystem */
    @e(c = "coil.intercept.EngineInterceptor", f = "EngineInterceptor.kt", l = {169}, m = "fetch")
    public static final class C12511 extends c {
        int I$0;
        Object L$0;
        Object L$1;
        Object L$2;
        Object L$3;
        Object L$4;
        Object L$5;
        Object L$6;
        int label;
        /* synthetic */ Object result;

        public C12511(d dVar) {
            super(dVar);
        }

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

    /* JADX INFO: renamed from: coil.intercept.EngineInterceptor$intercept$1, reason: invalid class name and case insensitive filesystem */
    @e(c = "coil.intercept.EngineInterceptor", f = "EngineInterceptor.kt", l = {75}, m = "intercept")
    public static final class C12521 extends c {
        Object L$0;
        Object L$1;
        int label;
        /* synthetic */ Object result;

        public C12521(d dVar) {
            super(dVar);
        }

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

    /* JADX INFO: renamed from: coil.intercept.EngineInterceptor$intercept$2, reason: invalid class name */
    @e(c = "coil.intercept.EngineInterceptor$intercept$2", f = "EngineInterceptor.kt", l = {77}, m = "invokeSuspend")
    public static final class AnonymousClass2 extends j implements J4.e {
        final /* synthetic */ MemoryCache.Key $cacheKey;
        final /* synthetic */ Interceptor.Chain $chain;
        final /* synthetic */ EventListener $eventListener;
        final /* synthetic */ Object $mappedData;
        final /* synthetic */ Options $options;
        final /* synthetic */ ImageRequest $request;
        int label;

        /* JADX WARN: 'super' call moved to the top of the method (can break code semantics) */
        public AnonymousClass2(ImageRequest imageRequest, Object obj, Options options, EventListener eventListener, MemoryCache.Key key, Interceptor.Chain chain, d dVar) {
            super(2, dVar);
            this.$request = imageRequest;
            this.$mappedData = obj;
            this.$options = options;
            this.$eventListener = eventListener;
            this.$cacheKey = key;
            this.$chain = chain;
        }

        @Override // C4.a
        public final d create(Object obj, d dVar) {
            return EngineInterceptor.this.new AnonymousClass2(this.$request, this.$mappedData, this.$options, this.$eventListener, this.$cacheKey, this.$chain, dVar);
        }

        @Override // J4.e
        public final Object invoke(C c6, d dVar) {
            return ((AnonymousClass2) create(c6, dVar)).invokeSuspend(C3137A.f25453a);
        }

        @Override // C4.a
        public final Object invokeSuspend(Object obj) throws Throwable {
            Object objExecute;
            a aVar = a.f492a;
            int i6 = this.label;
            if (i6 == 0) {
                AbstractC2467b.l(obj);
                EngineInterceptor engineInterceptor = EngineInterceptor.this;
                ImageRequest imageRequest = this.$request;
                Object obj2 = this.$mappedData;
                Options options = this.$options;
                EventListener eventListener = this.$eventListener;
                this.label = 1;
                objExecute = engineInterceptor.execute(imageRequest, obj2, options, eventListener, this);
                if (objExecute == aVar) {
                    return aVar;
                }
            } else {
                if (i6 != 1) {
                    throw new IllegalStateException("call to 'resume' before 'invoke' with coroutine");
                }
                AbstractC2467b.l(obj);
                objExecute = obj;
            }
            ExecuteResult executeResult = (ExecuteResult) objExecute;
            EngineInterceptor.this.systemCallbacks.registerMemoryPressureCallbacks();
            boolean cacheValue = EngineInterceptor.this.memoryCacheService.setCacheValue(this.$cacheKey, this.$request, executeResult);
            Drawable drawable = executeResult.getDrawable();
            ImageRequest imageRequest2 = this.$request;
            DataSource dataSource = executeResult.getDataSource();
            MemoryCache.Key key = this.$cacheKey;
            if (!cacheValue) {
                key = null;
            }
            return new SuccessResult(drawable, imageRequest2, dataSource, key, executeResult.getDiskCacheKey(), executeResult.isSampled(), Utils.isPlaceholderCached(this.$chain));
        }
    }

    public EngineInterceptor(ImageLoader imageLoader, SystemCallbacks systemCallbacks, RequestService requestService, Logger logger) {
        this.imageLoader = imageLoader;
        this.systemCallbacks = systemCallbacks;
        this.requestService = requestService;
        this.logger = logger;
        this.memoryCacheService = new MemoryCacheService(imageLoader, requestService, logger);
    }

    /* JADX INFO: Access modifiers changed from: private */
    public final Bitmap convertDrawableToBitmap(Drawable drawable, Options options, List<? extends Transformation> list) {
        if (drawable instanceof BitmapDrawable) {
            Bitmap bitmap = ((BitmapDrawable) drawable).getBitmap();
            Bitmap.Config safeConfig = Bitmaps.getSafeConfig(bitmap);
            if (AbstractC3250p.v(Utils.getVALID_TRANSFORMATION_CONFIGS(), safeConfig)) {
                return bitmap;
            }
            Logger logger = this.logger;
            if (logger != null && logger.getLevel() <= 4) {
                logger.log(TAG, 4, "Converting bitmap with config " + safeConfig + " to apply transformations: " + list + '.', null);
            }
        } else {
            Logger logger2 = this.logger;
            if (logger2 != null && logger2.getLevel() <= 4) {
                logger2.log(TAG, 4, "Converting drawable of type " + drawable.getClass().getCanonicalName() + " to apply transformations: " + list + '.', null);
            }
        }
        return DrawableUtils.INSTANCE.convertToBitmap(drawable, options.getConfig(), options.getSize(), options.getScale(), options.getAllowInexactSize());
    }

    /* JADX INFO: Access modifiers changed from: private */
    /* JADX WARN: Removed duplicated region for block: B:17:0x0066  */
    /* JADX WARN: Removed duplicated region for block: B:23:0x009f  */
    /* JADX WARN: Removed duplicated region for block: B:31:0x00c4  */
    /* JADX WARN: Removed duplicated region for block: B:32:0x00c8  */
    /* JADX WARN: Removed duplicated region for block: B:7:0x0013  */
    /* JADX WARN: Unsupported multi-entry loop pattern (BACK_EDGE: B:20:0x0091 -> B:21:0x0098). Please report as a decompilation issue!!! */
    /*
        Code decompiled incorrectly, please refer to instructions dump.
    */
    public final Object decode(SourceResult sourceResult, ComponentRegistry componentRegistry, ImageRequest imageRequest, Object obj, Options options, EventListener eventListener, d dVar) {
        AnonymousClass1 anonymousClass1;
        int i6;
        EngineInterceptor engineInterceptor;
        k kVarNewDecoder;
        if (dVar instanceof AnonymousClass1) {
            anonymousClass1 = (AnonymousClass1) dVar;
            int i7 = anonymousClass1.label;
            if ((i7 & Integer.MIN_VALUE) != 0) {
                anonymousClass1.label = i7 - Integer.MIN_VALUE;
            } else {
                anonymousClass1 = new AnonymousClass1(dVar);
            }
        }
        Object obj2 = anonymousClass1.result;
        a aVar = a.f492a;
        int i8 = anonymousClass1.label;
        if (i8 == 0) {
            AbstractC2467b.l(obj2);
            i6 = 0;
            engineInterceptor = this;
            kVarNewDecoder = componentRegistry.newDecoder(sourceResult, options, engineInterceptor.imageLoader, i6);
            if (kVarNewDecoder != null) {
            }
        } else {
            if (i8 != 1) {
                throw new IllegalStateException("call to 'resume' before 'invoke' with coroutine");
            }
            int i9 = anonymousClass1.I$0;
            Decoder decoder = (Decoder) anonymousClass1.L$7;
            EventListener eventListener2 = (EventListener) anonymousClass1.L$6;
            Options options2 = (Options) anonymousClass1.L$5;
            Object obj3 = anonymousClass1.L$4;
            ImageRequest imageRequest2 = (ImageRequest) anonymousClass1.L$3;
            ComponentRegistry componentRegistry2 = (ComponentRegistry) anonymousClass1.L$2;
            SourceResult sourceResult2 = (SourceResult) anonymousClass1.L$1;
            engineInterceptor = (EngineInterceptor) anonymousClass1.L$0;
            AbstractC2467b.l(obj2);
            AnonymousClass1 anonymousClass12 = anonymousClass1;
            int i10 = i9;
            sourceResult = sourceResult2;
            AnonymousClass1 anonymousClass13 = anonymousClass12;
            eventListener = eventListener2;
            imageRequest = imageRequest2;
            options = options2;
            obj = obj3;
            DecodeResult decodeResult = (DecodeResult) obj2;
            eventListener.decodeEnd(imageRequest, decoder, options, decodeResult);
            if (decodeResult == null) {
                Drawable drawable = decodeResult.getDrawable();
                boolean zIsSampled = decodeResult.isSampled();
                DataSource dataSource = sourceResult.getDataSource();
                ImageSource source = sourceResult.getSource();
                FileImageSource fileImageSource = source instanceof FileImageSource ? (FileImageSource) source : null;
                return new ExecuteResult(drawable, zIsSampled, dataSource, fileImageSource != null ? fileImageSource.getDiskCacheKey$coil_base_release() : null);
            }
            i6 = i10;
            componentRegistry = componentRegistry2;
            anonymousClass1 = anonymousClass13;
            kVarNewDecoder = componentRegistry.newDecoder(sourceResult, options, engineInterceptor.imageLoader, i6);
            if (kVarNewDecoder != null) {
                throw new IllegalStateException(("Unable to create a decoder that supports: " + obj).toString());
            }
            Decoder decoder2 = (Decoder) kVarNewDecoder.f25469a;
            int iIntValue = ((Number) kVarNewDecoder.f25470b).intValue() + 1;
            eventListener.decodeStart(imageRequest, decoder2, options);
            anonymousClass1.L$0 = engineInterceptor;
            anonymousClass1.L$1 = sourceResult;
            anonymousClass1.L$2 = componentRegistry;
            anonymousClass1.L$3 = imageRequest;
            anonymousClass1.L$4 = obj;
            anonymousClass1.L$5 = options;
            anonymousClass1.L$6 = eventListener;
            anonymousClass1.L$7 = decoder2;
            anonymousClass1.I$0 = iIntValue;
            anonymousClass1.label = 1;
            Object objDecode = decoder2.decode(anonymousClass1);
            if (objDecode == aVar) {
                return aVar;
            }
            componentRegistry2 = componentRegistry;
            decoder = decoder2;
            AnonymousClass1 anonymousClass14 = anonymousClass1;
            i10 = iIntValue;
            obj2 = objDecode;
            anonymousClass13 = anonymousClass14;
            DecodeResult decodeResult2 = (DecodeResult) obj2;
            eventListener.decodeEnd(imageRequest, decoder, options, decodeResult2);
            if (decodeResult2 == null) {
            }
        }
    }

    /* JADX INFO: Access modifiers changed from: private */
    /* JADX WARN: Code restructure failed: missing block: B:73:0x01d1, code lost:
    
        if (r0 == r9) goto L74;
     */
    /* JADX WARN: Multi-variable type inference failed */
    /* JADX WARN: Removed duplicated region for block: B:66:0x01a3  */
    /* JADX WARN: Removed duplicated region for block: B:67:0x01a6  */
    /* JADX WARN: Removed duplicated region for block: B:69:0x01a9  */
    /* JADX WARN: Removed duplicated region for block: B:87:0x01f9  */
    /* JADX WARN: Removed duplicated region for block: B:89:0x01fe  */
    /* JADX WARN: Removed duplicated region for block: B:8:0x0018  */
    /* JADX WARN: Type inference failed for: r2v22 */
    /* JADX WARN: Type inference failed for: r2v26 */
    /* JADX WARN: Type inference failed for: r2v3, types: [int] */
    /* JADX WARN: Type inference failed for: r2v9 */
    /*
        Code decompiled incorrectly, please refer to instructions dump.
    */
    public final Object execute(ImageRequest imageRequest, Object obj, Options options, EventListener eventListener, d dVar) throws Throwable {
        C12501 c12501;
        SourceResult sourceResult;
        ImageSource source;
        EngineInterceptor engineInterceptor;
        ImageRequest imageRequest2;
        Object obj2;
        EventListener eventListener2;
        kotlin.jvm.internal.C c6;
        kotlin.jvm.internal.C c7;
        kotlin.jvm.internal.C c8;
        kotlin.jvm.internal.C c9;
        kotlin.jvm.internal.C c10;
        ImageRequest imageRequest3;
        kotlin.jvm.internal.C c11;
        EventListener eventListener3;
        ExecuteResult executeResult;
        EventListener eventListener4;
        EngineInterceptor engineInterceptor2;
        SourceResult sourceResult2;
        ImageSource source2;
        Bitmap bitmap;
        if (dVar instanceof C12501) {
            c12501 = (C12501) dVar;
            int i6 = c12501.label;
            if ((i6 & Integer.MIN_VALUE) != 0) {
                c12501.label = i6 - Integer.MIN_VALUE;
            } else {
                c12501 = new C12501(dVar);
            }
        }
        C12501 c125012 = c12501;
        Object objH = c125012.result;
        a aVar = a.f492a;
        kotlin.jvm.internal.C c12 = c125012.label;
        try {
            if (c12 == 0) {
                AbstractC2467b.l(objH);
                kotlin.jvm.internal.C c13 = new kotlin.jvm.internal.C();
                c13.f20115a = options;
                kotlin.jvm.internal.C c14 = new kotlin.jvm.internal.C();
                c14.f20115a = this.imageLoader.getComponents();
                kotlin.jvm.internal.C c15 = new kotlin.jvm.internal.C();
                try {
                    c13.f20115a = this.requestService.updateOptionsOnWorkerThread((Options) c13.f20115a);
                    if (imageRequest.getFetcherFactory() != null || imageRequest.getDecoderFactory() != null) {
                        ComponentRegistry.Builder builderNewBuilder = ((ComponentRegistry) c14.f20115a).newBuilder();
                        k fetcherFactory = imageRequest.getFetcherFactory();
                        if (fetcherFactory != null) {
                            builderNewBuilder.getFetcherFactories$coil_base_release().add(0, fetcherFactory);
                        }
                        Decoder.Factory decoderFactory = imageRequest.getDecoderFactory();
                        if (decoderFactory != null) {
                            builderNewBuilder.getDecoderFactories$coil_base_release().add(0, decoderFactory);
                        }
                        c14.f20115a = builderNewBuilder.build();
                    }
                    ComponentRegistry componentRegistry = (ComponentRegistry) c14.f20115a;
                    Options options2 = (Options) c13.f20115a;
                    c125012.L$0 = this;
                    c125012.L$1 = imageRequest;
                    c125012.L$2 = obj;
                    c125012.L$3 = eventListener;
                    c125012.L$4 = c13;
                    c125012.L$5 = c14;
                    c125012.L$6 = c15;
                    c125012.L$7 = c15;
                    c125012.label = 1;
                    Object objFetch = fetch(componentRegistry, imageRequest, obj, options2, eventListener, c125012);
                    if (objFetch != aVar) {
                        engineInterceptor = this;
                        imageRequest2 = imageRequest;
                        obj2 = obj;
                        eventListener2 = eventListener;
                        c6 = c13;
                        objH = objFetch;
                        c7 = c14;
                        c8 = c15;
                        c9 = c8;
                    }
                    return aVar;
                } catch (Throwable th) {
                    th = th;
                    c12 = c15;
                    Object obj3 = c12.f20115a;
                    sourceResult = obj3 instanceof SourceResult ? (SourceResult) obj3 : null;
                    if (sourceResult != null && (source = sourceResult.getSource()) != null) {
                        Utils.closeQuietly(source);
                    }
                    throw th;
                }
            }
            if (c12 == 1) {
                c8 = (kotlin.jvm.internal.C) c125012.L$7;
                c9 = (kotlin.jvm.internal.C) c125012.L$6;
                kotlin.jvm.internal.C c16 = (kotlin.jvm.internal.C) c125012.L$5;
                kotlin.jvm.internal.C c17 = (kotlin.jvm.internal.C) c125012.L$4;
                EventListener eventListener5 = (EventListener) c125012.L$3;
                Object obj4 = c125012.L$2;
                ImageRequest imageRequest4 = (ImageRequest) c125012.L$1;
                EngineInterceptor engineInterceptor3 = (EngineInterceptor) c125012.L$0;
                try {
                    AbstractC2467b.l(objH);
                    c7 = c16;
                    c6 = c17;
                    eventListener2 = eventListener5;
                    obj2 = obj4;
                    imageRequest2 = imageRequest4;
                    engineInterceptor = engineInterceptor3;
                } catch (Throwable th2) {
                    th = th2;
                    c12 = c9;
                    Object obj32 = c12.f20115a;
                    if (obj32 instanceof SourceResult) {
                    }
                    if (sourceResult != null) {
                        Utils.closeQuietly(source);
                    }
                    throw th;
                }
            } else {
                if (c12 != 2) {
                    if (c12 != 3) {
                        throw new IllegalStateException("call to 'resume' before 'invoke' with coroutine");
                    }
                    AbstractC2467b.l(objH);
                    ExecuteResult executeResult2 = (ExecuteResult) objH;
                    Drawable drawable = executeResult2.getDrawable();
                    BitmapDrawable bitmapDrawable = drawable instanceof BitmapDrawable ? (BitmapDrawable) drawable : null;
                    if (bitmapDrawable != null && (bitmap = bitmapDrawable.getBitmap()) != null) {
                        bitmap.prepareToDraw();
                    }
                    return executeResult2;
                }
                c10 = (kotlin.jvm.internal.C) c125012.L$4;
                c11 = (kotlin.jvm.internal.C) c125012.L$3;
                eventListener4 = (EventListener) c125012.L$2;
                imageRequest3 = (ImageRequest) c125012.L$1;
                engineInterceptor2 = (EngineInterceptor) c125012.L$0;
                AbstractC2467b.l(objH);
                eventListener3 = eventListener4;
                engineInterceptor = engineInterceptor2;
                executeResult = (ExecuteResult) objH;
                kotlin.jvm.internal.C c18 = c11;
                Object obj5 = c10.f20115a;
                sourceResult2 = obj5 instanceof SourceResult ? (SourceResult) obj5 : null;
                if (sourceResult2 != null && (source2 = sourceResult2.getSource()) != null) {
                    Utils.closeQuietly(source2);
                }
                Options options3 = (Options) c18.f20115a;
                c125012.L$0 = null;
                c125012.L$1 = null;
                c125012.L$2 = null;
                c125012.L$3 = null;
                c125012.L$4 = null;
                c125012.L$5 = null;
                c125012.L$6 = null;
                c125012.L$7 = null;
                c125012.label = 3;
                objH = engineInterceptor.transform$coil_base_release(executeResult, imageRequest3, options3, eventListener3, c125012);
            }
            c8.f20115a = objH;
            Object obj6 = c9.f20115a;
            FetchResult fetchResult = (FetchResult) obj6;
            if (fetchResult instanceof SourceResult) {
                AbstractC0786y decoderDispatcher = imageRequest2.getDecoderDispatcher();
                kotlin.jvm.internal.C c19 = c9;
                try {
                    EngineInterceptor$execute$executeResult$1 engineInterceptor$execute$executeResult$1 = new EngineInterceptor$execute$executeResult$1(engineInterceptor, c19, c7, imageRequest2, obj2, c6, eventListener2, null);
                    c10 = c19;
                    imageRequest3 = imageRequest2;
                    c11 = c6;
                    eventListener4 = eventListener2;
                    c125012.L$0 = engineInterceptor;
                    c125012.L$1 = imageRequest3;
                    c125012.L$2 = eventListener4;
                    c125012.L$3 = c11;
                    c125012.L$4 = c10;
                    c125012.L$5 = null;
                    c125012.L$6 = null;
                    c125012.L$7 = null;
                    c125012.label = 2;
                    objH = E.H(decoderDispatcher, engineInterceptor$execute$executeResult$1, c125012);
                    if (objH == aVar) {
                        return aVar;
                    }
                    engineInterceptor2 = engineInterceptor;
                    eventListener3 = eventListener4;
                    engineInterceptor = engineInterceptor2;
                    executeResult = (ExecuteResult) objH;
                    kotlin.jvm.internal.C c182 = c11;
                    Object obj52 = c10.f20115a;
                    if (obj52 instanceof SourceResult) {
                    }
                    if (sourceResult2 != null) {
                        Utils.closeQuietly(source2);
                    }
                    Options options32 = (Options) c182.f20115a;
                    c125012.L$0 = null;
                    c125012.L$1 = null;
                    c125012.L$2 = null;
                    c125012.L$3 = null;
                    c125012.L$4 = null;
                    c125012.L$5 = null;
                    c125012.L$6 = null;
                    c125012.L$7 = null;
                    c125012.label = 3;
                    objH = engineInterceptor.transform$coil_base_release(executeResult, imageRequest3, options32, eventListener3, c125012);
                } catch (Throwable th3) {
                    th = th3;
                    c12 = c19;
                    Object obj322 = c12.f20115a;
                    if (obj322 instanceof SourceResult) {
                    }
                    if (sourceResult != null) {
                    }
                    throw th;
                }
            } else {
                c10 = c9;
                imageRequest3 = imageRequest2;
                c11 = c6;
                EventListener eventListener6 = eventListener2;
                if (!(fetchResult instanceof DrawableResult)) {
                    throw new v();
                }
                eventListener3 = eventListener6;
                executeResult = new ExecuteResult(((DrawableResult) obj6).getDrawable(), ((DrawableResult) c10.f20115a).isSampled(), ((DrawableResult) c10.f20115a).getDataSource(), null);
                kotlin.jvm.internal.C c1822 = c11;
                Object obj522 = c10.f20115a;
                if (obj522 instanceof SourceResult) {
                }
                if (sourceResult2 != null) {
                }
                Options options322 = (Options) c1822.f20115a;
                c125012.L$0 = null;
                c125012.L$1 = null;
                c125012.L$2 = null;
                c125012.L$3 = null;
                c125012.L$4 = null;
                c125012.L$5 = null;
                c125012.L$6 = null;
                c125012.L$7 = null;
                c125012.label = 3;
                objH = engineInterceptor.transform$coil_base_release(executeResult, imageRequest3, options322, eventListener3, c125012);
            }
        } catch (Throwable th4) {
            th = th4;
        }
    }

    /* JADX INFO: Access modifiers changed from: private */
    /* JADX WARN: Removed duplicated region for block: B:17:0x0062  */
    /* JADX WARN: Removed duplicated region for block: B:24:0x0096 A[RETURN] */
    /* JADX WARN: Removed duplicated region for block: B:25:0x0097  */
    /* JADX WARN: Removed duplicated region for block: B:36:0x00af  */
    /* JADX WARN: Removed duplicated region for block: B:7:0x0013  */
    /* JADX WARN: Unsupported multi-entry loop pattern (BACK_EDGE: B:20:0x008b -> B:21:0x008f). Please report as a decompilation issue!!! */
    /*
        Code decompiled incorrectly, please refer to instructions dump.
    */
    public final Object fetch(ComponentRegistry componentRegistry, ImageRequest imageRequest, Object obj, Options options, EventListener eventListener, d dVar) {
        C12511 c12511;
        int i6;
        EngineInterceptor engineInterceptor;
        k kVarNewFetcher;
        ImageSource source;
        if (dVar instanceof C12511) {
            c12511 = (C12511) dVar;
            int i7 = c12511.label;
            if ((i7 & Integer.MIN_VALUE) != 0) {
                c12511.label = i7 - Integer.MIN_VALUE;
            } else {
                c12511 = new C12511(dVar);
            }
        }
        Object obj2 = c12511.result;
        a aVar = a.f492a;
        int i8 = c12511.label;
        if (i8 == 0) {
            AbstractC2467b.l(obj2);
            i6 = 0;
            engineInterceptor = this;
            kVarNewFetcher = componentRegistry.newFetcher(obj, options, engineInterceptor.imageLoader, i6);
            if (kVarNewFetcher != null) {
            }
        } else {
            if (i8 != 1) {
                throw new IllegalStateException("call to 'resume' before 'invoke' with coroutine");
            }
            int i9 = c12511.I$0;
            Fetcher fetcher = (Fetcher) c12511.L$6;
            EventListener eventListener2 = (EventListener) c12511.L$5;
            options = (Options) c12511.L$4;
            Object obj3 = c12511.L$3;
            ImageRequest imageRequest2 = (ImageRequest) c12511.L$2;
            ComponentRegistry componentRegistry2 = (ComponentRegistry) c12511.L$1;
            engineInterceptor = (EngineInterceptor) c12511.L$0;
            AbstractC2467b.l(obj2);
            C12511 c125112 = c12511;
            int i10 = i9;
            componentRegistry = componentRegistry2;
            C12511 c125113 = c125112;
            Fetcher fetcher2 = fetcher;
            imageRequest = imageRequest2;
            eventListener = eventListener2;
            obj = obj3;
            FetchResult fetchResult = (FetchResult) obj2;
            try {
                eventListener.fetchEnd(imageRequest, fetcher2, options, fetchResult);
                if (fetchResult == null) {
                    return fetchResult;
                }
                i6 = i10;
                c12511 = c125113;
                kVarNewFetcher = componentRegistry.newFetcher(obj, options, engineInterceptor.imageLoader, i6);
                if (kVarNewFetcher != null) {
                    throw new IllegalStateException(("Unable to create a fetcher that supports: " + obj).toString());
                }
                fetcher2 = (Fetcher) kVarNewFetcher.f25469a;
                int iIntValue = ((Number) kVarNewFetcher.f25470b).intValue() + 1;
                eventListener.fetchStart(imageRequest, fetcher2, options);
                c12511.L$0 = engineInterceptor;
                c12511.L$1 = componentRegistry;
                c12511.L$2 = imageRequest;
                c12511.L$3 = obj;
                c12511.L$4 = options;
                c12511.L$5 = eventListener;
                c12511.L$6 = fetcher2;
                c12511.I$0 = iIntValue;
                c12511.label = 1;
                Object objFetch = fetcher2.fetch(c12511);
                if (objFetch == aVar) {
                    return aVar;
                }
                C12511 c125114 = c12511;
                i10 = iIntValue;
                obj2 = objFetch;
                c125113 = c125114;
                FetchResult fetchResult2 = (FetchResult) obj2;
                eventListener.fetchEnd(imageRequest, fetcher2, options, fetchResult2);
                if (fetchResult2 == null) {
                }
            } catch (Throwable th) {
                SourceResult sourceResult = fetchResult2 instanceof SourceResult ? (SourceResult) fetchResult2 : null;
                if (sourceResult != null && (source = sourceResult.getSource()) != null) {
                    Utils.closeQuietly(source);
                }
                throw th;
            }
        }
    }

    /* JADX WARN: Removed duplicated region for block: B:7:0x0013  */
    @Override // coil.intercept.Interceptor
    /*
        Code decompiled incorrectly, please refer to instructions dump.
    */
    public Object intercept(Interceptor.Chain chain, d dVar) throws Throwable {
        C12521 c12521;
        Throwable th;
        EngineInterceptor engineInterceptor;
        MemoryCache.Value cacheValue;
        if (dVar instanceof C12521) {
            c12521 = (C12521) dVar;
            int i6 = c12521.label;
            if ((i6 & Integer.MIN_VALUE) != 0) {
                c12521.label = i6 - Integer.MIN_VALUE;
            } else {
                c12521 = new C12521(dVar);
            }
        }
        Object obj = c12521.result;
        a aVar = a.f492a;
        int i7 = c12521.label;
        if (i7 == 0) {
            AbstractC2467b.l(obj);
            try {
                ImageRequest request = chain.getRequest();
                Object data = request.getData();
                Size size = chain.getSize();
                EventListener eventListener = Utils.getEventListener(chain);
                Options options = this.requestService.options(request, size);
                Scale scale = options.getScale();
                eventListener.mapStart(request, data);
                Object map = this.imageLoader.getComponents().map(data, options);
                eventListener.mapEnd(request, map);
                MemoryCache.Key keyNewCacheKey = this.memoryCacheService.newCacheKey(request, map, options, eventListener);
                if (keyNewCacheKey != null) {
                    try {
                        cacheValue = this.memoryCacheService.getCacheValue(request, keyNewCacheKey, size, scale);
                    } catch (Throwable th2) {
                        th = th2;
                        engineInterceptor = this;
                    }
                } else {
                    cacheValue = null;
                }
                if (cacheValue != null) {
                    return this.memoryCacheService.newResult(chain, request, keyNewCacheKey, cacheValue);
                }
                AbstractC0786y fetcherDispatcher = request.getFetcherDispatcher();
                try {
                    AnonymousClass2 anonymousClass2 = new AnonymousClass2(request, map, options, eventListener, keyNewCacheKey, chain, null);
                    c12521.L$0 = this;
                    c12521.L$1 = chain;
                    c12521.label = 1;
                    Object objH = E.H(fetcherDispatcher, anonymousClass2, c12521);
                    return objH == aVar ? aVar : objH;
                } catch (Throwable th3) {
                    th = th3;
                    engineInterceptor = this;
                    chain = chain;
                }
            } catch (Throwable th4) {
                th = th4;
                engineInterceptor = this;
            }
        } else {
            if (i7 != 1) {
                throw new IllegalStateException("call to 'resume' before 'invoke' with coroutine");
            }
            chain = (Interceptor.Chain) c12521.L$1;
            engineInterceptor = (EngineInterceptor) c12521.L$0;
            try {
                AbstractC2467b.l(obj);
                return obj;
            } catch (Throwable th5) {
                th = th5;
            }
        }
        if (th instanceof CancellationException) {
            throw th;
        }
        return engineInterceptor.requestService.errorResult(chain.getRequest(), th);
    }

    public final Object transform$coil_base_release(ExecuteResult executeResult, ImageRequest imageRequest, Options options, EventListener eventListener, d dVar) {
        List<Transformation> transformations = imageRequest.getTransformations();
        if (transformations.isEmpty()) {
            return executeResult;
        }
        if ((executeResult.getDrawable() instanceof BitmapDrawable) || imageRequest.getAllowConversionToBitmap()) {
            return E.H(imageRequest.getTransformationDispatcher(), new EngineInterceptor$transform$3(this, executeResult, options, transformations, eventListener, imageRequest, null), dVar);
        }
        Logger logger = this.logger;
        if (logger != null && logger.getLevel() <= 4) {
            logger.log(TAG, 4, A0.a.k('.', "allowConversionToBitmap=false, skipping transformations for type ", executeResult.getDrawable().getClass().getCanonicalName()), null);
        }
        return executeResult;
    }
}