package androidx.datastore.preferences.core;

import java.util.Arrays;
import java.util.Collections;
import java.util.Iterator;
import java.util.LinkedHashMap;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.atomic.AtomicBoolean;
import kotlin.Pair;
import kotlin.collections.i;
import kotlin.collections.n;
import sd.l;
import xyz.stream.utils.f0;

/* JADX INFO: loaded from: classes.dex */
public final class a extends f {

    /* JADX INFO: renamed from: a, reason: collision with root package name */
    public final Map f1984a;

    /* JADX INFO: renamed from: b, reason: collision with root package name */
    public final f0 f1985b;

    public a(boolean z10, Map map) {
        nb.g.i(map, "preferencesMap");
        this.f1984a = map;
        this.f1985b = new f0(z10);
    }

    @Override // androidx.datastore.preferences.core.f
    public final Map a() {
        Pair pair;
        Set<Map.Entry> setEntrySet = this.f1984a.entrySet();
        int iD = ua.b.D(i.Z0(10, setEntrySet));
        if (iD < 16) {
            iD = 16;
        }
        LinkedHashMap linkedHashMap = new LinkedHashMap(iD);
        for (Map.Entry entry : setEntrySet) {
            Object value = entry.getValue();
            if (value instanceof byte[]) {
                Object key = entry.getKey();
                byte[] bArr = (byte[]) value;
                byte[] bArrCopyOf = Arrays.copyOf(bArr, bArr.length);
                nb.g.h(bArrCopyOf, "copyOf(this, size)");
                pair = new Pair(key, bArrCopyOf);
            } else {
                pair = new Pair(entry.getKey(), entry.getValue());
            }
            linkedHashMap.put(pair.c(), pair.d());
        }
        Map mapUnmodifiableMap = Collections.unmodifiableMap(linkedHashMap);
        nb.g.h(mapUnmodifiableMap, "unmodifiableMap(map)");
        return mapUnmodifiableMap;
    }

    @Override // androidx.datastore.preferences.core.f
    public final Object b(d dVar) {
        nb.g.i(dVar, "key");
        Object obj = this.f1984a.get(dVar);
        if (!(obj instanceof byte[])) {
            return obj;
        }
        byte[] bArr = (byte[]) obj;
        byte[] bArrCopyOf = Arrays.copyOf(bArr, bArr.length);
        nb.g.h(bArrCopyOf, "copyOf(this, size)");
        return bArrCopyOf;
    }

    public final void c() {
        if (!(!((AtomicBoolean) this.f1985b.f36136b).get())) {
            throw new IllegalStateException("Do mutate preferences once returned to DataStore.".toString());
        }
    }

    public final void d(d dVar, Object obj) {
        nb.g.i(dVar, "key");
        c();
        Map map = this.f1984a;
        if (obj == null) {
            c();
            map.remove(dVar);
            return;
        }
        if (obj instanceof Set) {
            Set setUnmodifiableSet = Collections.unmodifiableSet(n.t1((Set) obj));
            nb.g.h(setUnmodifiableSet, "unmodifiableSet(set.toSet())");
            map.put(dVar, setUnmodifiableSet);
        } else {
            if (!(obj instanceof byte[])) {
                map.put(dVar, obj);
                return;
            }
            byte[] bArr = (byte[]) obj;
            byte[] bArrCopyOf = Arrays.copyOf(bArr, bArr.length);
            nb.g.h(bArrCopyOf, "copyOf(this, size)");
            map.put(dVar, bArrCopyOf);
        }
    }

    public final boolean equals(Object obj) {
        if (!(obj instanceof a)) {
            return false;
        }
        a aVar = (a) obj;
        Map map = aVar.f1984a;
        Map map2 = this.f1984a;
        if (map == map2) {
            return true;
        }
        if (map.size() != map2.size()) {
            return false;
        }
        Map map3 = aVar.f1984a;
        if (!map3.isEmpty()) {
            for (Map.Entry entry : map3.entrySet()) {
                Object obj2 = map2.get(entry.getKey());
                if (obj2 == null) {
                    return false;
                }
                Object value = entry.getValue();
                if (value instanceof byte[]) {
                    if (!(obj2 instanceof byte[]) || !Arrays.equals((byte[]) value, (byte[]) obj2)) {
                        return false;
                    }
                } else if (!nb.g.c(value, obj2)) {
                    return false;
                }
            }
        }
        return true;
    }

    public final int hashCode() {
        Iterator it = this.f1984a.entrySet().iterator();
        int iHashCode = 0;
        while (it.hasNext()) {
            Object value = ((Map.Entry) it.next()).getValue();
            iHashCode += value instanceof byte[] ? Arrays.hashCode((byte[]) value) : value.hashCode();
        }
        return iHashCode;
    }

    public final String toString() {
        return n.j1(this.f1984a.entrySet(), ",\n", "{\n", "\n}", new l() { // from class: androidx.datastore.preferences.core.MutablePreferences$toString$1
            @Override // sd.l
            public final Object invoke(Object obj) {
                String strValueOf;
                Map.Entry entry = (Map.Entry) obj;
                nb.g.i(entry, "entry");
                Object value = entry.getValue();
                if (value instanceof byte[]) {
                    byte[] bArr = (byte[]) value;
                    nb.g.i(bArr, "<this>");
                    StringBuilder sb = new StringBuilder();
                    sb.append((CharSequence) "[");
                    int i10 = 0;
                    for (byte b10 : bArr) {
                        i10++;
                        if (i10 > 1) {
                            sb.append((CharSequence) ", ");
                        }
                        sb.append((CharSequence) String.valueOf((int) b10));
                    }
                    sb.append((CharSequence) "]");
                    strValueOf = sb.toString();
                    nb.g.h(strValueOf, "joinTo(StringBuilder(), …ed, transform).toString()");
                } else {
                    strValueOf = String.valueOf(entry.getValue());
                }
                return defpackage.e.p(new StringBuilder("  "), ((d) entry.getKey()).f1991a, " = ", strValueOf);
            }
        }, 24);
    }

    public /* synthetic */ a(boolean z10) {
        this(z10, new LinkedHashMap());
    }
}