package p074z0;

import android.os.Parcelable;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import p037m.C1444a;

/* renamed from: z0.a */
/* loaded from: classes.dex */
public abstract class AbstractC1916a {

    /* renamed from: a */
    public final C1444a<String, Method> f4711a;

    /* renamed from: b */
    public final C1444a<String, Method> f4712b;

    /* renamed from: c */
    public final C1444a<String, Class> f4713c;

    public AbstractC1916a(C1444a<String, Method> c1444a, C1444a<String, Method> c1444a2, C1444a<String, Class> c1444a3) {
        this.f4711a = c1444a;
        this.f4712b = c1444a2;
        this.f4713c = c1444a3;
    }

    /* renamed from: A */
    public abstract void mo15A(byte[] bArr);

    /* renamed from: B */
    public void m39B(byte[] bArr, int i) {
        mo1w(i);
        mo15A(bArr);
    }

    /* renamed from: C */
    public abstract void mo14C(CharSequence charSequence);

    /* renamed from: D */
    public void m38D(CharSequence charSequence, int i) {
        mo1w(i);
        mo14C(charSequence);
    }

    /* renamed from: E */
    public abstract void mo13E(int i);

    /* renamed from: F */
    public void m37F(int i, int i2) {
        mo1w(i2);
        mo13E(i);
    }

    /* renamed from: G */
    public abstract void mo12G(Parcelable parcelable);

    /* renamed from: H */
    public void m36H(Parcelable parcelable, int i) {
        mo1w(i);
        mo12G(parcelable);
    }

    /* renamed from: I */
    public abstract void mo11I(String str);

    /* renamed from: J */
    public void m35J(String str, int i) {
        mo1w(i);
        mo11I(str);
    }

    /* renamed from: K */
    public <T extends InterfaceC1918c> void m34K(T t, AbstractC1916a abstractC1916a) {
        try {
            m28e(t.getClass()).invoke(null, t, abstractC1916a);
        } catch (ClassNotFoundException e) {
            throw new RuntimeException("VersionedParcel encountered ClassNotFoundException", e);
        } catch (IllegalAccessException e2) {
            throw new RuntimeException("VersionedParcel encountered IllegalAccessException", e2);
        } catch (NoSuchMethodException e3) {
            throw new RuntimeException("VersionedParcel encountered NoSuchMethodException", e3);
        } catch (InvocationTargetException e4) {
            if (!(e4.getCause() instanceof RuntimeException)) {
                throw new RuntimeException("VersionedParcel encountered InvocationTargetException", e4);
            }
            throw ((RuntimeException) e4.getCause());
        }
    }

    /* renamed from: L */
    public void m33L(InterfaceC1918c interfaceC1918c) {
        if (interfaceC1918c == null) {
            mo11I(null);
            return;
        }
        m31N(interfaceC1918c);
        AbstractC1916a mo9b = mo9b();
        m34K(interfaceC1918c, mo9b);
        mo9b.mo10a();
    }

    /* renamed from: M */
    public void m32M(InterfaceC1918c interfaceC1918c, int i) {
        mo1w(i);
        m33L(interfaceC1918c);
    }

    /* JADX WARN: Multi-variable type inference failed */
    /* renamed from: N */
    public final void m31N(InterfaceC1918c interfaceC1918c) {
        try {
            mo11I(m30c(interfaceC1918c.getClass()).getName());
        } catch (ClassNotFoundException e) {
            throw new RuntimeException(interfaceC1918c.getClass().getSimpleName() + " does not have a Parcelizer", e);
        }
    }

    /* renamed from: a */
    public abstract void mo10a();

    /* renamed from: b */
    public abstract AbstractC1916a mo9b();

    /* renamed from: c */
    public final Class m30c(Class<? extends InterfaceC1918c> cls) {
        Class cls2 = this.f4713c.get(cls.getName());
        if (cls2 == null) {
            Class<?> cls3 = Class.forName(String.format("%s.%sParcelizer", cls.getPackage().getName(), cls.getSimpleName()), false, cls.getClassLoader());
            this.f4713c.put(cls.getName(), cls3);
            return cls3;
        }
        return cls2;
    }

    /* renamed from: d */
    public final Method m29d(String str) {
        Method method = this.f4711a.get(str);
        if (method == null) {
            System.currentTimeMillis();
            Method declaredMethod = Class.forName(str, true, AbstractC1916a.class.getClassLoader()).getDeclaredMethod("read", AbstractC1916a.class);
            this.f4711a.put(str, declaredMethod);
            return declaredMethod;
        }
        return method;
    }

    /* renamed from: e */
    public final Method m28e(Class cls) {
        Method method = this.f4712b.get(cls.getName());
        if (method == null) {
            Class m30c = m30c(cls);
            System.currentTimeMillis();
            Method declaredMethod = m30c.getDeclaredMethod("write", cls, AbstractC1916a.class);
            this.f4712b.put(cls.getName(), declaredMethod);
            return declaredMethod;
        }
        return method;
    }

    /* renamed from: f */
    public boolean m27f() {
        return false;
    }

    /* renamed from: g */
    public abstract boolean mo8g();

    /* renamed from: h */
    public boolean m26h(boolean z, int i) {
        return !mo5m(i) ? z : mo8g();
    }

    /* renamed from: i */
    public abstract byte[] mo7i();

    /* renamed from: j */
    public byte[] m25j(byte[] bArr, int i) {
        return !mo5m(i) ? bArr : mo7i();
    }

    /* renamed from: k */
    public abstract CharSequence mo6k();

    /* renamed from: l */
    public CharSequence m24l(CharSequence charSequence, int i) {
        return !mo5m(i) ? charSequence : mo6k();
    }

    /* renamed from: m */
    public abstract boolean mo5m(int i);

    /* renamed from: n */
    public <T extends InterfaceC1918c> T m23n(String str, AbstractC1916a abstractC1916a) {
        try {
            return (T) m29d(str).invoke(null, abstractC1916a);
        } catch (ClassNotFoundException e) {
            throw new RuntimeException("VersionedParcel encountered ClassNotFoundException", e);
        } catch (IllegalAccessException e2) {
            throw new RuntimeException("VersionedParcel encountered IllegalAccessException", e2);
        } catch (NoSuchMethodException e3) {
            throw new RuntimeException("VersionedParcel encountered NoSuchMethodException", e3);
        } catch (InvocationTargetException e4) {
            if (e4.getCause() instanceof RuntimeException) {
                throw ((RuntimeException) e4.getCause());
            }
            throw new RuntimeException("VersionedParcel encountered InvocationTargetException", e4);
        }
    }

    /* renamed from: o */
    public abstract int mo4o();

    /* renamed from: p */
    public int m22p(int i, int i2) {
        return !mo5m(i2) ? i : mo4o();
    }

    /* renamed from: q */
    public abstract <T extends Parcelable> T mo3q();

    /* renamed from: r */
    public <T extends Parcelable> T m21r(T t, int i) {
        return !mo5m(i) ? t : (T) mo3q();
    }

    /* renamed from: s */
    public abstract String mo2s();

    /* renamed from: t */
    public String m20t(String str, int i) {
        return !mo5m(i) ? str : mo2s();
    }

    /* renamed from: u */
    public <T extends InterfaceC1918c> T m19u() {
        String mo2s = mo2s();
        if (mo2s == null) {
            return null;
        }
        return (T) m23n(mo2s, mo9b());
    }

    /* renamed from: v */
    public <T extends InterfaceC1918c> T m18v(T t, int i) {
        return !mo5m(i) ? t : (T) m19u();
    }

    /* renamed from: w */
    public abstract void mo1w(int i);

    /* renamed from: x */
    public void m17x(boolean z, boolean z2) {
    }

    /* renamed from: y */
    public abstract void mo0y(boolean z);

    /* renamed from: z */
    public void m16z(boolean z, int i) {
        mo1w(i);
        mo0y(z);
    }
}