package com.google.android.gms.internal.p002firebaseauthapi;

import com.google.android.gms.internal.p002firebaseauthapi.zzij;
import java.security.GeneralSecurityException;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ConcurrentMap;
import java.util.logging.Level;
import java.util.logging.Logger;
import q.AbstractC2761L;

/* JADX INFO: loaded from: classes3.dex */
public final class zzna {
    private static final Logger zza = Logger.getLogger(zzna.class.getName());
    private static final zzna zzb = new zzna();
    private ConcurrentMap<String, zzbn<?>> zzc = new ConcurrentHashMap();
    private ConcurrentMap<String, Boolean> zzd = new ConcurrentHashMap();

    private final synchronized zzbn<?> zzc(String str) {
        if (!this.zzc.containsKey(str)) {
            throw new GeneralSecurityException("No key manager found for key type " + str);
        }
        return this.zzc.get(str);
    }

    public final <P> zzbn<P> zza(String str, Class<P> cls) throws GeneralSecurityException {
        zzbn<P> zzbnVar = (zzbn<P>) zzc(str);
        if (zzbnVar.zza().equals(cls)) {
            return zzbnVar;
        }
        String name = cls.getName();
        String strValueOf = String.valueOf(zzbnVar.getClass());
        String strValueOf2 = String.valueOf(zzbnVar.zza());
        StringBuilder sbI = AbstractC2761L.i("Primitive type ", name, " not supported by key manager of type ", strValueOf, ", which only supports: ");
        sbI.append(strValueOf2);
        throw new GeneralSecurityException(sbI.toString());
    }

    public final boolean zzb(String str) {
        return this.zzd.get(str).booleanValue();
    }

    public final zzbn<?> zza(String str) {
        return zzc(str);
    }

    public static zzna zza() {
        return zzb;
    }

    private final synchronized void zza(zzbn<?> zzbnVar, boolean z6, boolean z7) {
        try {
            String strZzb = zzbnVar.zzb();
            if (z7 && this.zzd.containsKey(strZzb) && !this.zzd.get(strZzb).booleanValue()) {
                throw new GeneralSecurityException("New keys are already disallowed for key type " + strZzb);
            }
            zzbn<?> zzbnVar2 = this.zzc.get(strZzb);
            if (zzbnVar2 != null && !zzbnVar2.getClass().equals(zzbnVar.getClass())) {
                zza.logp(Level.WARNING, "com.google.crypto.tink.internal.KeyManagerRegistry", "insertKeyManager", "Attempted overwrite of a registered key manager for key type " + strZzb);
                throw new GeneralSecurityException("typeUrl (" + strZzb + ") is already registered with " + zzbnVar2.getClass().getName() + ", cannot be re-registered with " + zzbnVar.getClass().getName());
            }
            this.zzc.putIfAbsent(strZzb, zzbnVar);
            this.zzd.put(strZzb, Boolean.valueOf(z7));
        } catch (Throwable th) {
            throw th;
        }
    }

    public final synchronized <P> void zza(zzbn<P> zzbnVar, boolean z6) {
        zza(zzbnVar, zzij.zza.zza, z6);
    }

    public final synchronized <P> void zza(zzbn<P> zzbnVar, zzij.zza zzaVar, boolean z6) {
        if (zzaVar.zza()) {
            zza((zzbn<?>) zzbnVar, false, z6);
        } else {
            throw new GeneralSecurityException("Cannot register key manager: FIPS compatibility insufficient");
        }
    }
}