package o;

import android.content.Context;
import android.content.res.TypedArray;
import android.graphics.RectF;
import android.graphics.drawable.ColorDrawable;
import android.graphics.drawable.Drawable;
import android.util.AttributeSet;
import android.util.SparseIntArray;
import android.view.View;
import androidx.constraintlayout.motion.widget.MotionLayout;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Locale;
import o.C3345avm;
import o.Prc;

/* loaded from: classes.dex */
public class AZC extends AbstractC0558JiG {
    private float n;
    private int l = -1;
    private String m = null;
    private int D = -1;
    private String r = null;
    private String t = null;
    private int w = -1;
    private int v = -1;
    private View u = null;
    float h = 0.1f;

    /* renamed from: o, reason: collision with root package name */
    private boolean f8099o = true;
    private boolean k = true;
    private boolean q = true;
    private float s = Float.NaN;
    private boolean x = false;
    int j = -1;
    int i = -1;
    int f = -1;
    private RectF g = new RectF();
    private RectF y = new RectF();
    private HashMap<String, Method> p = new HashMap<>();

    @Override // o.AbstractC0558JiG
    public final void b(HashMap<String, YpW> hashMap) {
    }

    @Override // o.AbstractC0558JiG
    public final void b(HashSet<String> hashSet) {
    }

    public AZC() {
        this.c = 5;
        this.d = new HashMap<>();
    }

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

    private static void kB_(RectF rectF, View view, boolean z) {
        rectF.top = view.getTop();
        rectF.bottom = view.getBottom();
        rectF.left = view.getLeft();
        rectF.right = view.getRight();
        if (z) {
            view.getMatrix().mapRect(rectF);
        }
    }

    /* JADX WARN: Removed duplicated region for block: B:100:0x009e  */
    /* JADX WARN: Removed duplicated region for block: B:81:0x008a  */
    /* JADX WARN: Removed duplicated region for block: B:88:0x00b3  */
    /* JADX WARN: Removed duplicated region for block: B:95:0x00c9  */
    /*
        Code decompiled incorrectly, please refer to instructions dump.
        To view partially-correct add '--show-bad-code' argument
    */
    public final void e(float r10, android.view.View r11) {
        /*
            Method dump skipped, instructions count: 378
            To view this dump add '--comments-level debug' option
        */
        throw new UnsupportedOperationException("Method not decompiled: o.AZC.e(float, android.view.View):void");
    }

    /* JADX WARN: Failed to find 'out' block for switch in B:27:0x006e. Please report as an issue. */
    private void e(String str, View view) {
        Method method;
        if (str == null) {
            return;
        }
        if (!str.startsWith(".")) {
            if (this.p.containsKey(str)) {
                method = this.p.get(str);
                if (method == null) {
                    return;
                }
            } else {
                method = null;
            }
            if (method == null) {
                try {
                    method = view.getClass().getMethod(str, new Class[0]);
                    this.p.put(str, method);
                } catch (NoSuchMethodException unused) {
                    this.p.put(str, null);
                    C6805ccO.d(view);
                    return;
                }
            }
            try {
                method.invoke(view, new Object[0]);
                return;
            } catch (Exception unused2) {
                C6805ccO.d(view);
                return;
            }
        }
        boolean z = str.length() == 1;
        if (!z) {
            str = str.substring(1).toLowerCase(Locale.ROOT);
        }
        for (String str2 : this.d.keySet()) {
            String lowerCase = str2.toLowerCase(Locale.ROOT);
            if (z || lowerCase.matches(str)) {
                Prc prc = this.d.get(str2);
                if (prc != null) {
                    Class<?> cls = view.getClass();
                    String str3 = prc.f;
                    if (!prc.c) {
                        str3 = "set".concat(String.valueOf(str3));
                    }
                    try {
                        switch (Prc.AnonymousClass1.a[prc.g.ordinal()]) {
                            case 1:
                            case 6:
                                cls.getMethod(str3, Integer.TYPE).invoke(view, Integer.valueOf(prc.a));
                                break;
                            case 2:
                                cls.getMethod(str3, Boolean.TYPE).invoke(view, Boolean.valueOf(prc.b));
                                break;
                            case 3:
                                cls.getMethod(str3, CharSequence.class).invoke(view, prc.i);
                                break;
                            case 4:
                                cls.getMethod(str3, Integer.TYPE).invoke(view, Integer.valueOf(prc.d));
                                break;
                            case 5:
                                Method method2 = cls.getMethod(str3, Drawable.class);
                                ColorDrawable colorDrawable = new ColorDrawable();
                                colorDrawable.setColor(prc.d);
                                method2.invoke(view, colorDrawable);
                                break;
                            case 7:
                                cls.getMethod(str3, Float.TYPE).invoke(view, Float.valueOf(prc.e));
                                break;
                            case 8:
                                cls.getMethod(str3, Float.TYPE).invoke(view, Float.valueOf(prc.e));
                                break;
                        }
                    } catch (IllegalAccessException | InvocationTargetException unused3) {
                    } catch (NoSuchMethodException e) {
                        e.getMessage();
                    }
                }
            }
        }
    }

    /* loaded from: classes.dex */
    static class HBt {
        private static SparseIntArray c;

        static {
            SparseIntArray sparseIntArray = new SparseIntArray();
            c = sparseIntArray;
            sparseIntArray.append(C3345avm.IeS.KeyTrigger_framePosition, 8);
            c.append(C3345avm.IeS.KeyTrigger_onCross, 4);
            c.append(C3345avm.IeS.KeyTrigger_onNegativeCross, 1);
            c.append(C3345avm.IeS.KeyTrigger_onPositiveCross, 2);
            c.append(C3345avm.IeS.KeyTrigger_motionTarget, 7);
            c.append(C3345avm.IeS.KeyTrigger_triggerId, 6);
            c.append(C3345avm.IeS.KeyTrigger_triggerSlack, 5);
            c.append(C3345avm.IeS.KeyTrigger_motion_triggerOnCollision, 9);
            c.append(C3345avm.IeS.KeyTrigger_motion_postLayoutCollision, 10);
            c.append(C3345avm.IeS.KeyTrigger_triggerReceiver, 11);
            c.append(C3345avm.IeS.KeyTrigger_viewTransitionOnCross, 12);
            c.append(C3345avm.IeS.KeyTrigger_viewTransitionOnNegativeCross, 13);
            c.append(C3345avm.IeS.KeyTrigger_viewTransitionOnPositiveCross, 14);
        }

        public static void kD_(AZC azc, TypedArray typedArray) {
            int indexCount = typedArray.getIndexCount();
            for (int i = 0; i < indexCount; i++) {
                int index = typedArray.getIndex(i);
                switch (c.get(index)) {
                    case 1:
                        azc.r = typedArray.getString(index);
                        break;
                    case 2:
                        azc.t = typedArray.getString(index);
                        break;
                    case 3:
                    default:
                        c.get(index);
                        break;
                    case 4:
                        azc.m = typedArray.getString(index);
                        break;
                    case 5:
                        azc.h = typedArray.getFloat(index, azc.h);
                        break;
                    case 6:
                        azc.w = typedArray.getResourceId(index, azc.w);
                        break;
                    case 7:
                        if (MotionLayout.b) {
                            azc.a = typedArray.getResourceId(index, azc.a);
                            if (azc.a == -1) {
                                azc.b = typedArray.getString(index);
                                break;
                            } else {
                                break;
                            }
                        } else if (typedArray.peekValue(index).type == 3) {
                            azc.b = typedArray.getString(index);
                            break;
                        } else {
                            azc.a = typedArray.getResourceId(index, azc.a);
                            break;
                        }
                    case 8:
                        azc.e = typedArray.getInteger(index, azc.e);
                        azc.s = (azc.e + 0.5f) / 100.0f;
                        break;
                    case 9:
                        azc.v = typedArray.getResourceId(index, azc.v);
                        break;
                    case 10:
                        azc.x = typedArray.getBoolean(index, azc.x);
                        break;
                    case 11:
                        azc.D = typedArray.getResourceId(index, azc.D);
                        break;
                    case 12:
                        azc.f = typedArray.getResourceId(index, azc.f);
                        break;
                    case 13:
                        azc.j = typedArray.getResourceId(index, azc.j);
                        break;
                    case 14:
                        azc.i = typedArray.getResourceId(index, azc.i);
                        break;
                }
            }
        }
    }

    @Override // o.AbstractC0558JiG
    public final AbstractC0558JiG b(AbstractC0558JiG abstractC0558JiG) {
        super.b(abstractC0558JiG);
        AZC azc = (AZC) abstractC0558JiG;
        this.l = azc.l;
        this.m = azc.m;
        this.D = azc.D;
        this.r = azc.r;
        this.t = azc.t;
        this.w = azc.w;
        this.v = azc.v;
        this.u = azc.u;
        this.h = azc.h;
        this.f8099o = azc.f8099o;
        this.k = azc.k;
        this.q = azc.q;
        this.s = azc.s;
        this.n = azc.n;
        this.x = azc.x;
        this.g = azc.g;
        this.y = azc.y;
        this.p = azc.p;
        return this;
    }

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

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