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

import java.security.GeneralSecurityException;
import java.util.concurrent.ConcurrentHashMap;
import java.util.logging.Level;
import java.util.logging.Logger;

/* JADX INFO: loaded from: classes2.dex */
public final class yz1 {

    /* JADX INFO: renamed from: c, reason: collision with root package name */
    public static final Logger f19019c = Logger.getLogger(yz1.class.getName());

    /* JADX INFO: renamed from: d, reason: collision with root package name */
    public static final yz1 f19020d = new yz1();

    /* JADX INFO: renamed from: a, reason: collision with root package name */
    public final ConcurrentHashMap f19021a = new ConcurrentHashMap();

    /* JADX INFO: renamed from: b, reason: collision with root package name */
    public final ConcurrentHashMap f19022b = new ConcurrentHashMap();

    public final synchronized void a(e02 e02Var, boolean z10) {
        c(e02Var, 1, z10);
    }

    public final tv1 b(Class cls, String str) throws GeneralSecurityException {
        tv1 tv1VarD = d(str);
        if (((e02) tv1VarD).f10586b.equals(cls)) {
            return tv1VarD;
        }
        String name = cls.getName();
        String strValueOf = String.valueOf(tv1VarD.getClass());
        String string = ((e02) tv1VarD).f10586b.toString();
        StringBuilder sb = new StringBuilder(com.google.android.gms.measurement.internal.u1.c(strValueOf, name.length() + 53, 23) + string.length());
        u.a.h(sb, "Primitive type ", name, " not supported by key manager of type ", strValueOf);
        throw new GeneralSecurityException(defpackage.e.o(sb, ", which only supports: ", string));
    }

    public final synchronized void c(e02 e02Var, int i10, boolean z10) {
        if (!ih1.z(i10)) {
            throw new GeneralSecurityException("Cannot register key manager: FIPS compatibility insufficient");
        }
        e(e02Var, z10);
    }

    public final synchronized tv1 d(String str) {
        ConcurrentHashMap concurrentHashMap;
        concurrentHashMap = this.f19021a;
        if (!concurrentHashMap.containsKey(str)) {
            StringBuilder sb = new StringBuilder(String.valueOf(str).length() + 98);
            sb.append("No key manager found for key type ");
            sb.append(str);
            sb.append(", see https://developers.google.com/tink/faq/registration_errors");
            throw new GeneralSecurityException(sb.toString());
        }
        return (tv1) concurrentHashMap.get(str);
    }

    public final synchronized void e(e02 e02Var, boolean z10) {
        try {
            String str = e02Var.f10585a;
            if (z10) {
                ConcurrentHashMap concurrentHashMap = this.f19022b;
                if (concurrentHashMap.containsKey(str) && !((Boolean) concurrentHashMap.get(str)).booleanValue()) {
                    throw new GeneralSecurityException("New keys are already disallowed for key type ".concat(str));
                }
            }
            ConcurrentHashMap concurrentHashMap2 = this.f19021a;
            tv1 tv1Var = (tv1) concurrentHashMap2.get(str);
            if (tv1Var != null && !tv1Var.getClass().equals(e02Var.getClass())) {
                f19019c.logp(Level.WARNING, "com.google.crypto.tink.internal.KeyManagerRegistry", "insertKeyManager", "Attempted overwrite of a registered key manager for key type ".concat(str));
                throw new GeneralSecurityException(String.format("typeUrl (%s) is already registered with %s, cannot be re-registered with %s", str, tv1Var.getClass().getName(), e02Var.getClass().getName()));
            }
            concurrentHashMap2.putIfAbsent(str, e02Var);
            this.f19022b.put(str, Boolean.valueOf(z10));
        } catch (Throwable th) {
            throw th;
        }
    }
}