package z1;

import C1.l;
import android.content.Context;
import android.content.res.AssetManager;
import android.content.res.Resources;
import android.graphics.Typeface;
import android.graphics.fonts.FontVariationAxis;
import android.net.Uri;
import android.os.ParcelFileDescriptor;
import android.util.Log;
import java.io.IOException;
import java.lang.reflect.Array;
import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.nio.ByteBuffer;
import java.util.Collections;
import java.util.HashMap;
import java.util.Map;
import n2.AbstractC2613d;

/* JADX INFO: loaded from: classes.dex */
public class i extends g {

    /* JADX INFO: renamed from: h, reason: collision with root package name */
    public final Class f26288h;

    /* JADX INFO: renamed from: i, reason: collision with root package name */
    public final Constructor f26289i;

    /* JADX INFO: renamed from: j, reason: collision with root package name */
    public final Method f26290j;

    /* JADX INFO: renamed from: k, reason: collision with root package name */
    public final Method f26291k;
    public final Method l;

    /* JADX INFO: renamed from: m, reason: collision with root package name */
    public final Method f26292m;

    /* JADX INFO: renamed from: n, reason: collision with root package name */
    public final Method f26293n;

    public i() {
        Class<?> cls;
        Method method;
        Constructor<?> constructor;
        Method methodE;
        Method method2;
        Method method3;
        Method methodF;
        try {
            cls = Class.forName("android.graphics.FontFamily");
            constructor = cls.getConstructor(new Class[0]);
            methodE = E(cls);
            Class cls2 = Integer.TYPE;
            method2 = cls.getMethod("addFontFromBuffer", ByteBuffer.class, cls2, FontVariationAxis[].class, cls2, cls2);
            method3 = cls.getMethod("freeze", new Class[0]);
            method = cls.getMethod("abortCreation", new Class[0]);
            methodF = F(cls);
        } catch (ClassNotFoundException | NoSuchMethodException e6) {
            Log.e("TypefaceCompatApi26Impl", "Unable to collect necessary methods for class ".concat(e6.getClass().getName()), e6);
            cls = null;
            method = null;
            constructor = null;
            methodE = null;
            method2 = null;
            method3 = null;
            methodF = null;
        }
        this.f26288h = cls;
        this.f26289i = constructor;
        this.f26290j = methodE;
        this.f26291k = method2;
        this.l = method3;
        this.f26292m = method;
        this.f26293n = methodF;
    }

    public static Method E(Class cls) {
        Class cls2 = Integer.TYPE;
        return cls.getMethod("addFontFromAssetManager", AssetManager.class, String.class, cls2, Boolean.TYPE, cls2, cls2, cls2, FontVariationAxis[].class);
    }

    public final boolean A(Context context, Object obj, String str, int i6, int i7, int i8, FontVariationAxis[] fontVariationAxisArr) {
        try {
            return ((Boolean) this.f26290j.invoke(obj, context.getAssets(), str, 0, Boolean.FALSE, Integer.valueOf(i6), Integer.valueOf(i7), Integer.valueOf(i8), fontVariationAxisArr)).booleanValue();
        } catch (IllegalAccessException | InvocationTargetException unused) {
            return false;
        }
    }

    public Typeface B(Object obj) {
        try {
            Object objNewInstance = Array.newInstance((Class<?>) this.f26288h, 1);
            Array.set(objNewInstance, 0, obj);
            return (Typeface) this.f26293n.invoke(null, objNewInstance, -1, -1);
        } catch (IllegalAccessException | InvocationTargetException unused) {
            return null;
        }
    }

    public final boolean C(Object obj) {
        try {
            return ((Boolean) this.l.invoke(obj, new Object[0])).booleanValue();
        } catch (IllegalAccessException | InvocationTargetException unused) {
            return false;
        }
    }

    public final Object D() {
        try {
            return this.f26289i.newInstance(new Object[0]);
        } catch (IllegalAccessException | InstantiationException | InvocationTargetException unused) {
            return null;
        }
    }

    public Method F(Class cls) throws NoSuchMethodException {
        Class<?> cls2 = Array.newInstance((Class<?>) cls, 1).getClass();
        Class cls3 = Integer.TYPE;
        Method declaredMethod = Typeface.class.getDeclaredMethod("createFromFamiliesWithDefault", cls2, cls3, cls3);
        declaredMethod.setAccessible(true);
        return declaredMethod;
    }

    @Override // z1.g, n2.AbstractC2612c
    public final Typeface f(Context context, y1.e eVar, Resources resources) {
        Method method = this.f26290j;
        if (method == null) {
            Log.w("TypefaceCompatApi26Impl", "Unable to collect necessary private methods. Fallback to legacy implementation.");
        }
        if (method == null) {
            return super.f(context, eVar, resources);
        }
        Object objD = D();
        if (objD != null) {
            y1.f[] fVarArr = eVar.f26149a;
            int length = fVarArr.length;
            int i6 = 0;
            while (i6 < length) {
                y1.f fVar = fVarArr[i6];
                String str = fVar.f26150a;
                FontVariationAxis[] fontVariationAxisArrFromFontVariationSettings = FontVariationAxis.fromFontVariationSettings(fVar.f26153d);
                Context context2 = context;
                if (!A(context2, objD, str, fVar.f26154e, fVar.f26151b, fVar.f26152c ? 1 : 0, fontVariationAxisArrFromFontVariationSettings)) {
                    z(objD);
                    return null;
                }
                i6++;
                context = context2;
            }
            if (C(objD)) {
                return B(objD);
            }
        }
        return null;
    }

    @Override // z1.g, n2.AbstractC2612c
    public final Typeface g(Context context, l[] lVarArr, int i6) {
        Typeface typefaceB;
        boolean zBooleanValue;
        if (lVarArr.length >= 1) {
            Method method = this.f26290j;
            if (method == null) {
                Log.w("TypefaceCompatApi26Impl", "Unable to collect necessary private methods. Fallback to legacy implementation.");
            }
            if (method != null) {
                HashMap map = new HashMap();
                for (l lVar : lVarArr) {
                    if (lVar.f696e == 0) {
                        Uri uri = lVar.f692a;
                        if (!map.containsKey(uri)) {
                            map.put(uri, AbstractC2613d.j(context, uri));
                        }
                    }
                }
                Map mapUnmodifiableMap = Collections.unmodifiableMap(map);
                Object objD = D();
                if (objD != null) {
                    int length = lVarArr.length;
                    int i7 = 0;
                    boolean z6 = false;
                    while (i7 < length) {
                        l lVar2 = lVarArr[i7];
                        ByteBuffer byteBuffer = (ByteBuffer) mapUnmodifiableMap.get(lVar2.f692a);
                        if (byteBuffer != null) {
                            try {
                                zBooleanValue = ((Boolean) this.f26291k.invoke(objD, byteBuffer, Integer.valueOf(lVar2.f693b), null, Integer.valueOf(lVar2.f694c), Integer.valueOf(lVar2.f695d ? 1 : 0))).booleanValue();
                            } catch (IllegalAccessException | InvocationTargetException unused) {
                                zBooleanValue = false;
                            }
                            if (!zBooleanValue) {
                                z(objD);
                                return null;
                            }
                            z6 = true;
                        }
                        i7++;
                        z6 = z6;
                    }
                    if (!z6) {
                        z(objD);
                        return null;
                    }
                    if (C(objD) && (typefaceB = B(objD)) != null) {
                        return Typeface.create(typefaceB, i6);
                    }
                }
            } else {
                l lVarM = m(lVarArr, i6);
                try {
                    ParcelFileDescriptor parcelFileDescriptorOpenFileDescriptor = context.getContentResolver().openFileDescriptor(lVarM.f692a, "r", null);
                    if (parcelFileDescriptorOpenFileDescriptor != null) {
                        try {
                            Typeface typefaceBuild = new Typeface.Builder(parcelFileDescriptorOpenFileDescriptor.getFileDescriptor()).setWeight(lVarM.f694c).setItalic(lVarM.f695d).build();
                            parcelFileDescriptorOpenFileDescriptor.close();
                            return typefaceBuild;
                        } finally {
                        }
                    }
                    if (parcelFileDescriptorOpenFileDescriptor != null) {
                        parcelFileDescriptorOpenFileDescriptor.close();
                        return null;
                    }
                } catch (IOException unused2) {
                }
            }
        }
        return null;
    }

    @Override // n2.AbstractC2612c
    public final Typeface j(Context context, Resources resources, int i6, String str) {
        Method method = this.f26290j;
        if (method == null) {
            Log.w("TypefaceCompatApi26Impl", "Unable to collect necessary private methods. Fallback to legacy implementation.");
        }
        if (method == null) {
            return super.j(context, resources, i6, str);
        }
        Object objD = D();
        if (objD != null) {
            if (!A(context, objD, str, 0, -1, -1, null)) {
                z(objD);
                return null;
            }
            if (C(objD)) {
                return B(objD);
            }
        }
        return null;
    }

    public final void z(Object obj) {
        try {
            this.f26292m.invoke(obj, new Object[0]);
        } catch (IllegalAccessException | InvocationTargetException unused) {
        }
    }
}