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 java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import o.C3345avm;

/* renamed from: o.efW, reason: case insensitive filesystem */
/* loaded from: classes.dex */
public class C11446efW extends AbstractC0558JiG {
    private String s;
    private int i = -1;
    private boolean v = false;
    private float h = Float.NaN;
    private float j = Float.NaN;
    private float l = Float.NaN;

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

    public C11446efW() {
        this.c = 1;
        this.d = new HashMap<>();
    }

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

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

    @Override // o.AbstractC0558JiG
    public final void d(HashMap<String, Integer> hashMap) {
        if (this.i == -1) {
            return;
        }
        if (!Float.isNaN(this.h)) {
            hashMap.put("alpha", Integer.valueOf(this.i));
        }
        if (!Float.isNaN(this.j)) {
            hashMap.put("elevation", Integer.valueOf(this.i));
        }
        if (!Float.isNaN(this.l)) {
            hashMap.put("rotation", Integer.valueOf(this.i));
        }
        if (!Float.isNaN(this.f8994o)) {
            hashMap.put("rotationX", Integer.valueOf(this.i));
        }
        if (!Float.isNaN(this.k)) {
            hashMap.put("rotationY", Integer.valueOf(this.i));
        }
        if (!Float.isNaN(this.f)) {
            hashMap.put("transformPivotX", Integer.valueOf(this.i));
        }
        if (!Float.isNaN(this.g)) {
            hashMap.put("transformPivotY", Integer.valueOf(this.i));
        }
        if (!Float.isNaN(this.r)) {
            hashMap.put("translationX", Integer.valueOf(this.i));
        }
        if (!Float.isNaN(this.p)) {
            hashMap.put("translationY", Integer.valueOf(this.i));
        }
        if (!Float.isNaN(this.u)) {
            hashMap.put("translationZ", Integer.valueOf(this.i));
        }
        if (!Float.isNaN(this.q)) {
            hashMap.put("transitionPathRotate", Integer.valueOf(this.i));
        }
        if (!Float.isNaN(this.n)) {
            hashMap.put("scaleX", Integer.valueOf(this.i));
        }
        if (!Float.isNaN(this.t)) {
            hashMap.put("scaleY", Integer.valueOf(this.i));
        }
        if (!Float.isNaN(this.m)) {
            hashMap.put("progress", Integer.valueOf(this.i));
        }
        if (this.d.size() > 0) {
            Iterator<String> it = this.d.keySet().iterator();
            while (it.hasNext()) {
                hashMap.put("CUSTOM,".concat(String.valueOf(it.next())), Integer.valueOf(this.i));
            }
        }
    }

    /* JADX WARN: Code restructure failed: missing block: B:132:0x0095, code lost:
    
        if (r1.equals("scaleY") == false) goto L57;
     */
    @Override // o.AbstractC0558JiG
    /*
        Code decompiled incorrectly, please refer to instructions dump.
        To view partially-correct add '--show-bad-code' argument
    */
    public final void b(java.util.HashMap<java.lang.String, o.YpW> r6) {
        /*
            Method dump skipped, instructions count: 558
            To view this dump add '--comments-level debug' option
        */
        throw new UnsupportedOperationException("Method not decompiled: o.C11446efW.b(java.util.HashMap):void");
    }

    /* renamed from: o.efW$RVV */
    /* loaded from: classes.dex */
    static class RVV {
        private static SparseIntArray d;

        static {
            SparseIntArray sparseIntArray = new SparseIntArray();
            d = sparseIntArray;
            sparseIntArray.append(C3345avm.IeS.KeyAttribute_android_alpha, 1);
            d.append(C3345avm.IeS.KeyAttribute_android_elevation, 2);
            d.append(C3345avm.IeS.KeyAttribute_android_rotation, 4);
            d.append(C3345avm.IeS.KeyAttribute_android_rotationX, 5);
            d.append(C3345avm.IeS.KeyAttribute_android_rotationY, 6);
            d.append(C3345avm.IeS.KeyAttribute_android_transformPivotX, 19);
            d.append(C3345avm.IeS.KeyAttribute_android_transformPivotY, 20);
            d.append(C3345avm.IeS.KeyAttribute_android_scaleX, 7);
            d.append(C3345avm.IeS.KeyAttribute_transitionPathRotate, 8);
            d.append(C3345avm.IeS.KeyAttribute_transitionEasing, 9);
            d.append(C3345avm.IeS.KeyAttribute_motionTarget, 10);
            d.append(C3345avm.IeS.KeyAttribute_framePosition, 12);
            d.append(C3345avm.IeS.KeyAttribute_curveFit, 13);
            d.append(C3345avm.IeS.KeyAttribute_android_scaleY, 14);
            d.append(C3345avm.IeS.KeyAttribute_android_translationX, 15);
            d.append(C3345avm.IeS.KeyAttribute_android_translationY, 16);
            d.append(C3345avm.IeS.KeyAttribute_android_translationZ, 17);
            d.append(C3345avm.IeS.KeyAttribute_motionProgress, 18);
        }

        public static void ku_(C11446efW c11446efW, TypedArray typedArray) {
            int indexCount = typedArray.getIndexCount();
            for (int i = 0; i < indexCount; i++) {
                int index = typedArray.getIndex(i);
                switch (d.get(index)) {
                    case 1:
                        c11446efW.h = typedArray.getFloat(index, c11446efW.h);
                        break;
                    case 2:
                        c11446efW.j = typedArray.getDimension(index, c11446efW.j);
                        break;
                    case 3:
                    case 11:
                    default:
                        d.get(index);
                        break;
                    case 4:
                        c11446efW.l = typedArray.getFloat(index, c11446efW.l);
                        break;
                    case 5:
                        c11446efW.f8994o = typedArray.getFloat(index, c11446efW.f8994o);
                        break;
                    case 6:
                        c11446efW.k = typedArray.getFloat(index, c11446efW.k);
                        break;
                    case 7:
                        c11446efW.n = typedArray.getFloat(index, c11446efW.n);
                        break;
                    case 8:
                        c11446efW.q = typedArray.getFloat(index, c11446efW.q);
                        break;
                    case 9:
                        c11446efW.s = typedArray.getString(index);
                        break;
                    case 10:
                        if (MotionLayout.b) {
                            c11446efW.a = typedArray.getResourceId(index, c11446efW.a);
                            if (c11446efW.a == -1) {
                                c11446efW.b = typedArray.getString(index);
                                break;
                            } else {
                                break;
                            }
                        } else if (typedArray.peekValue(index).type == 3) {
                            c11446efW.b = typedArray.getString(index);
                            break;
                        } else {
                            c11446efW.a = typedArray.getResourceId(index, c11446efW.a);
                            break;
                        }
                    case 12:
                        c11446efW.e = typedArray.getInt(index, c11446efW.e);
                        break;
                    case 13:
                        c11446efW.i = typedArray.getInteger(index, c11446efW.i);
                        break;
                    case 14:
                        c11446efW.t = typedArray.getFloat(index, c11446efW.t);
                        break;
                    case 15:
                        c11446efW.r = typedArray.getDimension(index, c11446efW.r);
                        break;
                    case 16:
                        c11446efW.p = typedArray.getDimension(index, c11446efW.p);
                        break;
                    case 17:
                        c11446efW.u = typedArray.getDimension(index, c11446efW.u);
                        break;
                    case 18:
                        c11446efW.m = typedArray.getFloat(index, c11446efW.m);
                        break;
                    case 19:
                        c11446efW.f = typedArray.getDimension(index, c11446efW.f);
                        break;
                    case 20:
                        c11446efW.g = typedArray.getDimension(index, c11446efW.g);
                        break;
                }
            }
        }
    }

    @Override // o.AbstractC0558JiG
    public final AbstractC0558JiG b(AbstractC0558JiG abstractC0558JiG) {
        super.b(abstractC0558JiG);
        C11446efW c11446efW = (C11446efW) abstractC0558JiG;
        this.i = c11446efW.i;
        this.v = c11446efW.v;
        this.h = c11446efW.h;
        this.j = c11446efW.j;
        this.l = c11446efW.l;
        this.f8994o = c11446efW.f8994o;
        this.k = c11446efW.k;
        this.f = c11446efW.f;
        this.g = c11446efW.g;
        this.q = c11446efW.q;
        this.n = c11446efW.n;
        this.t = c11446efW.t;
        this.r = c11446efW.r;
        this.p = c11446efW.p;
        this.u = c11446efW.u;
        this.m = c11446efW.m;
        return this;
    }

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

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