package org.greenrobot.greendao;

import android.database.CrossProcessCursor;
import android.database.Cursor;
import android.database.CursorWindow;
import android.database.sqlite.SQLiteDatabase;
import android.database.sqlite.SQLiteStatement;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Iterator;
import java.util.List;
import org.greenrobot.greendao.database.Database;
import org.greenrobot.greendao.database.DatabaseStatement;
import org.greenrobot.greendao.identityscope.IdentityScope;
import org.greenrobot.greendao.identityscope.IdentityScopeLong;
import org.greenrobot.greendao.internal.DaoConfig;
import org.greenrobot.greendao.internal.TableStatements;
import org.greenrobot.greendao.query.QueryBuilder;

/* loaded from: classes2.dex */
public abstract class AbstractDao<T, K> {
    protected final DaoConfig a;
    protected final Database b;
    protected final boolean c;
    protected final IdentityScope<K, T> d;
    protected final IdentityScopeLong<T> e;
    protected final TableStatements f;
    protected final AbstractDaoSession g;
    protected final int h;

    public AbstractDao(DaoConfig daoConfig, AbstractDaoSession abstractDaoSession) {
        this.a = daoConfig;
        this.g = abstractDaoSession;
        this.b = daoConfig.a;
        this.c = this.b.b() instanceof SQLiteDatabase;
        this.d = (IdentityScope<K, T>) daoConfig.a();
        IdentityScope<K, T> identityScope = this.d;
        if (identityScope instanceof IdentityScopeLong) {
            this.e = (IdentityScopeLong) identityScope;
        } else {
            this.e = null;
        }
        this.f = daoConfig.i;
        Property property = daoConfig.g;
        this.h = property != null ? property.a : -1;
    }

    public T a(long j) {
        return d(this.b.a(this.f.f(), new String[]{Long.toString(j)}));
    }

    protected abstract T a(Cursor cursor, int i);

    protected abstract K a(T t, long j);

    protected abstract void a(Cursor cursor, T t, int i);

    protected abstract void a(SQLiteStatement sQLiteStatement, T t);

    protected void a(T t) {
    }

    protected abstract void a(DatabaseStatement databaseStatement, T t);

    protected abstract K b(Cursor cursor, int i);

    public void b(Iterable<T> iterable) {
        a(iterable, i());
    }

    public String[] c() {
        return this.a.d;
    }

    protected T d(Cursor cursor) {
        try {
            return c(cursor);
        } finally {
            cursor.close();
        }
    }

    protected abstract K d(T t);

    public Property e() {
        return this.a.g;
    }

    public Property[] f() {
        return this.a.c;
    }

    public AbstractDaoSession g() {
        return this.g;
    }

    public String h() {
        return this.a.b;
    }

    public void i(T t) {
        a();
        K e = e((AbstractDao<T, K>) t);
        Cursor a = this.b.a(this.f.e(), new String[]{e.toString()});
        try {
            if (!a.moveToFirst()) {
                throw new DaoException("Entity does not exist in the database anymore: " + t.getClass() + " with key " + e);
            }
            if (a.isLast()) {
                a(a, (Cursor) t, 0);
                a((AbstractDao<T, K>) e, (K) t, true);
            } else {
                throw new DaoException("Expected unique result, but count was " + a.getCount());
            }
        } finally {
            a.close();
        }
    }

    protected abstract boolean i();

    public List<T> j() {
        return a(this.b.a(this.f.d(), null));
    }

    public QueryBuilder<T> k() {
        return QueryBuilder.a(this);
    }

    private CursorWindow e(Cursor cursor) {
        this.d.unlock();
        try {
            return cursor.moveToNext() ? ((CrossProcessCursor) cursor).getWindow() : null;
        } finally {
            this.d.lock();
        }
    }

    public void b(Iterable<T> iterable, boolean z) {
        a(this.f.b(), (Iterable) iterable, z);
    }

    protected T c(Cursor cursor) {
        if (!cursor.moveToFirst()) {
            return null;
        }
        if (cursor.isLast()) {
            return a(cursor, 0, true);
        }
        throw new DaoException("Expected unique result, but count was " + cursor.getCount());
    }

    public long f(T t) {
        return b(t, this.f.c(), true);
    }

    public long g(T t) {
        return b(t, this.f.b(), true);
    }

    public T h(K k) {
        T t;
        a();
        if (k == null) {
            return null;
        }
        IdentityScope<K, T> identityScope = this.d;
        return (identityScope == null || (t = identityScope.get(k)) == null) ? d(this.b.a(this.f.e(), new String[]{k.toString()})) : t;
    }

    public void j(T t) {
        a();
        DatabaseStatement g = this.f.g();
        if (this.b.d()) {
            synchronized (g) {
                if (this.c) {
                    a((AbstractDao<T, K>) t, (SQLiteStatement) g.b(), true);
                } else {
                    a((AbstractDao<T, K>) t, g, true);
                }
            }
            return;
        }
        this.b.a();
        try {
            synchronized (g) {
                a((AbstractDao<T, K>) t, g, true);
            }
            this.b.c();
        } finally {
            this.b.e();
        }
    }

    private long b(T t, DatabaseStatement databaseStatement, boolean z) {
        long b;
        if (this.b.d()) {
            b = b((AbstractDao<T, K>) t, databaseStatement);
        } else {
            this.b.a();
            try {
                b = b((AbstractDao<T, K>) t, databaseStatement);
                this.b.c();
            } finally {
                this.b.e();
            }
        }
        if (z) {
            a((AbstractDao<T, K>) t, b, true);
        }
        return b;
    }

    protected List<T> a(Cursor cursor) {
        try {
            return b(cursor);
        } finally {
            cursor.close();
        }
    }

    public void d(Iterable<T> iterable) {
        DatabaseStatement g = this.f.g();
        this.b.a();
        try {
            synchronized (g) {
                if (this.d != null) {
                    this.d.lock();
                }
                try {
                    if (this.c) {
                        SQLiteStatement sQLiteStatement = (SQLiteStatement) g.b();
                        Iterator<T> it = iterable.iterator();
                        while (it.hasNext()) {
                            a((AbstractDao<T, K>) it.next(), sQLiteStatement, false);
                        }
                    } else {
                        Iterator<T> it2 = iterable.iterator();
                        while (it2.hasNext()) {
                            a((AbstractDao<T, K>) it2.next(), g, false);
                        }
                    }
                } finally {
                    if (this.d != null) {
                        this.d.unlock();
                    }
                }
            }
            this.b.c();
        } catch (RuntimeException e) {
            e = e;
            try {
                this.b.e();
            } catch (RuntimeException e2) {
                DaoLog.b("Could not end transaction (rethrowing initial exception)", e2);
                throw e;
            }
        } catch (Throwable th) {
            try {
                this.b.e();
                throw th;
            } catch (RuntimeException e3) {
                throw e3;
            }
        }
        try {
            this.b.e();
            e = null;
            if (e != null) {
                throw e;
            }
        } catch (RuntimeException e4) {
            throw e4;
        }
    }

    public void c(Iterable<T> iterable) {
        b(iterable, i());
    }

    public void a(Iterable<T> iterable, boolean z) {
        a(this.f.c(), (Iterable) iterable, z);
    }

    public void c(K k) {
        a();
        DatabaseStatement a = this.f.a();
        if (this.b.d()) {
            synchronized (a) {
                a((AbstractDao<T, K>) k, a);
            }
        } else {
            this.b.a();
            try {
                synchronized (a) {
                    a((AbstractDao<T, K>) k, a);
                }
                this.b.c();
            } finally {
                this.b.e();
            }
        }
        IdentityScope<K, T> identityScope = this.d;
        if (identityScope != null) {
            identityScope.remove(k);
        }
    }

    protected K e(T t) {
        K d = d((AbstractDao<T, K>) t);
        if (d != null) {
            return d;
        }
        if (t == null) {
            throw new NullPointerException("Entity may not be null");
        }
        throw new DaoException("Entity has no key");
    }

    public void a(T... tArr) {
        b(Arrays.asList(tArr), i());
    }

    private void a(DatabaseStatement databaseStatement, Iterable<T> iterable, boolean z) {
        this.b.a();
        try {
            synchronized (databaseStatement) {
                if (this.d != null) {
                    this.d.lock();
                }
                try {
                    if (this.c) {
                        SQLiteStatement sQLiteStatement = (SQLiteStatement) databaseStatement.b();
                        for (T t : iterable) {
                            a(sQLiteStatement, (SQLiteStatement) t);
                            if (z) {
                                a((AbstractDao<T, K>) t, sQLiteStatement.executeInsert(), false);
                            } else {
                                sQLiteStatement.execute();
                            }
                        }
                    } else {
                        for (T t2 : iterable) {
                            a(databaseStatement, (DatabaseStatement) t2);
                            if (z) {
                                a((AbstractDao<T, K>) t2, databaseStatement.c(), false);
                            } else {
                                databaseStatement.execute();
                            }
                        }
                    }
                } finally {
                    if (this.d != null) {
                        this.d.unlock();
                    }
                }
            }
            this.b.c();
        } finally {
            this.b.e();
        }
    }

    private long b(T t, DatabaseStatement databaseStatement) {
        synchronized (databaseStatement) {
            if (this.c) {
                SQLiteStatement sQLiteStatement = (SQLiteStatement) databaseStatement.b();
                a(sQLiteStatement, (SQLiteStatement) t);
                return sQLiteStatement.executeInsert();
            }
            a(databaseStatement, (DatabaseStatement) t);
            return databaseStatement.c();
        }
    }

    /* JADX WARN: Removed duplicated region for block: B:15:0x0054  */
    /* JADX WARN: Removed duplicated region for block: B:26:0x007d  */
    /*
        Code decompiled incorrectly, please refer to instructions dump.
        To view partially-correct code enable 'Show inconsistent code' option in preferences
    */
    protected java.util.List<T> b(android.database.Cursor r7) {
        /*
            r6 = this;
            int r0 = r7.getCount()
            if (r0 != 0) goto Lc
            java.util.ArrayList r7 = new java.util.ArrayList
            r7.<init>()
            return r7
        Lc:
            java.util.ArrayList r1 = new java.util.ArrayList
            r1.<init>(r0)
            r2 = 0
            boolean r3 = r7 instanceof android.database.CrossProcessCursor
            r4 = 0
            if (r3 == 0) goto L4d
            r2 = r7
            android.database.CrossProcessCursor r2 = (android.database.CrossProcessCursor) r2
            android.database.CursorWindow r2 = r2.getWindow()
            if (r2 == 0) goto L4d
            int r3 = r2.getNumRows()
            if (r3 != r0) goto L2d
            org.greenrobot.greendao.internal.FastCursor r7 = new org.greenrobot.greendao.internal.FastCursor
            r7.<init>(r2)
            r3 = 1
            goto L4e
        L2d:
            java.lang.StringBuilder r3 = new java.lang.StringBuilder
            r3.<init>()
            java.lang.String r5 = "Window vs. result size: "
            r3.append(r5)
            int r5 = r2.getNumRows()
            r3.append(r5)
            java.lang.String r5 = "/"
            r3.append(r5)
            r3.append(r0)
            java.lang.String r3 = r3.toString()
            org.greenrobot.greendao.DaoLog.a(r3)
        L4d:
            r3 = 0
        L4e:
            boolean r5 = r7.moveToFirst()
            if (r5 == 0) goto L8a
            org.greenrobot.greendao.identityscope.IdentityScope<K, T> r5 = r6.d
            if (r5 == 0) goto L60
            r5.lock()
            org.greenrobot.greendao.identityscope.IdentityScope<K, T> r5 = r6.d
            r5.a(r0)
        L60:
            if (r3 != 0) goto L6c
            if (r2 == 0) goto L6c
            org.greenrobot.greendao.identityscope.IdentityScope<K, T> r0 = r6.d     // Catch: java.lang.Throwable -> L81
            if (r0 == 0) goto L6c
            r6.a(r7, r2, r1)     // Catch: java.lang.Throwable -> L81
            goto L79
        L6c:
            java.lang.Object r0 = r6.a(r7, r4, r4)     // Catch: java.lang.Throwable -> L81
            r1.add(r0)     // Catch: java.lang.Throwable -> L81
            boolean r0 = r7.moveToNext()     // Catch: java.lang.Throwable -> L81
            if (r0 != 0) goto L6c
        L79:
            org.greenrobot.greendao.identityscope.IdentityScope<K, T> r7 = r6.d
            if (r7 == 0) goto L8a
            r7.unlock()
            goto L8a
        L81:
            r7 = move-exception
            org.greenrobot.greendao.identityscope.IdentityScope<K, T> r0 = r6.d
            if (r0 == 0) goto L89
            r0.unlock()
        L89:
            throw r7
        L8a:
            return r1
        */
        throw new UnsupportedOperationException("Method not decompiled: org.greenrobot.greendao.AbstractDao.b(android.database.Cursor):java.util.List");
    }

    public Database d() {
        return this.b;
    }

    protected void a(T t, long j, boolean z) {
        if (j != -1) {
            a((AbstractDao<T, K>) a((AbstractDao<T, K>) t, j), (K) t, z);
        } else {
            DaoLog.b("Could not insert row (executeInsert returned -1)");
        }
    }

    private void a(Cursor cursor, CursorWindow cursorWindow, List<T> list) {
        int startPosition = cursorWindow.getStartPosition() + cursorWindow.getNumRows();
        int i = 0;
        while (true) {
            list.add(a(cursor, 0, false));
            int i2 = i + 1;
            if (i2 >= startPosition) {
                CursorWindow e = e(cursor);
                if (e == null) {
                    return;
                } else {
                    startPosition = e.getStartPosition() + e.getNumRows();
                }
            } else if (!cursor.moveToNext()) {
                return;
            }
            i = i2 + 1;
        }
    }

    public void b() {
        this.b.a("DELETE FROM '" + this.a.b + "'");
        IdentityScope<K, T> identityScope = this.d;
        if (identityScope != null) {
            identityScope.clear();
        }
    }

    protected final T a(Cursor cursor, int i, boolean z) {
        if (this.e != null) {
            if (i != 0 && cursor.isNull(this.h + i)) {
                return null;
            }
            long j = cursor.getLong(this.h + i);
            IdentityScopeLong<T> identityScopeLong = this.e;
            T a = z ? identityScopeLong.a(j) : identityScopeLong.b(j);
            if (a != null) {
                return a;
            }
            T a2 = a(cursor, i);
            a((AbstractDao<T, K>) a2);
            if (z) {
                this.e.a(j, (long) a2);
            } else {
                this.e.b(j, (long) a2);
            }
            return a2;
        }
        if (this.d != null) {
            K b = b(cursor, i);
            if (i != 0 && b == null) {
                return null;
            }
            IdentityScope<K, T> identityScope = this.d;
            T a3 = z ? identityScope.get(b) : identityScope.a((IdentityScope<K, T>) b);
            if (a3 != null) {
                return a3;
            }
            T a4 = a(cursor, i);
            a((AbstractDao<T, K>) b, (K) a4, z);
            return a4;
        }
        if (i != 0 && b(cursor, i) == null) {
            return null;
        }
        T a5 = a(cursor, i);
        a((AbstractDao<T, K>) a5);
        return a5;
    }

    public void b(T t) {
        a();
        c((AbstractDao<T, K>) e((AbstractDao<T, K>) t));
    }

    public void b(T... tArr) {
        d((Iterable) Arrays.asList(tArr));
    }

    /* JADX WARN: Multi-variable type inference failed */
    private void a(K k, DatabaseStatement databaseStatement) {
        if (k instanceof Long) {
            databaseStatement.a(1, ((Long) k).longValue());
        } else if (k != 0) {
            databaseStatement.a(1, k.toString());
        } else {
            throw new DaoException("Cannot delete entity, key is null");
        }
        databaseStatement.execute();
    }

    private void a(Iterable<T> iterable, Iterable<K> iterable2) {
        ArrayList arrayList;
        a();
        DatabaseStatement a = this.f.a();
        this.b.a();
        try {
            synchronized (a) {
                if (this.d != null) {
                    this.d.lock();
                    arrayList = new ArrayList();
                } else {
                    arrayList = null;
                }
                if (iterable != null) {
                    try {
                        Iterator<T> it = iterable.iterator();
                        while (it.hasNext()) {
                            K e = e((AbstractDao<T, K>) it.next());
                            a((AbstractDao<T, K>) e, a);
                            if (arrayList != null) {
                                arrayList.add(e);
                            }
                        }
                    } catch (Throwable th) {
                        if (this.d != null) {
                            this.d.unlock();
                        }
                        throw th;
                    }
                }
                if (iterable2 != null) {
                    for (K k : iterable2) {
                        a((AbstractDao<T, K>) k, a);
                        if (arrayList != null) {
                            arrayList.add(k);
                        }
                    }
                }
                if (this.d != null) {
                    this.d.unlock();
                }
            }
            this.b.c();
            if (arrayList != null && this.d != null) {
                this.d.a((Iterable) arrayList);
            }
        } finally {
            this.b.e();
        }
    }

    public void a(Iterable<T> iterable) {
        a(iterable, (Iterable) null);
    }

    /* JADX WARN: Multi-variable type inference failed */
    protected void a(T t, DatabaseStatement databaseStatement, boolean z) {
        a(databaseStatement, (DatabaseStatement) t);
        int length = this.a.d.length + 1;
        Object d = d((AbstractDao<T, K>) t);
        if (d instanceof Long) {
            databaseStatement.a(length, ((Long) d).longValue());
        } else if (d != null) {
            databaseStatement.a(length, d.toString());
        } else {
            throw new DaoException("Cannot update entity without key - was it inserted before?");
        }
        databaseStatement.execute();
        a((AbstractDao<T, K>) d, t, z);
    }

    /* JADX WARN: Multi-variable type inference failed */
    protected void a(T t, SQLiteStatement sQLiteStatement, boolean z) {
        a(sQLiteStatement, (SQLiteStatement) t);
        int length = this.a.d.length + 1;
        Object d = d((AbstractDao<T, K>) t);
        if (d instanceof Long) {
            sQLiteStatement.bindLong(length, ((Long) d).longValue());
        } else if (d != null) {
            sQLiteStatement.bindString(length, d.toString());
        } else {
            throw new DaoException("Cannot update entity without key - was it inserted before?");
        }
        sQLiteStatement.execute();
        a((AbstractDao<T, K>) d, t, z);
    }

    protected final void a(K k, T t, boolean z) {
        a((AbstractDao<T, K>) t);
        IdentityScope<K, T> identityScope = this.d;
        if (identityScope == null || k == null) {
            return;
        }
        if (z) {
            identityScope.put(k, t);
        } else {
            identityScope.a(k, t);
        }
    }

    protected void a() {
        if (this.a.e.length == 1) {
            return;
        }
        throw new DaoException(this + " (" + this.a.b + ") does not have a single-column primary key");
    }
}