package com.google.firebase.firestore;

import com.google.firebase.firestore.AggregateField;
import com.google.firebase.firestore.DocumentSnapshot;
import com.google.firebase.firestore.util.Preconditions;
import e4.G0;
import e4.H0;
import java.util.Collections;
import java.util.Map;
import java.util.Objects;

/* JADX INFO: loaded from: classes3.dex */
public class AggregateQuerySnapshot {
    private final Map<String, H0> data;
    private final AggregateQuery query;

    public AggregateQuerySnapshot(AggregateQuery aggregateQuery, Map<String, H0> map) {
        Preconditions.checkNotNull(aggregateQuery);
        this.query = aggregateQuery;
        this.data = map;
    }

    private <T> T castTypedValue(Object obj, AggregateField aggregateField, Class<T> cls) {
        if (obj == null) {
            return null;
        }
        if (cls.isInstance(obj)) {
            return cls.cast(obj);
        }
        throw new RuntimeException("AggregateField '" + aggregateField.getAlias() + "' is not a " + cls.getName());
    }

    public static AggregateQuerySnapshot createWithCount(AggregateQuery aggregateQuery, long j4) {
        String alias = AggregateField.count().getAlias();
        G0 g0C = H0.C();
        g0C.k(j4);
        return new AggregateQuerySnapshot(aggregateQuery, Collections.singletonMap(alias, (H0) g0C.m359build()));
    }

    private Object getInternal(AggregateField aggregateField) {
        if (this.data.containsKey(aggregateField.getAlias())) {
            return new UserDataWriter(this.query.getQuery().firestore, DocumentSnapshot.ServerTimestampBehavior.DEFAULT).convertValue(this.data.get(aggregateField.getAlias()));
        }
        throw new IllegalArgumentException("'" + aggregateField.getOperator() + "(" + aggregateField.getFieldPath() + ")' was not requested in the aggregation query.");
    }

    private <T> T getTypedValue(AggregateField aggregateField, Class<T> cls) {
        return (T) castTypedValue(getInternal(aggregateField), aggregateField, cls);
    }

    public boolean equals(Object obj) {
        if (this == obj) {
            return true;
        }
        if (!(obj instanceof AggregateQuerySnapshot)) {
            return false;
        }
        AggregateQuerySnapshot aggregateQuerySnapshot = (AggregateQuerySnapshot) obj;
        return this.query.equals(aggregateQuerySnapshot.query) && this.data.equals(aggregateQuerySnapshot.data);
    }

    public Object get(AggregateField aggregateField) {
        return getInternal(aggregateField);
    }

    public long getCount() {
        return get(AggregateField.count());
    }

    public Double getDouble(AggregateField aggregateField) {
        Number number = (Number) getTypedValue(aggregateField, Number.class);
        if (number != null) {
            return Double.valueOf(number.doubleValue());
        }
        return null;
    }

    public Long getLong(AggregateField aggregateField) {
        Number number = (Number) getTypedValue(aggregateField, Number.class);
        if (number != null) {
            return Long.valueOf(number.longValue());
        }
        return null;
    }

    public AggregateQuery getQuery() {
        return this.query;
    }

    public int hashCode() {
        return Objects.hash(this.query, this.data);
    }

    public long get(AggregateField.CountAggregateField countAggregateField) {
        Long l = getLong(countAggregateField);
        if (l != null) {
            return l.longValue();
        }
        throw new IllegalArgumentException("RunAggregationQueryResponse alias " + countAggregateField.getAlias() + " is null");
    }

    public Double get(AggregateField.AverageAggregateField averageAggregateField) {
        return getDouble(averageAggregateField);
    }
}