package p138.p176.p278.p279;

import com.google.protobuf.InvalidProtocolBufferException;
import java.nio.ByteBuffer;
import java.security.GeneralSecurityException;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.Set;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ConcurrentMap;
import java.util.logging.Logger;
import p138.p139.p143.p144.C2803;
import p138.p176.p278.p279.C5190;
import p138.p176.p278.p279.p287.C5435;
import p138.p176.p278.p279.p287.C5441;
import p138.p176.p278.p279.p287.C5449;
import p138.p176.p278.p279.p287.EnumC5440;
import p138.p176.p328.AbstractC6013;
import p138.p176.p328.InterfaceC6049;

/* JADX INFO: renamed from: ދ.ހ.ހ.֏.ޒ, reason: contains not printable characters */
/* JADX INFO: loaded from: classes.dex */
public final class C5197 {

    /* JADX INFO: renamed from: ֏, reason: contains not printable characters */
    public static final Logger f15429 = Logger.getLogger(C5197.class.getName());

    /* JADX INFO: renamed from: ؠ, reason: contains not printable characters */
    public static final ConcurrentMap<String, InterfaceC5198> f15430 = new ConcurrentHashMap();

    /* JADX INFO: renamed from: ހ, reason: contains not printable characters */
    public static final ConcurrentMap<String, Boolean> f15431 = new ConcurrentHashMap();

    /* JADX INFO: renamed from: ށ, reason: contains not printable characters */
    public static final ConcurrentMap<String, InterfaceC5177<?>> f15432 = new ConcurrentHashMap();

    /* JADX INFO: renamed from: ނ, reason: contains not printable characters */
    public static final ConcurrentMap<Class<?>, InterfaceC5192<?>> f15433 = new ConcurrentHashMap();

    /* JADX INFO: renamed from: ދ.ހ.ހ.֏.ޒ$֏, reason: contains not printable characters */
    public interface InterfaceC5198 {
        /* JADX INFO: renamed from: ֏ */
        InterfaceC5182<?> mo8686();

        /* JADX INFO: renamed from: ֏ */
        <P> InterfaceC5182<P> mo8687(Class<P> cls);

        /* JADX INFO: renamed from: ؠ */
        Class<?> mo8688();

        /* JADX INFO: renamed from: ހ */
        Set<Class<?>> mo8689();
    }

    /* JADX INFO: renamed from: ֏, reason: contains not printable characters */
    public static <P> P m8690(String str, InterfaceC6049 interfaceC6049, Class<P> cls) throws GeneralSecurityException {
        AbstractC5183 abstractC5183;
        if (cls == null || (abstractC5183 = (AbstractC5183) m8693(str, cls)) == null) {
            throw null;
        }
        String strM4868 = C2803.m4868(abstractC5183.f15414, C2803.m4889("Expected proto of type "));
        if (abstractC5183.f15414.isInstance(interfaceC6049)) {
            return (P) abstractC5183.m8664(interfaceC6049);
        }
        throw new GeneralSecurityException(strM4868);
    }

    /* JADX INFO: renamed from: ֏, reason: contains not printable characters */
    public static <P> P m8691(String str, byte[] bArr, Class<P> cls) {
        AbstractC6013 abstractC6013M9354 = AbstractC6013.m9354(bArr);
        if (cls != null) {
            return (P) ((AbstractC5183) m8693(str, cls)).m8654(abstractC6013M9354);
        }
        throw null;
    }

    /* JADX INFO: renamed from: ֏, reason: contains not printable characters */
    public static InterfaceC5177<?> m8692(String str) {
        if (str == null) {
            throw new IllegalArgumentException("catalogueName must be non-null.");
        }
        InterfaceC5177<?> interfaceC5177 = f15432.get(str.toLowerCase());
        if (interfaceC5177 != null) {
            return interfaceC5177;
        }
        String strM4879 = String.format("no catalogue found for %s. ", str);
        if (str.toLowerCase().startsWith("tinkaead")) {
            strM4879 = C2803.m4879(strM4879, "Maybe call AeadConfig.register().");
        }
        if (str.toLowerCase().startsWith("tinkdeterministicaead")) {
            strM4879 = C2803.m4879(strM4879, "Maybe call DeterministicAeadConfig.register().");
        } else if (str.toLowerCase().startsWith("tinkstreamingaead")) {
            strM4879 = C2803.m4879(strM4879, "Maybe call StreamingAeadConfig.register().");
        } else if (str.toLowerCase().startsWith("tinkhybriddecrypt") || str.toLowerCase().startsWith("tinkhybridencrypt")) {
            strM4879 = C2803.m4879(strM4879, "Maybe call HybridConfig.register().");
        } else if (str.toLowerCase().startsWith("tinkmac")) {
            strM4879 = C2803.m4879(strM4879, "Maybe call MacConfig.register().");
        } else if (str.toLowerCase().startsWith("tinkpublickeysign") || str.toLowerCase().startsWith("tinkpublickeyverify")) {
            strM4879 = C2803.m4879(strM4879, "Maybe call SignatureConfig.register().");
        } else if (str.toLowerCase().startsWith("tink")) {
            strM4879 = C2803.m4879(strM4879, "Maybe call TinkConfig.register().");
        }
        throw new GeneralSecurityException(strM4879);
    }

    /* JADX INFO: renamed from: ֏, reason: contains not printable characters */
    public static <P> InterfaceC5182<P> m8693(String str, Class<P> cls) throws GeneralSecurityException {
        InterfaceC5198 interfaceC5198M8702 = m8702(str);
        if (cls == null) {
            return (InterfaceC5182<P>) interfaceC5198M8702.mo8686();
        }
        if (interfaceC5198M8702.mo8689().contains(cls)) {
            return interfaceC5198M8702.mo8687(cls);
        }
        StringBuilder sbM4889 = C2803.m4889("Primitive type ");
        sbM4889.append(cls.getName());
        sbM4889.append(" not supported by key manager of type ");
        sbM4889.append(interfaceC5198M8702.mo8688());
        sbM4889.append(", supported primitives: ");
        Set<Class<?>> setMo8689 = interfaceC5198M8702.mo8689();
        StringBuilder sb = new StringBuilder();
        boolean z = true;
        for (Class<?> cls2 : setMo8689) {
            if (!z) {
                sb.append(", ");
            }
            sb.append(cls2.getCanonicalName());
            z = false;
        }
        sbM4889.append(sb.toString());
        throw new GeneralSecurityException(sbM4889.toString());
    }

    /* JADX INFO: renamed from: ֏, reason: contains not printable characters */
    public static <P> C5190<P> m8694(C5184 c5184, Class<P> cls) {
        byte[] bArrArray;
        if (cls == null) {
            throw null;
        }
        C5200.m8705(c5184.f15417);
        C5190<P> c5190 = new C5190<>(cls);
        for (C5449.C5452 c5452 : c5184.f15417.f15807) {
            if (c5452.m8851() == EnumC5440.ENABLED) {
                String str = c5452.m8849().f15770;
                Object objM8654 = ((AbstractC5183) m8693(str, cls)).m8654(c5452.m8849().f15771);
                if (c5452.m8851() != EnumC5440.ENABLED) {
                    throw new GeneralSecurityException("only ENABLED key is allowed");
                }
                int iOrdinal = c5452.m8850().ordinal();
                if (iOrdinal == 1) {
                    bArrArray = ByteBuffer.allocate(5).put((byte) 1).putInt(c5452.f15813).array();
                } else if (iOrdinal == 2) {
                    bArrArray = ByteBuffer.allocate(5).put((byte) 0).putInt(c5452.f15813).array();
                } else if (iOrdinal != 3) {
                    if (iOrdinal != 4) {
                        throw new GeneralSecurityException("unknown output prefix type");
                    }
                    bArrArray = ByteBuffer.allocate(5).put((byte) 0).putInt(c5452.f15813).array();
                } else {
                    bArrArray = C5178.f15412;
                }
                C5190.C5191<P> c5191 = new C5190.C5191<>(objM8654, bArrArray, c5452.m8851(), c5452.m8850());
                ArrayList arrayList = new ArrayList();
                arrayList.add(c5191);
                String str2 = new String(c5191.m8683(), C5190.f15420);
                List<C5190.C5191<P>> listPut = c5190.f15421.put(str2, Collections.unmodifiableList(arrayList));
                if (listPut != null) {
                    ArrayList arrayList2 = new ArrayList();
                    arrayList2.addAll(listPut);
                    arrayList2.add(c5191);
                    c5190.f15421.put(str2, Collections.unmodifiableList(arrayList2));
                }
                if (c5452.f15813 != c5184.f15417.f15806) {
                    continue;
                } else {
                    if (c5191.f15426 != EnumC5440.ENABLED) {
                        throw new IllegalArgumentException("the primary entry has to be ENABLED");
                    }
                    if (c5190.m8682(c5191.m8683()).isEmpty()) {
                        throw new IllegalArgumentException("the primary entry cannot be set to an entry which is not held by this primitive set");
                    }
                    c5190.f15422 = c5191;
                }
            }
        }
        return c5190;
    }

    /* JADX INFO: renamed from: ֏, reason: contains not printable characters */
    public static synchronized InterfaceC6049 m8695(String str, InterfaceC6049 interfaceC6049) {
        InterfaceC5182 interfaceC5182M8693;
        interfaceC5182M8693 = m8693(str, (Class) null);
        if (!f15431.get(str).booleanValue()) {
            throw new GeneralSecurityException("newKey-operation not permitted for key type " + str);
        }
        return ((AbstractC5183) interfaceC5182M8693).m8658(interfaceC6049);
    }

    /* JADX INFO: renamed from: ֏, reason: contains not printable characters */
    public static synchronized InterfaceC6049 m8696(C5441 c5441) {
        AbstractC6013 abstractC6013;
        AbstractC5183 abstractC5183;
        InterfaceC5182<?> interfaceC5182Mo8686 = m8702(c5441.f15791).mo8686();
        if (!f15431.get(c5441.f15791).booleanValue()) {
            throw new GeneralSecurityException("newKey-operation not permitted for key type " + c5441.f15791);
        }
        abstractC6013 = c5441.f15792;
        abstractC5183 = (AbstractC5183) interfaceC5182Mo8686;
        if (abstractC5183 == null) {
            throw null;
        }
        try {
        } catch (InvalidProtocolBufferException e) {
            throw new GeneralSecurityException("Failures parsing proto of type " + abstractC5183.f15415.getName(), e);
        }
        return abstractC5183.m8662(abstractC5183.mo8659(abstractC6013));
    }

    /* JADX INFO: renamed from: ֏, reason: contains not printable characters */
    public static synchronized <P> void m8697(String str, Class<?> cls, boolean z) {
        if (f15430.containsKey(str)) {
            InterfaceC5198 interfaceC5198 = f15430.get(str);
            if (!interfaceC5198.mo8688().equals(cls)) {
                f15429.warning("Attempted overwrite of a registered key manager for key type " + str);
                throw new GeneralSecurityException(String.format("typeUrl (%s) is already registered with %s, cannot be re-registered with %s", str, interfaceC5198.mo8688().getName(), cls.getName()));
            }
            if (z && !f15431.get(str).booleanValue()) {
                throw new GeneralSecurityException("New keys are already disallowed for key type " + str);
            }
        }
    }

    /* JADX INFO: renamed from: ֏, reason: contains not printable characters */
    public static synchronized void m8698(String str, InterfaceC5177<?> interfaceC5177) {
        if (str == null) {
            throw new IllegalArgumentException("catalogueName must be non-null.");
        }
        if (interfaceC5177 == null) {
            throw new IllegalArgumentException("catalogue must be non-null.");
        }
        if (f15432.containsKey(str.toLowerCase())) {
            if (!interfaceC5177.getClass().equals(f15432.get(str.toLowerCase()).getClass())) {
                f15429.warning("Attempted overwrite of a catalogueName catalogue for name " + str);
                throw new GeneralSecurityException("catalogue for name " + str + " has been already registered");
            }
        }
        f15432.put(str.toLowerCase(), interfaceC5177);
    }

    /* JADX INFO: renamed from: ֏, reason: contains not printable characters */
    public static synchronized <P> void m8699(InterfaceC5182<P> interfaceC5182) {
        m8700((InterfaceC5182) interfaceC5182, true);
    }

    /* JADX INFO: renamed from: ֏, reason: contains not printable characters */
    public static synchronized <P> void m8700(InterfaceC5182<P> interfaceC5182, boolean z) {
        if (interfaceC5182 == null) {
            throw new IllegalArgumentException("key manager must be non-null.");
        }
        String str = ((AbstractC5183) interfaceC5182).f15416;
        m8697(str, interfaceC5182.getClass(), z);
        if (!f15430.containsKey(str)) {
            f15430.put(str, new C5196(interfaceC5182));
        }
        f15431.put(str, Boolean.valueOf(z));
    }

    /* JADX INFO: renamed from: ֏, reason: contains not printable characters */
    public static synchronized <P> void m8701(InterfaceC5192<P> interfaceC5192) {
        if (interfaceC5192 == null) {
            throw new IllegalArgumentException("wrapper must be non-null");
        }
        Class<P> clsMo8684 = interfaceC5192.mo8684();
        if (f15433.containsKey(clsMo8684)) {
            InterfaceC5192<?> interfaceC51922 = f15433.get(clsMo8684);
            if (!interfaceC5192.getClass().equals(interfaceC51922.getClass())) {
                f15429.warning("Attempted overwrite of a registered SetWrapper for type " + clsMo8684.toString());
                throw new GeneralSecurityException(String.format("SetWrapper for primitive (%s) is already registered to be %s, cannot be re-registered with %s", clsMo8684.getName(), interfaceC51922.getClass().getName(), interfaceC5192.getClass().getName()));
            }
        }
        f15433.put(clsMo8684, interfaceC5192);
    }

    /* JADX INFO: renamed from: ؠ, reason: contains not printable characters */
    public static synchronized InterfaceC5198 m8702(String str) {
        if (!f15430.containsKey(str)) {
            throw new GeneralSecurityException("No key manager found for key type " + str);
        }
        return f15430.get(str);
    }

    /* JADX INFO: renamed from: ؠ, reason: contains not printable characters */
    public static synchronized C5435 m8703(C5441 c5441) {
        InterfaceC5182<?> interfaceC5182Mo8686;
        interfaceC5182Mo8686 = m8702(c5441.f15791).mo8686();
        if (!f15431.get(c5441.f15791).booleanValue()) {
            throw new GeneralSecurityException("newKey-operation not permitted for key type " + c5441.f15791);
        }
        return ((AbstractC5183) interfaceC5182Mo8686).m8657(c5441.f15792);
    }
}