package p037.p109;

import android.annotation.SuppressLint;
import android.database.Cursor;
import android.database.sqlite.SQLiteException;
import android.util.Log;
import androidx.lifecycle.LiveData;
import java.lang.ref.WeakReference;
import java.util.Arrays;
import java.util.Collections;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.Locale;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.Callable;
import java.util.concurrent.atomic.AtomicBoolean;
import java.util.concurrent.locks.ReentrantReadWriteLock;
import p037.p052.p053.p055.C1706;
import p037.p115.p116.C2441;
import p037.p115.p116.InterfaceC2442;
import p037.p115.p116.p117.C2449;
import p037.p115.p116.p117.C2457;
import p138.p139.p143.p144.C2803;

/* JADX INFO: renamed from: މ.ސ.ބ, reason: contains not printable characters */
/* JADX INFO: loaded from: classes.dex */
public class C2387 {

    /* JADX INFO: renamed from: ފ, reason: contains not printable characters */
    public static final String[] f7548 = {"UPDATE", "DELETE", "INSERT"};

    /* JADX INFO: renamed from: ؠ, reason: contains not printable characters */
    public final String[] f7550;

    /* JADX INFO: renamed from: ހ, reason: contains not printable characters */
    public Map<String, Set<String>> f7551;

    /* JADX INFO: renamed from: ށ, reason: contains not printable characters */
    public final AbstractC2401 f7552;

    /* JADX INFO: renamed from: ބ, reason: contains not printable characters */
    public volatile C2457 f7555;

    /* JADX INFO: renamed from: ޅ, reason: contains not printable characters */
    public C2389 f7556;

    /* JADX INFO: renamed from: ކ, reason: contains not printable characters */
    public final C2386 f7557;

    /* JADX INFO: renamed from: ވ, reason: contains not printable characters */
    public C2393 f7559;

    /* JADX INFO: renamed from: ނ, reason: contains not printable characters */
    public AtomicBoolean f7553 = new AtomicBoolean(false);

    /* JADX INFO: renamed from: ރ, reason: contains not printable characters */
    public volatile boolean f7554 = false;

    /* JADX INFO: renamed from: އ, reason: contains not printable characters */
    @SuppressLint({"RestrictedApi"})
    public final C1706<AbstractC2390, C2391> f7558 = new C1706<>();

    /* JADX INFO: renamed from: މ, reason: contains not printable characters */
    public Runnable f7560 = new RunnableC2388();

    /* JADX INFO: renamed from: ֏, reason: contains not printable characters */
    public final HashMap<String, Integer> f7549 = new HashMap<>();

    /* JADX INFO: renamed from: މ.ސ.ބ$֏, reason: contains not printable characters */
    public class RunnableC2388 implements Runnable {
        public RunnableC2388() {
        }

        @Override // java.lang.Runnable
        public void run() {
            Set<Integer> setM4466;
            ReentrantReadWriteLock.ReadLock lock = C2387.this.f7552.f7603.readLock();
            try {
                try {
                    lock.lock();
                } finally {
                    lock.unlock();
                }
            } catch (SQLiteException | IllegalStateException e) {
                e = e;
                setM4466 = null;
            }
            if (C2387.this.m4460()) {
                if (C2387.this.f7553.compareAndSet(true, false)) {
                    if (C2387.this.f7552.m4482()) {
                        return;
                    }
                    if (C2387.this.f7552.f7601) {
                        try {
                            InterfaceC2442 writableDatabase = C2387.this.f7552.f7598.getWritableDatabase();
                            ((C2449) writableDatabase).f7741.beginTransaction();
                            try {
                                setM4466 = m4466();
                                try {
                                    ((C2449) writableDatabase).f7741.setTransactionSuccessful();
                                    ((C2449) writableDatabase).f7741.endTransaction();
                                } catch (Throwable th) {
                                    th = th;
                                    ((C2449) writableDatabase).f7741.endTransaction();
                                    throw th;
                                }
                            } catch (Throwable th2) {
                                th = th2;
                            }
                        } catch (SQLiteException e2) {
                            e = e2;
                            Log.e("ROOM", "Cannot run invalidation tracker. Is the db closed?", e);
                        } catch (IllegalStateException e3) {
                            e = e3;
                            Log.e("ROOM", "Cannot run invalidation tracker. Is the db closed?", e);
                        }
                    } else {
                        setM4466 = m4466();
                    }
                    if (setM4466 != null || setM4466.isEmpty()) {
                    }
                    synchronized (C2387.this.f7558) {
                        Iterator<Map.Entry<AbstractC2390, C2391>> it = C2387.this.f7558.iterator();
                        while (true) {
                            C1706.AbstractC1711 abstractC1711 = (C1706.AbstractC1711) it;
                            if (abstractC1711.hasNext()) {
                                C2391 c2391 = (C2391) ((Map.Entry) abstractC1711.next()).getValue();
                                int length = c2391.f7568.length;
                                Set<String> hashSet = null;
                                for (int i = 0; i < length; i++) {
                                    if (setM4466.contains(Integer.valueOf(c2391.f7568[i]))) {
                                        if (length == 1) {
                                            hashSet = c2391.f7571;
                                        } else {
                                            if (hashSet == null) {
                                                hashSet = new HashSet<>(length);
                                            }
                                            hashSet.add(c2391.f7569[i]);
                                        }
                                    }
                                }
                                if (hashSet != null) {
                                    c2391.f7570.mo4471(hashSet);
                                }
                            }
                        }
                    }
                    return;
                }
                return;
            }
            return;
            Log.e("ROOM", "Cannot run invalidation tracker. Is the db closed?", e);
            if (setM4466 != null) {
            }
        }

        /* JADX INFO: renamed from: ֏, reason: contains not printable characters */
        public final Set<Integer> m4466() {
            HashSet hashSet = new HashSet();
            Cursor cursorM4474 = C2387.this.f7552.m4474(new C2441("SELECT * FROM room_table_modification_log WHERE invalidated = 1;"), null);
            while (cursorM4474.moveToNext()) {
                try {
                    hashSet.add(Integer.valueOf(cursorM4474.getInt(0)));
                } catch (Throwable th) {
                    cursorM4474.close();
                    throw th;
                }
            }
            cursorM4474.close();
            if (!hashSet.isEmpty()) {
                C2387.this.f7555.m4533();
            }
            return hashSet;
        }
    }

    /* JADX INFO: renamed from: މ.ސ.ބ$ؠ, reason: contains not printable characters */
    public static class C2389 {

        /* JADX INFO: renamed from: ֏, reason: contains not printable characters */
        public final long[] f7562;

        /* JADX INFO: renamed from: ؠ, reason: contains not printable characters */
        public final boolean[] f7563;

        /* JADX INFO: renamed from: ހ, reason: contains not printable characters */
        public final int[] f7564;

        /* JADX INFO: renamed from: ށ, reason: contains not printable characters */
        public boolean f7565;

        /* JADX INFO: renamed from: ނ, reason: contains not printable characters */
        public boolean f7566;

        public C2389(int i) {
            long[] jArr = new long[i];
            this.f7562 = jArr;
            this.f7563 = new boolean[i];
            this.f7564 = new int[i];
            Arrays.fill(jArr, 0L);
            Arrays.fill(this.f7563, false);
        }

        /* JADX INFO: renamed from: ֏, reason: contains not printable characters */
        public boolean m4467(int... iArr) {
            boolean z;
            synchronized (this) {
                z = false;
                for (int i : iArr) {
                    long j = this.f7562[i];
                    this.f7562[i] = 1 + j;
                    if (j == 0) {
                        this.f7565 = true;
                        z = true;
                    }
                }
            }
            return z;
        }

        /* JADX INFO: renamed from: ֏, reason: contains not printable characters */
        public int[] m4468() {
            synchronized (this) {
                if (this.f7565 && !this.f7566) {
                    int length = this.f7562.length;
                    int i = 0;
                    while (true) {
                        int i2 = 1;
                        if (i >= length) {
                            this.f7566 = true;
                            this.f7565 = false;
                            return this.f7564;
                        }
                        boolean z = this.f7562[i] > 0;
                        if (z != this.f7563[i]) {
                            int[] iArr = this.f7564;
                            if (!z) {
                                i2 = 2;
                            }
                            iArr[i] = i2;
                        } else {
                            this.f7564[i] = 0;
                        }
                        this.f7563[i] = z;
                        i++;
                    }
                }
                return null;
            }
        }

        /* JADX INFO: renamed from: ؠ, reason: contains not printable characters */
        public void m4469() {
            synchronized (this) {
                this.f7566 = false;
            }
        }

        /* JADX INFO: renamed from: ؠ, reason: contains not printable characters */
        public boolean m4470(int... iArr) {
            boolean z;
            synchronized (this) {
                z = false;
                for (int i : iArr) {
                    long j = this.f7562[i];
                    this.f7562[i] = j - 1;
                    if (j == 1) {
                        this.f7565 = true;
                        z = true;
                    }
                }
            }
            return z;
        }
    }

    /* JADX INFO: renamed from: މ.ސ.ބ$ހ, reason: contains not printable characters */
    public static abstract class AbstractC2390 {

        /* JADX INFO: renamed from: ֏, reason: contains not printable characters */
        public final String[] f7567;

        public AbstractC2390(String[] strArr) {
            this.f7567 = (String[]) Arrays.copyOf(strArr, strArr.length);
        }

        /* JADX INFO: renamed from: ֏, reason: contains not printable characters */
        public abstract void mo4471(Set<String> set);

        /* JADX INFO: renamed from: ֏, reason: contains not printable characters */
        public boolean mo4472() {
            return false;
        }
    }

    /* JADX INFO: renamed from: މ.ސ.ބ$ށ, reason: contains not printable characters */
    public static class C2391 {

        /* JADX INFO: renamed from: ֏, reason: contains not printable characters */
        public final int[] f7568;

        /* JADX INFO: renamed from: ؠ, reason: contains not printable characters */
        public final String[] f7569;

        /* JADX INFO: renamed from: ހ, reason: contains not printable characters */
        public final AbstractC2390 f7570;

        /* JADX INFO: renamed from: ށ, reason: contains not printable characters */
        public final Set<String> f7571;

        public C2391(AbstractC2390 abstractC2390, int[] iArr, String[] strArr) {
            this.f7570 = abstractC2390;
            this.f7568 = iArr;
            this.f7569 = strArr;
            if (iArr.length != 1) {
                this.f7571 = null;
                return;
            }
            HashSet hashSet = new HashSet();
            hashSet.add(this.f7569[0]);
            this.f7571 = Collections.unmodifiableSet(hashSet);
        }

        /* JADX INFO: renamed from: ֏, reason: contains not printable characters */
        public void m4473(String[] strArr) {
            Set<String> set = null;
            if (this.f7569.length == 1) {
                int length = strArr.length;
                int i = 0;
                while (true) {
                    if (i >= length) {
                        break;
                    }
                    if (strArr[i].equalsIgnoreCase(this.f7569[0])) {
                        set = this.f7571;
                        break;
                    }
                    i++;
                }
            } else {
                HashSet hashSet = new HashSet();
                for (String str : strArr) {
                    String[] strArr2 = this.f7569;
                    int length2 = strArr2.length;
                    int i2 = 0;
                    while (true) {
                        if (i2 < length2) {
                            String str2 = strArr2[i2];
                            if (str2.equalsIgnoreCase(str)) {
                                hashSet.add(str2);
                                break;
                            }
                            i2++;
                        }
                    }
                }
                if (hashSet.size() > 0) {
                    set = hashSet;
                }
            }
            if (set != null) {
                this.f7570.mo4471(set);
            }
        }
    }

    /* JADX INFO: renamed from: މ.ސ.ބ$ނ, reason: contains not printable characters */
    public static class C2392 extends AbstractC2390 {

        /* JADX INFO: renamed from: ؠ, reason: contains not printable characters */
        public final C2387 f7572;

        /* JADX INFO: renamed from: ހ, reason: contains not printable characters */
        public final WeakReference<AbstractC2390> f7573;

        public C2392(C2387 c2387, AbstractC2390 abstractC2390) {
            super(abstractC2390.f7567);
            this.f7572 = c2387;
            this.f7573 = new WeakReference<>(abstractC2390);
        }

        @Override // p037.p109.C2387.AbstractC2390
        /* JADX INFO: renamed from: ֏ */
        public void mo4471(Set<String> set) {
            AbstractC2390 abstractC2390 = this.f7573.get();
            if (abstractC2390 == null) {
                this.f7572.m4462(this);
            } else {
                abstractC2390.mo4471(set);
            }
        }
    }

    public C2387(AbstractC2401 abstractC2401, Map<String, String> map, Map<String, Set<String>> map2, String... strArr) {
        this.f7552 = abstractC2401;
        this.f7556 = new C2389(strArr.length);
        this.f7551 = map2;
        this.f7557 = new C2386(this.f7552);
        int length = strArr.length;
        this.f7550 = new String[length];
        for (int i = 0; i < length; i++) {
            String lowerCase = strArr[i].toLowerCase(Locale.US);
            this.f7549.put(lowerCase, Integer.valueOf(i));
            String str = map.get(strArr[i]);
            if (str != null) {
                this.f7550[i] = str.toLowerCase(Locale.US);
            } else {
                this.f7550[i] = lowerCase;
            }
        }
        for (Map.Entry<String, String> entry : map.entrySet()) {
            String lowerCase2 = entry.getValue().toLowerCase(Locale.US);
            if (this.f7549.containsKey(lowerCase2)) {
                String lowerCase3 = entry.getKey().toLowerCase(Locale.US);
                HashMap<String, Integer> map3 = this.f7549;
                map3.put(lowerCase3, map3.get(lowerCase2));
            }
        }
    }

    /* JADX INFO: renamed from: ֏, reason: contains not printable characters */
    public <T> LiveData<T> m4455(String[] strArr, boolean z, Callable<T> callable) {
        C2386 c2386 = this.f7557;
        String[] strArrM4465 = m4465(strArr);
        for (String str : strArrM4465) {
            if (!this.f7549.containsKey(str.toLowerCase(Locale.US))) {
                throw new IllegalArgumentException(C2803.m4879("There is no table with name ", str));
            }
        }
        if (c2386 != null) {
            return new C2410(c2386.f7547, c2386, z, callable, strArrM4465);
        }
        throw null;
    }

    @SuppressLint({"RestrictedApi"})
    /* JADX INFO: renamed from: ֏, reason: contains not printable characters */
    public void m4456(AbstractC2390 abstractC2390) {
        C2391 c2391Mo3327;
        String[] strArrM4465 = m4465(abstractC2390.f7567);
        int[] iArr = new int[strArrM4465.length];
        int length = strArrM4465.length;
        for (int i = 0; i < length; i++) {
            Integer num = this.f7549.get(strArrM4465[i].toLowerCase(Locale.US));
            if (num == null) {
                StringBuilder sbM4889 = C2803.m4889("There is no table with name ");
                sbM4889.append(strArrM4465[i]);
                throw new IllegalArgumentException(sbM4889.toString());
            }
            iArr[i] = num.intValue();
        }
        C2391 c2391 = new C2391(abstractC2390, iArr, strArrM4465);
        synchronized (this.f7558) {
            c2391Mo3327 = this.f7558.mo3327(abstractC2390, c2391);
        }
        if (c2391Mo3327 == null && this.f7556.m4467(iArr)) {
            m4461();
        }
    }

    /* JADX INFO: renamed from: ֏, reason: contains not printable characters */
    public void m4457(InterfaceC2442 interfaceC2442) {
        synchronized (this) {
            if (this.f7554) {
                Log.e("ROOM", "Invalidation tracker is initialized twice :/.");
                return;
            }
            ((C2449) interfaceC2442).f7741.execSQL("PRAGMA temp_store = MEMORY;");
            ((C2449) interfaceC2442).f7741.execSQL("PRAGMA recursive_triggers='ON';");
            ((C2449) interfaceC2442).f7741.execSQL("CREATE TEMP TABLE room_table_modification_log(table_id INTEGER PRIMARY KEY, invalidated INTEGER NOT NULL DEFAULT 0)");
            m4463(interfaceC2442);
            this.f7555 = new C2457(((C2449) interfaceC2442).f7741.compileStatement("UPDATE room_table_modification_log SET invalidated = 0 WHERE invalidated = 1 "));
            this.f7554 = true;
        }
    }

    /* JADX INFO: renamed from: ֏, reason: contains not printable characters */
    public final void m4458(InterfaceC2442 interfaceC2442, int i) {
        C2449 c2449 = (C2449) interfaceC2442;
        c2449.f7741.execSQL(C2803.m4872("INSERT OR IGNORE INTO room_table_modification_log VALUES(", i, ", 0)"));
        String str = this.f7550[i];
        StringBuilder sb = new StringBuilder();
        for (String str2 : f7548) {
            sb.setLength(0);
            sb.append("CREATE TEMP TRIGGER IF NOT EXISTS ");
            sb.append("`");
            sb.append("room_table_modification_trigger_");
            C2803.m4893(sb, str, "_", str2, "`");
            C2803.m4893(sb, " AFTER ", str2, " ON `", str);
            C2803.m4893(sb, "` BEGIN UPDATE ", "room_table_modification_log", " SET ", "invalidated");
            C2803.m4893(sb, " = 1", " WHERE ", "table_id", " = ");
            sb.append(i);
            sb.append(" AND ");
            sb.append("invalidated");
            sb.append(" = 0");
            sb.append("; END");
            c2449.f7741.execSQL(sb.toString());
        }
    }

    /* JADX INFO: renamed from: ֏, reason: contains not printable characters */
    public void m4459(String... strArr) {
        synchronized (this.f7558) {
            Iterator<Map.Entry<AbstractC2390, C2391>> it = this.f7558.iterator();
            while (true) {
                C1706.AbstractC1711 abstractC1711 = (C1706.AbstractC1711) it;
                if (abstractC1711.hasNext()) {
                    Map.Entry entry = (Map.Entry) abstractC1711.next();
                    if (!((AbstractC2390) entry.getKey()).mo4472()) {
                        ((C2391) entry.getValue()).m4473(strArr);
                    }
                }
            }
        }
    }

    /* JADX INFO: renamed from: ֏, reason: contains not printable characters */
    public boolean m4460() {
        if (!this.f7552.m4483()) {
            return false;
        }
        if (!this.f7554) {
            this.f7552.f7598.getWritableDatabase();
        }
        if (this.f7554) {
            return true;
        }
        Log.e("ROOM", "database is not initialized even though it is open");
        return false;
    }

    /* JADX INFO: renamed from: ؠ, reason: contains not printable characters */
    public void m4461() {
        if (this.f7552.m4483()) {
            m4463(this.f7552.f7598.getWritableDatabase());
        }
    }

    @SuppressLint({"RestrictedApi"})
    /* JADX INFO: renamed from: ؠ, reason: contains not printable characters */
    public void m4462(AbstractC2390 abstractC2390) {
        C2391 c2391Remove;
        synchronized (this.f7558) {
            c2391Remove = this.f7558.remove(abstractC2390);
        }
        if (c2391Remove == null || !this.f7556.m4470(c2391Remove.f7568)) {
            return;
        }
        m4461();
    }

    /* JADX INFO: renamed from: ؠ, reason: contains not printable characters */
    public void m4463(InterfaceC2442 interfaceC2442) {
        if (((C2449) interfaceC2442).f7741.inTransaction()) {
            return;
        }
        while (true) {
            try {
                ReentrantReadWriteLock.ReadLock lock = this.f7552.f7603.readLock();
                lock.lock();
                try {
                    int[] iArrM4468 = this.f7556.m4468();
                    if (iArrM4468 == null) {
                        return;
                    }
                    int length = iArrM4468.length;
                    ((C2449) interfaceC2442).f7741.beginTransaction();
                    for (int i = 0; i < length; i++) {
                        try {
                            int i2 = iArrM4468[i];
                            if (i2 == 1) {
                                m4458(interfaceC2442, i);
                            } else if (i2 == 2) {
                                m4464(interfaceC2442, i);
                            }
                        } finally {
                        }
                    }
                    ((C2449) interfaceC2442).f7741.setTransactionSuccessful();
                    ((C2449) interfaceC2442).f7741.endTransaction();
                    this.f7556.m4469();
                } finally {
                    lock.unlock();
                }
            } catch (SQLiteException | IllegalStateException e) {
                Log.e("ROOM", "Cannot run invalidation tracker. Is the db closed?", e);
                return;
            }
        }
    }

    /* JADX INFO: renamed from: ؠ, reason: contains not printable characters */
    public final void m4464(InterfaceC2442 interfaceC2442, int i) {
        String str = this.f7550[i];
        StringBuilder sb = new StringBuilder();
        for (String str2 : f7548) {
            sb.setLength(0);
            sb.append("DROP TRIGGER IF EXISTS ");
            sb.append("`");
            sb.append("room_table_modification_trigger_");
            sb.append(str);
            sb.append("_");
            sb.append(str2);
            sb.append("`");
            ((C2449) interfaceC2442).f7741.execSQL(sb.toString());
        }
    }

    /* JADX INFO: renamed from: ؠ, reason: contains not printable characters */
    public final String[] m4465(String[] strArr) {
        HashSet hashSet = new HashSet();
        for (String str : strArr) {
            String lowerCase = str.toLowerCase(Locale.US);
            if (this.f7551.containsKey(lowerCase)) {
                hashSet.addAll(this.f7551.get(lowerCase));
            } else {
                hashSet.add(str);
            }
        }
        return (String[]) hashSet.toArray(new String[hashSet.size()]);
    }
}