package o;

import android.content.Context;
import android.content.res.TypedArray;
import android.util.AttributeSet;
import android.util.SparseIntArray;
import androidx.constraintlayout.motion.widget.MotionLayout;
import com.google.android.gms.maps.model.BitmapDescriptorFactory;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import o.C3345avm;

/* renamed from: o.fnE, reason: case insensitive filesystem */
/* loaded from: classes.dex */
public class C14118fnE extends AbstractC0558JiG {
    private String s = null;
    private int g = 0;
    private int y = -1;
    private String j = null;
    private float u = Float.NaN;
    private float x = BitmapDescriptorFactory.HUE_RED;
    private float w = BitmapDescriptorFactory.HUE_RED;
    private float h = Float.NaN;
    private int v = -1;
    private float f = Float.NaN;
    private float i = Float.NaN;

    /* renamed from: o, reason: collision with root package name */
    private float f9130o = Float.NaN;
    private float r = Float.NaN;
    private float m = Float.NaN;
    private float k = Float.NaN;
    private float n = Float.NaN;
    private float l = Float.NaN;
    private float t = Float.NaN;
    private float q = Float.NaN;
    private float p = Float.NaN;

    public C14118fnE() {
        this.c = 4;
        this.d = new HashMap<>();
    }

    @Override // o.AbstractC0558JiG
    public final void kC_(Context context, AttributeSet attributeSet) {
        Sts.kw_(this, context.obtainStyledAttributes(attributeSet, C3345avm.IeS.KeyCycle));
    }

    @Override // o.AbstractC0558JiG
    public final void b(HashSet<String> hashSet) {
        if (!Float.isNaN(this.f)) {
            hashSet.add("alpha");
        }
        if (!Float.isNaN(this.i)) {
            hashSet.add("elevation");
        }
        if (!Float.isNaN(this.f9130o)) {
            hashSet.add("rotation");
        }
        if (!Float.isNaN(this.m)) {
            hashSet.add("rotationX");
        }
        if (!Float.isNaN(this.k)) {
            hashSet.add("rotationY");
        }
        if (!Float.isNaN(this.n)) {
            hashSet.add("scaleX");
        }
        if (!Float.isNaN(this.l)) {
            hashSet.add("scaleY");
        }
        if (!Float.isNaN(this.r)) {
            hashSet.add("transitionPathRotate");
        }
        if (!Float.isNaN(this.t)) {
            hashSet.add("translationX");
        }
        if (!Float.isNaN(this.q)) {
            hashSet.add("translationY");
        }
        if (!Float.isNaN(this.p)) {
            hashSet.add("translationZ");
        }
        if (this.d.size() > 0) {
            Iterator<String> it = this.d.keySet().iterator();
            while (it.hasNext()) {
                hashSet.add("CUSTOM,".concat(String.valueOf(it.next())));
            }
        }
    }

    /* JADX WARN: Code restructure failed: missing block: B:58:0x00aa, code lost:
    
        if (r1.equals("scaleY") != false) goto L60;
     */
    /*
        Code decompiled incorrectly, please refer to instructions dump.
        To view partially-correct add '--show-bad-code' argument
    */
    public final void e(java.util.HashMap<java.lang.String, o.AbstractC0234Bzx> r15) {
        /*
            Method dump skipped, instructions count: 432
            To view this dump add '--comments-level debug' option
        */
        throw new UnsupportedOperationException("Method not decompiled: o.C14118fnE.e(java.util.HashMap):void");
    }

    @Override // o.AbstractC0558JiG
    public final void b(HashMap<String, YpW> hashMap) {
        char c;
        hashMap.size();
        StackTraceElement[] stackTrace = new Throwable().getStackTrace();
        int min = Math.min(2, stackTrace.length - 1);
        for (int i = 1; i <= min; i++) {
            StackTraceElement stackTraceElement = stackTrace[i];
        }
        for (String str : hashMap.keySet()) {
            YpW ypW = hashMap.get(str);
            if (ypW != null) {
                str.hashCode();
                switch (str.hashCode()) {
                    case -1249320806:
                        if (str.equals("rotationX")) {
                            c = 0;
                            break;
                        }
                        break;
                    case -1249320805:
                        if (str.equals("rotationY")) {
                            c = 1;
                            break;
                        }
                        break;
                    case -1225497657:
                        if (str.equals("translationX")) {
                            c = 2;
                            break;
                        }
                        break;
                    case -1225497656:
                        if (str.equals("translationY")) {
                            c = 3;
                            break;
                        }
                        break;
                    case -1225497655:
                        if (str.equals("translationZ")) {
                            c = 4;
                            break;
                        }
                        break;
                    case -1001078227:
                        if (str.equals("progress")) {
                            c = 5;
                            break;
                        }
                        break;
                    case -908189618:
                        if (str.equals("scaleX")) {
                            c = 6;
                            break;
                        }
                        break;
                    case -908189617:
                        if (str.equals("scaleY")) {
                            c = 7;
                            break;
                        }
                        break;
                    case -40300674:
                        if (str.equals("rotation")) {
                            c = '\b';
                            break;
                        }
                        break;
                    case -4379043:
                        if (str.equals("elevation")) {
                            c = '\t';
                            break;
                        }
                        break;
                    case 37232917:
                        if (str.equals("transitionPathRotate")) {
                            c = '\n';
                            break;
                        }
                        break;
                    case 92909918:
                        if (str.equals("alpha")) {
                            c = 11;
                            break;
                        }
                        break;
                    case 156108012:
                        if (str.equals("waveOffset")) {
                            c = '\f';
                            break;
                        }
                        break;
                    case 1530034690:
                        if (str.equals("wavePhase")) {
                            c = '\r';
                            break;
                        }
                        break;
                }
                c = 65535;
                switch (c) {
                    case 0:
                        ypW.c(this.e, this.m);
                        break;
                    case 1:
                        ypW.c(this.e, this.k);
                        break;
                    case 2:
                        ypW.c(this.e, this.t);
                        break;
                    case 3:
                        ypW.c(this.e, this.q);
                        break;
                    case 4:
                        ypW.c(this.e, this.p);
                        break;
                    case 5:
                        ypW.c(this.e, this.h);
                        break;
                    case 6:
                        ypW.c(this.e, this.n);
                        break;
                    case 7:
                        ypW.c(this.e, this.l);
                        break;
                    case '\b':
                        ypW.c(this.e, this.f9130o);
                        break;
                    case '\t':
                        ypW.c(this.e, this.i);
                        break;
                    case '\n':
                        ypW.c(this.e, this.r);
                        break;
                    case 11:
                        ypW.c(this.e, this.f);
                        break;
                    case '\f':
                        ypW.c(this.e, this.x);
                        break;
                    case '\r':
                        ypW.c(this.e, this.w);
                        break;
                    default:
                        str.startsWith("CUSTOM");
                        break;
                }
            }
        }
    }

    /* renamed from: o.fnE$Sts */
    /* loaded from: classes.dex */
    static class Sts {
        private static SparseIntArray c;

        static {
            SparseIntArray sparseIntArray = new SparseIntArray();
            c = sparseIntArray;
            sparseIntArray.append(C3345avm.IeS.KeyCycle_motionTarget, 1);
            c.append(C3345avm.IeS.KeyCycle_framePosition, 2);
            c.append(C3345avm.IeS.KeyCycle_transitionEasing, 3);
            c.append(C3345avm.IeS.KeyCycle_curveFit, 4);
            c.append(C3345avm.IeS.KeyCycle_waveShape, 5);
            c.append(C3345avm.IeS.KeyCycle_wavePeriod, 6);
            c.append(C3345avm.IeS.KeyCycle_waveOffset, 7);
            c.append(C3345avm.IeS.KeyCycle_waveVariesBy, 8);
            c.append(C3345avm.IeS.KeyCycle_android_alpha, 9);
            c.append(C3345avm.IeS.KeyCycle_android_elevation, 10);
            c.append(C3345avm.IeS.KeyCycle_android_rotation, 11);
            c.append(C3345avm.IeS.KeyCycle_android_rotationX, 12);
            c.append(C3345avm.IeS.KeyCycle_android_rotationY, 13);
            c.append(C3345avm.IeS.KeyCycle_transitionPathRotate, 14);
            c.append(C3345avm.IeS.KeyCycle_android_scaleX, 15);
            c.append(C3345avm.IeS.KeyCycle_android_scaleY, 16);
            c.append(C3345avm.IeS.KeyCycle_android_translationX, 17);
            c.append(C3345avm.IeS.KeyCycle_android_translationY, 18);
            c.append(C3345avm.IeS.KeyCycle_android_translationZ, 19);
            c.append(C3345avm.IeS.KeyCycle_motionProgress, 20);
            c.append(C3345avm.IeS.KeyCycle_wavePhase, 21);
        }

        static /* synthetic */ void kw_(C14118fnE c14118fnE, TypedArray typedArray) {
            int indexCount = typedArray.getIndexCount();
            for (int i = 0; i < indexCount; i++) {
                int index = typedArray.getIndex(i);
                switch (c.get(index)) {
                    case 1:
                        if (MotionLayout.b) {
                            c14118fnE.a = typedArray.getResourceId(index, c14118fnE.a);
                            if (c14118fnE.a == -1) {
                                c14118fnE.b = typedArray.getString(index);
                                break;
                            } else {
                                break;
                            }
                        } else if (typedArray.peekValue(index).type == 3) {
                            c14118fnE.b = typedArray.getString(index);
                            break;
                        } else {
                            c14118fnE.a = typedArray.getResourceId(index, c14118fnE.a);
                            break;
                        }
                    case 2:
                        c14118fnE.e = typedArray.getInt(index, c14118fnE.e);
                        break;
                    case 3:
                        c14118fnE.s = typedArray.getString(index);
                        break;
                    case 4:
                        c14118fnE.g = typedArray.getInteger(index, c14118fnE.g);
                        break;
                    case 5:
                        if (typedArray.peekValue(index).type == 3) {
                            c14118fnE.j = typedArray.getString(index);
                            c14118fnE.y = 7;
                            break;
                        } else {
                            c14118fnE.y = typedArray.getInt(index, c14118fnE.y);
                            break;
                        }
                    case 6:
                        c14118fnE.u = typedArray.getFloat(index, c14118fnE.u);
                        break;
                    case 7:
                        if (typedArray.peekValue(index).type == 5) {
                            c14118fnE.x = typedArray.getDimension(index, c14118fnE.x);
                            break;
                        } else {
                            c14118fnE.x = typedArray.getFloat(index, c14118fnE.x);
                            break;
                        }
                    case 8:
                        c14118fnE.v = typedArray.getInt(index, c14118fnE.v);
                        break;
                    case 9:
                        c14118fnE.f = typedArray.getFloat(index, c14118fnE.f);
                        break;
                    case 10:
                        c14118fnE.i = typedArray.getDimension(index, c14118fnE.i);
                        break;
                    case 11:
                        c14118fnE.f9130o = typedArray.getFloat(index, c14118fnE.f9130o);
                        break;
                    case 12:
                        c14118fnE.m = typedArray.getFloat(index, c14118fnE.m);
                        break;
                    case 13:
                        c14118fnE.k = typedArray.getFloat(index, c14118fnE.k);
                        break;
                    case 14:
                        c14118fnE.r = typedArray.getFloat(index, c14118fnE.r);
                        break;
                    case 15:
                        c14118fnE.n = typedArray.getFloat(index, c14118fnE.n);
                        break;
                    case 16:
                        c14118fnE.l = typedArray.getFloat(index, c14118fnE.l);
                        break;
                    case 17:
                        c14118fnE.t = typedArray.getDimension(index, c14118fnE.t);
                        break;
                    case 18:
                        c14118fnE.q = typedArray.getDimension(index, c14118fnE.q);
                        break;
                    case 19:
                        c14118fnE.p = typedArray.getDimension(index, c14118fnE.p);
                        break;
                    case 20:
                        c14118fnE.h = typedArray.getFloat(index, c14118fnE.h);
                        break;
                    case 21:
                        c14118fnE.w = typedArray.getFloat(index, c14118fnE.w) / 360.0f;
                        break;
                    default:
                        c.get(index);
                        break;
                }
            }
        }
    }

    @Override // o.AbstractC0558JiG
    public final AbstractC0558JiG b(AbstractC0558JiG abstractC0558JiG) {
        super.b(abstractC0558JiG);
        C14118fnE c14118fnE = (C14118fnE) abstractC0558JiG;
        this.s = c14118fnE.s;
        this.g = c14118fnE.g;
        this.y = c14118fnE.y;
        this.j = c14118fnE.j;
        this.u = c14118fnE.u;
        this.x = c14118fnE.x;
        this.w = c14118fnE.w;
        this.h = c14118fnE.h;
        this.v = c14118fnE.v;
        this.f = c14118fnE.f;
        this.i = c14118fnE.i;
        this.f9130o = c14118fnE.f9130o;
        this.r = c14118fnE.r;
        this.m = c14118fnE.m;
        this.k = c14118fnE.k;
        this.n = c14118fnE.n;
        this.l = c14118fnE.l;
        this.t = c14118fnE.t;
        this.q = c14118fnE.q;
        this.p = c14118fnE.p;
        return this;
    }

    @Override // o.AbstractC0558JiG
    /* renamed from: d */
    public final AbstractC0558JiG clone() {
        return new C14118fnE().b((AbstractC0558JiG) this);
    }

    @Override // o.AbstractC0558JiG
    public /* synthetic */ Object clone() throws CloneNotSupportedException {
        return new C14118fnE().b((AbstractC0558JiG) this);
    }
}