package com.google.ads.interactivemedia.v3.internal;

import com.google.android.gms.measurement.internal.u1;
import defpackage.e;
import java.lang.reflect.AccessibleObject;
import java.lang.reflect.Field;
import java.lang.reflect.Member;
import java.lang.reflect.Method;
import java.lang.reflect.Modifier;
import java.lang.reflect.Type;
import java.util.ArrayList;
import java.util.Collections;
import java.util.LinkedHashMap;
import java.util.List;

/* JADX INFO: loaded from: classes2.dex */
public final class zzzq implements zzwk {
    private final zzxl zza;
    private final zzxn zzb;
    private final zzyx zzc;
    private final List zzd;
    private final int zze;

    public zzzq(zzxl zzxlVar, int i10, zzxn zzxnVar, zzyx zzyxVar, List list) {
        this.zza = zzxlVar;
        this.zze = i10;
        this.zzb = zzxnVar;
        this.zzc = zzyxVar;
        this.zzd = list;
    }

    /* JADX WARN: Multi-variable type inference failed */
    public static /* bridge */ /* synthetic */ void zzb(Object obj, AccessibleObject accessibleObject) {
        if (true == Modifier.isStatic(((Member) accessibleObject).getModifiers())) {
            obj = null;
        }
        if (!zzyf.zza(accessibleObject, obj)) {
            throw new zzvx(zzabp.zze(accessibleObject, true).concat(" is not accessible and ReflectionAccessFilter does not permit making it accessible. Register a TypeAdapter for the declaring type, adjust the access filter or increase the visibility of the element and its declaring type."));
        }
    }

    /* JADX WARN: Removed duplicated region for block: B:117:0x0204 A[SYNTHETIC] */
    /* JADX WARN: Removed duplicated region for block: B:31:0x0090  */
    /* JADX WARN: Removed duplicated region for block: B:45:0x00c9  */
    /* JADX WARN: Removed duplicated region for block: B:51:0x00e7  */
    /* JADX WARN: Removed duplicated region for block: B:59:0x00fd  */
    /* JADX WARN: Removed duplicated region for block: B:65:0x0131  */
    /* JADX WARN: Removed duplicated region for block: B:68:0x013a  */
    /* JADX WARN: Removed duplicated region for block: B:74:0x014f  */
    /* JADX WARN: Removed duplicated region for block: B:77:0x015c  */
    /* JADX WARN: Removed duplicated region for block: B:78:0x017b  */
    /* JADX WARN: Removed duplicated region for block: B:80:0x018a  */
    /* JADX WARN: Removed duplicated region for block: B:81:0x0192  */
    /* JADX WARN: Removed duplicated region for block: B:86:0x01a6  */
    /* JADX WARN: Removed duplicated region for block: B:89:0x01cc  */
    /* JADX WARN: Removed duplicated region for block: B:99:0x01f2  */
    /*
        Code decompiled incorrectly, please refer to instructions dump.
    */
    private final zzzo zzc(zzvr zzvrVar, zzaca zzacaVar, Class cls, boolean z10, boolean z11) {
        boolean z12;
        boolean z13;
        Method methodZzh;
        zzwm zzwmVar;
        int i10;
        List list;
        List listSingletonList;
        zzwl zzwlVar;
        zzaca zzacaVar2;
        String str;
        Field field;
        int i11;
        int i12;
        boolean z14;
        zzwj zzwjVarZzb;
        zzaca zzacaVar3;
        zzwj zzwjVarZza;
        boolean z15;
        Field[] fieldArr;
        Class cls2;
        zzzq zzzqVar = this;
        if (cls.isInterface()) {
            return zzzo.zza;
        }
        LinkedHashMap linkedHashMap = new LinkedHashMap();
        LinkedHashMap linkedHashMap2 = new LinkedHashMap();
        zzaca zzacaVarZzb = zzacaVar;
        boolean z16 = z10;
        Class clsZzc = cls;
        while (clsZzc != Object.class) {
            Field[] declaredFields = clsZzc.getDeclaredFields();
            boolean z17 = true;
            boolean z18 = false;
            if (clsZzc == cls || declaredFields.length <= 0) {
                z12 = z16;
            } else {
                int iZzb = zzyf.zzb(zzzqVar.zzd, clsZzc);
                if (iZzb == 4) {
                    throw new zzvx("ReflectionAccessFilter does not permit using reflection for " + String.valueOf(clsZzc) + " (supertype of " + String.valueOf(cls) + "). Register a TypeAdapter for this type or adjust the access filter.");
                }
                z12 = iZzb == 3;
            }
            int length = declaredFields.length;
            int i13 = 0;
            while (i13 < length) {
                Field field2 = declaredFields[i13];
                boolean zZze = zzzqVar.zze(field2, z17);
                boolean zZze2 = zzzqVar.zze(field2, z18);
                if (zZze) {
                    if (z11) {
                        z13 = zZze2;
                        methodZzh = null;
                    } else if (Modifier.isStatic(field2.getModifiers())) {
                        methodZzh = null;
                        z13 = z18;
                    } else {
                        methodZzh = zzabp.zzh(clsZzc, field2);
                        if (!z12) {
                            zzabp.zzi(methodZzh);
                        }
                        if (methodZzh.getAnnotation(zzwm.class) != null && field2.getAnnotation(zzwm.class) == null) {
                            throw new zzvx(u1.k("@SerializedName on ", zzabp.zze(methodZzh, z18), " is not supported"));
                        }
                        z13 = zZze2;
                    }
                    if (!z12 && methodZzh == null) {
                        zzabp.zzi(field2);
                    }
                    Type typeZze = zzwr.zze(zzacaVarZzb.zzd(), clsZzc, field2.getGenericType());
                    zzwmVar = (zzwm) field2.getAnnotation(zzwm.class);
                    if (zzwmVar != null) {
                        int i14 = zzzqVar.zze;
                        if (i14 == 0) {
                            throw null;
                        }
                        if (i14 - 1 != 0) {
                            throw null;
                        }
                        listSingletonList = Collections.singletonList(field2.getName());
                    } else {
                        String strZza = zzwmVar.zza();
                        String[] strArrZzb = zzwmVar.zzb();
                        int length2 = strArrZzb.length;
                        if (length2 == 0) {
                            listSingletonList = Collections.singletonList(strZza);
                        } else {
                            i10 = i13;
                            ArrayList arrayList = new ArrayList(length2 + 1);
                            arrayList.add(strZza);
                            Collections.addAll(arrayList, strArrZzb);
                            list = arrayList;
                            String str2 = (String) list.get(0);
                            zzaca zzacaVarZzb2 = zzaca.zzb(typeZze);
                            Class clsZzc2 = zzacaVarZzb2.zzc();
                            boolean z19 = (clsZzc2 instanceof Class) && clsZzc2.isPrimitive();
                            int modifiers = field2.getModifiers();
                            boolean z20 = !Modifier.isStatic(modifiers) && Modifier.isFinal(modifiers);
                            zzwlVar = (zzwl) field2.getAnnotation(zzwl.class);
                            if (zzwlVar == null) {
                                zzacaVar2 = zzacaVarZzb2;
                                str = str2;
                                field = field2;
                                i12 = i10;
                                z14 = false;
                                i11 = length;
                                zzwjVarZzb = zzzqVar.zzc.zzb(zzzqVar.zza, zzvrVar, zzacaVar2, zzwlVar, false);
                            } else {
                                zzacaVar2 = zzacaVarZzb2;
                                str = str2;
                                field = field2;
                                i11 = length;
                                i12 = i10;
                                z14 = false;
                                zzwjVarZzb = null;
                            }
                            if (zzwjVarZzb != null) {
                                zzacaVar3 = zzacaVar2;
                                zzwjVarZza = zzvrVar.zza(zzacaVar3);
                            } else {
                                zzacaVar3 = zzacaVar2;
                                zzwjVarZza = zzwjVarZzb;
                            }
                            List<String> list2 = list;
                            z15 = true;
                            fieldArr = declaredFields;
                            cls2 = clsZzc;
                            zzzk zzzkVar = new zzzk(this, str, field, z12, methodZzh, (zZze || zzwjVarZzb != null) ? zzwjVarZza : new zzzw(zzvrVar, zzwjVarZza, zzacaVar3.zzd()), zzwjVarZza, z19, z20);
                            if (z13) {
                                for (String str3 : list2) {
                                    zzzm zzzmVar = (zzzm) linkedHashMap.put(str3, zzzkVar);
                                    if (zzzmVar != null) {
                                        throw zzd(cls, str3, zzzmVar.zzh, field);
                                    }
                                }
                            }
                            Field field3 = field;
                            if (zZze) {
                                continue;
                            } else {
                                String str4 = str;
                                zzzm zzzmVar2 = (zzzm) linkedHashMap2.put(str4, zzzkVar);
                                if (zzzmVar2 != null) {
                                    throw zzd(cls, str4, zzzmVar2.zzh, field3);
                                }
                            }
                        }
                    }
                    list = listSingletonList;
                    i10 = i13;
                    String str22 = (String) list.get(0);
                    zzaca zzacaVarZzb22 = zzaca.zzb(typeZze);
                    Class clsZzc22 = zzacaVarZzb22.zzc();
                    if (clsZzc22 instanceof Class) {
                        int modifiers2 = field2.getModifiers();
                        if (Modifier.isStatic(modifiers2)) {
                            zzwlVar = (zzwl) field2.getAnnotation(zzwl.class);
                            if (zzwlVar == null) {
                            }
                            if (zzwjVarZzb != null) {
                            }
                            if (zZze) {
                                List<String> list22 = list;
                                z15 = true;
                                fieldArr = declaredFields;
                                cls2 = clsZzc;
                                zzzk zzzkVar2 = new zzzk(this, str, field, z12, methodZzh, (zZze || zzwjVarZzb != null) ? zzwjVarZza : new zzzw(zzvrVar, zzwjVarZza, zzacaVar3.zzd()), zzwjVarZza, z19, z20);
                                if (z13) {
                                }
                                Field field32 = field;
                                if (zZze) {
                                }
                            }
                        }
                    }
                } else if (zZze2) {
                    zZze2 = z17;
                    if (z11) {
                    }
                    if (!z12) {
                        zzabp.zzi(field2);
                    }
                    Type typeZze2 = zzwr.zze(zzacaVarZzb.zzd(), clsZzc, field2.getGenericType());
                    zzwmVar = (zzwm) field2.getAnnotation(zzwm.class);
                    if (zzwmVar != null) {
                    }
                    list = listSingletonList;
                    i10 = i13;
                    String str222 = (String) list.get(0);
                    zzaca zzacaVarZzb222 = zzaca.zzb(typeZze2);
                    Class clsZzc222 = zzacaVarZzb222.zzc();
                    if (clsZzc222 instanceof Class) {
                    }
                } else {
                    i12 = i13;
                    i11 = length;
                    z14 = z18;
                    z15 = z17;
                    fieldArr = declaredFields;
                    cls2 = clsZzc;
                }
                i13 = i12 + 1;
                zzzqVar = this;
                clsZzc = cls2;
                z17 = z15;
                z18 = z14;
                declaredFields = fieldArr;
                length = i11;
            }
            Class cls3 = clsZzc;
            zzacaVarZzb = zzaca.zzb(zzwr.zze(zzacaVarZzb.zzd(), cls3, cls3.getGenericSuperclass()));
            clsZzc = zzacaVarZzb.zzc();
            zzzqVar = this;
            z16 = z12;
        }
        return new zzzo(linkedHashMap, new ArrayList(linkedHashMap2.values()));
    }

    private static IllegalArgumentException zzd(Class cls, String str, Field field, Field field2) {
        String name = cls.getName();
        throw new IllegalArgumentException(com.bytedance.sdk.component.adexpress.dynamic.dynamicview.b.h(e.t("Class ", name, " declares multiple JSON fields named '", str, "'; conflict is caused by fields "), zzabp.zzd(field), " and ", zzabp.zzd(field2), "\nSee https://github.com/google/gson/blob/main/Troubleshooting.md#duplicate-fields"));
    }

    private final boolean zze(Field field, boolean z10) {
        return !this.zzb.zzd(field, z10);
    }

    @Override // com.google.ads.interactivemedia.v3.internal.zzwk
    public final zzwj zza(zzvr zzvrVar, zzaca zzacaVar) {
        Class clsZzc = zzacaVar.zzc();
        if (!Object.class.isAssignableFrom(clsZzc)) {
            return null;
        }
        if (zzabp.zzj(clsZzc)) {
            return new zzzj(this);
        }
        int iZzb = zzyf.zzb(this.zzd, clsZzc);
        if (iZzb == 4) {
            throw new zzvx(u1.k("ReflectionAccessFilter does not permit using reflection for ", String.valueOf(clsZzc), ". Register a TypeAdapter for this type or adjust the access filter."));
        }
        boolean z10 = iZzb == 3;
        return zzabp.zzk(clsZzc) ? new zzzp(clsZzc, zzc(zzvrVar, zzacaVar, clsZzc, z10, true), z10) : new zzzn(this.zza.zza(zzacaVar), zzc(zzvrVar, zzacaVar, clsZzc, z10, false));
    }
}