package F;

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;

/* JADX INFO: loaded from: classes.dex */
public class h extends f {

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

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

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

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

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

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

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

    public h() throws NoSuchMethodException {
        Method methodW;
        Constructor<?> constructor;
        Method methodV;
        Method method;
        Method method2;
        Method method3;
        Class<?> cls = null;
        try {
            Class<?> cls2 = Class.forName("android.graphics.FontFamily");
            constructor = cls2.getConstructor(null);
            methodV = V(cls2);
            Class<?> cls3 = Integer.TYPE;
            method = cls2.getMethod("addFontFromBuffer", ByteBuffer.class, cls3, FontVariationAxis[].class, cls3, cls3);
            method2 = cls2.getMethod("freeze", null);
            method3 = cls2.getMethod("abortCreation", null);
            methodW = W(cls2);
            cls = cls2;
        } catch (ClassNotFoundException | NoSuchMethodException e8) {
            Log.e("TypefaceCompatApi26Impl", "Unable to collect necessary methods for class ".concat(e8.getClass().getName()), e8);
            methodW = null;
            constructor = null;
            methodV = null;
            method = null;
            method2 = null;
            method3 = null;
        }
        this.f2245m = cls;
        this.f2246n = constructor;
        this.f2247o = methodV;
        this.f2248p = method;
        this.f2249q = method2;
        this.f2250r = method3;
        this.f2251s = methodW;
    }

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

    public final void Q(Object obj) {
        try {
            this.f2250r.invoke(obj, null);
        } catch (IllegalAccessException | InvocationTargetException unused) {
        }
    }

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

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

    public final boolean T(Object obj) {
        try {
            return ((Boolean) this.f2249q.invoke(obj, null)).booleanValue();
        } catch (IllegalAccessException | InvocationTargetException unused) {
            return false;
        }
    }

    public final Object U() {
        try {
            return this.f2246n.newInstance(null);
        } catch (IllegalAccessException | InstantiationException | InvocationTargetException unused) {
            return null;
        }
    }

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

    @Override // F.f, U2.a
    public final Typeface h(Context context, E.e eVar, Resources resources, int i) {
        Method method = this.f2247o;
        if (method == null) {
            Log.w("TypefaceCompatApi26Impl", "Unable to collect necessary private methods. Fallback to legacy implementation.");
        }
        if (method == null) {
            return super.h(context, eVar, resources, i);
        }
        Object objU = U();
        if (objU != null) {
            E.f[] fVarArr = eVar.f1937a;
            int length = fVarArr.length;
            int i5 = 0;
            while (i5 < length) {
                E.f fVar = fVarArr[i5];
                String str = fVar.f1938a;
                FontVariationAxis[] fontVariationAxisArrFromFontVariationSettings = FontVariationAxis.fromFontVariationSettings(fVar.f1941d);
                Context context2 = context;
                if (!R(context2, objU, str, fVar.f1942e, fVar.f1939b, fVar.f1940c ? 1 : 0, fontVariationAxisArrFromFontVariationSettings)) {
                    Q(objU);
                    return null;
                }
                i5++;
                context = context2;
            }
            if (T(objU)) {
                return S(objU);
            }
        }
        return null;
    }

    @Override // F.f, U2.a
    public final Typeface i(Context context, J.j[] jVarArr, int i) {
        Typeface typefaceS;
        boolean zBooleanValue;
        if (jVarArr.length >= 1) {
            Method method = this.f2247o;
            if (method == null) {
                Log.w("TypefaceCompatApi26Impl", "Unable to collect necessary private methods. Fallback to legacy implementation.");
            }
            if (method != null) {
                HashMap map = new HashMap();
                for (J.j jVar : jVarArr) {
                    if (jVar.f3439e == 0) {
                        Uri uri = jVar.f3435a;
                        if (!map.containsKey(uri)) {
                            map.put(uri, W2.g.B(context, uri));
                        }
                    }
                }
                Map mapUnmodifiableMap = Collections.unmodifiableMap(map);
                Object objU = U();
                if (objU != null) {
                    int length = jVarArr.length;
                    int i5 = 0;
                    boolean z8 = false;
                    while (i5 < length) {
                        J.j jVar2 = jVarArr[i5];
                        ByteBuffer byteBuffer = (ByteBuffer) mapUnmodifiableMap.get(jVar2.f3435a);
                        if (byteBuffer != null) {
                            try {
                                zBooleanValue = ((Boolean) this.f2248p.invoke(objU, byteBuffer, Integer.valueOf(jVar2.f3436b), null, Integer.valueOf(jVar2.f3437c), Integer.valueOf(jVar2.f3438d ? 1 : 0))).booleanValue();
                            } catch (IllegalAccessException | InvocationTargetException unused) {
                                zBooleanValue = false;
                            }
                            if (!zBooleanValue) {
                                Q(objU);
                                return null;
                            }
                            z8 = true;
                        }
                        i5++;
                        z8 = z8;
                    }
                    if (!z8) {
                        Q(objU);
                        return null;
                    }
                    if (T(objU) && (typefaceS = S(objU)) != null) {
                        return Typeface.create(typefaceS, i);
                    }
                }
            } else {
                J.j jVarA = A(jVarArr, i);
                try {
                    ParcelFileDescriptor parcelFileDescriptorOpenFileDescriptor = context.getContentResolver().openFileDescriptor(jVarA.f3435a, "r", null);
                    if (parcelFileDescriptorOpenFileDescriptor != null) {
                        try {
                            Typeface typefaceBuild = new Typeface.Builder(parcelFileDescriptorOpenFileDescriptor.getFileDescriptor()).setWeight(jVarA.f3437c).setItalic(jVarA.f3438d).build();
                            parcelFileDescriptorOpenFileDescriptor.close();
                            return typefaceBuild;
                        } finally {
                        }
                    }
                    if (parcelFileDescriptorOpenFileDescriptor != null) {
                        parcelFileDescriptorOpenFileDescriptor.close();
                        return null;
                    }
                } catch (IOException unused2) {
                }
            }
        }
        return null;
    }

    @Override // U2.a
    public final Typeface l(Context context, Resources resources, int i, String str, int i5) {
        Method method = this.f2247o;
        if (method == null) {
            Log.w("TypefaceCompatApi26Impl", "Unable to collect necessary private methods. Fallback to legacy implementation.");
        }
        if (method == null) {
            return super.l(context, resources, i, str, i5);
        }
        Object objU = U();
        if (objU != null) {
            if (!R(context, objU, str, 0, -1, -1, null)) {
                Q(objU);
                return null;
            }
            if (T(objU)) {
                return S(objU);
            }
        }
        return null;
    }
}