package i.b.a.h;

import android.os.Handler;
import android.os.Looper;
import android.os.Message;
import i.b.a.h.a;
import i.b.a.l.e;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.Callable;
import java.util.concurrent.Executors;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.TimeUnit;

/* JADX INFO: compiled from: AsyncOperationExecutor.java */
/* JADX INFO: loaded from: classes.dex */
class b implements Runnable, Handler.Callback {

    /* JADX INFO: renamed from: g, reason: collision with root package name */
    private volatile c f4260g;

    /* JADX INFO: renamed from: h, reason: collision with root package name */
    private volatile c f4261h;

    /* JADX INFO: renamed from: j, reason: collision with root package name */
    private int f4263j;

    /* JADX INFO: renamed from: k, reason: collision with root package name */
    private int f4264k;
    private Handler l;

    /* JADX INFO: renamed from: b, reason: collision with root package name */
    private final BlockingQueue<i.b.a.h.a> f4258b = new LinkedBlockingQueue();

    /* JADX INFO: renamed from: f, reason: collision with root package name */
    private volatile int f4259f = 50;

    /* JADX INFO: renamed from: i, reason: collision with root package name */
    private volatile int f4262i = 50;

    /* JADX INFO: compiled from: AsyncOperationExecutor.java */
    static /* synthetic */ class a {
        static final /* synthetic */ int[] a;

        static {
            int[] iArr = new int[a.EnumC0132a.values().length];
            a = iArr;
            try {
                iArr[a.EnumC0132a.Delete.ordinal()] = 1;
            } catch (NoSuchFieldError unused) {
            }
            try {
                a[a.EnumC0132a.DeleteInTxIterable.ordinal()] = 2;
            } catch (NoSuchFieldError unused2) {
            }
            try {
                a[a.EnumC0132a.DeleteInTxArray.ordinal()] = 3;
            } catch (NoSuchFieldError unused3) {
            }
            try {
                a[a.EnumC0132a.Insert.ordinal()] = 4;
            } catch (NoSuchFieldError unused4) {
            }
            try {
                a[a.EnumC0132a.InsertInTxIterable.ordinal()] = 5;
            } catch (NoSuchFieldError unused5) {
            }
            try {
                a[a.EnumC0132a.InsertInTxArray.ordinal()] = 6;
            } catch (NoSuchFieldError unused6) {
            }
            try {
                a[a.EnumC0132a.InsertOrReplace.ordinal()] = 7;
            } catch (NoSuchFieldError unused7) {
            }
            try {
                a[a.EnumC0132a.InsertOrReplaceInTxIterable.ordinal()] = 8;
            } catch (NoSuchFieldError unused8) {
            }
            try {
                a[a.EnumC0132a.InsertOrReplaceInTxArray.ordinal()] = 9;
            } catch (NoSuchFieldError unused9) {
            }
            try {
                a[a.EnumC0132a.Update.ordinal()] = 10;
            } catch (NoSuchFieldError unused10) {
            }
            try {
                a[a.EnumC0132a.UpdateInTxIterable.ordinal()] = 11;
            } catch (NoSuchFieldError unused11) {
            }
            try {
                a[a.EnumC0132a.UpdateInTxArray.ordinal()] = 12;
            } catch (NoSuchFieldError unused12) {
            }
            try {
                a[a.EnumC0132a.TransactionRunnable.ordinal()] = 13;
            } catch (NoSuchFieldError unused13) {
            }
            try {
                a[a.EnumC0132a.TransactionCallable.ordinal()] = 14;
            } catch (NoSuchFieldError unused14) {
            }
            try {
                a[a.EnumC0132a.QueryList.ordinal()] = 15;
            } catch (NoSuchFieldError unused15) {
            }
            try {
                a[a.EnumC0132a.QueryUnique.ordinal()] = 16;
            } catch (NoSuchFieldError unused16) {
            }
            try {
                a[a.EnumC0132a.DeleteByKey.ordinal()] = 17;
            } catch (NoSuchFieldError unused17) {
            }
            try {
                a[a.EnumC0132a.DeleteAll.ordinal()] = 18;
            } catch (NoSuchFieldError unused18) {
            }
            try {
                a[a.EnumC0132a.Load.ordinal()] = 19;
            } catch (NoSuchFieldError unused19) {
            }
            try {
                a[a.EnumC0132a.LoadAll.ordinal()] = 20;
            } catch (NoSuchFieldError unused20) {
            }
            try {
                a[a.EnumC0132a.Count.ordinal()] = 21;
            } catch (NoSuchFieldError unused21) {
            }
            try {
                a[a.EnumC0132a.Refresh.ordinal()] = 22;
            } catch (NoSuchFieldError unused22) {
            }
        }
    }

    static {
        Executors.newCachedThreadPool();
    }

    b() {
    }

    private void a(i.b.a.h.a aVar) {
        aVar.f4253f = System.currentTimeMillis();
        try {
            switch (a.a[aVar.a.ordinal()]) {
                case 1:
                    aVar.f4249b.delete(aVar.f4251d);
                    break;
                case 2:
                    aVar.f4249b.deleteInTx((Iterable<Object>) aVar.f4251d);
                    break;
                case 3:
                    aVar.f4249b.deleteInTx((Object[]) aVar.f4251d);
                    break;
                case 4:
                    aVar.f4249b.insert(aVar.f4251d);
                    break;
                case 5:
                    aVar.f4249b.insertInTx((Iterable<Object>) aVar.f4251d);
                    break;
                case 6:
                    aVar.f4249b.insertInTx((Object[]) aVar.f4251d);
                    break;
                case 7:
                    aVar.f4249b.insertOrReplace(aVar.f4251d);
                    break;
                case 8:
                    aVar.f4249b.insertOrReplaceInTx((Iterable<Object>) aVar.f4251d);
                    break;
                case 9:
                    aVar.f4249b.insertOrReplaceInTx((Object[]) aVar.f4251d);
                    break;
                case 10:
                    aVar.f4249b.update(aVar.f4251d);
                    break;
                case 11:
                    aVar.f4249b.updateInTx((Iterable<Object>) aVar.f4251d);
                    break;
                case 12:
                    aVar.f4249b.updateInTx((Object[]) aVar.f4251d);
                    break;
                case 13:
                    d(aVar);
                    break;
                case 14:
                    c(aVar);
                    break;
                case 15:
                    aVar.f4256i = ((e) aVar.f4251d).d().f();
                    break;
                case 16:
                    aVar.f4256i = ((e) aVar.f4251d).d().g();
                    break;
                case 17:
                    aVar.f4249b.deleteByKey(aVar.f4251d);
                    break;
                case 18:
                    aVar.f4249b.deleteAll();
                    break;
                case 19:
                    aVar.f4256i = aVar.f4249b.load(aVar.f4251d);
                    break;
                case 20:
                    aVar.f4256i = aVar.f4249b.loadAll();
                    break;
                case 21:
                    aVar.f4256i = Long.valueOf(aVar.f4249b.count());
                    break;
                case 22:
                    aVar.f4249b.refresh(aVar.f4251d);
                    break;
                default:
                    throw new i.b.a.d("Unsupported operation: " + aVar.a);
            }
        } catch (Throwable th) {
            aVar.f4255h = th;
        }
        aVar.f4254g = System.currentTimeMillis();
    }

    private void b(i.b.a.h.a aVar) {
        a(aVar);
        e(aVar);
    }

    private void c(i.b.a.h.a aVar) throws Exception {
        i.b.a.i.a aVarA = aVar.a();
        aVarA.c();
        try {
            aVar.f4256i = ((Callable) aVar.f4251d).call();
            aVarA.g();
        } finally {
            aVarA.b();
        }
    }

    private void d(i.b.a.h.a aVar) {
        i.b.a.i.a aVarA = aVar.a();
        aVarA.c();
        try {
            ((Runnable) aVar.f4251d).run();
            aVarA.g();
        } finally {
            aVarA.b();
        }
    }

    private void e(i.b.a.h.a aVar) {
        aVar.f();
        c cVar = this.f4260g;
        if (cVar != null) {
            cVar.a(aVar);
        }
        if (this.f4261h != null) {
            if (this.l == null) {
                this.l = new Handler(Looper.getMainLooper(), this);
            }
            this.l.sendMessage(this.l.obtainMessage(1, aVar));
        }
        synchronized (this) {
            int i2 = this.f4264k + 1;
            this.f4264k = i2;
            if (i2 == this.f4263j) {
                notifyAll();
            }
        }
    }

    /* JADX WARN: Code restructure failed: missing block: B:19:0x005c, code lost:
    
        r8.g();
     */
    /* JADX WARN: Code restructure failed: missing block: B:22:0x0063, code lost:
    
        r4 = false;
     */
    /* JADX WARN: Code restructure failed: missing block: B:23:0x0064, code lost:
    
        r8.b();
     */
    /* JADX WARN: Code restructure failed: missing block: B:24:0x0067, code lost:
    
        r9 = r4;
     */
    /* JADX WARN: Code restructure failed: missing block: B:25:0x0069, code lost:
    
        r8 = move-exception;
     */
    /* JADX WARN: Code restructure failed: missing block: B:26:0x006a, code lost:
    
        i.b.a.e.d("Async transaction could not be ended, success so far was: " + r4, r8);
     */
    /*
        Code decompiled incorrectly, please refer to instructions dump.
        To view partially-correct add '--show-bad-code' argument
    */
    private void f(i.b.a.h.a r8, i.b.a.h.a r9) {
        /*
            Method dump skipped, instruction units count: 206
            To view this dump add '--comments-level debug' option
        */
        throw new UnsupportedOperationException("Method not decompiled: i.b.a.h.b.f(i.b.a.h.a, i.b.a.h.a):void");
    }

    @Override // android.os.Handler.Callback
    public boolean handleMessage(Message message) {
        c cVar = this.f4261h;
        if (cVar == null) {
            return false;
        }
        cVar.a((i.b.a.h.a) message.obj);
        return false;
    }

    @Override // java.lang.Runnable
    public void run() {
        i.b.a.h.a aVarPoll;
        i.b.a.h.a aVarPoll2;
        while (true) {
            try {
                aVarPoll = this.f4258b.poll(1L, TimeUnit.SECONDS);
            } catch (InterruptedException e2) {
                i.b.a.e.f(Thread.currentThread().getName() + " was interruppted", e2);
                return;
            }
            if (aVarPoll == null) {
                synchronized (this) {
                    aVarPoll = this.f4258b.poll();
                    if (aVarPoll == null) {
                        return;
                    }
                    i.b.a.e.f(Thread.currentThread().getName() + " was interruppted", e2);
                    return;
                }
            }
            if (!aVarPoll.c() || (aVarPoll2 = this.f4258b.poll(this.f4262i, TimeUnit.MILLISECONDS)) == null) {
                b(aVarPoll);
            } else if (aVarPoll.d(aVarPoll2)) {
                f(aVarPoll, aVarPoll2);
            } else {
                b(aVarPoll);
                b(aVarPoll2);
            }
        }
    }
}