package androidx.datastore.preferences.core;

import android.R;
import android.content.Context;
import android.content.res.TypedArray;
import android.net.Uri;
import android.os.Build;
import android.os.Trace;
import androidx.datastore.core.q;
import androidx.media3.common.util.Assertions;
import androidx.media3.common.util.ParsableBitArray;
import androidx.media3.common.util.ParsableByteArray;
import androidx.media3.common.util.Util;
import androidx.media3.extractor.f0;
import androidx.media3.extractor.k0;
import androidx.work.BackoffPolicy;
import androidx.work.NetworkType;
import androidx.work.OutOfQuotaPolicy;
import androidx.work.WorkInfo$State;
import java.io.ByteArrayInputStream;
import java.io.File;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.Collection;
import java.util.List;
import kotlin.collections.n;
import kotlin.coroutines.Continuation;
import kotlin.jvm.functions.Function2;
import kotlin.text.i;
import kotlinx.coroutines.x;

/* JADX INFO: loaded from: classes.dex */
public abstract class c {

    /* JADX INFO: renamed from: a, reason: collision with root package name */
    public static long f1987a;

    /* JADX INFO: renamed from: b, reason: collision with root package name */
    public static Method f1988b;

    /* JADX INFO: renamed from: c, reason: collision with root package name */
    public static Method f1989c;

    /* JADX INFO: renamed from: d, reason: collision with root package name */
    public static Method f1990d;

    /* JADX WARN: Removed duplicated region for block: B:50:0x0062 A[EXC_TOP_SPLITTER, SYNTHETIC] */
    /*
        Code decompiled incorrectly, please refer to instructions dump.
    */
    public static androidx.work.g a(byte[] bArr) throws Throwable {
        Throwable th;
        ObjectInputStream objectInputStream;
        IOException e10;
        androidx.work.g gVar = new androidx.work.g();
        if (bArr == null) {
            return gVar;
        }
        ByteArrayInputStream byteArrayInputStream = new ByteArrayInputStream(bArr);
        ObjectInputStream objectInputStream2 = null;
        try {
            try {
                try {
                    objectInputStream = new ObjectInputStream(byteArrayInputStream);
                    try {
                        for (int i10 = objectInputStream.readInt(); i10 > 0; i10--) {
                            gVar.f4559a.add(new androidx.work.f(Uri.parse(objectInputStream.readUTF()), objectInputStream.readBoolean()));
                        }
                        try {
                            objectInputStream.close();
                        } catch (IOException e11) {
                            e11.printStackTrace();
                        }
                        byteArrayInputStream.close();
                    } catch (IOException e12) {
                        e10 = e12;
                        e10.printStackTrace();
                        if (objectInputStream != null) {
                            try {
                                objectInputStream.close();
                            } catch (IOException e13) {
                                e13.printStackTrace();
                            }
                        }
                        byteArrayInputStream.close();
                    }
                } catch (Throwable th2) {
                    th = th2;
                    if (0 != 0) {
                        try {
                            objectInputStream2.close();
                        } catch (IOException e14) {
                            e14.printStackTrace();
                        }
                    }
                    try {
                        byteArrayInputStream.close();
                        throw th;
                    } catch (IOException e15) {
                        e15.printStackTrace();
                        throw th;
                    }
                }
            } catch (IOException e16) {
                objectInputStream = null;
                e10 = e16;
            } catch (Throwable th3) {
                th = th3;
                if (0 != 0) {
                }
                byteArrayInputStream.close();
                throw th;
            }
        } catch (IOException e17) {
            e17.printStackTrace();
        }
        return gVar;
    }

    public static boolean b(ParsableByteArray parsableByteArray, k0 k0Var, int i10, f0 f0Var) {
        int position = parsableByteArray.getPosition();
        long unsignedInt = parsableByteArray.readUnsignedInt();
        long j10 = unsignedInt >>> 16;
        if (j10 != i10) {
            return false;
        }
        boolean z10 = (j10 & 1) == 1;
        int i11 = (int) ((unsignedInt >> 12) & 15);
        int i12 = (int) ((unsignedInt >> 8) & 15);
        int i13 = (int) (15 & (unsignedInt >> 4));
        int i14 = (int) ((unsignedInt >> 1) & 7);
        boolean z11 = (unsignedInt & 1) == 1;
        if (i13 <= 7) {
            if (i13 != k0Var.f3405g - 1) {
                return false;
            }
        } else if (i13 > 10 || k0Var.f3405g != 2) {
            return false;
        }
        if (!(i14 == 0 || i14 == k0Var.f3407i) || z11) {
            return false;
        }
        try {
            long utf8EncodedLong = parsableByteArray.readUtf8EncodedLong();
            if (!z10) {
                utf8EncodedLong *= (long) k0Var.f3400b;
            }
            f0Var.f3366a = utf8EncodedLong;
            int iO = o(i11, parsableByteArray);
            if (iO == -1 || iO > k0Var.f3400b) {
                return false;
            }
            if (i12 != 0) {
                if (i12 > 11) {
                    int i15 = k0Var.f3403e;
                    if (i12 == 12) {
                        if (parsableByteArray.readUnsignedByte() * 1000 != i15) {
                            return false;
                        }
                    } else {
                        if (i12 > 14) {
                            return false;
                        }
                        int unsignedShort = parsableByteArray.readUnsignedShort();
                        if (i12 == 14) {
                            unsignedShort *= 10;
                        }
                        if (unsignedShort != i15) {
                            return false;
                        }
                    }
                } else if (i12 != k0Var.f3404f) {
                    return false;
                }
            }
            return parsableByteArray.readUnsignedByte() == Util.crc8(parsableByteArray.getData(), position, parsableByteArray.getPosition() - 1, 0);
        } catch (NumberFormatException unused) {
            return false;
        }
    }

    public static b c(List list, x xVar, final sd.a aVar) {
        nb.g.i(list, "migrations");
        nb.g.i(xVar, "scope");
        return new b(new b(androidx.datastore.core.g.a(new q(h.f1993a, new sd.a() { // from class: androidx.datastore.preferences.core.PreferenceDataStoreFactory$create$delegate$1
            {
                super(0);
            }

            @Override // sd.a
            public final Object invoke() {
                File file = (File) aVar.invoke();
                nb.g.i(file, "<this>");
                String name = file.getName();
                nb.g.h(name, "name");
                if (nb.g.c(i.F0(name, ""), "preferences_pb")) {
                    File absoluteFile = file.getAbsoluteFile();
                    nb.g.h(absoluteFile, "file.absoluteFile");
                    return absoluteFile;
                }
                throw new IllegalStateException(("File extension for file: " + file + " does not match required extension for Preferences file: preferences_pb").toString());
            }
        }), list, xVar)));
    }

    public static final long d() {
        return Thread.currentThread().getId();
    }

    public static final boolean e(String str, String str2) {
        if (nb.g.c(str, str2)) {
            return true;
        }
        if (str.length() != 0) {
            int i10 = 0;
            int i11 = 0;
            int i12 = 0;
            while (true) {
                if (i10 < str.length()) {
                    char cCharAt = str.charAt(i10);
                    int i13 = i12 + 1;
                    if (i12 == 0 && cCharAt != '(') {
                        break;
                    }
                    if (cCharAt == '(') {
                        i11++;
                    } else if (cCharAt == ')' && i11 - 1 == 0 && i12 != str.length() - 1) {
                        break;
                    }
                    i10++;
                    i12 = i13;
                } else if (i11 == 0) {
                    String strSubstring = str.substring(1, str.length() - 1);
                    nb.g.h(strSubstring, "substring(...)");
                    return nb.g.c(i.G0(strSubstring).toString(), str2);
                }
            }
        }
        return false;
    }

    public static final Object f(androidx.datastore.core.h hVar, Function2 function2, Continuation continuation) {
        return hVar.a(new PreferencesKt$edit$2(function2, null), continuation);
    }

    public static final String g(Collection collection) {
        nb.g.i(collection, "collection");
        return collection.isEmpty() ^ true ? kotlin.text.d.X(n.j1(collection, ",\n", "\n", "\n", null, 56)).concat("},") : " }";
    }

    public static void h(Exception exc) {
        if (exc instanceof InvocationTargetException) {
            Throwable cause = exc.getCause();
            if (!(cause instanceof RuntimeException)) {
                throw new RuntimeException(cause);
            }
            throw ((RuntimeException) cause);
        }
    }

    public static BackoffPolicy i(int i10) {
        if (i10 == 0) {
            return BackoffPolicy.f4494a;
        }
        if (i10 == 1) {
            return BackoffPolicy.f4495b;
        }
        throw new IllegalArgumentException(defpackage.e.e("Could not convert ", i10, " to BackoffPolicy"));
    }

    public static NetworkType j(int i10) {
        if (i10 == 0) {
            return NetworkType.f4506a;
        }
        if (i10 == 1) {
            return NetworkType.f4507b;
        }
        if (i10 == 2) {
            return NetworkType.f4508c;
        }
        if (i10 == 3) {
            return NetworkType.f4509d;
        }
        if (i10 == 4) {
            return NetworkType.f4510e;
        }
        if (Build.VERSION.SDK_INT < 30 || i10 != 5) {
            throw new IllegalArgumentException(defpackage.e.e("Could not convert ", i10, " to NetworkType"));
        }
        return NetworkType.f4511f;
    }

    public static OutOfQuotaPolicy k(int i10) {
        if (i10 == 0) {
            return OutOfQuotaPolicy.f4513a;
        }
        if (i10 == 1) {
            return OutOfQuotaPolicy.f4514b;
        }
        throw new IllegalArgumentException(defpackage.e.e("Could not convert ", i10, " to OutOfQuotaPolicy"));
    }

    public static WorkInfo$State l(int i10) {
        if (i10 == 0) {
            return WorkInfo$State.f4516a;
        }
        if (i10 == 1) {
            return WorkInfo$State.f4517b;
        }
        if (i10 == 2) {
            return WorkInfo$State.f4518c;
        }
        if (i10 == 3) {
            return WorkInfo$State.f4519d;
        }
        if (i10 == 4) {
            return WorkInfo$State.f4520e;
        }
        if (i10 == 5) {
            return WorkInfo$State.f4521f;
        }
        throw new IllegalArgumentException(defpackage.e.e("Could not convert ", i10, " to State"));
    }

    public static boolean m() {
        if (Build.VERSION.SDK_INT >= 29) {
            return q3.a.c();
        }
        try {
            if (f1988b == null) {
                f1987a = Trace.class.getField("TRACE_TAG_APP").getLong(null);
                f1988b = Trace.class.getMethod("isTagEnabled", Long.TYPE);
            }
            return ((Boolean) f1988b.invoke(null, Long.valueOf(f1987a))).booleanValue();
        } catch (Exception e10) {
            h(e10);
            return false;
        }
    }

    public static int n(ParsableBitArray parsableBitArray, int i10, int i11, int i12) {
        Assertions.checkArgument(Math.max(Math.max(i10, i11), i12) <= 31);
        int i13 = (1 << i10) - 1;
        int i14 = (1 << i11) - 1;
        com.bumptech.glide.h.i(com.bumptech.glide.h.i(i13, i14), 1 << i12);
        if (parsableBitArray.bitsLeft() < i10) {
            return -1;
        }
        int bits = parsableBitArray.readBits(i10);
        if (bits != i13) {
            return bits;
        }
        if (parsableBitArray.bitsLeft() < i11) {
            return -1;
        }
        int bits2 = parsableBitArray.readBits(i11);
        int i15 = bits + bits2;
        if (bits2 != i14) {
            return i15;
        }
        if (parsableBitArray.bitsLeft() < i12) {
            return -1;
        }
        return i15 + parsableBitArray.readBits(i12);
    }

    public static int o(int i10, ParsableByteArray parsableByteArray) {
        switch (i10) {
            case 1:
                return 192;
            case 2:
            case 3:
            case 4:
            case 5:
                return 576 << (i10 - 2);
            case 6:
                return parsableByteArray.readUnsignedByte() + 1;
            case 7:
                return parsableByteArray.readUnsignedShort() + 1;
            case 8:
            case 9:
            case 10:
            case 11:
            case 12:
            case 13:
            case 14:
            case 15:
                return 256 << (i10 - 8);
            default:
                return -1;
        }
    }

    public static void p(ParsableBitArray parsableBitArray) {
        parsableBitArray.skipBits(3);
        parsableBitArray.skipBits(8);
        boolean bit = parsableBitArray.readBit();
        boolean bit2 = parsableBitArray.readBit();
        if (bit) {
            parsableBitArray.skipBits(5);
        }
        if (bit2) {
            parsableBitArray.skipBits(6);
        }
    }

    public static void q(ParsableBitArray parsableBitArray) {
        int bits;
        int bits2 = parsableBitArray.readBits(2);
        if (bits2 == 0) {
            parsableBitArray.skipBits(6);
            return;
        }
        int iN = n(parsableBitArray, 5, 8, 16) + 1;
        if (bits2 == 1) {
            parsableBitArray.skipBits(iN * 7);
            return;
        }
        if (bits2 == 2) {
            boolean bit = parsableBitArray.readBit();
            int i10 = bit ? 1 : 5;
            int i11 = bit ? 7 : 5;
            int i12 = bit ? 8 : 6;
            int i13 = 0;
            while (i13 < iN) {
                if (parsableBitArray.readBit()) {
                    parsableBitArray.skipBits(7);
                    bits = 0;
                } else {
                    if (parsableBitArray.readBits(2) == 3 && parsableBitArray.readBits(i11) * i10 != 0) {
                        parsableBitArray.skipBit();
                    }
                    bits = parsableBitArray.readBits(i12) * i10;
                    if (bits != 0 && bits != 180) {
                        parsableBitArray.skipBit();
                    }
                    parsableBitArray.skipBit();
                }
                if (bits != 0 && bits != 180 && parsableBitArray.readBit()) {
                    i13++;
                }
                i13++;
            }
        }
    }

    public static int r(WorkInfo$State workInfo$State) {
        int iOrdinal = workInfo$State.ordinal();
        if (iOrdinal == 0) {
            return 0;
        }
        int i10 = 1;
        if (iOrdinal != 1) {
            i10 = 2;
            if (iOrdinal != 2) {
                i10 = 3;
                if (iOrdinal != 3) {
                    i10 = 4;
                    if (iOrdinal != 4) {
                        if (iOrdinal == 5) {
                            return 5;
                        }
                        throw new IllegalArgumentException("Could not convert " + workInfo$State + " to int");
                    }
                }
            }
        }
        return i10;
    }

    public static int s(Context context, int i10) {
        TypedArray typedArrayObtainStyledAttributes = context.obtainStyledAttributes(R.style.Animation.Activity, new int[]{i10});
        int resourceId = typedArrayObtainStyledAttributes.getResourceId(0, -1);
        typedArrayObtainStyledAttributes.recycle();
        return resourceId;
    }

    public static String t(String str) {
        return str.length() <= 127 ? str : str.substring(0, 127);
    }
}