package com.google.firebase.firestore.util;

import android.os.Handler;
import android.os.Looper;
import androidx.media3.common.C1118r;
import com.google.android.gms.tasks.Continuation;
import com.google.android.gms.tasks.Task;
import com.google.firebase.firestore.FieldPath;
import com.google.firebase.firestore.FirebaseFirestoreException;
import com.google.protobuf.AbstractC1320n;
import e4.C;
import java.security.SecureRandom;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Random;
import java.util.SortedSet;
import k4.r0;
import k4.s0;
import k4.t0;

/* JADX INFO: loaded from: classes3.dex */
public class Util {
    private static final String AUTO_ID_ALPHABET = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
    private static final int AUTO_ID_LENGTH = 20;
    private static final Random rand = new SecureRandom();
    private static final Continuation<Void, Void> VOID_ERROR_TRANSFORMER = new C1118r(28);

    private static <T> T advanceIterator(Iterator<T> it) {
        if (it.hasNext()) {
            return it.next();
        }
        return null;
    }

    public static String autoId() {
        StringBuilder sb = new StringBuilder();
        for (int i6 = 0; i6 < 20; i6++) {
            sb.append(AUTO_ID_ALPHABET.charAt(rand.nextInt(62)));
        }
        return sb.toString();
    }

    public static List<Object> collectUpdateArguments(int i6, Object obj, Object obj2, Object... objArr) {
        if (objArr.length % 2 == 1) {
            throw new IllegalArgumentException("Missing value in call to update().  There must be an even number of arguments that alternate between field names and values");
        }
        ArrayList arrayList = new ArrayList();
        arrayList.add(obj);
        arrayList.add(obj2);
        Collections.addAll(arrayList, objArr);
        for (int i7 = 0; i7 < arrayList.size(); i7 += 2) {
            Object obj3 = arrayList.get(i7);
            if (!(obj3 instanceof String) && !(obj3 instanceof FieldPath)) {
                throw new IllegalArgumentException("Excepted field name at argument position " + (i7 + i6 + 1) + " but got " + obj3 + " in call to update.  The arguments to update should alternate between field names and values");
            }
        }
        return arrayList;
    }

    public static <T extends Comparable<T>> Comparator<T> comparator() {
        return new C1.c(16);
    }

    public static int compareBooleans(boolean z6, boolean z7) {
        if (z6 == z7) {
            return 0;
        }
        return z6 ? 1 : -1;
    }

    public static int compareByteArrays(byte[] bArr, byte[] bArr2) {
        int iMin = Math.min(bArr.length, bArr2.length);
        for (int i6 = 0; i6 < iMin; i6++) {
            int i7 = bArr[i6] & 255;
            int i8 = bArr2[i6] & 255;
            if (i7 < i8) {
                return -1;
            }
            if (i7 > i8) {
                return 1;
            }
        }
        return compareIntegers(bArr.length, bArr2.length);
    }

    public static int compareByteStrings(AbstractC1320n abstractC1320n, AbstractC1320n abstractC1320n2) {
        int iMin = Math.min(abstractC1320n.size(), abstractC1320n2.size());
        for (int i6 = 0; i6 < iMin; i6++) {
            int iH = abstractC1320n.h(i6) & 255;
            int iH2 = abstractC1320n2.h(i6) & 255;
            if (iH < iH2) {
                return -1;
            }
            if (iH > iH2) {
                return 1;
            }
        }
        return compareIntegers(abstractC1320n.size(), abstractC1320n2.size());
    }

    public static int compareDoubles(double d6, double d7) {
        return C.A(d6, d7);
    }

    public static int compareIntegers(int i6, int i7) {
        if (i6 < i7) {
            return -1;
        }
        return i6 > i7 ? 1 : 0;
    }

    public static int compareLongs(long j4, long j6) {
        return Long.compare(j4, j6);
    }

    public static int compareMixed(double d6, long j4) {
        if (Double.isNaN(d6) || d6 < -9.223372036854776E18d) {
            return -1;
        }
        if (d6 >= 9.223372036854776E18d) {
            return 1;
        }
        int iCompare = Long.compare((long) d6, j4);
        return iCompare != 0 ? iCompare : C.A(d6, j4);
    }

    public static int compareUtf8Strings(String str, String str2) {
        return compareByteStrings(AbstractC1320n.m(str), AbstractC1320n.m(str2));
    }

    private static Exception convertStatusException(Exception exc) {
        return exc instanceof s0 ? exceptionFromStatus(((s0) exc).f19953a) : exc instanceof t0 ? exceptionFromStatus(((t0) exc).f19955a) : exc;
    }

    public static Exception convertThrowableToException(Throwable th) {
        return th instanceof Exception ? convertStatusException((Exception) th) : new Exception(th);
    }

    public static void crashMainThread(RuntimeException runtimeException) {
        new Handler(Looper.getMainLooper()).post(new b(runtimeException, 2));
    }

    public static <T> void diffCollections(Collection<T> collection, Collection<T> collection2, Comparator<T> comparator, Consumer<T> consumer, Consumer<T> consumer2) {
        ArrayList arrayList = new ArrayList(collection);
        Collections.sort(arrayList, comparator);
        ArrayList arrayList2 = new ArrayList(collection2);
        Collections.sort(arrayList2, comparator);
        diffCollections(arrayList.iterator(), arrayList2.iterator(), comparator, consumer, consumer2);
    }

    public static FirebaseFirestoreException exceptionFromStatus(r0 r0Var) {
        r0Var.getClass();
        s0 s0Var = new s0(r0Var);
        return new FirebaseFirestoreException(s0Var.getMessage(), FirebaseFirestoreException.Code.fromValue(r0Var.f19949a.f19933a), s0Var);
    }

    /* JADX WARN: Multi-variable type inference failed */
    public static <K, V> Map<K, V> firstNEntries(Map<K, V> map, int i6, final Comparator<V> comparator) {
        if (map.size() <= i6) {
            return map;
        }
        ArrayList arrayList = new ArrayList(map.entrySet());
        Collections.sort(arrayList, new Comparator() { // from class: com.google.firebase.firestore.util.f
            @Override // java.util.Comparator
            public final int compare(Object obj, Object obj2) {
                return Util.lambda$firstNEntries$4(comparator, (Map.Entry) obj, (Map.Entry) obj2);
            }
        });
        HashMap map2 = new HashMap();
        for (int i7 = 0; i7 < i6; i7++) {
            map2.put(((Map.Entry) arrayList.get(i7)).getKey(), ((Map.Entry) arrayList.get(i7)).getValue());
        }
        return map2;
    }

    /* JADX INFO: Access modifiers changed from: private */
    public static /* synthetic */ int lambda$firstNEntries$4(Comparator comparator, Map.Entry entry, Map.Entry entry2) {
        return comparator.compare(entry.getValue(), entry2.getValue());
    }

    /* JADX INFO: Access modifiers changed from: private */
    public static /* synthetic */ Void lambda$static$0(Task task) throws Exception {
        if (task.isSuccessful()) {
            return (Void) task.getResult();
        }
        Exception excConvertStatusException = convertStatusException(task.getException());
        if (excConvertStatusException instanceof FirebaseFirestoreException) {
            throw excConvertStatusException;
        }
        throw new FirebaseFirestoreException(excConvertStatusException.getMessage(), FirebaseFirestoreException.Code.UNKNOWN, excConvertStatusException);
    }

    /* JADX INFO: Access modifiers changed from: private */
    public static /* synthetic */ Iterator lambda$values$3(Iterable iterable) {
        final Iterator it = iterable.iterator();
        return new Iterator<V>() { // from class: com.google.firebase.firestore.util.Util.1
            @Override // java.util.Iterator
            public boolean hasNext() {
                return it.hasNext();
            }

            @Override // java.util.Iterator
            public V next() {
                return (V) ((Map.Entry) it.next()).getValue();
            }
        };
    }

    public static StringBuilder repeatSequence(CharSequence charSequence, int i6, CharSequence charSequence2) {
        StringBuilder sb = new StringBuilder();
        if (i6 != 0) {
            sb.append(charSequence);
            for (int i7 = 1; i7 < i6; i7++) {
                sb.append(charSequence2);
                sb.append(charSequence);
            }
        }
        return sb;
    }

    public static String toDebugString(AbstractC1320n abstractC1320n) {
        int size = abstractC1320n.size();
        StringBuilder sb = new StringBuilder(size * 2);
        for (int i6 = 0; i6 < size; i6++) {
            byte bH = abstractC1320n.h(i6);
            sb.append(Character.forDigit((bH & 255) >>> 4, 16));
            sb.append(Character.forDigit(bH & 15, 16));
        }
        return sb.toString();
    }

    public static String typeName(Object obj) {
        return obj == null ? "null" : obj.getClass().getName();
    }

    public static <K, V> Iterable<V> values(final Iterable<Map.Entry<K, V>> iterable) {
        return new Iterable() { // from class: com.google.firebase.firestore.util.g
            @Override // java.lang.Iterable
            public final Iterator iterator() {
                return Util.lambda$values$3(iterable);
            }
        };
    }

    public static Continuation<Void, Void> voidErrorTransformer() {
        return VOID_ERROR_TRANSFORMER;
    }

    public static <T extends Comparable<T>> void diffCollections(SortedSet<T> sortedSet, SortedSet<T> sortedSet2, Consumer<T> consumer, Consumer<T> consumer2) {
        diffCollections(sortedSet.iterator(), sortedSet2.iterator(), sortedSet.comparator() != null ? sortedSet.comparator() : new C1.c(15), consumer, consumer2);
    }

    /* JADX WARN: Removed duplicated region for block: B:18:0x0023  */
    /*
        Code decompiled incorrectly, please refer to instructions dump.
    */
    private static <T> void diffCollections(Iterator<T> it, Iterator<T> it2, Comparator<? super T> comparator, Consumer<T> consumer, Consumer<T> consumer2) {
        T t6 = (Object) advanceIterator(it);
        T t7 = (Object) advanceIterator(it2);
        while (true) {
            if (t6 == null && t7 == null) {
                return;
            }
            boolean z6 = false;
            boolean z7 = true;
            if (t6 != null && t7 != null) {
                int iCompare = comparator.compare(t6, t7);
                if (iCompare >= 0) {
                    if (iCompare <= 0) {
                        z7 = false;
                    }
                }
            } else if (t6 == null) {
                z7 = false;
                z6 = true;
            }
            if (z6) {
                consumer.accept(t7);
                t7 = (Object) advanceIterator(it2);
            } else if (z7) {
                consumer2.accept(t6);
                t6 = (Object) advanceIterator(it);
            } else {
                t6 = (Object) advanceIterator(it);
                t7 = (Object) advanceIterator(it2);
            }
        }
    }

    /* JADX INFO: Access modifiers changed from: private */
    public static /* synthetic */ void lambda$crashMainThread$1(RuntimeException runtimeException) {
        throw runtimeException;
    }
}