package p037.p109;

import android.annotation.SuppressLint;
import android.app.ActivityManager;
import android.content.Context;
import android.database.Cursor;
import android.os.CancellationSignal;
import android.os.Looper;
import android.util.Log;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Set;
import java.util.TreeMap;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.Executor;
import java.util.concurrent.locks.ReentrantReadWriteLock;
import p037.p052.p053.p054.C1700;
import p037.p109.p110.AbstractC2419;
import p037.p115.p116.InterfaceC2442;
import p037.p115.p116.InterfaceC2443;
import p037.p115.p116.InterfaceC2448;
import p037.p115.p116.p117.C2449;
import p037.p115.p116.p117.C2451;
import p037.p115.p116.p117.C2455;
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 abstract class AbstractC2401 {

    /* JADX INFO: renamed from: ֏, reason: contains not printable characters */
    @Deprecated
    public volatile InterfaceC2442 f7595;

    /* JADX INFO: renamed from: ؠ, reason: contains not printable characters */
    public Executor f7596;

    /* JADX INFO: renamed from: ހ, reason: contains not printable characters */
    public Executor f7597;

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

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

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

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

    /* JADX INFO: renamed from: ޅ, reason: contains not printable characters */
    @Deprecated
    public List<AbstractC2403> f7602;

    /* JADX INFO: renamed from: ކ, reason: contains not printable characters */
    public final ReentrantReadWriteLock f7603 = new ReentrantReadWriteLock();

    /* JADX INFO: renamed from: އ, reason: contains not printable characters */
    public final ThreadLocal<Integer> f7604 = new ThreadLocal<>();

    /* JADX INFO: renamed from: މ.ސ.ކ$֏, reason: contains not printable characters */
    public static class C2402<T extends AbstractC2401> {

        /* JADX INFO: renamed from: ֏, reason: contains not printable characters */
        public final Class<T> f7605;

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

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

        /* JADX INFO: renamed from: ށ, reason: contains not printable characters */
        public ArrayList<AbstractC2403> f7608;

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

        /* JADX INFO: renamed from: ރ, reason: contains not printable characters */
        public Executor f7610;

        /* JADX INFO: renamed from: ބ, reason: contains not printable characters */
        public InterfaceC2443.InterfaceC2446 f7611;

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

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

        /* JADX INFO: renamed from: ފ, reason: contains not printable characters */
        public Set<Integer> f7617;

        /* JADX INFO: renamed from: ކ, reason: contains not printable characters */
        public EnumC2404 f7613 = EnumC2404.AUTOMATIC;

        /* JADX INFO: renamed from: އ, reason: contains not printable characters */
        public boolean f7614 = true;

        /* JADX INFO: renamed from: މ, reason: contains not printable characters */
        public final C2405 f7616 = new C2405();

        public C2402(Context context, Class<T> cls, String str) {
            this.f7607 = context;
            this.f7605 = cls;
            this.f7606 = str;
        }

        /* JADX INFO: renamed from: ֏, reason: contains not printable characters */
        public C2402<T> m4485(AbstractC2419... abstractC2419Arr) {
            if (this.f7617 == null) {
                this.f7617 = new HashSet();
            }
            for (AbstractC2419 abstractC2419 : abstractC2419Arr) {
                this.f7617.add(Integer.valueOf(abstractC2419.f7668));
                this.f7617.add(Integer.valueOf(abstractC2419.f7669));
            }
            C2405 c2405 = this.f7616;
            if (c2405 == null) {
                throw null;
            }
            for (AbstractC2419 abstractC24192 : abstractC2419Arr) {
                int i = abstractC24192.f7668;
                int i2 = abstractC24192.f7669;
                TreeMap<Integer, AbstractC2419> treeMap = c2405.f7622.get(Integer.valueOf(i));
                if (treeMap == null) {
                    treeMap = new TreeMap<>();
                    c2405.f7622.put(Integer.valueOf(i), treeMap);
                }
                AbstractC2419 abstractC24193 = treeMap.get(Integer.valueOf(i2));
                if (abstractC24193 != null) {
                    Log.w("ROOM", "Overriding migration " + abstractC24193 + " with " + abstractC24192);
                }
                treeMap.put(Integer.valueOf(i2), abstractC24192);
            }
            return this;
        }

        @SuppressLint({"RestrictedApi"})
        /* JADX INFO: renamed from: ֏, reason: contains not printable characters */
        public T m4486() {
            Executor executor;
            String str;
            if (this.f7607 == null) {
                throw new IllegalArgumentException("Cannot provide null context for the database.");
            }
            if (this.f7605 == null) {
                throw new IllegalArgumentException("Must provide an abstract class that extends RoomDatabase");
            }
            if (this.f7609 == null && this.f7610 == null) {
                Executor executor2 = C1700.f5542;
                this.f7610 = executor2;
                this.f7609 = executor2;
            } else {
                Executor executor3 = this.f7609;
                if (executor3 != null && this.f7610 == null) {
                    this.f7610 = executor3;
                } else if (this.f7609 == null && (executor = this.f7610) != null) {
                    this.f7609 = executor;
                }
            }
            if (this.f7611 == null) {
                this.f7611 = new C2455();
            }
            Context context = this.f7607;
            String str2 = this.f7606;
            InterfaceC2443.InterfaceC2446 interfaceC2446 = this.f7611;
            C2405 c2405 = this.f7616;
            ArrayList<AbstractC2403> arrayList = this.f7608;
            boolean z = this.f7612;
            EnumC2404 enumC2404 = this.f7613;
            if (enumC2404 == null) {
                throw null;
            }
            if (enumC2404 == EnumC2404.AUTOMATIC) {
                ActivityManager activityManager = (ActivityManager) context.getSystemService("activity");
                enumC2404 = (activityManager == null || activityManager.isLowRamDevice()) ? EnumC2404.TRUNCATE : EnumC2404.WRITE_AHEAD_LOGGING;
            }
            C2377 c2377 = new C2377(context, str2, interfaceC2446, c2405, arrayList, z, enumC2404, this.f7609, this.f7610, false, this.f7614, this.f7615, null, null, null);
            Class<T> cls = this.f7605;
            String name = cls.getPackage().getName();
            String canonicalName = cls.getCanonicalName();
            if (!name.isEmpty()) {
                canonicalName = canonicalName.substring(name.length() + 1);
            }
            String str3 = canonicalName.replace('.', '_') + "_Impl";
            try {
                if (name.isEmpty()) {
                    str = str3;
                } else {
                    str = name + "." + str3;
                }
                T t = (T) Class.forName(str).newInstance();
                InterfaceC2443 interfaceC2443Mo856 = t.mo856(c2377);
                t.f7598 = interfaceC2443Mo856;
                if (interfaceC2443Mo856 instanceof C2414) {
                    ((C2414) interfaceC2443Mo856).f7656 = c2377;
                }
                boolean z2 = c2377.f7537 == EnumC2404.WRITE_AHEAD_LOGGING;
                t.f7598.setWriteAheadLoggingEnabled(z2);
                t.f7602 = c2377.f7535;
                t.f7596 = c2377.f7538;
                t.f7597 = new ExecutorC2417(c2377.f7539);
                t.f7600 = c2377.f7536;
                t.f7601 = z2;
                if (c2377.f7540) {
                    C2387 c2387 = t.f7599;
                    c2387.f7559 = new C2393(c2377.f7532, c2377.f7533, c2387, c2387.f7552.f7596);
                }
                return t;
            } catch (ClassNotFoundException unused) {
                StringBuilder sbM4889 = C2803.m4889("cannot find implementation for ");
                sbM4889.append(cls.getCanonicalName());
                sbM4889.append(". ");
                sbM4889.append(str3);
                sbM4889.append(" does not exist");
                throw new RuntimeException(sbM4889.toString());
            } catch (IllegalAccessException unused2) {
                StringBuilder sbM48892 = C2803.m4889("Cannot access the constructor");
                sbM48892.append(cls.getCanonicalName());
                throw new RuntimeException(sbM48892.toString());
            } catch (InstantiationException unused3) {
                StringBuilder sbM48893 = C2803.m4889("Failed to create an instance of ");
                sbM48893.append(cls.getCanonicalName());
                throw new RuntimeException(sbM48893.toString());
            }
        }
    }

    /* JADX INFO: renamed from: މ.ސ.ކ$ؠ, reason: contains not printable characters */
    public static abstract class AbstractC2403 {
        /* JADX INFO: renamed from: ֏, reason: contains not printable characters */
        public void mo4487(InterfaceC2442 interfaceC2442) {
        }
    }

    /* JADX INFO: renamed from: މ.ސ.ކ$ހ, reason: contains not printable characters */
    public enum EnumC2404 {
        AUTOMATIC,
        TRUNCATE,
        WRITE_AHEAD_LOGGING
    }

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

        /* JADX INFO: renamed from: ֏, reason: contains not printable characters */
        public HashMap<Integer, TreeMap<Integer, AbstractC2419>> f7622 = new HashMap<>();
    }

    public AbstractC2401() {
        new ConcurrentHashMap();
        this.f7599 = mo857();
    }

    /* JADX INFO: renamed from: ֏, reason: contains not printable characters */
    public Cursor m4474(InterfaceC2448 interfaceC2448, CancellationSignal cancellationSignal) {
        m4476();
        m4478();
        if (cancellationSignal == null) {
            return ((C2449) this.f7598.getWritableDatabase()).m4525(interfaceC2448);
        }
        C2449 c2449 = (C2449) this.f7598.getWritableDatabase();
        return c2449.f7741.rawQueryWithFactory(new C2451(c2449, interfaceC2448), interfaceC2448.mo4491(), C2449.f7740, null, cancellationSignal);
    }

    /* JADX INFO: renamed from: ֏ */
    public abstract InterfaceC2443 mo856(C2377 c2377);

    /* JADX INFO: renamed from: ֏, reason: contains not printable characters */
    public C2457 m4475(String str) {
        m4476();
        m4478();
        return new C2457(((C2449) this.f7598.getWritableDatabase()).f7741.compileStatement(str));
    }

    /* JADX INFO: renamed from: ֏, reason: contains not printable characters */
    public void m4476() {
        if (this.f7600) {
            return;
        }
        if (Looper.getMainLooper().getThread() == Thread.currentThread()) {
            throw new IllegalStateException("Cannot access database on the main thread since it may potentially lock the UI for a long period of time.");
        }
    }

    /* JADX INFO: renamed from: ֏, reason: contains not printable characters */
    public void m4477(Runnable runnable) {
        m4479();
        try {
            runnable.run();
            m4484();
        } finally {
            m4481();
        }
    }

    /* JADX INFO: renamed from: ؠ, reason: contains not printable characters */
    public void m4478() {
        if (!m4482() && this.f7604.get() != null) {
            throw new IllegalStateException("Cannot access database on a different coroutine context inherited from a suspending transaction.");
        }
    }

    @Deprecated
    /* JADX INFO: renamed from: ހ, reason: contains not printable characters */
    public void m4479() {
        m4476();
        InterfaceC2442 writableDatabase = this.f7598.getWritableDatabase();
        this.f7599.m4463(writableDatabase);
        ((C2449) writableDatabase).f7741.beginTransaction();
    }

    /* JADX INFO: renamed from: ށ, reason: contains not printable characters */
    public void m4480() {
        if (m4483()) {
            ReentrantReadWriteLock.WriteLock writeLock = this.f7603.writeLock();
            try {
                writeLock.lock();
                C2387 c2387 = this.f7599;
                C2393 c2393 = c2387.f7559;
                if (c2393 != null) {
                    if (c2393.f7582.compareAndSet(false, true)) {
                        c2393.f7580.execute(c2393.f7586);
                    }
                    c2387.f7559 = null;
                }
                this.f7598.close();
            } finally {
                writeLock.unlock();
            }
        }
    }

    /* JADX INFO: renamed from: ނ */
    public abstract C2387 mo857();

    @Deprecated
    /* JADX INFO: renamed from: ރ, reason: contains not printable characters */
    public void m4481() {
        ((C2449) this.f7598.getWritableDatabase()).f7741.endTransaction();
        if (m4482()) {
            return;
        }
        C2387 c2387 = this.f7599;
        if (c2387.f7553.compareAndSet(false, true)) {
            c2387.f7552.f7596.execute(c2387.f7560);
        }
    }

    /* JADX INFO: renamed from: ބ, reason: contains not printable characters */
    public boolean m4482() {
        return ((C2449) this.f7598.getWritableDatabase()).f7741.inTransaction();
    }

    /* JADX INFO: renamed from: ޅ, reason: contains not printable characters */
    public boolean m4483() {
        InterfaceC2442 interfaceC2442 = this.f7595;
        return interfaceC2442 != null && ((C2449) interfaceC2442).f7741.isOpen();
    }

    @Deprecated
    /* JADX INFO: renamed from: ކ, reason: contains not printable characters */
    public void m4484() {
        ((C2449) this.f7598.getWritableDatabase()).f7741.setTransactionSuccessful();
    }
}