package com.revenuecat.purchases.utils.serializers;

import J4.c;
import g5.a;
import i5.e;
import i5.g;
import j5.d;
import java.lang.Enum;
import java.util.LinkedHashMap;
import java.util.Locale;
import java.util.Map;
import kotlin.jvm.internal.h;
import kotlin.jvm.internal.o;
import kotlin.jvm.internal.p;
import w4.j;
import x4.AbstractC3229F;

/* JADX INFO: loaded from: classes3.dex */
public abstract class EnumDeserializerWithDefault<T extends Enum<T>> implements a {
    private final T defaultValue;
    private final g descriptor;
    private final String enumName;
    private final Map<String, T> valuesByType;

    /* JADX INFO: renamed from: com.revenuecat.purchases.utils.serializers.EnumDeserializerWithDefault$1, reason: invalid class name */
    public static final class AnonymousClass1 extends p implements c {
        public static final AnonymousClass1 INSTANCE = new AnonymousClass1();

        public AnonymousClass1() {
            super(1);
        }

        @Override // J4.c
        public final String invoke(T value) {
            o.h(value, "value");
            String lowerCase = value.name().toLowerCase(Locale.ROOT);
            o.g(lowerCase, "toLowerCase(...)");
            return lowerCase;
        }
    }

    /* JADX WARN: Multi-variable type inference failed */
    public EnumDeserializerWithDefault(Map<String, ? extends T> valuesByType, T defaultValue) {
        o.h(valuesByType, "valuesByType");
        o.h(defaultValue, "defaultValue");
        this.valuesByType = valuesByType;
        this.defaultValue = defaultValue;
        String simpleName = defaultValue.getClass().getSimpleName();
        this.enumName = simpleName;
        this.descriptor = W.a.L(simpleName, e.f19086r);
    }

    @Override // g5.a
    public g getDescriptor() {
        return this.descriptor;
    }

    @Override // g5.a
    public T deserialize(j5.c decoder) {
        o.h(decoder, "decoder");
        T t6 = this.valuesByType.get(decoder.q());
        return t6 == null ? this.defaultValue : t6;
    }

    @Override // g5.a
    public void serialize(d encoder, T value) {
        o.h(encoder, "encoder");
        o.h(value, "value");
        throw new j("Serialization is not implemented because it is not needed.");
    }

    public /* synthetic */ EnumDeserializerWithDefault(Enum r12, c cVar, int i6, h hVar) {
        this(r12, (i6 & 2) != 0 ? AnonymousClass1.INSTANCE : cVar);
    }

    public EnumDeserializerWithDefault(T defaultValue, c typeForValue) {
        o.h(defaultValue, "defaultValue");
        o.h(typeForValue, "typeForValue");
        Object[] enumConstants = defaultValue.getClass().getEnumConstants();
        o.g(enumConstants, "defaultValue::class.java.enumConstants");
        int iU = AbstractC3229F.u(enumConstants.length);
        LinkedHashMap linkedHashMap = new LinkedHashMap(iU < 16 ? 16 : iU);
        for (Object obj : enumConstants) {
            linkedHashMap.put(typeForValue.invoke(obj), obj);
        }
        this(linkedHashMap, defaultValue);
    }
}