package com.strmr.ps.ui.splash;

import android.util.Log;
import com.strmr.ps.data.model.ContentItem;
import com.strmr.ps.data.model.trakt.TraktLastActivities;
import com.strmr.ps.data.repository.ContinueWatchingRepository;
import com.strmr.ps.data.repository.TraktSyncRepository;
import defpackage.ak1;
import defpackage.ck1;
import defpackage.cr4;
import defpackage.e6a;
import defpackage.gr3;
import defpackage.s38;
import java.util.Collection;
import java.util.List;
import kotlin.Metadata;
import kotlin.coroutines.Continuation;
import kotlin.coroutines.jvm.internal.DebugMetadata;
import kotlin.coroutines.jvm.internal.SuspendLambda;

/* JADX INFO: loaded from: classes3.dex */
@Metadata(d1 = {"\u0000\u0010\n\u0002\u0018\u0002\n\u0002\u0010 \n\u0002\u0018\u0002\n\u0002\b\u0002\u0010\u0003\u001a\b\u0012\u0004\u0012\u00020\u00020\u0001*\u00020\u0000H\n¢\u0006\u0004\b\u0003\u0010\u0004"}, d2 = {"Lak1;", "", "Lcom/strmr/ps/data/model/ContentItem;", "<anonymous>", "(Lak1;)Ljava/util/List;"}, k = 3, mv = {2, 0, 0})
@DebugMetadata(c = "com.strmr.ps.ui.splash.SyncSplashActivity$onCreate$2$2$1", f = "SyncSplashActivity.kt", i = {}, l = {340, 341, 344, 346, 351, 353, 354}, m = "invokeSuspend", n = {}, s = {})
final class f extends SuspendLambda implements gr3<ak1, Continuation<? super List<? extends ContentItem>>, Object> {
    public int a;
    public final /* synthetic */ boolean b;
    public final /* synthetic */ SyncSplashActivity c;

    /* JADX WARN: 'super' call moved to the top of the method (can break code semantics) */
    public f(boolean z, SyncSplashActivity syncSplashActivity, Continuation continuation) {
        super(2, continuation);
        this.b = z;
        this.c = syncSplashActivity;
    }

    @Override // kotlin.coroutines.jvm.internal.BaseContinuationImpl
    public final Continuation create(Object obj, Continuation continuation) {
        return new f(this.b, this.c, continuation);
    }

    @Override // defpackage.gr3
    public final Object invoke(Object obj, Object obj2) {
        return ((f) create((ak1) obj, (Continuation) obj2)).invokeSuspend(e6a.a);
    }

    /* JADX WARN: Code restructure failed: missing block: B:21:0x005a, code lost:
    
        if (r7 == r0) goto L51;
     */
    /* JADX WARN: Code restructure failed: missing block: B:34:0x0080, code lost:
    
        if (r7 == r0) goto L51;
     */
    /* JADX WARN: Code restructure failed: missing block: B:40:0x009f, code lost:
    
        if (r7 == r0) goto L51;
     */
    /* JADX WARN: Code restructure failed: missing block: B:50:0x00c6, code lost:
    
        if (r7 == r0) goto L51;
     */
    /* JADX WARN: Removed duplicated region for block: B:20:0x004f  */
    /* JADX WARN: Removed duplicated region for block: B:33:0x0075  */
    /* JADX WARN: Removed duplicated region for block: B:37:0x008a  */
    /* JADX WARN: Removed duplicated region for block: B:39:0x008d  */
    /* JADX WARN: Removed duplicated region for block: B:44:0x00a5  */
    /* JADX WARN: Removed duplicated region for block: B:49:0x00bb  */
    @Override // kotlin.coroutines.jvm.internal.BaseContinuationImpl
    /*
        Code decompiled incorrectly, please refer to instructions dump.
    */
    public final Object invokeSuspend(Object obj) {
        Collection collection;
        TraktLastActivities traktLastActivities;
        boolean zBooleanValue;
        Collection collection2;
        ck1 ck1Var = ck1.a;
        int i = this.a;
        SyncSplashActivity syncSplashActivity = this.c;
        switch (i) {
            case 0:
                s38.b(obj);
                if (!this.b) {
                    TraktSyncRepository traktSyncRepository = syncSplashActivity.i;
                    if (traktSyncRepository == null) {
                        cr4.n("traktSyncRepository");
                        throw null;
                    }
                    this.a = 3;
                    obj = traktSyncRepository.getRemoteActivities(this);
                    if (obj != ck1Var) {
                        traktLastActivities = (TraktLastActivities) obj;
                        if (traktLastActivities == null) {
                            ContinueWatchingRepository continueWatchingRepositoryH = syncSplashActivity.h();
                            this.a = 4;
                            obj = continueWatchingRepositoryH.hasRemoteContinueWatchingChanges(traktLastActivities, this);
                        } else {
                            zBooleanValue = false;
                            if (!zBooleanValue) {
                                Log.w("SyncSplashActivity", "CW data changed remotely — force-refreshing in splash");
                                ContinueWatchingRepository continueWatchingRepositoryH2 = syncSplashActivity.h();
                                this.a = 5;
                                obj = continueWatchingRepositoryH2.load(true, this);
                            } else {
                                ContinueWatchingRepository continueWatchingRepositoryH3 = syncSplashActivity.h();
                                this.a = 6;
                                obj = continueWatchingRepositoryH3.loadFromCache(this);
                                if (obj != ck1Var) {
                                    collection2 = (Collection) obj;
                                    if (collection2.isEmpty()) {
                                        ContinueWatchingRepository continueWatchingRepositoryH4 = syncSplashActivity.h();
                                        this.a = 7;
                                        obj = continueWatchingRepositoryH4.load(false, this);
                                        break;
                                    }
                                    return (List) collection2;
                                }
                            }
                        }
                    }
                    break;
                } else {
                    ContinueWatchingRepository continueWatchingRepositoryH5 = syncSplashActivity.h();
                    this.a = 1;
                    obj = continueWatchingRepositoryH5.loadFromCache(this);
                    if (obj != ck1Var) {
                        collection = (Collection) obj;
                        if (collection.isEmpty()) {
                            ContinueWatchingRepository continueWatchingRepositoryH6 = syncSplashActivity.h();
                            this.a = 2;
                            obj = continueWatchingRepositoryH6.load(false, this);
                            break;
                        }
                        return (List) collection;
                    }
                }
                return ck1Var;
            case 1:
                s38.b(obj);
                collection = (Collection) obj;
                if (collection.isEmpty()) {
                }
                return (List) collection;
            case 2:
                s38.b(obj);
                collection = (List) obj;
                return (List) collection;
            case 3:
                s38.b(obj);
                traktLastActivities = (TraktLastActivities) obj;
                if (traktLastActivities == null) {
                }
                break;
            case 4:
                s38.b(obj);
                zBooleanValue = ((Boolean) obj).booleanValue();
                if (!zBooleanValue) {
                }
                return ck1Var;
            case 5:
                s38.b(obj);
                return (List) obj;
            case 6:
                s38.b(obj);
                collection2 = (Collection) obj;
                if (collection2.isEmpty()) {
                }
                return (List) collection2;
            case 7:
                s38.b(obj);
                collection2 = (List) obj;
                return (List) collection2;
            default:
                throw new IllegalStateException("call to 'resume' before 'invoke' with coroutine");
        }
    }
}