package defpackage;

import android.graphics.Rect;
import android.os.Bundle;
import android.view.KeyEvent;
import android.view.MotionEvent;
import android.view.View;
import android.view.ViewParent;
import android.view.accessibility.AccessibilityEvent;
import android.view.accessibility.AccessibilityManager;
import android.view.accessibility.AccessibilityNodeInfo;
import androidx.media3.extractor.ts.TsExtractor;
import defpackage.kg3;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.WeakHashMap;

/* JADX INFO: loaded from: classes.dex */
public abstract class bu2 extends b3 {
    private static final String DEFAULT_CLASS_NAME = "android.view.View";
    public static final int HOST_ID = -1;
    public static final int INVALID_ID = Integer.MIN_VALUE;
    private static final Rect INVALID_PARENT_BOUNDS = new Rect(Integer.MAX_VALUE, Integer.MAX_VALUE, Integer.MIN_VALUE, Integer.MIN_VALUE);
    private static final kg3.a<i3> NODE_ADAPTER = new a();
    private static final kg3.b<wy8<i3>, i3> SPARSE_VALUES_ADAPTER = new b();
    private final View mHost;
    private final AccessibilityManager mManager;
    private c mNodeProvider;
    private final Rect mTempScreenRect = new Rect();
    private final Rect mTempParentRect = new Rect();
    private final Rect mTempVisibleRect = new Rect();
    private final int[] mTempGlobalRect = new int[2];
    int mAccessibilityFocusedVirtualViewId = Integer.MIN_VALUE;
    int mKeyboardFocusedVirtualViewId = Integer.MIN_VALUE;
    private int mHoveredVirtualViewId = Integer.MIN_VALUE;

    public class a implements kg3.a<i3> {
        @Override // kg3.a
        public final void a(Object obj, Rect rect) {
            ((i3) obj).f(rect);
        }
    }

    public class b implements kg3.b<wy8<i3>, i3> {
        @Override // kg3.b
        public final int a(wy8 wy8Var) {
            return wy8Var.f();
        }

        @Override // kg3.b
        public final i3 b(wy8 wy8Var, int i) {
            return (i3) wy8Var.g(i);
        }
    }

    public class c extends j3 {
        public c() {
        }

        @Override // defpackage.j3
        public final i3 a(int i) {
            return new i3(AccessibilityNodeInfo.obtain(bu2.this.obtainAccessibilityNodeInfo(i).a));
        }

        @Override // defpackage.j3
        public final i3 b(int i) {
            bu2 bu2Var = bu2.this;
            int i2 = i == 2 ? bu2Var.mAccessibilityFocusedVirtualViewId : bu2Var.mKeyboardFocusedVirtualViewId;
            if (i2 == Integer.MIN_VALUE) {
                return null;
            }
            return a(i2);
        }

        @Override // defpackage.j3
        public final boolean c(int i, int i2, Bundle bundle) {
            return bu2.this.performAction(i, i2, bundle);
        }
    }

    public bu2(View view) {
        if (view == null) {
            throw new IllegalArgumentException("View may not be null");
        }
        this.mHost = view;
        this.mManager = (AccessibilityManager) view.getContext().getSystemService("accessibility");
        view.setFocusable(true);
        WeakHashMap weakHashMap = sia.a;
        if (view.getImportantForAccessibility() == 0) {
            view.setImportantForAccessibility(1);
        }
    }

    public final AccessibilityEvent a(int i, int i2) {
        if (i == -1) {
            AccessibilityEvent accessibilityEventObtain = AccessibilityEvent.obtain(i2);
            this.mHost.onInitializeAccessibilityEvent(accessibilityEventObtain);
            return accessibilityEventObtain;
        }
        AccessibilityEvent accessibilityEventObtain2 = AccessibilityEvent.obtain(i2);
        i3 i3VarObtainAccessibilityNodeInfo = obtainAccessibilityNodeInfo(i);
        accessibilityEventObtain2.getText().add(i3VarObtainAccessibilityNodeInfo.g());
        AccessibilityNodeInfo accessibilityNodeInfo = i3VarObtainAccessibilityNodeInfo.a;
        accessibilityEventObtain2.setContentDescription(accessibilityNodeInfo.getContentDescription());
        accessibilityEventObtain2.setScrollable(accessibilityNodeInfo.isScrollable());
        accessibilityEventObtain2.setPassword(accessibilityNodeInfo.isPassword());
        accessibilityEventObtain2.setEnabled(accessibilityNodeInfo.isEnabled());
        accessibilityEventObtain2.setChecked(accessibilityNodeInfo.isChecked());
        onPopulateEventForVirtualView(i, accessibilityEventObtain2);
        if (accessibilityEventObtain2.getText().isEmpty() && accessibilityEventObtain2.getContentDescription() == null) {
            throw new RuntimeException("Callbacks must add text or a content description in populateEventForVirtualViewId()");
        }
        accessibilityEventObtain2.setClassName(accessibilityNodeInfo.getClassName());
        accessibilityEventObtain2.setSource(this.mHost, i);
        accessibilityEventObtain2.setPackageName(this.mHost.getContext().getPackageName());
        return accessibilityEventObtain2;
    }

    public final i3 b(int i) {
        AccessibilityNodeInfo accessibilityNodeInfoObtain = AccessibilityNodeInfo.obtain();
        i3 i3Var = new i3(accessibilityNodeInfoObtain);
        accessibilityNodeInfoObtain.setEnabled(true);
        accessibilityNodeInfoObtain.setFocusable(true);
        i3Var.i(DEFAULT_CLASS_NAME);
        Rect rect = INVALID_PARENT_BOUNDS;
        accessibilityNodeInfoObtain.setBoundsInParent(rect);
        accessibilityNodeInfoObtain.setBoundsInScreen(rect);
        accessibilityNodeInfoObtain.setParent(this.mHost);
        onPopulateNodeForVirtualView(i, i3Var);
        if (i3Var.g() == null && accessibilityNodeInfoObtain.getContentDescription() == null) {
            throw new RuntimeException("Callbacks must add text or a content description in populateNodeForVirtualViewId()");
        }
        i3Var.f(this.mTempParentRect);
        if (this.mTempParentRect.equals(rect)) {
            throw new RuntimeException("Callbacks must set parent bounds in populateNodeForVirtualViewId()");
        }
        int actions = accessibilityNodeInfoObtain.getActions();
        if ((actions & 64) != 0) {
            throw new RuntimeException("Callbacks must not add ACTION_ACCESSIBILITY_FOCUS in populateNodeForVirtualViewId()");
        }
        if ((actions & 128) != 0) {
            throw new RuntimeException("Callbacks must not add ACTION_CLEAR_ACCESSIBILITY_FOCUS in populateNodeForVirtualViewId()");
        }
        accessibilityNodeInfoObtain.setPackageName(this.mHost.getContext().getPackageName());
        View view = this.mHost;
        i3Var.b = i;
        accessibilityNodeInfoObtain.setSource(view, i);
        if (this.mAccessibilityFocusedVirtualViewId == i) {
            accessibilityNodeInfoObtain.setAccessibilityFocused(true);
            i3Var.a(128);
        } else {
            accessibilityNodeInfoObtain.setAccessibilityFocused(false);
            i3Var.a(64);
        }
        boolean z = this.mKeyboardFocusedVirtualViewId == i;
        if (z) {
            i3Var.a(2);
        } else if (accessibilityNodeInfoObtain.isFocusable()) {
            i3Var.a(1);
        }
        accessibilityNodeInfoObtain.setFocused(z);
        this.mHost.getLocationOnScreen(this.mTempGlobalRect);
        accessibilityNodeInfoObtain.getBoundsInScreen(this.mTempScreenRect);
        if (this.mTempScreenRect.equals(rect)) {
            i3Var.f(this.mTempScreenRect);
            this.mTempScreenRect.offset(this.mTempGlobalRect[0] - this.mHost.getScrollX(), this.mTempGlobalRect[1] - this.mHost.getScrollY());
        }
        if (this.mHost.getLocalVisibleRect(this.mTempVisibleRect)) {
            this.mTempVisibleRect.offset(this.mTempGlobalRect[0] - this.mHost.getScrollX(), this.mTempGlobalRect[1] - this.mHost.getScrollY());
            if (this.mTempScreenRect.intersect(this.mTempVisibleRect)) {
                accessibilityNodeInfoObtain.setBoundsInScreen(this.mTempScreenRect);
                Rect rect2 = this.mTempScreenRect;
                if (rect2 != null && !rect2.isEmpty() && this.mHost.getWindowVisibility() == 0) {
                    Object parent = this.mHost.getParent();
                    while (true) {
                        if (parent instanceof View) {
                            View view2 = (View) parent;
                            if (view2.getAlpha() <= 0.0f || view2.getVisibility() != 0) {
                                break;
                            }
                            parent = view2.getParent();
                        } else if (parent != null) {
                            i3Var.a.setVisibleToUser(true);
                        }
                    }
                }
            }
        }
        return i3Var;
    }

    /* JADX WARN: Removed duplicated region for block: B:67:0x0138  */
    /* JADX WARN: Removed duplicated region for block: B:87:0x018b  */
    /*
        Code decompiled incorrectly, please refer to instructions dump.
    */
    public final boolean c(int i, Rect rect) {
        Object obj;
        i3 i3Var;
        int iD;
        ArrayList arrayList = new ArrayList();
        getVisibleVirtualViews(arrayList);
        wy8 wy8Var = new wy8();
        int i2 = 0;
        for (int i3 = 0; i3 < arrayList.size(); i3++) {
            wy8Var.e(((Integer) arrayList.get(i3)).intValue(), b(((Integer) arrayList.get(i3)).intValue()));
        }
        int i4 = this.mKeyboardFocusedVirtualViewId;
        i3 i3Var2 = i4 == Integer.MIN_VALUE ? null : (i3) wy8Var.c(i4);
        int i5 = -1;
        if (i == 1 || i == 2) {
            View view = this.mHost;
            WeakHashMap weakHashMap = sia.a;
            boolean z = view.getLayoutDirection() == 1;
            kg3.b<wy8<i3>, i3> bVar = SPARSE_VALUES_ADAPTER;
            kg3.a<i3> aVar = NODE_ADAPTER;
            int iA = bVar.a(wy8Var);
            ArrayList arrayList2 = new ArrayList(iA);
            for (int i6 = 0; i6 < iA; i6++) {
                arrayList2.add(bVar.b(wy8Var, i6));
            }
            Collections.sort(arrayList2, new kg3.c(z, aVar));
            if (i == 1) {
                int size = arrayList2.size();
                if (i3Var2 != null) {
                    size = arrayList2.indexOf(i3Var2);
                }
                int i7 = size - 1;
                if (i7 >= 0) {
                    obj = arrayList2.get(i7);
                }
                i3Var = (i3) obj;
            } else {
                if (i != 2) {
                    throw new IllegalArgumentException("direction must be one of {FOCUS_FORWARD, FOCUS_BACKWARD}.");
                }
                int size2 = arrayList2.size();
                int iLastIndexOf = (i3Var2 == null ? -1 : arrayList2.lastIndexOf(i3Var2)) + 1;
                obj = iLastIndexOf < size2 ? arrayList2.get(iLastIndexOf) : null;
                i3Var = (i3) obj;
            }
        } else {
            if (i != 17 && i != 33 && i != 66 && i != 130) {
                throw new IllegalArgumentException("direction must be one of {FOCUS_FORWARD, FOCUS_BACKWARD, FOCUS_UP, FOCUS_DOWN, FOCUS_LEFT, FOCUS_RIGHT}.");
            }
            Rect rect2 = new Rect();
            int i8 = this.mKeyboardFocusedVirtualViewId;
            if (i8 != Integer.MIN_VALUE) {
                obtainAccessibilityNodeInfo(i8).f(rect2);
            } else if (rect != null) {
                rect2.set(rect);
            } else {
                View view2 = this.mHost;
                int width = view2.getWidth();
                int height = view2.getHeight();
                if (i == 17) {
                    rect2.set(width, 0, width, height);
                } else if (i == 33) {
                    rect2.set(0, height, width, height);
                } else if (i == 66) {
                    rect2.set(-1, 0, -1, height);
                } else {
                    if (i != 130) {
                        throw new IllegalArgumentException("direction must be one of {FOCUS_UP, FOCUS_DOWN, FOCUS_LEFT, FOCUS_RIGHT}.");
                    }
                    rect2.set(0, -1, width, -1);
                }
            }
            kg3.b<wy8<i3>, i3> bVar2 = SPARSE_VALUES_ADAPTER;
            kg3.a<i3> aVar2 = NODE_ADAPTER;
            Rect rect3 = new Rect(rect2);
            if (i == 17) {
                rect3.offset(rect2.width() + 1, 0);
            } else if (i == 33) {
                rect3.offset(0, rect2.height() + 1);
            } else if (i == 66) {
                rect3.offset(-(rect2.width() + 1), 0);
            } else {
                if (i != 130) {
                    throw new IllegalArgumentException("direction must be one of {FOCUS_UP, FOCUS_DOWN, FOCUS_LEFT, FOCUS_RIGHT}.");
                }
                rect3.offset(0, -(rect2.height() + 1));
            }
            int iA2 = bVar2.a(wy8Var);
            Rect rect4 = new Rect();
            i3Var = null;
            for (int i9 = 0; i9 < iA2; i9++) {
                i3 i3VarB = bVar2.b(wy8Var, i9);
                if (i3VarB != i3Var2) {
                    aVar2.a(i3VarB, rect4);
                    if (kg3.c(i, rect2, rect4)) {
                        if (kg3.c(i, rect2, rect3) && !kg3.a(i, rect2, rect4, rect3)) {
                            if (!kg3.a(i, rect2, rect3, rect4)) {
                                int iD2 = kg3.d(i, rect2, rect4);
                                int iE = kg3.e(i, rect2, rect4);
                                int i10 = (iE * iE) + (iD2 * 13 * iD2);
                                int iD3 = kg3.d(i, rect2, rect3);
                                int iE2 = kg3.e(i, rect2, rect3);
                                if (i10 < (iE2 * iE2) + (iD3 * 13 * iD3)) {
                                    rect3.set(rect4);
                                    i3Var = i3VarB;
                                }
                            }
                        }
                    }
                }
            }
        }
        i3 i3Var3 = i3Var;
        if (i3Var3 == null) {
            iD = Integer.MIN_VALUE;
        } else {
            if (wy8Var.a) {
                C0746xy8.a(wy8Var);
            }
            int i11 = wy8Var.d;
            while (true) {
                if (i2 >= i11) {
                    break;
                }
                if (wy8Var.c[i2] == i3Var3) {
                    i5 = i2;
                    break;
                }
                i2++;
            }
            iD = wy8Var.d(i5);
        }
        return requestKeyboardFocusForVirtualView(iD);
    }

    public final boolean clearKeyboardFocusForVirtualView(int i) {
        if (this.mKeyboardFocusedVirtualViewId != i) {
            return false;
        }
        this.mKeyboardFocusedVirtualViewId = Integer.MIN_VALUE;
        onVirtualViewKeyboardFocusChanged(i, false);
        sendEventForVirtualView(i, 8);
        return true;
    }

    public final boolean dispatchHoverEvent(@vo6 MotionEvent motionEvent) {
        int i;
        if (!this.mManager.isEnabled() || !this.mManager.isTouchExplorationEnabled()) {
            return false;
        }
        int action = motionEvent.getAction();
        if (action == 7 || action == 9) {
            int virtualViewAt = getVirtualViewAt(motionEvent.getX(), motionEvent.getY());
            int i2 = this.mHoveredVirtualViewId;
            if (i2 != virtualViewAt) {
                this.mHoveredVirtualViewId = virtualViewAt;
                sendEventForVirtualView(virtualViewAt, 128);
                sendEventForVirtualView(i2, 256);
            }
            if (virtualViewAt == Integer.MIN_VALUE) {
                return false;
            }
        } else {
            if (action != 10 || (i = this.mHoveredVirtualViewId) == Integer.MIN_VALUE) {
                return false;
            }
            if (i != Integer.MIN_VALUE) {
                this.mHoveredVirtualViewId = Integer.MIN_VALUE;
                sendEventForVirtualView(Integer.MIN_VALUE, 128);
                sendEventForVirtualView(i, 256);
                return true;
            }
        }
        return true;
    }

    /* JADX WARN: Can't fix incorrect switch cases order, some code will duplicate */
    /* JADX WARN: Removed duplicated region for block: B:27:0x0046  */
    /*
        Code decompiled incorrectly, please refer to instructions dump.
    */
    public final boolean dispatchKeyEvent(@vo6 KeyEvent keyEvent) {
        int i = 0;
        if (keyEvent.getAction() != 1) {
            int keyCode = keyEvent.getKeyCode();
            if (keyCode != 61) {
                int i2 = 66;
                if (keyCode != 66) {
                    switch (keyCode) {
                        case 19:
                        case 20:
                        case 21:
                        case 22:
                            if (keyEvent.hasNoModifiers()) {
                                if (keyCode == 19) {
                                    i2 = 33;
                                } else if (keyCode == 21) {
                                    i2 = 17;
                                } else if (keyCode != 22) {
                                    i2 = TsExtractor.TS_STREAM_TYPE_HDMV_DTS;
                                }
                                int repeatCount = keyEvent.getRepeatCount() + 1;
                                boolean z = false;
                                while (i < repeatCount && c(i2, null)) {
                                    i++;
                                    z = true;
                                }
                                return z;
                            }
                            break;
                        case 23:
                            if (keyEvent.hasNoModifiers() && keyEvent.getRepeatCount() == 0) {
                                int i3 = this.mKeyboardFocusedVirtualViewId;
                                if (i3 != Integer.MIN_VALUE) {
                                    onPerformActionForVirtualView(i3, 16, null);
                                }
                                return true;
                            }
                            break;
                    }
                }
            } else {
                if (keyEvent.hasNoModifiers()) {
                    return c(2, null);
                }
                if (keyEvent.hasModifiers(1)) {
                    return c(1, null);
                }
            }
        }
        return false;
    }

    public final int getAccessibilityFocusedVirtualViewId() {
        return this.mAccessibilityFocusedVirtualViewId;
    }

    @Override // defpackage.b3
    public j3 getAccessibilityNodeProvider(View view) {
        if (this.mNodeProvider == null) {
            this.mNodeProvider = new c();
        }
        return this.mNodeProvider;
    }

    @Deprecated
    public int getFocusedVirtualView() {
        return getAccessibilityFocusedVirtualViewId();
    }

    public final int getKeyboardFocusedVirtualViewId() {
        return this.mKeyboardFocusedVirtualViewId;
    }

    public abstract int getVirtualViewAt(float f, float f2);

    public abstract void getVisibleVirtualViews(List list);

    public final void invalidateRoot() {
        invalidateVirtualView(-1, 1);
    }

    public final void invalidateVirtualView(int i) {
        invalidateVirtualView(i, 0);
    }

    @vo6
    public i3 obtainAccessibilityNodeInfo(int i) {
        if (i != -1) {
            return b(i);
        }
        AccessibilityNodeInfo accessibilityNodeInfoObtain = AccessibilityNodeInfo.obtain(this.mHost);
        i3 i3Var = new i3(accessibilityNodeInfoObtain);
        View view = this.mHost;
        WeakHashMap weakHashMap = sia.a;
        view.onInitializeAccessibilityNodeInfo(accessibilityNodeInfoObtain);
        ArrayList arrayList = new ArrayList();
        getVisibleVirtualViews(arrayList);
        if (accessibilityNodeInfoObtain.getChildCount() > 0 && arrayList.size() > 0) {
            throw new RuntimeException("Views cannot have both real and virtual children");
        }
        int size = arrayList.size();
        for (int i2 = 0; i2 < size; i2++) {
            i3Var.a.addChild(this.mHost, ((Integer) arrayList.get(i2)).intValue());
        }
        return i3Var;
    }

    public final void onFocusChanged(boolean z, int i, @rq6 Rect rect) {
        int i2 = this.mKeyboardFocusedVirtualViewId;
        if (i2 != Integer.MIN_VALUE) {
            clearKeyboardFocusForVirtualView(i2);
        }
        if (z) {
            c(i, rect);
        }
    }

    @Override // defpackage.b3
    public void onInitializeAccessibilityEvent(View view, AccessibilityEvent accessibilityEvent) {
        super.onInitializeAccessibilityEvent(view, accessibilityEvent);
        onPopulateEventForHost(accessibilityEvent);
    }

    @Override // defpackage.b3
    public void onInitializeAccessibilityNodeInfo(View view, i3 i3Var) {
        super.onInitializeAccessibilityNodeInfo(view, i3Var);
        onPopulateNodeForHost(i3Var);
    }

    public abstract boolean onPerformActionForVirtualView(int i, int i2, Bundle bundle);

    public void onPopulateEventForHost(@vo6 AccessibilityEvent accessibilityEvent) {
    }

    public void onPopulateEventForVirtualView(int i, @vo6 AccessibilityEvent accessibilityEvent) {
    }

    public void onPopulateNodeForHost(@vo6 i3 i3Var) {
    }

    public abstract void onPopulateNodeForVirtualView(int i, i3 i3Var);

    public void onVirtualViewKeyboardFocusChanged(int i, boolean z) {
    }

    public boolean performAction(int i, int i2, Bundle bundle) {
        int i3;
        if (i == -1) {
            View view = this.mHost;
            WeakHashMap weakHashMap = sia.a;
            return view.performAccessibilityAction(i2, bundle);
        }
        if (i2 == 1) {
            return requestKeyboardFocusForVirtualView(i);
        }
        if (i2 == 2) {
            return clearKeyboardFocusForVirtualView(i);
        }
        if (i2 != 64) {
            if (i2 != 128) {
                return onPerformActionForVirtualView(i, i2, bundle);
            }
            if (this.mAccessibilityFocusedVirtualViewId != i) {
                return false;
            }
            this.mAccessibilityFocusedVirtualViewId = Integer.MIN_VALUE;
            this.mHost.invalidate();
            sendEventForVirtualView(i, 65536);
            return true;
        }
        if (!this.mManager.isEnabled() || !this.mManager.isTouchExplorationEnabled() || (i3 = this.mAccessibilityFocusedVirtualViewId) == i) {
            return false;
        }
        if (i3 != Integer.MIN_VALUE) {
            this.mAccessibilityFocusedVirtualViewId = Integer.MIN_VALUE;
            this.mHost.invalidate();
            sendEventForVirtualView(i3, 65536);
        }
        this.mAccessibilityFocusedVirtualViewId = i;
        this.mHost.invalidate();
        sendEventForVirtualView(i, 32768);
        return true;
    }

    public final boolean requestKeyboardFocusForVirtualView(int i) {
        int i2;
        if ((!this.mHost.isFocused() && !this.mHost.requestFocus()) || (i2 = this.mKeyboardFocusedVirtualViewId) == i) {
            return false;
        }
        if (i2 != Integer.MIN_VALUE) {
            clearKeyboardFocusForVirtualView(i2);
        }
        if (i == Integer.MIN_VALUE) {
            return false;
        }
        this.mKeyboardFocusedVirtualViewId = i;
        onVirtualViewKeyboardFocusChanged(i, true);
        sendEventForVirtualView(i, 8);
        return true;
    }

    public final boolean sendEventForVirtualView(int i, int i2) {
        ViewParent parent;
        if (i == Integer.MIN_VALUE || !this.mManager.isEnabled() || (parent = this.mHost.getParent()) == null) {
            return false;
        }
        return parent.requestSendAccessibilityEvent(this.mHost, a(i, i2));
    }

    public final void invalidateVirtualView(int i, int i2) {
        ViewParent parent;
        if (i == Integer.MIN_VALUE || !this.mManager.isEnabled() || (parent = this.mHost.getParent()) == null) {
            return;
        }
        AccessibilityEvent accessibilityEventA = a(i, 2048);
        accessibilityEventA.setContentChangeTypes(i2);
        parent.requestSendAccessibilityEvent(this.mHost, accessibilityEventA);
    }
}