package com.bumptech.glide;

import android.content.Context;
import android.graphics.drawable.Drawable;
import android.widget.ImageView;
import com.bumptech.glide.load.engine.DiskCacheStrategy;
import com.bumptech.glide.request.ErrorRequestCoordinator;
import com.bumptech.glide.request.Request;
import com.bumptech.glide.request.RequestCoordinator;
import com.bumptech.glide.request.RequestListener;
import com.bumptech.glide.request.RequestOptions;
import com.bumptech.glide.request.SingleRequest;
import com.bumptech.glide.request.ThumbnailRequestCoordinator;
import com.bumptech.glide.request.target.Target;
import com.bumptech.glide.request.target.ViewTarget;
import com.bumptech.glide.signature.ApplicationVersionSignature;
import com.bumptech.glide.util.Preconditions;
import com.bumptech.glide.util.Util;
import java.io.File;

/* loaded from: classes.dex */
public class RequestBuilder<TranscodeType> implements Cloneable, ModelTypes<RequestBuilder<TranscodeType>> {
    private final Context a;
    private final RequestManager b;
    private final Class<TranscodeType> c;
    private final RequestOptions d;
    private final GlideContext e;
    protected RequestOptions f;
    private TransitionOptions<?, ? super TranscodeType> g;
    private Object h;
    private RequestListener<TranscodeType> i;
    private RequestBuilder<TranscodeType> j;
    private RequestBuilder<TranscodeType> k;
    private Float l;
    private boolean m = true;
    private boolean n;
    private boolean o;

    /* renamed from: com.bumptech.glide.RequestBuilder$2, reason: invalid class name */
    static /* synthetic */ class AnonymousClass2 {
        static final /* synthetic */ int[] a;
        static final /* synthetic */ int[] b = new int[Priority.values().length];

        static {
            try {
                b[Priority.LOW.ordinal()] = 1;
            } catch (NoSuchFieldError unused) {
            }
            try {
                b[Priority.NORMAL.ordinal()] = 2;
            } catch (NoSuchFieldError unused2) {
            }
            try {
                b[Priority.HIGH.ordinal()] = 3;
            } catch (NoSuchFieldError unused3) {
            }
            try {
                b[Priority.IMMEDIATE.ordinal()] = 4;
            } catch (NoSuchFieldError unused4) {
            }
            a = new int[ImageView.ScaleType.values().length];
            try {
                a[ImageView.ScaleType.CENTER_CROP.ordinal()] = 1;
            } catch (NoSuchFieldError unused5) {
            }
            try {
                a[ImageView.ScaleType.CENTER_INSIDE.ordinal()] = 2;
            } catch (NoSuchFieldError unused6) {
            }
            try {
                a[ImageView.ScaleType.FIT_CENTER.ordinal()] = 3;
            } catch (NoSuchFieldError unused7) {
            }
            try {
                a[ImageView.ScaleType.FIT_START.ordinal()] = 4;
            } catch (NoSuchFieldError unused8) {
            }
            try {
                a[ImageView.ScaleType.FIT_END.ordinal()] = 5;
            } catch (NoSuchFieldError unused9) {
            }
            try {
                a[ImageView.ScaleType.FIT_XY.ordinal()] = 6;
            } catch (NoSuchFieldError unused10) {
            }
            try {
                a[ImageView.ScaleType.CENTER.ordinal()] = 7;
            } catch (NoSuchFieldError unused11) {
            }
            try {
                a[ImageView.ScaleType.MATRIX.ordinal()] = 8;
            } catch (NoSuchFieldError unused12) {
            }
        }
    }

    static {
        new RequestOptions().a(DiskCacheStrategy.c).a(Priority.LOW).a(true);
    }

    protected RequestBuilder(Glide glide, RequestManager requestManager, Class<TranscodeType> cls, Context context) {
        this.b = requestManager;
        this.c = cls;
        this.d = requestManager.f();
        this.a = context;
        this.g = requestManager.b(cls);
        this.f = this.d;
        this.e = glide.g();
    }

    private RequestBuilder<TranscodeType> b(Object obj) {
        this.h = obj;
        this.n = true;
        return this;
    }

    public RequestBuilder<TranscodeType> a(RequestOptions requestOptions) {
        Preconditions.a(requestOptions);
        this.f = a().a(requestOptions);
        return this;
    }

    /* renamed from: clone, reason: merged with bridge method [inline-methods] */
    public RequestBuilder<TranscodeType> m4clone() {
        try {
            RequestBuilder<TranscodeType> requestBuilder = (RequestBuilder) super.clone();
            requestBuilder.f = requestBuilder.f.m6clone();
            requestBuilder.g = (TransitionOptions<?, ? super TranscodeType>) requestBuilder.g.m5clone();
            return requestBuilder;
        } catch (CloneNotSupportedException e) {
            throw new RuntimeException(e);
        }
    }

    private <Y extends Target<TranscodeType>> Y b(Y y, RequestListener<TranscodeType> requestListener, RequestOptions requestOptions) {
        Util.b();
        Preconditions.a(y);
        if (this.n) {
            requestOptions.a();
            Request a = a(y, requestListener, requestOptions);
            Request c = y.c();
            if (a.a(c) && !a(requestOptions, c)) {
                a.a();
                Preconditions.a(c);
                if (!c.isRunning()) {
                    c.e();
                }
                return y;
            }
            this.b.a((Target<?>) y);
            y.a(a);
            this.b.a(y, a);
            return y;
        }
        throw new IllegalArgumentException("You must call #load() before calling #into()");
    }

    protected RequestOptions a() {
        RequestOptions requestOptions = this.d;
        RequestOptions requestOptions2 = this.f;
        return requestOptions == requestOptions2 ? requestOptions2.m6clone() : requestOptions2;
    }

    public RequestBuilder<TranscodeType> a(RequestListener<TranscodeType> requestListener) {
        this.i = requestListener;
        return this;
    }

    public RequestBuilder<TranscodeType> a(float f) {
        if (f >= 0.0f && f <= 1.0f) {
            this.l = Float.valueOf(f);
            return this;
        }
        throw new IllegalArgumentException("sizeMultiplier must be between 0 and 1");
    }

    public RequestBuilder<TranscodeType> a(Object obj) {
        b(obj);
        return this;
    }

    public RequestBuilder<TranscodeType> a(Drawable drawable) {
        b(drawable);
        a(RequestOptions.b(DiskCacheStrategy.b));
        return this;
    }

    public RequestBuilder<TranscodeType> a(String str) {
        b(str);
        return this;
    }

    public RequestBuilder<TranscodeType> a(File file) {
        b(file);
        return this;
    }

    public RequestBuilder<TranscodeType> a(Integer num) {
        b(num);
        a(RequestOptions.b(ApplicationVersionSignature.b(this.a)));
        return this;
    }

    public <Y extends Target<TranscodeType>> Y a(Y y) {
        a((RequestBuilder<TranscodeType>) y, (RequestListener) null);
        return y;
    }

    <Y extends Target<TranscodeType>> Y a(Y y, RequestListener<TranscodeType> requestListener) {
        b(y, requestListener, a());
        return y;
    }

    private boolean a(RequestOptions requestOptions, Request request) {
        return !requestOptions.C() && request.g();
    }

    public ViewTarget<ImageView, TranscodeType> a(ImageView imageView) {
        Util.b();
        Preconditions.a(imageView);
        RequestOptions requestOptions = this.f;
        if (!requestOptions.H() && requestOptions.F() && imageView.getScaleType() != null) {
            switch (AnonymousClass2.a[imageView.getScaleType().ordinal()]) {
                case 1:
                    requestOptions = requestOptions.m6clone().K();
                    break;
                case 2:
                    requestOptions = requestOptions.m6clone().L();
                    break;
                case 3:
                case 4:
                case 5:
                    requestOptions = requestOptions.m6clone().M();
                    break;
                case 6:
                    requestOptions = requestOptions.m6clone().L();
                    break;
            }
        }
        ViewTarget<ImageView, TranscodeType> a = this.e.a(imageView, this.c);
        b(a, null, requestOptions);
        return a;
    }

    private Request b(Target<TranscodeType> target, RequestListener<TranscodeType> requestListener, RequestCoordinator requestCoordinator, TransitionOptions<?, ? super TranscodeType> transitionOptions, Priority priority, int i, int i2, RequestOptions requestOptions) {
        RequestBuilder<TranscodeType> requestBuilder = this.j;
        if (requestBuilder != null) {
            if (!this.o) {
                TransitionOptions<?, ? super TranscodeType> transitionOptions2 = requestBuilder.m ? transitionOptions : requestBuilder.g;
                Priority u = this.j.f.D() ? this.j.f.u() : a(priority);
                int r = this.j.f.r();
                int q = this.j.f.q();
                if (Util.b(i, i2) && !this.j.f.I()) {
                    r = requestOptions.r();
                    q = requestOptions.q();
                }
                ThumbnailRequestCoordinator thumbnailRequestCoordinator = new ThumbnailRequestCoordinator(requestCoordinator);
                Request a = a(target, requestListener, requestOptions, thumbnailRequestCoordinator, transitionOptions, priority, i, i2);
                this.o = true;
                RequestBuilder<TranscodeType> requestBuilder2 = this.j;
                Request a2 = requestBuilder2.a(target, requestListener, thumbnailRequestCoordinator, transitionOptions2, u, r, q, requestBuilder2.f);
                this.o = false;
                thumbnailRequestCoordinator.a(a, a2);
                return thumbnailRequestCoordinator;
            }
            throw new IllegalStateException("You cannot use a request as both the main request and a thumbnail, consider using clone() on the request(s) passed to thumbnail()");
        }
        if (this.l != null) {
            ThumbnailRequestCoordinator thumbnailRequestCoordinator2 = new ThumbnailRequestCoordinator(requestCoordinator);
            thumbnailRequestCoordinator2.a(a(target, requestListener, requestOptions, thumbnailRequestCoordinator2, transitionOptions, priority, i, i2), a(target, requestListener, requestOptions.m6clone().a(this.l.floatValue()), thumbnailRequestCoordinator2, transitionOptions, a(priority), i, i2));
            return thumbnailRequestCoordinator2;
        }
        return a(target, requestListener, requestOptions, requestCoordinator, transitionOptions, priority, i, i2);
    }

    private Priority a(Priority priority) {
        int i = AnonymousClass2.b[priority.ordinal()];
        if (i == 1) {
            return Priority.NORMAL;
        }
        if (i == 2) {
            return Priority.HIGH;
        }
        if (i != 3 && i != 4) {
            throw new IllegalArgumentException("unknown priority: " + this.f.u());
        }
        return Priority.IMMEDIATE;
    }

    private Request a(Target<TranscodeType> target, RequestListener<TranscodeType> requestListener, RequestOptions requestOptions) {
        return a(target, requestListener, (RequestCoordinator) null, this.g, requestOptions.u(), requestOptions.r(), requestOptions.q(), requestOptions);
    }

    /* JADX WARN: Multi-variable type inference failed */
    private Request a(Target<TranscodeType> target, RequestListener<TranscodeType> requestListener, RequestCoordinator requestCoordinator, TransitionOptions<?, ? super TranscodeType> transitionOptions, Priority priority, int i, int i2, RequestOptions requestOptions) {
        RequestCoordinator requestCoordinator2;
        RequestCoordinator requestCoordinator3;
        if (this.k != null) {
            requestCoordinator3 = new ErrorRequestCoordinator(requestCoordinator);
            requestCoordinator2 = requestCoordinator3;
        } else {
            requestCoordinator2 = null;
            requestCoordinator3 = requestCoordinator;
        }
        Request b = b(target, requestListener, requestCoordinator3, transitionOptions, priority, i, i2, requestOptions);
        if (requestCoordinator2 == null) {
            return b;
        }
        int r = this.k.f.r();
        int q = this.k.f.q();
        if (Util.b(i, i2) && !this.k.f.I()) {
            r = requestOptions.r();
            q = requestOptions.q();
        }
        RequestBuilder<TranscodeType> requestBuilder = this.k;
        ErrorRequestCoordinator errorRequestCoordinator = requestCoordinator2;
        errorRequestCoordinator.a(b, requestBuilder.a(target, requestListener, requestCoordinator2, requestBuilder.g, requestBuilder.f.u(), r, q, this.k.f));
        return errorRequestCoordinator;
    }

    private Request a(Target<TranscodeType> target, RequestListener<TranscodeType> requestListener, RequestOptions requestOptions, RequestCoordinator requestCoordinator, TransitionOptions<?, ? super TranscodeType> transitionOptions, Priority priority, int i, int i2) {
        Context context = this.a;
        GlideContext glideContext = this.e;
        return SingleRequest.b(context, glideContext, this.h, this.c, requestOptions, i, i2, priority, target, requestListener, this.i, requestCoordinator, glideContext.c(), transitionOptions.a());
    }
}