package com.bumptech.glide.load.model;

import androidx.core.util.Pools$Pool;
import com.bumptech.glide.Registry;
import com.bumptech.glide.load.Options;
import com.bumptech.glide.load.model.ModelLoader;
import com.bumptech.glide.util.Preconditions;
import java.util.ArrayList;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Set;

/* loaded from: classes.dex */
public class MultiModelLoaderFactory {
    private static final Factory e = new Factory();
    private static final ModelLoader<Object, Object> f = new EmptyModelLoader();
    private final List<Entry<?, ?>> a;
    private final Factory b;
    private final Set<Entry<?, ?>> c;
    private final Pools$Pool<List<Throwable>> d;

    private static class EmptyModelLoader implements ModelLoader<Object, Object> {
        EmptyModelLoader() {
        }

        @Override // com.bumptech.glide.load.model.ModelLoader
        public ModelLoader.LoadData<Object> a(Object obj, int i, int i2, Options options) {
            return null;
        }

        @Override // com.bumptech.glide.load.model.ModelLoader
        public boolean a(Object obj) {
            return false;
        }
    }

    private static class Entry<Model, Data> {
        private final Class<Model> a;
        final Class<Data> b;
        final ModelLoaderFactory<? extends Model, ? extends Data> c;

        public Entry(Class<Model> cls, Class<Data> cls2, ModelLoaderFactory<? extends Model, ? extends Data> modelLoaderFactory) {
            this.a = cls;
            this.b = cls2;
            this.c = modelLoaderFactory;
        }

        public boolean a(Class<?> cls, Class<?> cls2) {
            return a(cls) && this.b.isAssignableFrom(cls2);
        }

        public boolean a(Class<?> cls) {
            return this.a.isAssignableFrom(cls);
        }
    }

    static class Factory {
        Factory() {
        }

        public <Model, Data> MultiModelLoader<Model, Data> a(List<ModelLoader<Model, Data>> list, Pools$Pool<List<Throwable>> pools$Pool) {
            return new MultiModelLoader<>(list, pools$Pool);
        }
    }

    public MultiModelLoaderFactory(Pools$Pool<List<Throwable>> pools$Pool) {
        this(pools$Pool, e);
    }

    synchronized <Model, Data> void a(Class<Model> cls, Class<Data> cls2, ModelLoaderFactory<? extends Model, ? extends Data> modelLoaderFactory) {
        a(cls, cls2, modelLoaderFactory, true);
    }

    synchronized <Model, Data> List<ModelLoaderFactory<? extends Model, ? extends Data>> b(Class<Model> cls, Class<Data> cls2, ModelLoaderFactory<? extends Model, ? extends Data> modelLoaderFactory) {
        List<ModelLoaderFactory<? extends Model, ? extends Data>> b;
        b = b(cls, cls2);
        a(cls, cls2, modelLoaderFactory);
        return b;
    }

    MultiModelLoaderFactory(Pools$Pool<List<Throwable>> pools$Pool, Factory factory) {
        this.a = new ArrayList();
        this.c = new HashSet();
        this.d = pools$Pool;
        this.b = factory;
    }

    private <Model, Data> void a(Class<Model> cls, Class<Data> cls2, ModelLoaderFactory<? extends Model, ? extends Data> modelLoaderFactory, boolean z) {
        Entry<?, ?> entry = new Entry<>(cls, cls2, modelLoaderFactory);
        List<Entry<?, ?>> list = this.a;
        list.add(z ? list.size() : 0, entry);
    }

    synchronized <Model, Data> List<ModelLoaderFactory<? extends Model, ? extends Data>> b(Class<Model> cls, Class<Data> cls2) {
        ArrayList arrayList;
        arrayList = new ArrayList();
        Iterator<Entry<?, ?>> it = this.a.iterator();
        while (it.hasNext()) {
            Entry<?, ?> next = it.next();
            if (next.a(cls, cls2)) {
                it.remove();
                arrayList.add(b(next));
            }
        }
        return arrayList;
    }

    synchronized <Model> List<ModelLoader<Model, ?>> a(Class<Model> cls) {
        ArrayList arrayList;
        try {
            arrayList = new ArrayList();
            for (Entry<?, ?> entry : this.a) {
                if (!this.c.contains(entry) && entry.a(cls)) {
                    this.c.add(entry);
                    arrayList.add(a(entry));
                    this.c.remove(entry);
                }
            }
        } catch (Throwable th) {
            this.c.clear();
            throw th;
        }
        return arrayList;
    }

    synchronized List<Class<?>> b(Class<?> cls) {
        ArrayList arrayList;
        arrayList = new ArrayList();
        for (Entry<?, ?> entry : this.a) {
            if (!arrayList.contains(entry.b) && entry.a(cls)) {
                arrayList.add(entry.b);
            }
        }
        return arrayList;
    }

    public synchronized <Model, Data> ModelLoader<Model, Data> a(Class<Model> cls, Class<Data> cls2) {
        try {
            ArrayList arrayList = new ArrayList();
            boolean z = false;
            for (Entry<?, ?> entry : this.a) {
                if (this.c.contains(entry)) {
                    z = true;
                } else if (entry.a(cls, cls2)) {
                    this.c.add(entry);
                    arrayList.add(a(entry));
                    this.c.remove(entry);
                }
            }
            if (arrayList.size() > 1) {
                return this.b.a(arrayList, this.d);
            }
            if (arrayList.size() == 1) {
                return (ModelLoader) arrayList.get(0);
            }
            if (z) {
                return a();
            }
            throw new Registry.NoModelLoaderAvailableException(cls, cls2);
        } catch (Throwable th) {
            this.c.clear();
            throw th;
        }
    }

    private <Model, Data> ModelLoaderFactory<Model, Data> b(Entry<?, ?> entry) {
        return (ModelLoaderFactory<Model, Data>) entry.c;
    }

    private <Model, Data> ModelLoader<Model, Data> a(Entry<?, ?> entry) {
        Object a = entry.c.a(this);
        Preconditions.a(a);
        return (ModelLoader) a;
    }

    private static <Model, Data> ModelLoader<Model, Data> a() {
        return (ModelLoader<Model, Data>) f;
    }
}