package androidx.credentials.webauthn;

import androidx.annotation.RestrictTo;
import java.util.ArrayList;
import java.util.Comparator;
import java.util.Iterator;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import kotlin.collections.ArraysKt___ArraysJvmKt;
import kotlin.collections.ArraysKt___ArraysKt;
import kotlin.collections.CollectionsKt___CollectionsKt;
import kotlin.collections.MapsKt__MapsKt;
import kotlin.jvm.internal.Intrinsics;
import kotlin.jvm.internal.Ref;
import kotlin.ranges.IntRange;
import kotlin.ranges.RangesKt___RangesKt;
import kotlin.text.Charsets;
import kotlin.text.StringsKt__StringsJVMKt;

@RestrictTo({RestrictTo.Scope.LIBRARY})
/* loaded from: classes.dex */
public final class Cbor {
    private final int TYPE_UNSIGNED_INT;
    private final int TYPE_NEGATIVE_INT = 1;
    private final int TYPE_BYTE_STRING = 2;
    private final int TYPE_TEXT_STRING = 3;
    private final int TYPE_ARRAY = 4;
    private final int TYPE_MAP = 5;
    private final int TYPE_TAG = 6;
    private final int TYPE_FLOAT = 7;

    public final int getTYPE_ARRAY() {
        return this.TYPE_ARRAY;
    }

    public final int getTYPE_BYTE_STRING() {
        return this.TYPE_BYTE_STRING;
    }

    public final int getTYPE_FLOAT() {
        return this.TYPE_FLOAT;
    }

    public final int getTYPE_MAP() {
        return this.TYPE_MAP;
    }

    public final int getTYPE_NEGATIVE_INT() {
        return this.TYPE_NEGATIVE_INT;
    }

    public final int getTYPE_TAG() {
        return this.TYPE_TAG;
    }

    public final int getTYPE_TEXT_STRING() {
        return this.TYPE_TEXT_STRING;
    }

    public final int getTYPE_UNSIGNED_INT() {
        return this.TYPE_UNSIGNED_INT;
    }

    public static final class Item {
        private final Object item;
        private final int len;

        public static /* synthetic */ Item copy$default(Item item, Object obj, int i, int i2, Object obj2) {
            if ((i2 & 1) != 0) {
                obj = item.item;
            }
            if ((i2 & 2) != 0) {
                i = item.len;
            }
            return item.copy(obj, i);
        }

        public final Object component1() {
            return this.item;
        }

        public final int component2() {
            return this.len;
        }

        public final Item copy(Object item, int i) {
            Intrinsics.checkNotNullParameter(item, "item");
            return new Item(item, i);
        }

        public boolean equals(Object obj) {
            if (this == obj) {
                return true;
            }
            if (!(obj instanceof Item)) {
                return false;
            }
            Item item = (Item) obj;
            return Intrinsics.areEqual(this.item, item.item) && this.len == item.len;
        }

        public final Object getItem() {
            return this.item;
        }

        public final int getLen() {
            return this.len;
        }

        public int hashCode() {
            return (this.item.hashCode() * 31) + Integer.hashCode(this.len);
        }

        public String toString() {
            return "Item(item=" + this.item + ", len=" + this.len + ')';
        }

        public Item(Object item, int i) {
            Intrinsics.checkNotNullParameter(item, "item");
            this.item = item;
            this.len = i;
        }
    }

    public static final class Arg {
        private final long arg;
        private final int len;

        public static /* synthetic */ Arg copy$default(Arg arg, long j, int i, int i2, Object obj) {
            if ((i2 & 1) != 0) {
                j = arg.arg;
            }
            if ((i2 & 2) != 0) {
                i = arg.len;
            }
            return arg.copy(j, i);
        }

        public final long component1() {
            return this.arg;
        }

        public final int component2() {
            return this.len;
        }

        public final Arg copy(long j, int i) {
            return new Arg(j, i);
        }

        public boolean equals(Object obj) {
            if (this == obj) {
                return true;
            }
            if (!(obj instanceof Arg)) {
                return false;
            }
            Arg arg = (Arg) obj;
            return this.arg == arg.arg && this.len == arg.len;
        }

        public final long getArg() {
            return this.arg;
        }

        public final int getLen() {
            return this.len;
        }

        public int hashCode() {
            return (Long.hashCode(this.arg) * 31) + Integer.hashCode(this.len);
        }

        public String toString() {
            return "Arg(arg=" + this.arg + ", len=" + this.len + ')';
        }

        public Arg(long j, int i) {
            this.arg = j;
            this.len = i;
        }
    }

    public final Object decode(byte[] data) {
        Intrinsics.checkNotNullParameter(data, "data");
        return parseItem(data, 0).getItem();
    }

    /* JADX WARN: Type inference failed for: r2v0, types: [T, java.util.LinkedHashMap] */
    public final byte[] encode(Object data) {
        byte[] plus;
        byte[] encodeToByteArray;
        byte[] plus2;
        byte[] plus3;
        Intrinsics.checkNotNullParameter(data, "data");
        if (data instanceof Number) {
            if (data instanceof Double) {
                throw new IllegalArgumentException("Don't support doubles yet");
            }
            long longValue = ((Number) data).longValue();
            if (longValue >= 0) {
                return createArg(this.TYPE_UNSIGNED_INT, longValue);
            }
            return createArg(this.TYPE_NEGATIVE_INT, (-1) - longValue);
        }
        if (data instanceof byte[]) {
            plus3 = ArraysKt___ArraysJvmKt.plus(createArg(this.TYPE_BYTE_STRING, r6.length), (byte[]) data);
            return plus3;
        }
        if (data instanceof String) {
            byte[] createArg = createArg(this.TYPE_TEXT_STRING, r6.length());
            encodeToByteArray = StringsKt__StringsJVMKt.encodeToByteArray((String) data);
            plus2 = ArraysKt___ArraysJvmKt.plus(createArg, encodeToByteArray);
            return plus2;
        }
        if (data instanceof List) {
            byte[] createArg2 = createArg(this.TYPE_ARRAY, r6.size());
            for (Object obj : (List) data) {
                Intrinsics.checkNotNull(obj);
                createArg2 = ArraysKt___ArraysJvmKt.plus(createArg2, encode(obj));
            }
            return createArg2;
        }
        if (data instanceof Map) {
            byte[] createArg3 = createArg(this.TYPE_MAP, r6.size());
            final Ref.ObjectRef objectRef = new Ref.ObjectRef();
            objectRef.element = new LinkedHashMap();
            for (Map.Entry entry : ((Map) data).entrySet()) {
                Map map = (Map) objectRef.element;
                Object key = entry.getKey();
                Intrinsics.checkNotNull(key);
                byte[] encode = encode(key);
                Object value = entry.getValue();
                Intrinsics.checkNotNull(value);
                map.put(encode, encode(value));
            }
            ArrayList arrayList = new ArrayList(((Map) objectRef.element).keySet());
            CollectionsKt___CollectionsKt.sortedWith(arrayList, new Comparator() { // from class: androidx.credentials.webauthn.Cbor$$ExternalSyntheticLambda0
                @Override // java.util.Comparator
                public final int compare(Object obj2, Object obj3) {
                    int encode$lambda$0;
                    encode$lambda$0 = Cbor.encode$lambda$0(Ref.ObjectRef.this, (byte[]) obj2, (byte[]) obj3);
                    return encode$lambda$0;
                }
            });
            Iterator it = arrayList.iterator();
            while (it.hasNext()) {
                byte[] key2 = (byte[]) it.next();
                Intrinsics.checkNotNullExpressionValue(key2, "key");
                plus = ArraysKt___ArraysJvmKt.plus(createArg3, key2);
                Object obj2 = ((Map) objectRef.element).get(key2);
                Intrinsics.checkNotNull(obj2);
                createArg3 = ArraysKt___ArraysJvmKt.plus(plus, (byte[]) obj2);
            }
            return createArg3;
        }
        throw new IllegalArgumentException("Bad type");
    }

    /* JADX INFO: Access modifiers changed from: private */
    public static final int encode$lambda$0(Ref.ObjectRef objectRef, byte[] bArr, byte[] bArr2) {
        Object obj = ((Map) objectRef.element).get(bArr);
        Intrinsics.checkNotNull(obj);
        byte[] bArr3 = (byte[]) obj;
        Object obj2 = ((Map) objectRef.element).get(bArr2);
        Intrinsics.checkNotNull(obj2);
        byte[] bArr4 = (byte[]) obj2;
        if (bArr.length > bArr2.length) {
            return 1;
        }
        if (bArr.length >= bArr2.length) {
            if (bArr3.length > bArr4.length) {
                return 1;
            }
            if (bArr3.length >= bArr4.length) {
                return 0;
            }
        }
        return -1;
    }

    private final int getType(byte[] bArr, int i) {
        return (bArr[i] & 255) >> 5;
    }

    private final Arg getArg(byte[] bArr, int i) {
        long j = bArr[i] & 31;
        if (j < 24) {
            return new Arg(j, 1);
        }
        if (j == 24) {
            return new Arg(bArr[i + 1] & 255, 2);
        }
        if (j == 25) {
            return new Arg((bArr[i + 2] & 255) | ((bArr[i + 1] & 255) << 8), 3);
        }
        if (j == 26) {
            return new Arg((bArr[i + 4] & 255) | ((bArr[i + 1] & 255) << 24) | ((bArr[i + 2] & 255) << 16) | ((bArr[i + 3] & 255) << 8), 5);
        }
        throw new IllegalArgumentException("Bad arg");
    }

    private final Item parseItem(byte[] bArr, int i) {
        Map map;
        IntRange until;
        byte[] sliceArray;
        IntRange until2;
        byte[] sliceArray2;
        int type = getType(bArr, i);
        Arg arg = getArg(bArr, i);
        System.out.println((Object) ("Type " + type + ' ' + arg.getArg() + ' ' + arg.getLen()));
        if (type == this.TYPE_UNSIGNED_INT) {
            return new Item(Long.valueOf(arg.getArg()), arg.getLen());
        }
        if (type == this.TYPE_NEGATIVE_INT) {
            return new Item(Long.valueOf((-1) - arg.getArg()), arg.getLen());
        }
        if (type == this.TYPE_BYTE_STRING) {
            until2 = RangesKt___RangesKt.until(arg.getLen() + i, i + arg.getLen() + ((int) arg.getArg()));
            sliceArray2 = ArraysKt___ArraysKt.sliceArray(bArr, until2);
            return new Item(sliceArray2, arg.getLen() + ((int) arg.getArg()));
        }
        if (type == this.TYPE_TEXT_STRING) {
            until = RangesKt___RangesKt.until(arg.getLen() + i, i + arg.getLen() + ((int) arg.getArg()));
            sliceArray = ArraysKt___ArraysKt.sliceArray(bArr, until);
            return new Item(new String(sliceArray, Charsets.UTF_8), arg.getLen() + ((int) arg.getArg()));
        }
        int i2 = 0;
        if (type == this.TYPE_ARRAY) {
            ArrayList arrayList = new ArrayList();
            int len = arg.getLen();
            int arg2 = (int) arg.getArg();
            while (i2 < arg2) {
                Item parseItem = parseItem(bArr, i + len);
                arrayList.add(parseItem.getItem());
                len += parseItem.getLen();
                i2++;
            }
            return new Item(CollectionsKt___CollectionsKt.toList(arrayList), len);
        }
        if (type == this.TYPE_MAP) {
            LinkedHashMap linkedHashMap = new LinkedHashMap();
            int len2 = arg.getLen();
            int arg3 = (int) arg.getArg();
            while (i2 < arg3) {
                Item parseItem2 = parseItem(bArr, i + len2);
                int len3 = len2 + parseItem2.getLen();
                Item parseItem3 = parseItem(bArr, i + len3);
                len2 = len3 + parseItem3.getLen();
                linkedHashMap.put(parseItem2.getItem(), parseItem3.getItem());
                i2++;
            }
            map = MapsKt__MapsKt.toMap(linkedHashMap);
            return new Item(map, len2);
        }
        throw new IllegalArgumentException("Bad type");
    }

    private final byte[] createArg(int i, long j) {
        int i2 = i << 5;
        int i3 = (int) j;
        if (j < 24) {
            return new byte[]{(byte) ((i2 | i3) & 255)};
        }
        if (j <= 255) {
            return new byte[]{(byte) ((i2 | 24) & 255), (byte) (i3 & 255)};
        }
        if (j <= 65535) {
            return new byte[]{(byte) ((i2 | 25) & 255), (byte) ((i3 >> 8) & 255), (byte) (i3 & 255)};
        }
        if (j <= 4294967295L) {
            return new byte[]{(byte) ((i2 | 26) & 255), (byte) ((i3 >> 24) & 255), (byte) ((i3 >> 16) & 255), (byte) ((i3 >> 8) & 255), (byte) (i3 & 255)};
        }
        throw new IllegalArgumentException("bad Arg");
    }
}