package com.revenuecat.purchases.ui.revenuecatui.helpers;

import J4.c;
import androidx.compose.runtime.internal.StabilityInferred;
import java.util.Collection;
import java.util.Iterator;
import java.util.LinkedHashMap;
import java.util.Map;
import java.util.Set;
import java.util.function.BiFunction;
import java.util.function.Function;
import kotlin.jvm.internal.o;
import w4.k;
import x4.AbstractC3229F;
import x4.AbstractC3251q;

/* JADX INFO: loaded from: classes3.dex */
@StabilityInferred(parameters = 0)
public final class NonEmptyMap<K, V> implements Map<K, V>, K4.a {
    public static final int $stable = 8;
    private final Map<K, V> all;
    private final Map.Entry<K, V> entry;
    private final NonEmptySet<K> keys;

    /* JADX WARN: Multi-variable type inference failed */
    private NonEmptyMap(Map.Entry<? extends K, ? extends V> entry, Map<K, ? extends V> map) {
        this.entry = entry;
        this.all = map;
        this.keys = new NonEmptySet<>(entry.getKey(), (Iterable<? extends Object>) map.keySet());
    }

    @Override // java.util.Map
    public void clear() {
        throw new UnsupportedOperationException("Operation is not supported for read-only collection");
    }

    @Override // java.util.Map
    public V compute(K k6, BiFunction<? super K, ? super V, ? extends V> biFunction) {
        throw new UnsupportedOperationException("Operation is not supported for read-only collection");
    }

    @Override // java.util.Map
    public V computeIfAbsent(K k6, Function<? super K, ? extends V> function) {
        throw new UnsupportedOperationException("Operation is not supported for read-only collection");
    }

    @Override // java.util.Map
    public V computeIfPresent(K k6, BiFunction<? super K, ? super V, ? extends V> biFunction) {
        throw new UnsupportedOperationException("Operation is not supported for read-only collection");
    }

    @Override // java.util.Map
    public boolean containsKey(Object obj) {
        return this.all.containsKey(obj);
    }

    @Override // java.util.Map
    public boolean containsValue(Object obj) {
        return this.all.containsValue(obj);
    }

    @Override // java.util.Map
    public final /* bridge */ Set<Map.Entry<K, V>> entrySet() {
        return getEntries();
    }

    @Override // java.util.Map
    public boolean equals(Object obj) {
        if (!(obj instanceof NonEmptyMap)) {
            return o.c(this.all, obj);
        }
        NonEmptyMap nonEmptyMap = (NonEmptyMap) obj;
        return o.c(this.entry, nonEmptyMap.entry) && o.c(this.all, nonEmptyMap.all);
    }

    @Override // java.util.Map
    public V get(Object obj) {
        return this.all.get(obj);
    }

    public Set<Map.Entry<K, V>> getEntries() {
        return this.all.entrySet();
    }

    public final /* synthetic */ Map.Entry getEntry() {
        return this.entry;
    }

    public NonEmptySet<K> getKeys() {
        return this.keys;
    }

    public int getSize() {
        return this.all.size();
    }

    public Collection<V> getValues() {
        return this.all.values();
    }

    @Override // java.util.Map
    public int hashCode() {
        return this.all.hashCode();
    }

    @Override // java.util.Map
    public /* synthetic */ boolean isEmpty() {
        return false;
    }

    @Override // java.util.Map
    public final /* bridge */ NonEmptySet<K> keySet() {
        return getKeys();
    }

    /* JADX WARN: Multi-variable type inference failed */
    public final <R> NonEmptyMap<R, V> mapKeys(c transform) {
        o.h(transform, "transform");
        Object objInvoke = transform.invoke(getEntry());
        Map map = this.all;
        LinkedHashMap linkedHashMap = new LinkedHashMap(AbstractC3229F.u(map.size()));
        Iterator<T> it = map.entrySet().iterator();
        while (it.hasNext()) {
            Map.Entry entry = (Map.Entry) it.next();
            linkedHashMap.put(o.c(entry.getKey(), getEntry().getKey()) ? objInvoke : transform.invoke(entry), entry.getValue());
        }
        return NonEmptyMapKt.nonEmptyMapOf(new k(objInvoke, AbstractC3229F.t(objInvoke, linkedHashMap)), linkedHashMap);
    }

    /* JADX WARN: Multi-variable type inference failed */
    public final <R> NonEmptyMap<K, R> mapValues(c transform) {
        o.h(transform, "transform");
        Map map = this.all;
        LinkedHashMap linkedHashMap = new LinkedHashMap(AbstractC3229F.u(map.size()));
        for (Object obj : map.entrySet()) {
            linkedHashMap.put(((Map.Entry) obj).getKey(), transform.invoke(obj));
        }
        return NonEmptyMapKt.nonEmptyMapOf(new k(getEntry().getKey(), AbstractC3229F.t(getEntry().getKey(), linkedHashMap)), linkedHashMap);
    }

    @Override // java.util.Map
    public V merge(K k6, V v3, BiFunction<? super V, ? super V, ? extends V> biFunction) {
        throw new UnsupportedOperationException("Operation is not supported for read-only collection");
    }

    @Override // java.util.Map
    public V put(K k6, V v3) {
        throw new UnsupportedOperationException("Operation is not supported for read-only collection");
    }

    @Override // java.util.Map
    public void putAll(Map<? extends K, ? extends V> map) {
        throw new UnsupportedOperationException("Operation is not supported for read-only collection");
    }

    @Override // java.util.Map
    public V putIfAbsent(K k6, V v3) {
        throw new UnsupportedOperationException("Operation is not supported for read-only collection");
    }

    @Override // java.util.Map
    public V remove(Object obj) {
        throw new UnsupportedOperationException("Operation is not supported for read-only collection");
    }

    @Override // java.util.Map
    public V replace(K k6, V v3) {
        throw new UnsupportedOperationException("Operation is not supported for read-only collection");
    }

    @Override // java.util.Map
    public void replaceAll(BiFunction<? super K, ? super V, ? extends V> biFunction) {
        throw new UnsupportedOperationException("Operation is not supported for read-only collection");
    }

    @Override // java.util.Map
    public final /* bridge */ int size() {
        return getSize();
    }

    public final /* synthetic */ Map toMap() {
        return this.all;
    }

    public String toString() {
        return Z0.o.r(new StringBuilder("NonEmptyMap("), AbstractC3251q.m0(this.all.entrySet(), null, null, null, null, 63), ')');
    }

    @Override // java.util.Map
    public final /* bridge */ Collection<V> values() {
        return getValues();
    }

    @Override // java.util.Map
    public boolean remove(Object obj, Object obj2) {
        throw new UnsupportedOperationException("Operation is not supported for read-only collection");
    }

    @Override // java.util.Map
    public boolean replace(K k6, V v3, V v6) {
        throw new UnsupportedOperationException("Operation is not supported for read-only collection");
    }

    /* JADX WARN: 'this' call moved to the top of the method (can break code semantics) */
    public NonEmptyMap(k entry, Map<K, ? extends V> tail) {
        this((Map.Entry) AbstractC3251q.d0(AbstractC3229F.v(entry).entrySet()), AbstractC3229F.A(entry, tail));
        o.h(entry, "entry");
        o.h(tail, "tail");
    }
}