package com.google.android.material.progressindicator;

import android.animation.ValueAnimator;
import android.content.ContentResolver;
import android.content.Context;
import android.content.res.TypedArray;
import android.graphics.Canvas;
import android.graphics.drawable.Drawable;
import android.os.SystemClock;
import android.util.AttributeSet;
import android.view.View;
import android.widget.ProgressBar;
import androidx.annotation.AttrRes;
import androidx.annotation.ColorInt;
import androidx.annotation.FloatRange;
import androidx.annotation.NonNull;
import androidx.annotation.Nullable;
import androidx.annotation.Px;
import androidx.annotation.RestrictTo;
import androidx.annotation.StyleRes;
import androidx.annotation.VisibleForTesting;
import androidx.media3.exoplayer.upstream.experimental.SlidingPercentileBandwidthStatistic;
import com.google.android.material.internal.q0;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.util.ArrayList;
import java.util.Arrays;
import p9.a;
import p9.b;
import p9.c;
import p9.d;
import p9.k;
import p9.p;
import p9.q;
import x8.l;
import x8.m;

/* JADX INFO: loaded from: classes2.dex */
public abstract class BaseProgressIndicator<S extends d> extends ProgressBar {
    public static final int Q = l.Widget_MaterialComponents_ProgressIndicator;

    /* JADX INFO: renamed from: a, reason: collision with root package name */
    public final d f22975a;

    /* JADX INFO: renamed from: b, reason: collision with root package name */
    public int f22976b;

    /* JADX INFO: renamed from: c, reason: collision with root package name */
    public boolean f22977c;

    /* JADX INFO: renamed from: d, reason: collision with root package name */
    public final boolean f22978d;

    /* JADX INFO: renamed from: e, reason: collision with root package name */
    public final int f22979e;

    /* JADX INFO: renamed from: f, reason: collision with root package name */
    public a f22980f;

    /* JADX INFO: renamed from: g, reason: collision with root package name */
    public boolean f22981g;

    /* JADX INFO: renamed from: h, reason: collision with root package name */
    public int f22982h;

    /* JADX INFO: renamed from: i, reason: collision with root package name */
    public boolean f22983i;

    /* JADX INFO: renamed from: j, reason: collision with root package name */
    public final b f22984j;

    /* JADX INFO: renamed from: k, reason: collision with root package name */
    public final b f22985k;

    /* JADX INFO: renamed from: l, reason: collision with root package name */
    public final c f22986l;

    /* JADX INFO: renamed from: m, reason: collision with root package name */
    public final c f22987m;

    @Retention(RetentionPolicy.SOURCE)
    @RestrictTo({RestrictTo.Scope.f556b})
    public @interface HideAnimationBehavior {
    }

    @Retention(RetentionPolicy.SOURCE)
    @RestrictTo({RestrictTo.Scope.f556b})
    public @interface ShowAnimationBehavior {
    }

    public BaseProgressIndicator(@NonNull Context context, @Nullable AttributeSet attributeSet, @AttrRes int i10, @StyleRes int i11) {
        super(x9.a.wrap(context, attributeSet, i10, Q), attributeSet, i10);
        this.f22981g = false;
        this.f22982h = 4;
        this.f22984j = new b(this, 0);
        this.f22985k = new b(this, 1);
        this.f22986l = new c(this, 0);
        this.f22987m = new c(this, 1);
        Context context2 = getContext();
        this.f22975a = a(context2, attributeSet);
        TypedArray typedArrayC = q0.c(context2, attributeSet, m.BaseProgressIndicator, i10, i11, new int[0]);
        typedArrayC.getInt(m.BaseProgressIndicator_showDelay, -1);
        this.f22979e = Math.min(typedArrayC.getInt(m.BaseProgressIndicator_minHideDelay, -1), 1000);
        typedArrayC.recycle();
        this.f22980f = new a();
        this.f22978d = true;
    }

    @Nullable
    private p getCurrentDrawingDelegate() {
        if (isIndeterminate()) {
            if (getIndeterminateDrawable() == null) {
                return null;
            }
            return getIndeterminateDrawable().Q;
        }
        if (getProgressDrawable() == null) {
            return null;
        }
        return getProgressDrawable().Q;
    }

    public abstract d a(Context context, AttributeSet attributeSet);

    public final void b() {
        if (getProgressDrawable() == null || getIndeterminateDrawable() == null) {
            return;
        }
        getIndeterminateDrawable().R.registerAnimatorsCompleteCallback(this.f22986l);
    }

    /* JADX WARN: Code restructure failed: missing block: B:17:0x0025, code lost:
    
        return true;
     */
    /*
        Code decompiled incorrectly, please refer to instructions dump.
    */
    public final boolean c() {
        if (isAttachedToWindow() && getWindowVisibility() == 0) {
            View view = this;
            while (true) {
                if (view.getVisibility() != 0) {
                    break;
                }
                Object parent = view.getParent();
                if (parent == null) {
                    if (getWindowVisibility() == 0) {
                        break;
                    }
                } else {
                    if (!(parent instanceof View)) {
                        break;
                    }
                    view = (View) parent;
                }
            }
        }
        return false;
    }

    @Override // android.widget.ProgressBar
    @Nullable
    public Drawable getCurrentDrawable() {
        return isIndeterminate() ? getIndeterminateDrawable() : getProgressDrawable();
    }

    public int getHideAnimationBehavior() {
        return this.f22975a.f31793h;
    }

    @NonNull
    public int[] getIndicatorColor() {
        return this.f22975a.f31790e;
    }

    @Px
    public int getIndicatorTrackGapSize() {
        return this.f22975a.f31794i;
    }

    public int getShowAnimationBehavior() {
        return this.f22975a.f31792g;
    }

    @ColorInt
    public int getTrackColor() {
        return this.f22975a.f31791f;
    }

    @Px
    public int getTrackCornerRadius() {
        return this.f22975a.f31787b;
    }

    public float getTrackCornerRadiusFraction() {
        return this.f22975a.f31788c;
    }

    @Px
    public int getTrackThickness() {
        return this.f22975a.f31786a;
    }

    @Px
    public int getWaveAmplitude() {
        return this.f22975a.f31797l;
    }

    @Px
    public int getWaveSpeed() {
        return this.f22975a.f31798m;
    }

    @Px
    public int getWavelengthDeterminate() {
        return this.f22975a.f31795j;
    }

    @Px
    public int getWavelengthIndeterminate() {
        return this.f22975a.f31796k;
    }

    @Override // android.view.View
    public final void invalidate() {
        super.invalidate();
        if (getCurrentDrawable() != null) {
            getCurrentDrawable().invalidateSelf();
        }
    }

    @Override // android.widget.ProgressBar, android.view.View
    public final void onAttachedToWindow() {
        super.onAttachedToWindow();
        b();
        k progressDrawable = getProgressDrawable();
        c cVar = this.f22987m;
        if (progressDrawable != null) {
            k progressDrawable2 = getProgressDrawable();
            if (progressDrawable2.f31858g == null) {
                progressDrawable2.f31858g = new ArrayList();
            }
            if (!progressDrawable2.f31858g.contains(cVar)) {
                progressDrawable2.f31858g.add(cVar);
            }
        }
        if (getIndeterminateDrawable() != null) {
            q indeterminateDrawable = getIndeterminateDrawable();
            if (indeterminateDrawable.f31858g == null) {
                indeterminateDrawable.f31858g = new ArrayList();
            }
            if (!indeterminateDrawable.f31858g.contains(cVar)) {
                indeterminateDrawable.f31858g.add(cVar);
            }
        }
        if (c()) {
            if (this.f22979e > 0) {
                SystemClock.uptimeMillis();
            }
            setVisibility(0);
        }
    }

    @Override // android.widget.ProgressBar, android.view.View
    public final void onDetachedFromWindow() {
        removeCallbacks(this.f22985k);
        removeCallbacks(this.f22984j);
        ((p9.m) getCurrentDrawable()).d(false, false, false);
        q indeterminateDrawable = getIndeterminateDrawable();
        c cVar = this.f22987m;
        if (indeterminateDrawable != null) {
            getIndeterminateDrawable().f(cVar);
            getIndeterminateDrawable().R.g();
        }
        if (getProgressDrawable() != null) {
            getProgressDrawable().f(cVar);
        }
        super.onDetachedFromWindow();
    }

    @Override // android.widget.ProgressBar, android.view.View
    public final synchronized void onDraw(Canvas canvas) {
        try {
            int iSave = canvas.save();
            if (getPaddingLeft() != 0 || getPaddingTop() != 0) {
                canvas.translate(getPaddingLeft(), getPaddingTop());
            }
            if (getPaddingRight() != 0 || getPaddingBottom() != 0) {
                canvas.clipRect(0, 0, getWidth() - (getPaddingLeft() + getPaddingRight()), getHeight() - (getPaddingTop() + getPaddingBottom()));
            }
            getCurrentDrawable().draw(canvas);
            canvas.restoreToCount(iSave);
        } catch (Throwable th) {
            throw th;
        }
    }

    @Override // android.view.View
    public void onLayout(boolean z10, int i10, int i11, int i12, int i13) {
        super.onLayout(z10, i10, i11, i12, i13);
        getCurrentDrawingDelegate().g();
    }

    @Override // android.widget.ProgressBar, android.view.View
    public final synchronized void onMeasure(int i10, int i11) {
        try {
            p currentDrawingDelegate = getCurrentDrawingDelegate();
            if (currentDrawingDelegate == null) {
                return;
            }
            setMeasuredDimension(currentDrawingDelegate.f() < 0 ? View.getDefaultSize(getSuggestedMinimumWidth(), i10) : currentDrawingDelegate.f() + getPaddingLeft() + getPaddingRight(), currentDrawingDelegate.e() < 0 ? View.getDefaultSize(getSuggestedMinimumHeight(), i11) : currentDrawingDelegate.e() + getPaddingTop() + getPaddingBottom());
        } catch (Throwable th) {
            throw th;
        }
    }

    @Override // android.view.View
    public final void onVisibilityChanged(View view, int i10) {
        super.onVisibilityChanged(view, i10);
        boolean z10 = i10 == 0;
        if (this.f22978d) {
            ((p9.m) getCurrentDrawable()).d(c(), false, z10);
        }
    }

    @Override // android.view.View
    public final void onWindowVisibilityChanged(int i10) {
        super.onWindowVisibilityChanged(i10);
        if (this.f22978d) {
            ((p9.m) getCurrentDrawable()).d(c(), false, false);
        }
    }

    @RestrictTo({RestrictTo.Scope.f556b})
    @VisibleForTesting
    public void setAnimatorDurationScaleProvider(@NonNull a aVar) {
        this.f22980f = aVar;
        if (getProgressDrawable() != null) {
            getProgressDrawable().f31854c = aVar;
        }
        if (getIndeterminateDrawable() != null) {
            getIndeterminateDrawable().f31854c = aVar;
        }
    }

    public void setHideAnimationBehavior(int i10) {
        this.f22975a.f31793h = i10;
        invalidate();
    }

    @Override // android.widget.ProgressBar
    public synchronized void setIndeterminate(boolean z10) {
        try {
            if (z10 == isIndeterminate()) {
                return;
            }
            p9.m mVar = (p9.m) getCurrentDrawable();
            if (mVar != null) {
                mVar.d(false, false, false);
            }
            super.setIndeterminate(z10);
            p9.m mVar2 = (p9.m) getCurrentDrawable();
            if (mVar2 != null) {
                mVar2.d(c(), false, false);
            }
            if ((mVar2 instanceof q) && c()) {
                ((q) mVar2).R.f();
            }
            this.f22981g = false;
        } catch (Throwable th) {
            throw th;
        }
    }

    public void setIndeterminateAnimatorDurationScale(@FloatRange(from = 0.10000000149011612d, to = 10.0d) float f10) {
        d dVar = this.f22975a;
        if (dVar.f31799n != f10) {
            dVar.f31799n = f10;
            getIndeterminateDrawable().R.c();
        }
    }

    @Override // android.widget.ProgressBar
    public void setIndeterminateDrawable(@Nullable Drawable drawable) {
        if (drawable instanceof q) {
            ((p9.m) drawable).d(false, false, false);
            super.setIndeterminateDrawable(drawable);
        } else {
            if (this.f22983i) {
                throw new IllegalArgumentException("Cannot set framework drawable as indeterminate drawable.");
            }
            super.setIndeterminateDrawable(drawable);
        }
    }

    public void setIndicatorColor(@ColorInt int... iArr) {
        if (iArr.length == 0) {
            iArr = new int[]{h9.a.c(getContext(), d.a.colorPrimary, -1)};
        }
        if (Arrays.equals(getIndicatorColor(), iArr)) {
            return;
        }
        this.f22975a.f31790e = iArr;
        getIndeterminateDrawable().R.c();
        invalidate();
    }

    public void setIndicatorTrackGapSize(@Px int i10) {
        d dVar = this.f22975a;
        if (dVar.f31794i != i10) {
            dVar.f31794i = i10;
            dVar.d();
            invalidate();
        }
    }

    @Override // android.widget.ProgressBar
    public synchronized void setProgress(int i10) {
        if (isIndeterminate()) {
            return;
        }
        setProgressCompat(i10, false);
    }

    public void setProgressCompat(int i10, boolean z10) {
        if (!isIndeterminate()) {
            super.setProgress(i10);
            if (getProgressDrawable() == null || z10) {
                return;
            }
            getProgressDrawable().jumpToCurrentState();
            return;
        }
        if (getProgressDrawable() != null) {
            this.f22976b = i10;
            this.f22977c = z10;
            this.f22981g = true;
            if (getIndeterminateDrawable().isVisible()) {
                a aVar = this.f22980f;
                ContentResolver contentResolver = getContext().getContentResolver();
                aVar.getClass();
                if (a.a(contentResolver) != 0.0f) {
                    getIndeterminateDrawable().R.e();
                    return;
                }
            }
            this.f22986l.a(getIndeterminateDrawable());
        }
    }

    @Override // android.widget.ProgressBar
    public void setProgressDrawable(@Nullable Drawable drawable) {
        if (!(drawable instanceof k)) {
            if (this.f22983i) {
                throw new IllegalArgumentException("Cannot set framework drawable as progress drawable.");
            }
            super.setProgressDrawable(drawable);
        } else {
            k kVar = (k) drawable;
            kVar.d(false, false, false);
            super.setProgressDrawable(kVar);
            kVar.setLevel((int) ((getProgress() / getMax()) * 10000.0f));
        }
    }

    public void setShowAnimationBehavior(int i10) {
        this.f22975a.f31792g = i10;
        invalidate();
    }

    public void setTrackColor(@ColorInt int i10) {
        d dVar = this.f22975a;
        if (dVar.f31791f != i10) {
            dVar.f31791f = i10;
            invalidate();
        }
    }

    public void setTrackCornerRadius(@Px int i10) {
        d dVar = this.f22975a;
        if (dVar.f31787b != i10) {
            dVar.f31787b = Math.min(i10, dVar.f31786a / 2);
            dVar.f31789d = false;
            invalidate();
        }
    }

    public void setTrackCornerRadiusFraction(@FloatRange(from = 0.0d, to = SlidingPercentileBandwidthStatistic.DEFAULT_PERCENTILE) float f10) {
        d dVar = this.f22975a;
        if (dVar.f31788c != f10) {
            dVar.f31788c = Math.min(f10, 0.5f);
            dVar.f31789d = true;
            invalidate();
        }
    }

    public void setTrackThickness(@Px int i10) {
        d dVar = this.f22975a;
        if (dVar.f31786a != i10) {
            dVar.f31786a = i10;
            requestLayout();
        }
    }

    public void setVisibilityAfterHide(int i10) {
        if (i10 != 0 && i10 != 4 && i10 != 8) {
            throw new IllegalArgumentException("The component's visibility must be one of VISIBLE, INVISIBLE, and GONE defined in View.");
        }
        this.f22982h = i10;
    }

    public void setWaveAmplitude(@Px int i10) {
        d dVar = this.f22975a;
        if (dVar.f31797l != i10) {
            dVar.f31797l = Math.abs(i10);
            requestLayout();
        }
    }

    public void setWaveSpeed(@Px int i10) {
        d dVar = this.f22975a;
        dVar.f31798m = i10;
        k progressDrawable = getProgressDrawable();
        boolean z10 = dVar.f31798m != 0;
        ValueAnimator valueAnimator = progressDrawable.W;
        if (z10 && !valueAnimator.isRunning()) {
            valueAnimator.start();
        } else {
            if (z10 || !valueAnimator.isRunning()) {
                return;
            }
            valueAnimator.cancel();
        }
    }

    public void setWavelength(@Px int i10) {
        setWavelengthDeterminate(i10);
        setWavelengthIndeterminate(i10);
    }

    public void setWavelengthDeterminate(@Px int i10) {
        d dVar = this.f22975a;
        if (dVar.f31795j != i10) {
            dVar.f31795j = Math.abs(i10);
            if (isIndeterminate()) {
                return;
            }
            requestLayout();
        }
    }

    public void setWavelengthIndeterminate(@Px int i10) {
        d dVar = this.f22975a;
        if (dVar.f31796k != i10) {
            dVar.f31796k = Math.abs(i10);
            if (isIndeterminate()) {
                requestLayout();
            }
        }
    }

    @Override // android.widget.ProgressBar
    @Nullable
    public q getIndeterminateDrawable() {
        return (q) super.getIndeterminateDrawable();
    }

    @Override // android.widget.ProgressBar
    @Nullable
    public k getProgressDrawable() {
        return (k) super.getProgressDrawable();
    }
}