package androidx.room;

import java.util.HashMap;
import java.util.LinkedHashMap;
import java.util.Locale;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.atomic.AtomicBoolean;
import kotlin.collections.EmptySet;
import kotlin.coroutines.Continuation;
import kotlin.coroutines.intrinsics.CoroutineSingletons;

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

    /* JADX INFO: renamed from: l, reason: collision with root package name */
    public static final String[] f4199l = {"INSERT", "UPDATE", "DELETE"};

    /* JADX INFO: renamed from: a, reason: collision with root package name */
    public final RoomDatabase f4200a;

    /* JADX INFO: renamed from: b, reason: collision with root package name */
    public final Map f4201b;

    /* JADX INFO: renamed from: c, reason: collision with root package name */
    public final Map f4202c;

    /* JADX INFO: renamed from: d, reason: collision with root package name */
    public final boolean f4203d;

    /* JADX INFO: renamed from: e, reason: collision with root package name */
    public final sd.l f4204e;

    /* JADX INFO: renamed from: f, reason: collision with root package name */
    public final LinkedHashMap f4205f;

    /* JADX INFO: renamed from: g, reason: collision with root package name */
    public final String[] f4206g;

    /* JADX INFO: renamed from: h, reason: collision with root package name */
    public final x f4207h;

    /* JADX INFO: renamed from: i, reason: collision with root package name */
    public final androidx.datastore.core.o f4208i;

    /* JADX INFO: renamed from: j, reason: collision with root package name */
    public final AtomicBoolean f4209j;

    /* JADX INFO: renamed from: k, reason: collision with root package name */
    public sd.a f4210k;

    public x0(RoomDatabase roomDatabase, HashMap map, HashMap map2, String[] strArr, boolean z10, sd.l lVar) {
        String lowerCase;
        nb.g.i(roomDatabase, "database");
        this.f4200a = roomDatabase;
        this.f4201b = map;
        this.f4202c = map2;
        this.f4203d = z10;
        this.f4204e = lVar;
        this.f4209j = new AtomicBoolean(false);
        this.f4210k = new defpackage.c(1);
        this.f4205f = new LinkedHashMap();
        int length = strArr.length;
        String[] strArr2 = new String[length];
        for (int i10 = 0; i10 < length; i10++) {
            String str = strArr[i10];
            Locale locale = Locale.ROOT;
            String lowerCase2 = str.toLowerCase(locale);
            nb.g.h(lowerCase2, "toLowerCase(...)");
            this.f4205f.put(lowerCase2, Integer.valueOf(i10));
            String str2 = (String) this.f4201b.get(strArr[i10]);
            if (str2 != null) {
                lowerCase = str2.toLowerCase(locale);
                nb.g.h(lowerCase, "toLowerCase(...)");
            } else {
                lowerCase = null;
            }
            if (lowerCase != null) {
                lowerCase2 = lowerCase;
            }
            strArr2[i10] = lowerCase2;
        }
        this.f4206g = strArr2;
        for (Map.Entry entry : this.f4201b.entrySet()) {
            String str3 = (String) entry.getValue();
            Locale locale2 = Locale.ROOT;
            String lowerCase3 = str3.toLowerCase(locale2);
            nb.g.h(lowerCase3, "toLowerCase(...)");
            if (this.f4205f.containsKey(lowerCase3)) {
                String lowerCase4 = ((String) entry.getKey()).toLowerCase(locale2);
                nb.g.h(lowerCase4, "toLowerCase(...)");
                LinkedHashMap linkedHashMap = this.f4205f;
                linkedHashMap.put(lowerCase4, kotlin.collections.q.Y(lowerCase3, linkedHashMap));
            }
        }
        this.f4207h = new x(this.f4206g.length);
        this.f4208i = new androidx.datastore.core.o(this.f4206g.length);
    }

    /* JADX WARN: Removed duplicated region for block: B:7:0x0016  */
    /*
        Code decompiled incorrectly, please refer to instructions dump.
    */
    public static final Object a(x0 x0Var, u0 u0Var, Continuation continuation) {
        TriggerBasedInvalidationTracker$checkInvalidatedTables$1 triggerBasedInvalidationTracker$checkInvalidatedTables$1;
        a0 a0Var;
        Set set;
        x0Var.getClass();
        if (continuation instanceof TriggerBasedInvalidationTracker$checkInvalidatedTables$1) {
            triggerBasedInvalidationTracker$checkInvalidatedTables$1 = (TriggerBasedInvalidationTracker$checkInvalidatedTables$1) continuation;
            int i10 = triggerBasedInvalidationTracker$checkInvalidatedTables$1.label;
            if ((i10 & Integer.MIN_VALUE) != 0) {
                triggerBasedInvalidationTracker$checkInvalidatedTables$1.label = i10 - Integer.MIN_VALUE;
            } else {
                triggerBasedInvalidationTracker$checkInvalidatedTables$1 = new TriggerBasedInvalidationTracker$checkInvalidatedTables$1(x0Var, continuation);
            }
        }
        Object objD = triggerBasedInvalidationTracker$checkInvalidatedTables$1.result;
        CoroutineSingletons coroutineSingletons = CoroutineSingletons.f29226a;
        int i11 = triggerBasedInvalidationTracker$checkInvalidatedTables$1.label;
        if (i11 == 0) {
            kotlin.a.d(objD);
            w0 w0Var = new w0(1);
            triggerBasedInvalidationTracker$checkInvalidatedTables$1.L$0 = u0Var;
            triggerBasedInvalidationTracker$checkInvalidatedTables$1.label = 1;
            a0Var = (androidx.room.coroutines.a) u0Var;
            objD = a0Var.d("SELECT * FROM room_table_modification_log WHERE invalidated = 1", w0Var, triggerBasedInvalidationTracker$checkInvalidatedTables$1);
            if (objD == coroutineSingletons) {
                return coroutineSingletons;
            }
        } else {
            if (i11 != 1) {
                if (i11 != 2) {
                    throw new IllegalStateException("call to 'resume' before 'invoke' with coroutine");
                }
                set = (Set) triggerBasedInvalidationTracker$checkInvalidatedTables$1.L$0;
                kotlin.a.d(objD);
                return set;
            }
            a0Var = (a0) triggerBasedInvalidationTracker$checkInvalidatedTables$1.L$0;
            kotlin.a.d(objD);
        }
        Set set2 = (Set) objD;
        if (!(!set2.isEmpty())) {
            return set2;
        }
        triggerBasedInvalidationTracker$checkInvalidatedTables$1.L$0 = set2;
        triggerBasedInvalidationTracker$checkInvalidatedTables$1.label = 2;
        if (ua.b.s(a0Var, "UPDATE room_table_modification_log SET invalidated = 0 WHERE invalidated = 1", triggerBasedInvalidationTracker$checkInvalidatedTables$1) == coroutineSingletons) {
            return coroutineSingletons;
        }
        set = set2;
        return set;
    }

    /* JADX WARN: Removed duplicated region for block: B:33:0x008c A[Catch: all -> 0x0097, TRY_LEAVE, TryCatch #1 {all -> 0x0097, blocks: (B:31:0x0082, B:33:0x008c, B:20:0x004d, B:22:0x0056, B:25:0x005e, B:27:0x006c, B:28:0x006f), top: B:43:0x004d }] */
    /* JADX WARN: Removed duplicated region for block: B:7:0x0016  */
    /*
        Code decompiled incorrectly, please refer to instructions dump.
    */
    public static final Object b(x0 x0Var, Continuation continuation) throws Throwable {
        TriggerBasedInvalidationTracker$notifyInvalidation$1 triggerBasedInvalidationTracker$notifyInvalidation$1;
        f3.a closeBarrier$room_runtime_release;
        f3.a aVar;
        Set set;
        x0Var.getClass();
        if (continuation instanceof TriggerBasedInvalidationTracker$notifyInvalidation$1) {
            triggerBasedInvalidationTracker$notifyInvalidation$1 = (TriggerBasedInvalidationTracker$notifyInvalidation$1) continuation;
            int i10 = triggerBasedInvalidationTracker$notifyInvalidation$1.label;
            if ((i10 & Integer.MIN_VALUE) != 0) {
                triggerBasedInvalidationTracker$notifyInvalidation$1.label = i10 - Integer.MIN_VALUE;
            } else {
                triggerBasedInvalidationTracker$notifyInvalidation$1 = new TriggerBasedInvalidationTracker$notifyInvalidation$1(x0Var, continuation);
            }
        }
        Object objUseConnection$room_runtime_release = triggerBasedInvalidationTracker$notifyInvalidation$1.result;
        CoroutineSingletons coroutineSingletons = CoroutineSingletons.f29226a;
        int i11 = triggerBasedInvalidationTracker$notifyInvalidation$1.label;
        if (i11 == 0) {
            kotlin.a.d(objUseConnection$room_runtime_release);
            RoomDatabase roomDatabase = x0Var.f4200a;
            closeBarrier$room_runtime_release = roomDatabase.getCloseBarrier$room_runtime_release();
            if (!closeBarrier$room_runtime_release.a()) {
                return EmptySet.f29205a;
            }
            try {
                if (x0Var.f4209j.compareAndSet(true, false) && ((Boolean) x0Var.f4210k.invoke()).booleanValue()) {
                    TriggerBasedInvalidationTracker$notifyInvalidation$2$invalidatedTableIds$1 triggerBasedInvalidationTracker$notifyInvalidation$2$invalidatedTableIds$1 = new TriggerBasedInvalidationTracker$notifyInvalidation$2$invalidatedTableIds$1(x0Var, null);
                    triggerBasedInvalidationTracker$notifyInvalidation$1.L$0 = x0Var;
                    triggerBasedInvalidationTracker$notifyInvalidation$1.L$1 = closeBarrier$room_runtime_release;
                    triggerBasedInvalidationTracker$notifyInvalidation$1.label = 1;
                    objUseConnection$room_runtime_release = roomDatabase.useConnection$room_runtime_release(false, triggerBasedInvalidationTracker$notifyInvalidation$2$invalidatedTableIds$1, triggerBasedInvalidationTracker$notifyInvalidation$1);
                    if (objUseConnection$room_runtime_release == coroutineSingletons) {
                        return coroutineSingletons;
                    }
                    set = (Set) objUseConnection$room_runtime_release;
                    if (!set.isEmpty()) {
                    }
                } else {
                    set = EmptySet.f29205a;
                }
            } catch (Throwable th) {
                th = th;
                aVar = closeBarrier$room_runtime_release;
                aVar.b();
                throw th;
            }
        } else {
            if (i11 != 1) {
                throw new IllegalStateException("call to 'resume' before 'invoke' with coroutine");
            }
            aVar = (f3.a) triggerBasedInvalidationTracker$notifyInvalidation$1.L$1;
            x0 x0Var2 = (x0) triggerBasedInvalidationTracker$notifyInvalidation$1.L$0;
            try {
                kotlin.a.d(objUseConnection$room_runtime_release);
                closeBarrier$room_runtime_release = aVar;
                x0Var = x0Var2;
                set = (Set) objUseConnection$room_runtime_release;
                if (!set.isEmpty()) {
                    x0Var.f4208i.b(set);
                    x0Var.f4204e.invoke(set);
                }
            } catch (Throwable th2) {
                th = th2;
                aVar.b();
                throw th;
            }
        }
        closeBarrier$room_runtime_release.b();
        return set;
    }

    /* JADX WARN: Removed duplicated region for block: B:21:0x009c  */
    /* JADX WARN: Removed duplicated region for block: B:30:0x00ef  */
    /* JADX WARN: Removed duplicated region for block: B:7:0x001e  */
    /* JADX WARN: Unsupported multi-entry loop pattern (BACK_EDGE: B:28:0x00eb -> B:29:0x00ec). Please report as a decompilation issue!!! */
    /*
        Code decompiled incorrectly, please refer to instructions dump.
    */
    public static final Object c(x0 x0Var, v0 v0Var, int i10, Continuation continuation) {
        TriggerBasedInvalidationTracker$startTrackingTable$1 triggerBasedInvalidationTracker$startTrackingTable$1;
        String[] strArr;
        x0 x0Var2;
        int i11;
        a0 a0Var;
        int i12;
        String str;
        x0 x0Var3 = x0Var;
        a0 a0Var2 = v0Var;
        int i13 = i10;
        x0Var.getClass();
        if (continuation instanceof TriggerBasedInvalidationTracker$startTrackingTable$1) {
            triggerBasedInvalidationTracker$startTrackingTable$1 = (TriggerBasedInvalidationTracker$startTrackingTable$1) continuation;
            int i14 = triggerBasedInvalidationTracker$startTrackingTable$1.label;
            if ((i14 & Integer.MIN_VALUE) != 0) {
                triggerBasedInvalidationTracker$startTrackingTable$1.label = i14 - Integer.MIN_VALUE;
            } else {
                triggerBasedInvalidationTracker$startTrackingTable$1 = new TriggerBasedInvalidationTracker$startTrackingTable$1(x0Var3, continuation);
            }
        }
        Object obj = triggerBasedInvalidationTracker$startTrackingTable$1.result;
        CoroutineSingletons coroutineSingletons = CoroutineSingletons.f29226a;
        int i15 = triggerBasedInvalidationTracker$startTrackingTable$1.label;
        if (i15 == 0) {
            kotlin.a.d(obj);
            String str2 = "INSERT OR IGNORE INTO room_table_modification_log VALUES(" + i13 + ", 0)";
            triggerBasedInvalidationTracker$startTrackingTable$1.L$0 = x0Var3;
            triggerBasedInvalidationTracker$startTrackingTable$1.L$1 = a0Var2;
            triggerBasedInvalidationTracker$startTrackingTable$1.I$0 = i13;
            triggerBasedInvalidationTracker$startTrackingTable$1.label = 1;
            if (ua.b.s(a0Var2, str2, triggerBasedInvalidationTracker$startTrackingTable$1) == coroutineSingletons) {
                return coroutineSingletons;
            }
        } else if (i15 == 1) {
            int i16 = triggerBasedInvalidationTracker$startTrackingTable$1.I$0;
            a0Var2 = (a0) triggerBasedInvalidationTracker$startTrackingTable$1.L$1;
            x0 x0Var4 = (x0) triggerBasedInvalidationTracker$startTrackingTable$1.L$0;
            kotlin.a.d(obj);
            i13 = i16;
            x0Var3 = x0Var4;
        } else {
            if (i15 != 2) {
                throw new IllegalStateException("call to 'resume' before 'invoke' with coroutine");
            }
            i11 = triggerBasedInvalidationTracker$startTrackingTable$1.I$2;
            i12 = triggerBasedInvalidationTracker$startTrackingTable$1.I$1;
            i13 = triggerBasedInvalidationTracker$startTrackingTable$1.I$0;
            strArr = (String[]) triggerBasedInvalidationTracker$startTrackingTable$1.L$3;
            str = (String) triggerBasedInvalidationTracker$startTrackingTable$1.L$2;
            a0Var = (a0) triggerBasedInvalidationTracker$startTrackingTable$1.L$1;
            x0Var2 = (x0) triggerBasedInvalidationTracker$startTrackingTable$1.L$0;
            kotlin.a.d(obj);
            int i17 = 1;
            i12 += i17;
            if (i12 < i11) {
                String str3 = strArr[i12];
                StringBuilder sbT = defpackage.e.t("CREATE ", x0Var2.f4203d ? "TEMP" : "", " TRIGGER IF NOT EXISTS `", "room_table_modification_trigger_" + str + '_' + str3, "` AFTER ");
                u.a.h(sbT, str3, " ON `", str, "` BEGIN UPDATE room_table_modification_log SET invalidated = 1 WHERE table_id = ");
                String strB = u.a.b(sbT, i13, " AND invalidated = 0; END");
                triggerBasedInvalidationTracker$startTrackingTable$1.L$0 = x0Var2;
                triggerBasedInvalidationTracker$startTrackingTable$1.L$1 = a0Var;
                triggerBasedInvalidationTracker$startTrackingTable$1.L$2 = str;
                triggerBasedInvalidationTracker$startTrackingTable$1.L$3 = strArr;
                triggerBasedInvalidationTracker$startTrackingTable$1.I$0 = i13;
                triggerBasedInvalidationTracker$startTrackingTable$1.I$1 = i12;
                triggerBasedInvalidationTracker$startTrackingTable$1.I$2 = i11;
                triggerBasedInvalidationTracker$startTrackingTable$1.label = 2;
                if (ua.b.s(a0Var, strB, triggerBasedInvalidationTracker$startTrackingTable$1) == coroutineSingletons) {
                    return coroutineSingletons;
                }
                i17 = 1;
                i12 += i17;
                if (i12 < i11) {
                    return kd.e.f29109a;
                }
            }
        }
        String str4 = x0Var3.f4206g[i13];
        strArr = f4199l;
        x0Var2 = x0Var3;
        i11 = 3;
        a0Var = a0Var2;
        i12 = 0;
        str = str4;
        if (i12 < i11) {
        }
    }

    /* JADX WARN: Removed duplicated region for block: B:16:0x0058  */
    /* JADX WARN: Removed duplicated region for block: B:20:0x0098  */
    /* JADX WARN: Removed duplicated region for block: B:7:0x0016  */
    /* JADX WARN: Unsupported multi-entry loop pattern (BACK_EDGE: B:17:0x0093 -> B:19:0x0096). Please report as a decompilation issue!!! */
    /*
        Code decompiled incorrectly, please refer to instructions dump.
    */
    public static final Object d(x0 x0Var, v0 v0Var, int i10, Continuation continuation) {
        TriggerBasedInvalidationTracker$stopTrackingTable$1 triggerBasedInvalidationTracker$stopTrackingTable$1;
        String str;
        int i11;
        a0 a0Var;
        int i12;
        String[] strArr;
        x0Var.getClass();
        if (continuation instanceof TriggerBasedInvalidationTracker$stopTrackingTable$1) {
            triggerBasedInvalidationTracker$stopTrackingTable$1 = (TriggerBasedInvalidationTracker$stopTrackingTable$1) continuation;
            int i13 = triggerBasedInvalidationTracker$stopTrackingTable$1.label;
            if ((i13 & Integer.MIN_VALUE) != 0) {
                triggerBasedInvalidationTracker$stopTrackingTable$1.label = i13 - Integer.MIN_VALUE;
            } else {
                triggerBasedInvalidationTracker$stopTrackingTable$1 = new TriggerBasedInvalidationTracker$stopTrackingTable$1(x0Var, continuation);
            }
        }
        Object obj = triggerBasedInvalidationTracker$stopTrackingTable$1.result;
        CoroutineSingletons coroutineSingletons = CoroutineSingletons.f29226a;
        int i14 = triggerBasedInvalidationTracker$stopTrackingTable$1.label;
        if (i14 == 0) {
            kotlin.a.d(obj);
            str = x0Var.f4206g[i10];
            i11 = 3;
            a0Var = v0Var;
            i12 = 0;
            strArr = f4199l;
            if (i12 < i11) {
            }
        } else {
            if (i14 != 1) {
                throw new IllegalStateException("call to 'resume' before 'invoke' with coroutine");
            }
            i11 = triggerBasedInvalidationTracker$stopTrackingTable$1.I$1;
            i12 = triggerBasedInvalidationTracker$stopTrackingTable$1.I$0;
            String[] strArr2 = (String[]) triggerBasedInvalidationTracker$stopTrackingTable$1.L$2;
            str = (String) triggerBasedInvalidationTracker$stopTrackingTable$1.L$1;
            a0 a0Var2 = (a0) triggerBasedInvalidationTracker$stopTrackingTable$1.L$0;
            kotlin.a.d(obj);
            strArr = strArr2;
            a0Var = a0Var2;
            i12++;
            if (i12 < i11) {
                String str2 = "DROP TRIGGER IF EXISTS `" + ("room_table_modification_trigger_" + str + '_' + strArr[i12]) + '`';
                triggerBasedInvalidationTracker$stopTrackingTable$1.L$0 = a0Var;
                triggerBasedInvalidationTracker$stopTrackingTable$1.L$1 = str;
                triggerBasedInvalidationTracker$stopTrackingTable$1.L$2 = strArr;
                triggerBasedInvalidationTracker$stopTrackingTable$1.I$0 = i12;
                triggerBasedInvalidationTracker$stopTrackingTable$1.I$1 = i11;
                triggerBasedInvalidationTracker$stopTrackingTable$1.label = 1;
                if (ua.b.s(a0Var, str2, triggerBasedInvalidationTracker$stopTrackingTable$1) == coroutineSingletons) {
                    return coroutineSingletons;
                }
                i12++;
                if (i12 < i11) {
                    return kd.e.f29109a;
                }
            }
        }
    }

    public final void e(p pVar, p pVar2) {
        nb.g.i(pVar, "onRefreshScheduled");
        nb.g.i(pVar2, "onRefreshCompleted");
        if (this.f4209j.compareAndSet(false, true)) {
            pVar.invoke();
            hb.a.k0(this.f4200a.getCoroutineScope(), new kotlinx.coroutines.w(), new TriggerBasedInvalidationTracker$refreshInvalidationAsync$3(this, pVar2, null), 2);
        }
    }

    /* JADX WARN: Removed duplicated region for block: B:7:0x0013  */
    /*
        Code decompiled incorrectly, please refer to instructions dump.
    */
    public final Object f(Continuation continuation) throws Throwable {
        TriggerBasedInvalidationTracker$syncTriggers$1 triggerBasedInvalidationTracker$syncTriggers$1;
        f3.a aVar;
        if (continuation instanceof TriggerBasedInvalidationTracker$syncTriggers$1) {
            triggerBasedInvalidationTracker$syncTriggers$1 = (TriggerBasedInvalidationTracker$syncTriggers$1) continuation;
            int i10 = triggerBasedInvalidationTracker$syncTriggers$1.label;
            if ((i10 & Integer.MIN_VALUE) != 0) {
                triggerBasedInvalidationTracker$syncTriggers$1.label = i10 - Integer.MIN_VALUE;
            } else {
                triggerBasedInvalidationTracker$syncTriggers$1 = new TriggerBasedInvalidationTracker$syncTriggers$1(this, continuation);
            }
        }
        Object obj = triggerBasedInvalidationTracker$syncTriggers$1.result;
        CoroutineSingletons coroutineSingletons = CoroutineSingletons.f29226a;
        int i11 = triggerBasedInvalidationTracker$syncTriggers$1.label;
        if (i11 == 0) {
            kotlin.a.d(obj);
            RoomDatabase roomDatabase = this.f4200a;
            f3.a closeBarrier$room_runtime_release = roomDatabase.getCloseBarrier$room_runtime_release();
            if (closeBarrier$room_runtime_release.a()) {
                try {
                    TriggerBasedInvalidationTracker$syncTriggers$2$1 triggerBasedInvalidationTracker$syncTriggers$2$1 = new TriggerBasedInvalidationTracker$syncTriggers$2$1(this, null);
                    triggerBasedInvalidationTracker$syncTriggers$1.L$0 = closeBarrier$room_runtime_release;
                    triggerBasedInvalidationTracker$syncTriggers$1.label = 1;
                    if (roomDatabase.useConnection$room_runtime_release(false, triggerBasedInvalidationTracker$syncTriggers$2$1, triggerBasedInvalidationTracker$syncTriggers$1) == coroutineSingletons) {
                        return coroutineSingletons;
                    }
                    aVar = closeBarrier$room_runtime_release;
                    aVar.b();
                } catch (Throwable th) {
                    th = th;
                    aVar = closeBarrier$room_runtime_release;
                    aVar.b();
                    throw th;
                }
            }
        } else {
            if (i11 != 1) {
                throw new IllegalStateException("call to 'resume' before 'invoke' with coroutine");
            }
            aVar = (f3.a) triggerBasedInvalidationTracker$syncTriggers$1.L$0;
            try {
                kotlin.a.d(obj);
                aVar.b();
            } catch (Throwable th2) {
                th = th2;
                aVar.b();
                throw th;
            }
        }
        return kd.e.f29109a;
    }
}