package o;

import android.content.Context;
import android.content.res.ColorStateList;
import android.graphics.Canvas;
import android.graphics.ColorFilter;
import android.graphics.Outline;
import android.graphics.Paint;
import android.graphics.Path;
import android.graphics.PointF;
import android.graphics.PorterDuff;
import android.graphics.PorterDuffColorFilter;
import android.graphics.Rect;
import android.graphics.RectF;
import android.graphics.drawable.Drawable;
import android.graphics.drawable.RippleDrawable;
import android.graphics.drawable.ShapeDrawable;
import android.graphics.drawable.shapes.OvalShape;
import android.text.TextUtils;
import android.util.AttributeSet;
import android.util.TypedValue;
import com.google.android.gms.maps.model.BitmapDescriptorFactory;
import java.lang.ref.WeakReference;
import java.util.Arrays;
import o.pMl;

/* loaded from: classes2.dex */
public class xcs extends C4363bXv implements Drawable.Callback, pMl.LWm {
    private static final int[] I = {android.R.attr.state_enabled};
    private static final ShapeDrawable K = new ShapeDrawable(new OvalShape());
    public boolean A;
    private int J;
    private ColorStateList L;
    private Drawable M;
    private boolean N;
    private boolean O;
    private float P;
    private ColorStateList Q;
    private final Paint R;
    private Drawable S;
    private int[] T;
    private ColorStateList U;
    private float V;
    private ColorStateList W;
    private Drawable X;
    private boolean Y;
    private int Z;
    public ColorStateList a;
    private int aa;
    private int ab;
    private ColorFilter ac;
    private int ad;
    private int ae;
    private int af;
    private int ag;
    private final Paint ah;
    private boolean ai;
    private float aj;
    private final Paint.FontMetrics ak;
    private final PointF al;
    private float am;
    private PorterDuff.Mode an;
    private final Path ao;
    private final RectF ap;
    private PorterDuffColorFilter aq;
    private ColorStateList ar;
    public float b;
    public boolean c;
    public float d;
    public float e;
    public ColorStateList f;
    public Drawable g;
    public float h;
    public float i;
    public CharSequence j;
    public boolean k;
    public final Context l;
    public ColorStateList m;
    public float n;

    /* renamed from: o, reason: collision with root package name */
    public float f9313o;
    public int p;
    public ColorStateList q;
    public WeakReference<LWm> r;
    public boolean s;
    public boolean t;
    public final pMl u;
    public float v;
    public float w;
    public CharSequence x;
    public TextUtils.TruncateAt y;

    /* loaded from: classes2.dex */
    public interface LWm {
        void e();
    }

    @Override // o.C4363bXv, android.graphics.drawable.Drawable
    public int getOpacity() {
        return -3;
    }

    public xcs(Context context, AttributeSet attributeSet, int i, int i2) {
        super(context, attributeSet, i, i2);
        this.d = -1.0f;
        this.R = new Paint(1);
        this.ak = new Paint.FontMetrics();
        this.ap = new RectF();
        this.al = new PointF();
        this.ao = new Path();
        this.J = 255;
        this.an = PorterDuff.Mode.SRC_IN;
        this.r = new WeakReference<>(null);
        d(context);
        this.l = context;
        pMl pml = new pMl(this);
        this.u = pml;
        this.x = "";
        pml.e.density = context.getResources().getDisplayMetrics().density;
        this.ah = null;
        int[] iArr = I;
        setState(iArr);
        e(iArr);
        this.s = true;
        if (C0459HUs.b) {
            K.setTint(-1);
        }
    }

    @Override // android.graphics.drawable.Drawable
    public int getIntrinsicWidth() {
        float f;
        float f2 = this.i;
        float c = c();
        float f3 = this.v;
        pMl pml = this.u;
        String obj = this.x.toString();
        if (pml.i) {
            float measureText = obj == null ? BitmapDescriptorFactory.HUE_RED : pml.e.measureText((CharSequence) obj, 0, obj.length());
            pml.d = measureText;
            pml.i = false;
            f = measureText;
        } else {
            f = pml.d;
        }
        return Math.min(Math.round(f2 + c + f3 + f + this.w + g() + this.b), this.p);
    }

    private float i() {
        Drawable drawable = this.Y ? this.M : this.S;
        float f = this.P;
        return (f > BitmapDescriptorFactory.HUE_RED || drawable == null) ? f : drawable.getIntrinsicWidth();
    }

    @Override // o.C4363bXv, android.graphics.drawable.Drawable
    public void draw(Canvas canvas) {
        float f;
        int i;
        Rect bounds = getBounds();
        if (bounds.isEmpty() || getAlpha() == 0) {
            return;
        }
        int saveLayerAlpha = this.J < 255 ? canvas.saveLayerAlpha(bounds.left, bounds.top, bounds.right, bounds.bottom, this.J) : 0;
        if (!this.t) {
            this.R.setColor(this.Z);
            this.R.setStyle(Paint.Style.FILL);
            this.ap.set(bounds);
            canvas.drawRoundRect(this.ap, this.t ? h() : this.d, this.t ? h() : this.d, this.R);
        }
        if (!this.t) {
            this.R.setColor(this.ab);
            this.R.setStyle(Paint.Style.FILL);
            Paint paint = this.R;
            ColorFilter colorFilter = this.ac;
            if (colorFilter == null) {
                colorFilter = this.aq;
            }
            paint.setColorFilter(colorFilter);
            this.ap.set(bounds);
            canvas.drawRoundRect(this.ap, this.t ? h() : this.d, this.t ? h() : this.d, this.R);
        }
        if (this.t) {
            super.draw(canvas);
        }
        float f2 = this.V;
        float f3 = BitmapDescriptorFactory.HUE_RED;
        if (f2 > BitmapDescriptorFactory.HUE_RED && !this.t) {
            this.R.setColor(this.aa);
            this.R.setStyle(Paint.Style.STROKE);
            if (!this.t) {
                Paint paint2 = this.R;
                ColorFilter colorFilter2 = this.ac;
                if (colorFilter2 == null) {
                    colorFilter2 = this.aq;
                }
                paint2.setColorFilter(colorFilter2);
            }
            this.ap.set(bounds.left + (this.V / 2.0f), bounds.top + (this.V / 2.0f), bounds.right - (this.V / 2.0f), bounds.bottom - (this.V / 2.0f));
            float f4 = this.d - (this.V / 2.0f);
            canvas.drawRoundRect(this.ap, f4, f4, this.R);
        }
        this.R.setColor(this.ae);
        this.R.setStyle(Paint.Style.FILL);
        this.ap.set(bounds);
        boolean z = this.t;
        if (!z) {
            canvas.drawRoundRect(this.ap, z ? h() : this.d, this.t ? h() : this.d, this.R);
        } else {
            Lf_(new RectF(bounds), this.ao);
            Paint paint3 = this.R;
            Path path = this.ao;
            this.F.set(getBounds());
            super.Lg_(canvas, paint3, path, this.F);
        }
        if (this.O && this.S != null) {
            IC_(bounds, this.ap);
            float f5 = this.ap.left;
            float f6 = this.ap.top;
            canvas.translate(f5, f6);
            this.S.setBounds(0, 0, (int) this.ap.width(), (int) this.ap.height());
            this.S.draw(canvas);
            canvas.translate(-f5, -f6);
        }
        if (this.N && this.M != null && this.Y) {
            IC_(bounds, this.ap);
            float f7 = this.ap.left;
            float f8 = this.ap.top;
            canvas.translate(f7, f8);
            this.M.setBounds(0, 0, (int) this.ap.width(), (int) this.ap.height());
            this.M.draw(canvas);
            canvas.translate(-f7, -f8);
        }
        if (this.s && this.x != null) {
            PointF pointF = this.al;
            pointF.set(BitmapDescriptorFactory.HUE_RED, BitmapDescriptorFactory.HUE_RED);
            Paint.Align align = Paint.Align.LEFT;
            if (this.x != null) {
                float c = this.i + c() + this.v;
                if (Tlu.pw_(this) == 0) {
                    pointF.x = bounds.left + c;
                    align = Paint.Align.LEFT;
                } else {
                    pointF.x = bounds.right - c;
                    align = Paint.Align.RIGHT;
                }
                float centerY = bounds.centerY();
                this.u.e.getFontMetrics(this.ak);
                pointF.y = centerY - ((this.ak.descent + this.ak.ascent) / 2.0f);
            }
            RectF rectF = this.ap;
            rectF.setEmpty();
            if (this.x != null) {
                float c2 = this.i + c() + this.v;
                float g = this.b + g() + this.w;
                if (Tlu.pw_(this) == 0) {
                    rectF.left = bounds.left + c2;
                    rectF.right = bounds.right - g;
                } else {
                    rectF.left = bounds.left + g;
                    rectF.right = bounds.right - c2;
                }
                rectF.top = bounds.top;
                rectF.bottom = bounds.bottom;
            }
            if (this.u.b != null) {
                this.u.e.drawableState = getState();
                pMl pml = this.u;
                pml.b.KA_(this.l, pml.e, pml.c);
            }
            this.u.e.setTextAlign(align);
            pMl pml2 = this.u;
            String obj = this.x.toString();
            if (pml2.i) {
                if (obj != null) {
                    f3 = pml2.e.measureText((CharSequence) obj, 0, obj.length());
                }
                pml2.d = f3;
                pml2.i = false;
                f = f3;
            } else {
                f = pml2.d;
            }
            boolean z2 = Math.round(f) > Math.round(this.ap.width());
            if (z2) {
                int save = canvas.save();
                canvas.clipRect(this.ap);
                i = save;
            } else {
                i = 0;
            }
            CharSequence charSequence = this.x;
            if (z2 && this.y != null) {
                charSequence = TextUtils.ellipsize(charSequence, this.u.e, this.ap.width(), this.y);
            }
            CharSequence charSequence2 = charSequence;
            canvas.drawText(charSequence2, 0, charSequence2.length(), this.al.x, this.al.y, this.u.e);
            if (z2) {
                canvas.restoreToCount(i);
            }
        }
        if (this.k && this.g != null) {
            RectF rectF2 = this.ap;
            rectF2.setEmpty();
            if (this.k && this.g != null) {
                float f9 = this.b + this.h;
                if (Tlu.pw_(this) == 0) {
                    rectF2.right = bounds.right - f9;
                    rectF2.left = rectF2.right - this.n;
                } else {
                    rectF2.left = bounds.left + f9;
                    rectF2.right = rectF2.left + this.n;
                }
                rectF2.top = bounds.exactCenterY() - (this.n / 2.0f);
                rectF2.bottom = rectF2.top + this.n;
            }
            float f10 = this.ap.left;
            float f11 = this.ap.top;
            canvas.translate(f10, f11);
            this.g.setBounds(0, 0, (int) this.ap.width(), (int) this.ap.height());
            if (C0459HUs.b) {
                this.X.setBounds(this.g.getBounds());
                this.X.jumpToCurrentState();
                this.X.draw(canvas);
            } else {
                this.g.draw(canvas);
            }
            canvas.translate(-f10, -f11);
        }
        if (this.J < 255) {
            canvas.restoreToCount(saveLayerAlpha);
        }
    }

    private void IC_(Rect rect, RectF rectF) {
        float f;
        rectF.setEmpty();
        if ((!this.O || this.S == null) && !(this.N && this.M != null && this.Y)) {
            return;
        }
        float f2 = this.i + this.aj;
        float i = i();
        if (Tlu.pw_(this) == 0) {
            rectF.left = rect.left + f2;
            rectF.right = rectF.left + i;
        } else {
            rectF.right = rect.right - f2;
            rectF.left = rectF.right - i;
        }
        Drawable drawable = this.Y ? this.M : this.S;
        float f3 = this.P;
        if (f3 <= BitmapDescriptorFactory.HUE_RED && drawable != null) {
            f3 = (float) Math.ceil(TypedValue.applyDimension(1, 24.0f, this.l.getResources().getDisplayMetrics()));
            if (drawable.getIntrinsicHeight() <= f3) {
                f = drawable.getIntrinsicHeight();
                rectF.top = rect.exactCenterY() - (f / 2.0f);
                rectF.bottom = rectF.top + f;
            }
        }
        f = f3;
        rectF.top = rect.exactCenterY() - (f / 2.0f);
        rectF.bottom = rectF.top + f;
    }

    public final boolean e(int[] iArr) {
        if (Arrays.equals(this.T, iArr)) {
            return false;
        }
        this.T = iArr;
        if (!this.k || this.g == null) {
            return false;
        }
        return e(getState(), iArr);
    }

    @Override // o.pMl.LWm
    public final void d() {
        LWm lWm = this.r.get();
        if (lWm != null) {
            lWm.e();
        }
        invalidateSelf();
    }

    @Override // o.C4363bXv, android.graphics.drawable.Drawable
    public boolean onStateChange(int[] iArr) {
        if (this.t) {
            super.onStateChange(iArr);
        }
        return e(iArr, this.T);
    }

    private boolean e(int[] iArr, int[] iArr2) {
        boolean z;
        boolean z2;
        LWm lWm;
        Drawable drawable;
        boolean onStateChange = super.onStateChange(iArr);
        ColorStateList colorStateList = this.f;
        int e = e(colorStateList != null ? colorStateList.getColorForState(iArr, this.Z) : 0);
        boolean z3 = true;
        if (this.Z != e) {
            this.Z = e;
            onStateChange = true;
        }
        ColorStateList colorStateList2 = this.a;
        int e2 = e(colorStateList2 != null ? colorStateList2.getColorForState(iArr, this.ab) : 0);
        if (this.ab != e2) {
            this.ab = e2;
            onStateChange = true;
        }
        int a = Rez.a(e2, e);
        if ((this.af != a) | (this.B.d == null)) {
            this.af = a;
            ColorStateList valueOf = ColorStateList.valueOf(a);
            if (this.B.d != valueOf) {
                this.B.d = valueOf;
                onStateChange(getState());
            }
            onStateChange = true;
        }
        ColorStateList colorStateList3 = this.W;
        int colorForState = colorStateList3 != null ? colorStateList3.getColorForState(iArr, this.aa) : 0;
        if (this.aa != colorForState) {
            this.aa = colorForState;
            onStateChange = true;
        }
        int colorForState2 = (this.m == null || !C0459HUs.b(iArr)) ? 0 : this.m.getColorForState(iArr, this.ae);
        if (this.ae != colorForState2) {
            this.ae = colorForState2;
            if (this.A) {
                onStateChange = true;
            }
        }
        int colorForState3 = (this.u.b == null || this.u.b.g == null) ? 0 : this.u.b.g.getColorForState(iArr, this.ag);
        if (this.ag != colorForState3) {
            this.ag = colorForState3;
            onStateChange = true;
        }
        int[] state = getState();
        if (state != null) {
            int length = state.length;
            int i = 0;
            while (true) {
                if (i >= length) {
                    break;
                }
                if (state[i] != 16842912) {
                    i++;
                } else if (this.c) {
                    z = true;
                }
            }
        }
        z = false;
        if (this.Y == z || this.M == null) {
            z2 = false;
        } else {
            float c = c();
            this.Y = z;
            if (c != c()) {
                onStateChange = true;
                z2 = true;
            } else {
                z2 = false;
                onStateChange = true;
            }
        }
        ColorStateList colorStateList4 = this.ar;
        int colorForState4 = colorStateList4 != null ? colorStateList4.getColorForState(iArr, this.ad) : 0;
        if (this.ad != colorForState4) {
            this.ad = colorForState4;
            ColorStateList colorStateList5 = this.ar;
            PorterDuff.Mode mode = this.an;
            this.aq = (colorStateList5 == null || mode == null) ? null : new PorterDuffColorFilter(colorStateList5.getColorForState(getState(), 0), mode);
        } else {
            z3 = onStateChange;
        }
        Drawable drawable2 = this.S;
        if (drawable2 != null && drawable2.isStateful()) {
            z3 |= this.S.setState(iArr);
        }
        Drawable drawable3 = this.M;
        if (drawable3 != null && drawable3.isStateful()) {
            z3 |= this.M.setState(iArr);
        }
        Drawable drawable4 = this.g;
        if (drawable4 != null && drawable4.isStateful()) {
            int[] iArr3 = new int[iArr.length + iArr2.length];
            System.arraycopy(iArr, 0, iArr3, 0, iArr.length);
            System.arraycopy(iArr2, 0, iArr3, iArr.length, iArr2.length);
            z3 |= this.g.setState(iArr3);
        }
        if (C0459HUs.b && (drawable = this.X) != null && drawable.isStateful()) {
            z3 |= this.X.setState(iArr2);
        }
        if (z3) {
            invalidateSelf();
        }
        if (z2 && (lWm = this.r.get()) != null) {
            lWm.e();
        }
        return z3;
    }

    @Override // android.graphics.drawable.Drawable
    public boolean onLayoutDirectionChanged(int i) {
        Drawable drawable;
        Drawable drawable2;
        Drawable drawable3;
        boolean onLayoutDirectionChanged = super.onLayoutDirectionChanged(i);
        if (this.O && (drawable3 = this.S) != null) {
            onLayoutDirectionChanged |= Tlu.pD_(drawable3, i);
        }
        if (this.N && (drawable2 = this.M) != null && this.Y) {
            onLayoutDirectionChanged |= Tlu.pD_(drawable2, i);
        }
        if (this.k && (drawable = this.g) != null) {
            onLayoutDirectionChanged |= Tlu.pD_(drawable, i);
        }
        if (!onLayoutDirectionChanged) {
            return true;
        }
        invalidateSelf();
        return true;
    }

    @Override // android.graphics.drawable.Drawable
    protected boolean onLevelChange(int i) {
        Drawable drawable;
        Drawable drawable2;
        Drawable drawable3;
        boolean onLevelChange = super.onLevelChange(i);
        if (this.O && (drawable3 = this.S) != null) {
            onLevelChange |= drawable3.setLevel(i);
        }
        if (this.N && (drawable2 = this.M) != null && this.Y) {
            onLevelChange |= drawable2.setLevel(i);
        }
        if (this.k && (drawable = this.g) != null) {
            onLevelChange |= drawable.setLevel(i);
        }
        if (onLevelChange) {
            invalidateSelf();
        }
        return onLevelChange;
    }

    @Override // android.graphics.drawable.Drawable
    public boolean setVisible(boolean z, boolean z2) {
        Drawable drawable;
        Drawable drawable2;
        Drawable drawable3;
        boolean visible = super.setVisible(z, z2);
        if (this.O && (drawable3 = this.S) != null) {
            visible |= drawable3.setVisible(z, z2);
        }
        if (this.N && (drawable2 = this.M) != null && this.Y) {
            visible |= drawable2.setVisible(z, z2);
        }
        if (this.k && (drawable = this.g) != null) {
            visible |= drawable.setVisible(z, z2);
        }
        if (visible) {
            invalidateSelf();
        }
        return visible;
    }

    @Override // o.C4363bXv, android.graphics.drawable.Drawable
    public void setAlpha(int i) {
        if (this.J != i) {
            this.J = i;
            invalidateSelf();
        }
    }

    @Override // o.C4363bXv, android.graphics.drawable.Drawable
    public void setColorFilter(ColorFilter colorFilter) {
        if (this.ac != colorFilter) {
            this.ac = colorFilter;
            invalidateSelf();
        }
    }

    @Override // o.C4363bXv, android.graphics.drawable.Drawable
    public void setTintList(ColorStateList colorStateList) {
        if (this.ar != colorStateList) {
            this.ar = colorStateList;
            onStateChange(getState());
        }
    }

    @Override // o.C4363bXv, android.graphics.drawable.Drawable
    public void getOutline(Outline outline) {
        if (this.t) {
            super.getOutline(outline);
            return;
        }
        Rect bounds = getBounds();
        if (!bounds.isEmpty()) {
            outline.setRoundRect(bounds, this.d);
        } else {
            outline.setRoundRect(0, 0, getIntrinsicWidth(), getIntrinsicHeight(), this.d);
        }
        outline.setAlpha(getAlpha() / 255.0f);
    }

    @Override // android.graphics.drawable.Drawable.Callback
    public void invalidateDrawable(Drawable drawable) {
        Drawable.Callback callback = getCallback();
        if (callback != null) {
            callback.invalidateDrawable(this);
        }
    }

    @Override // android.graphics.drawable.Drawable.Callback
    public void scheduleDrawable(Drawable drawable, Runnable runnable, long j) {
        Drawable.Callback callback = getCallback();
        if (callback != null) {
            callback.scheduleDrawable(this, runnable, j);
        }
    }

    @Override // android.graphics.drawable.Drawable.Callback
    public void unscheduleDrawable(Drawable drawable, Runnable runnable) {
        Drawable.Callback callback = getCallback();
        if (callback != null) {
            callback.unscheduleDrawable(this, runnable);
        }
    }

    private void IB_(Drawable drawable) {
        if (drawable == null) {
            return;
        }
        drawable.setCallback(this);
        Tlu.pD_(drawable, Tlu.pw_(this));
        drawable.setLevel(getLevel());
        drawable.setVisible(isVisible(), false);
        if (drawable == this.g) {
            if (drawable.isStateful()) {
                drawable.setState(this.T);
            }
            Tlu.pF_(drawable, this.U);
            return;
        }
        Drawable drawable2 = this.S;
        if (drawable == drawable2 && this.ai) {
            Tlu.pF_(drawable2, this.Q);
        }
        if (drawable.isStateful()) {
            drawable.setState(getState());
        }
    }

    public final void d(float f) {
        if (this.e != f) {
            this.e = f;
            invalidateSelf();
            LWm lWm = this.r.get();
            if (lWm != null) {
                lWm.e();
            }
        }
    }

    public final void IH_(ColorStateList colorStateList) {
        if (this.W != colorStateList) {
            this.W = colorStateList;
            if (this.t && this.B.r != colorStateList) {
                this.B.r = colorStateList;
                onStateChange(getState());
            }
            onStateChange(getState());
        }
    }

    public final void e(float f) {
        if (this.V != f) {
            this.V = f;
            this.R.setStrokeWidth(f);
            if (this.t) {
                this.B.p = f;
                invalidateSelf();
            }
            invalidateSelf();
        }
    }

    public final void b(CharSequence charSequence) {
        if (charSequence == null) {
            charSequence = "";
        }
        if (TextUtils.equals(this.x, charSequence)) {
            return;
        }
        this.x = charSequence;
        this.u.i = true;
        invalidateSelf();
        LWm lWm = this.r.get();
        if (lWm != null) {
            lWm.e();
        }
    }

    public final void IF_(Drawable drawable) {
        LWm lWm;
        Drawable drawable2;
        Drawable drawable3 = this.S;
        Drawable pH_ = drawable3 != null ? Tlu.pH_(drawable3) : null;
        if (pH_ != drawable) {
            float c = c();
            this.S = drawable != null ? Tlu.pI_(drawable).mutate() : null;
            float c2 = c();
            if (pH_ != null) {
                pH_.setCallback(null);
            }
            if (this.O && (drawable2 = this.S) != null) {
                IB_(drawable2);
            }
            invalidateSelf();
            if (c == c2 || (lWm = this.r.get()) == null) {
                return;
            }
            lWm.e();
        }
    }

    public final void a(float f) {
        LWm lWm;
        if (this.P != f) {
            float c = c();
            this.P = f;
            float c2 = c();
            invalidateSelf();
            if (c == c2 || (lWm = this.r.get()) == null) {
                return;
            }
            lWm.e();
        }
    }

    public final void II_(Drawable drawable) {
        LWm lWm;
        Drawable drawable2;
        Drawable drawable3 = this.g;
        Drawable pH_ = drawable3 != null ? Tlu.pH_(drawable3) : null;
        if (pH_ != drawable) {
            float g = g();
            this.g = drawable != null ? Tlu.pI_(drawable).mutate() : null;
            if (C0459HUs.b) {
                this.X = new RippleDrawable(C0459HUs.KI_(this.q), this.g, K);
            }
            float g2 = g();
            if (pH_ != null) {
                pH_.setCallback(null);
            }
            if (this.k && (drawable2 = this.g) != null) {
                IB_(drawable2);
            }
            invalidateSelf();
            if (g == g2 || (lWm = this.r.get()) == null) {
                return;
            }
            lWm.e();
        }
    }

    public final void h(float f) {
        LWm lWm;
        if (this.n != f) {
            this.n = f;
            invalidateSelf();
            if (!this.k || this.g == null || (lWm = this.r.get()) == null) {
                return;
            }
            lWm.e();
        }
    }

    public final void d(boolean z) {
        LWm lWm;
        if (this.c != z) {
            this.c = z;
            float c = c();
            if (!z && this.Y) {
                this.Y = false;
            }
            float c2 = c();
            invalidateSelf();
            if (c == c2 || (lWm = this.r.get()) == null) {
                return;
            }
            lWm.e();
        }
    }

    public final void ID_(Drawable drawable) {
        LWm lWm;
        if (this.M != drawable) {
            float c = c();
            this.M = drawable;
            float c2 = c();
            Drawable drawable2 = this.M;
            if (drawable2 != null) {
                drawable2.setCallback(null);
            }
            IB_(this.M);
            invalidateSelf();
            if (c == c2 || (lWm = this.r.get()) == null) {
                return;
            }
            lWm.e();
        }
    }

    public final void c(float f) {
        if (this.i != f) {
            this.i = f;
            invalidateSelf();
            LWm lWm = this.r.get();
            if (lWm != null) {
                lWm.e();
            }
        }
    }

    public final void f(float f) {
        LWm lWm;
        if (this.aj != f) {
            float c = c();
            this.aj = f;
            float c2 = c();
            invalidateSelf();
            if (c == c2 || (lWm = this.r.get()) == null) {
                return;
            }
            lWm.e();
        }
    }

    public final void i(float f) {
        LWm lWm;
        if (this.am != f) {
            float c = c();
            this.am = f;
            float c2 = c();
            invalidateSelf();
            if (c == c2 || (lWm = this.r.get()) == null) {
                return;
            }
            lWm.e();
        }
    }

    public final void o(float f) {
        if (this.v != f) {
            this.v = f;
            invalidateSelf();
            LWm lWm = this.r.get();
            if (lWm != null) {
                lWm.e();
            }
        }
    }

    public final void m(float f) {
        if (this.w != f) {
            this.w = f;
            invalidateSelf();
            LWm lWm = this.r.get();
            if (lWm != null) {
                lWm.e();
            }
        }
    }

    public final void g(float f) {
        LWm lWm;
        if (this.f9313o != f) {
            this.f9313o = f;
            invalidateSelf();
            if (!this.k || this.g == null || (lWm = this.r.get()) == null) {
                return;
            }
            lWm.e();
        }
    }

    public final void j(float f) {
        LWm lWm;
        if (this.h != f) {
            this.h = f;
            invalidateSelf();
            if (!this.k || this.g == null || (lWm = this.r.get()) == null) {
                return;
            }
            lWm.e();
        }
    }

    public final void b(float f) {
        if (this.b != f) {
            this.b = f;
            invalidateSelf();
            LWm lWm = this.r.get();
            if (lWm != null) {
                lWm.e();
            }
        }
    }

    public final float c() {
        return ((!this.O || this.S == null) && !(this.N && this.M != null && this.Y)) ? BitmapDescriptorFactory.HUE_RED : this.aj + i() + this.am;
    }

    private float g() {
        return (!this.k || this.g == null) ? BitmapDescriptorFactory.HUE_RED : this.f9313o + this.n + this.h;
    }

    public final void IE_(ColorStateList colorStateList) {
        Drawable drawable;
        if (this.L != colorStateList) {
            this.L = colorStateList;
            if (this.N && (drawable = this.M) != null && this.c) {
                Tlu.pF_(drawable, colorStateList);
            }
            onStateChange(getState());
        }
    }

    public final void c(boolean z) {
        boolean z2 = this.N;
        if (z2 != z) {
            boolean z3 = z2 && this.M != null && this.Y;
            this.N = z;
            boolean z4 = z && this.M != null && this.Y;
            if (z3 != z4) {
                if (z4) {
                    IB_(this.M);
                } else {
                    Drawable drawable = this.M;
                    if (drawable != null) {
                        drawable.setCallback(null);
                    }
                }
                invalidateSelf();
                LWm lWm = this.r.get();
                if (lWm != null) {
                    lWm.e();
                }
            }
        }
    }

    public final void IG_(ColorStateList colorStateList) {
        Drawable drawable;
        this.ai = true;
        if (this.Q != colorStateList) {
            this.Q = colorStateList;
            if (this.O && (drawable = this.S) != null) {
                Tlu.pF_(drawable, colorStateList);
            }
            onStateChange(getState());
        }
    }

    public final void e(boolean z) {
        boolean z2 = this.O;
        if (z2 != z) {
            boolean z3 = z2 && this.S != null;
            this.O = z;
            boolean z4 = z && this.S != null;
            if (z3 != z4) {
                if (z4) {
                    IB_(this.S);
                } else {
                    Drawable drawable = this.S;
                    if (drawable != null) {
                        drawable.setCallback(null);
                    }
                }
                invalidateSelf();
                LWm lWm = this.r.get();
                if (lWm != null) {
                    lWm.e();
                }
            }
        }
    }

    public final void IJ_(ColorStateList colorStateList) {
        Drawable drawable;
        if (this.U != colorStateList) {
            this.U = colorStateList;
            if (this.k && (drawable = this.g) != null) {
                Tlu.pF_(drawable, colorStateList);
            }
            onStateChange(getState());
        }
    }

    public final void a(boolean z) {
        boolean z2 = this.k;
        if (z2 != z) {
            boolean z3 = z2 && this.g != null;
            this.k = z;
            boolean z4 = z && this.g != null;
            if (z3 != z4) {
                if (z4) {
                    IB_(this.g);
                } else {
                    Drawable drawable = this.g;
                    if (drawable != null) {
                        drawable.setCallback(null);
                    }
                }
                invalidateSelf();
                LWm lWm = this.r.get();
                if (lWm != null) {
                    lWm.e();
                }
            }
        }
    }

    @Override // o.C4363bXv, android.graphics.drawable.Drawable
    public void setTintMode(PorterDuff.Mode mode) {
        if (this.an != mode) {
            this.an = mode;
            ColorStateList colorStateList = this.ar;
            this.aq = (colorStateList == null || mode == null) ? null : new PorterDuffColorFilter(colorStateList.getColorForState(getState(), 0), mode);
            invalidateSelf();
        }
    }

    @Override // o.C4363bXv, android.graphics.drawable.Drawable
    public boolean isStateful() {
        ColorStateList colorStateList;
        ColorStateList colorStateList2;
        Rzh rzh;
        Drawable drawable;
        Drawable drawable2;
        ColorStateList colorStateList3;
        ColorStateList colorStateList4;
        ColorStateList colorStateList5 = this.f;
        return (colorStateList5 != null && colorStateList5.isStateful()) || ((colorStateList = this.a) != null && colorStateList.isStateful()) || (((colorStateList2 = this.W) != null && colorStateList2.isStateful()) || ((this.A && (colorStateList4 = this.m) != null && colorStateList4.isStateful()) || (!((rzh = this.u.b) == null || rzh.g == null || !rzh.g.isStateful()) || ((this.N && this.M != null && this.c) || (((drawable = this.S) != null && drawable.isStateful()) || (((drawable2 = this.M) != null && drawable2.isStateful()) || ((colorStateList3 = this.ar) != null && colorStateList3.isStateful())))))));
    }

    @Override // android.graphics.drawable.Drawable
    public int getIntrinsicHeight() {
        return (int) this.e;
    }

    @Override // android.graphics.drawable.Drawable
    public ColorFilter getColorFilter() {
        return this.ac;
    }

    @Override // o.C4363bXv, android.graphics.drawable.Drawable
    public int getAlpha() {
        return this.J;
    }
}