package com.squareup.haha.guava.collect;

import com.squareup.haha.guava.base.Joiner;
import com.squareup.haha.guava.collect.Maps;
import java.util.AbstractCollection;
import java.util.Collection;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;

/* loaded from: classes.dex */
abstract class AbstractMultimap<K, V> implements Multimap<K, V> {
    private transient Map<K, Collection<V>> asMap;
    private transient Collection<Map.Entry<K, V>> entries;
    private transient Set<K> keySet;
    private transient Collection<V> values;

    class Entries extends Multimaps$Entries<K, V> {
        private Entries() {
        }

        @Override // java.util.AbstractCollection, java.util.Collection, java.lang.Iterable
        public Iterator<Map.Entry<K, V>> iterator() {
            return AbstractMultimap.this.entryIterator();
        }

        @Override // com.squareup.haha.guava.collect.Multimaps$Entries
        final Multimap<K, V> multimap() {
            return AbstractMultimap.this;
        }

        /* synthetic */ Entries(AbstractMultimap abstractMultimap, byte b) {
            this();
        }
    }

    class EntrySet extends Entries implements Set {
        private EntrySet(AbstractMultimap abstractMultimap) {
            super(abstractMultimap, (byte) 0);
        }

        @Override // java.util.Collection, java.util.Set
        public final boolean equals(Object obj) {
            return Joiner.equalsImpl(this, obj);
        }

        @Override // java.util.Collection, java.util.Set
        public final int hashCode() {
            Iterator it = iterator();
            int i = 0;
            while (it.hasNext()) {
                Object next = it.next();
                i = ~(~(i + (next != null ? next.hashCode() : 0)));
            }
            return i;
        }

        /* synthetic */ EntrySet(AbstractMultimap abstractMultimap, byte b) {
            this(abstractMultimap);
        }
    }

    class Values extends AbstractCollection<V> {
        Values() {
        }

        @Override // java.util.AbstractCollection, java.util.Collection
        public final void clear() {
            AbstractMultimap.this.clear();
        }

        @Override // java.util.AbstractCollection, java.util.Collection
        public final boolean contains(Object obj) {
            return AbstractMultimap.this.containsValue(obj);
        }

        @Override // java.util.AbstractCollection, java.util.Collection, java.lang.Iterable
        public final Iterator<V> iterator() {
            return AbstractMultimap.this.valueIterator();
        }

        @Override // java.util.AbstractCollection, java.util.Collection
        public final int size() {
            return AbstractMultimap.this.size();
        }
    }

    AbstractMultimap() {
    }

    @Override // com.squareup.haha.guava.collect.Multimap
    public Map<K, Collection<V>> asMap() {
        Map<K, Collection<V>> map = this.asMap;
        if (map != null) {
            return map;
        }
        Map<K, Collection<V>> createAsMap = createAsMap();
        this.asMap = createAsMap;
        return createAsMap;
    }

    @Override // com.squareup.haha.guava.collect.Multimap
    public boolean containsEntry(Object obj, Object obj2) {
        Collection<V> collection = asMap().get(obj);
        return collection != null && collection.contains(obj2);
    }

    public boolean containsValue(Object obj) {
        Iterator<Collection<V>> it = asMap().values().iterator();
        while (it.hasNext()) {
            if (it.next().contains(obj)) {
                return true;
            }
        }
        return false;
    }

    abstract Map<K, Collection<V>> createAsMap();

    Set<K> createKeySet() {
        return new Maps.KeySet(asMap());
    }

    public Collection<Map.Entry<K, V>> entries() {
        Collection<Map.Entry<K, V>> collection = this.entries;
        if (collection == null) {
            byte b = 0;
            collection = this instanceof SetMultimap ? new EntrySet(this, b) : new Entries(this, b);
            this.entries = collection;
        }
        return collection;
    }

    abstract Iterator<Map.Entry<K, V>> entryIterator();

    public boolean equals(Object obj) {
        if (obj == this) {
            return true;
        }
        if (obj instanceof Multimap) {
            return asMap().equals(((Multimap) obj).asMap());
        }
        return false;
    }

    public int hashCode() {
        return asMap().hashCode();
    }

    public Set<K> keySet() {
        Set<K> set = this.keySet;
        if (set != null) {
            return set;
        }
        Set<K> createKeySet = createKeySet();
        this.keySet = createKeySet;
        return createKeySet;
    }

    @Override // com.squareup.haha.guava.collect.Multimap
    public boolean put(K k, V v) {
        return get(k).add(v);
    }

    @Override // com.squareup.haha.guava.collect.Multimap
    public boolean remove(Object obj, Object obj2) {
        Collection<V> collection = asMap().get(obj);
        return collection != null && collection.remove(obj2);
    }

    public String toString() {
        return asMap().toString();
    }

    Iterator<V> valueIterator() {
        return Maps.valueIterator(entries().iterator());
    }

    @Override // com.squareup.haha.guava.collect.Multimap
    public Collection<V> values() {
        Collection<V> collection = this.values;
        if (collection != null) {
            return collection;
        }
        Values values = new Values();
        this.values = values;
        return values;
    }
}