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;

/* loaded from: classes.dex */
public class QQt extends AbstractC0558JiG {
    private String x;
    private int w = -1;
    float h = Float.NaN;
    float j = Float.NaN;
    float i = Float.NaN;
    float g = Float.NaN;
    float k = Float.NaN;
    float l = Float.NaN;
    float m = Float.NaN;
    float n = Float.NaN;

    /* renamed from: o, reason: collision with root package name */
    float f8327o = Float.NaN;
    float t = Float.NaN;
    float q = Float.NaN;
    float f = Float.NaN;
    int s = 0;
    private String v = null;
    float r = Float.NaN;
    float p = BitmapDescriptorFactory.HUE_RED;

    public QQt() {
        this.c = 3;
        this.d = new HashMap<>();
    }

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

    @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.i)) {
            hashSet.add("rotation");
        }
        if (!Float.isNaN(this.g)) {
            hashSet.add("rotationX");
        }
        if (!Float.isNaN(this.k)) {
            hashSet.add("rotationY");
        }
        if (!Float.isNaN(this.f8327o)) {
            hashSet.add("translationX");
        }
        if (!Float.isNaN(this.t)) {
            hashSet.add("translationY");
        }
        if (!Float.isNaN(this.q)) {
            hashSet.add("translationZ");
        }
        if (!Float.isNaN(this.l)) {
            hashSet.add("transitionPathRotate");
        }
        if (!Float.isNaN(this.m)) {
            hashSet.add("scaleX");
        }
        if (!Float.isNaN(this.n)) {
            hashSet.add("scaleY");
        }
        if (!Float.isNaN(this.f)) {
            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.w == -1) {
            return;
        }
        if (!Float.isNaN(this.h)) {
            hashMap.put("alpha", Integer.valueOf(this.w));
        }
        if (!Float.isNaN(this.j)) {
            hashMap.put("elevation", Integer.valueOf(this.w));
        }
        if (!Float.isNaN(this.i)) {
            hashMap.put("rotation", Integer.valueOf(this.w));
        }
        if (!Float.isNaN(this.g)) {
            hashMap.put("rotationX", Integer.valueOf(this.w));
        }
        if (!Float.isNaN(this.k)) {
            hashMap.put("rotationY", Integer.valueOf(this.w));
        }
        if (!Float.isNaN(this.f8327o)) {
            hashMap.put("translationX", Integer.valueOf(this.w));
        }
        if (!Float.isNaN(this.t)) {
            hashMap.put("translationY", Integer.valueOf(this.w));
        }
        if (!Float.isNaN(this.q)) {
            hashMap.put("translationZ", Integer.valueOf(this.w));
        }
        if (!Float.isNaN(this.l)) {
            hashMap.put("transitionPathRotate", Integer.valueOf(this.w));
        }
        if (!Float.isNaN(this.m)) {
            hashMap.put("scaleX", Integer.valueOf(this.w));
        }
        if (!Float.isNaN(this.m)) {
            hashMap.put("scaleY", Integer.valueOf(this.w));
        }
        if (!Float.isNaN(this.f)) {
            hashMap.put("progress", Integer.valueOf(this.w));
        }
        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.w));
            }
        }
    }

    @Override // o.AbstractC0558JiG
    public final void b(HashMap<String, YpW> hashMap) {
        throw new IllegalArgumentException(" KeyTimeCycles do not support SplineSet");
    }

    /* loaded from: classes.dex */
    static class IeS {
        private static SparseIntArray b;

        static {
            SparseIntArray sparseIntArray = new SparseIntArray();
            b = sparseIntArray;
            sparseIntArray.append(C3345avm.IeS.KeyTimeCycle_android_alpha, 1);
            b.append(C3345avm.IeS.KeyTimeCycle_android_elevation, 2);
            b.append(C3345avm.IeS.KeyTimeCycle_android_rotation, 4);
            b.append(C3345avm.IeS.KeyTimeCycle_android_rotationX, 5);
            b.append(C3345avm.IeS.KeyTimeCycle_android_rotationY, 6);
            b.append(C3345avm.IeS.KeyTimeCycle_android_scaleX, 7);
            b.append(C3345avm.IeS.KeyTimeCycle_transitionPathRotate, 8);
            b.append(C3345avm.IeS.KeyTimeCycle_transitionEasing, 9);
            b.append(C3345avm.IeS.KeyTimeCycle_motionTarget, 10);
            b.append(C3345avm.IeS.KeyTimeCycle_framePosition, 12);
            b.append(C3345avm.IeS.KeyTimeCycle_curveFit, 13);
            b.append(C3345avm.IeS.KeyTimeCycle_android_scaleY, 14);
            b.append(C3345avm.IeS.KeyTimeCycle_android_translationX, 15);
            b.append(C3345avm.IeS.KeyTimeCycle_android_translationY, 16);
            b.append(C3345avm.IeS.KeyTimeCycle_android_translationZ, 17);
            b.append(C3345avm.IeS.KeyTimeCycle_motionProgress, 18);
            b.append(C3345avm.IeS.KeyTimeCycle_wavePeriod, 20);
            b.append(C3345avm.IeS.KeyTimeCycle_waveOffset, 21);
            b.append(C3345avm.IeS.KeyTimeCycle_waveShape, 19);
        }

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

    @Override // o.AbstractC0558JiG
    public final AbstractC0558JiG b(AbstractC0558JiG abstractC0558JiG) {
        super.b(abstractC0558JiG);
        QQt qQt = (QQt) abstractC0558JiG;
        this.x = qQt.x;
        this.w = qQt.w;
        this.s = qQt.s;
        this.r = qQt.r;
        this.p = qQt.p;
        this.f = qQt.f;
        this.h = qQt.h;
        this.j = qQt.j;
        this.i = qQt.i;
        this.l = qQt.l;
        this.g = qQt.g;
        this.k = qQt.k;
        this.m = qQt.m;
        this.n = qQt.n;
        this.f8327o = qQt.f8327o;
        this.t = qQt.t;
        this.q = qQt.q;
        return this;
    }

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

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