package coil.util;

import E3.v;
import S4.p;
import S4.w;
import V4.H;
import android.app.ActivityManager;
import android.content.Context;
import android.content.res.Configuration;
import android.graphics.Bitmap;
import android.graphics.ColorSpace;
import android.graphics.drawable.BitmapDrawable;
import android.graphics.drawable.Drawable;
import android.graphics.drawable.VectorDrawable;
import android.net.Uri;
import android.os.Build;
import android.os.Looper;
import android.view.View;
import android.webkit.MimeTypeMap;
import android.widget.ImageView;
import androidx.media3.exoplayer.source.ProgressiveMediaSource;
import coil.ComponentRegistry;
import coil.EventListener;
import coil.base.R;
import coil.decode.DataSource;
import coil.decode.Decoder;
import coil.disk.DiskCache;
import coil.intercept.Interceptor;
import coil.intercept.RealInterceptorChain;
import coil.memory.MemoryCache;
import coil.request.Parameters;
import coil.request.Tags;
import coil.request.ViewTargetRequestManager;
import coil.size.Dimension;
import coil.size.Scale;
import coil.size.Size;
import coil.size.Sizes;
import java.io.Closeable;
import java.io.File;
import kotlin.jvm.internal.o;
import okhttp3.Headers;
import okhttp3.Response;
import okhttp3.ResponseBody;
import w2.b;
import w4.k;
import x1.AbstractC3209a;
import x4.AbstractC3251q;

/* JADX INFO: renamed from: coil.util.-Utils, reason: invalid class name */
/* JADX INFO: loaded from: classes.dex */
public final class Utils {
    public static final String ASSET_FILE_PATH_ROOT = "android_asset";
    private static final Bitmap.Config DEFAULT_BITMAP_CONFIG;
    private static final int DEFAULT_MEMORY_CLASS_MEGABYTES = 256;
    private static final Headers EMPTY_HEADERS;
    private static final double LOW_MEMORY_MULTIPLIER = 0.15d;
    public static final String MIME_TYPE_HEIC = "image/heic";
    public static final String MIME_TYPE_HEIF = "image/heif";
    public static final String MIME_TYPE_JPEG = "image/jpeg";
    public static final String MIME_TYPE_WEBP = "image/webp";
    private static final ColorSpace NULL_COLOR_SPACE = null;
    private static final double STANDARD_MEMORY_MULTIPLIER = 0.2d;
    private static final Bitmap.Config[] VALID_TRANSFORMATION_CONFIGS;

    /* JADX INFO: renamed from: coil.util.-Utils$WhenMappings */
    public /* synthetic */ class WhenMappings {
        public static final /* synthetic */ int[] $EnumSwitchMapping$0;
        public static final /* synthetic */ int[] $EnumSwitchMapping$1;
        public static final /* synthetic */ int[] $EnumSwitchMapping$2;

        static {
            int[] iArr = new int[DataSource.values().length];
            try {
                iArr[DataSource.MEMORY_CACHE.ordinal()] = 1;
            } catch (NoSuchFieldError unused) {
            }
            try {
                iArr[DataSource.MEMORY.ordinal()] = 2;
            } catch (NoSuchFieldError unused2) {
            }
            try {
                iArr[DataSource.DISK.ordinal()] = 3;
            } catch (NoSuchFieldError unused3) {
            }
            try {
                iArr[DataSource.NETWORK.ordinal()] = 4;
            } catch (NoSuchFieldError unused4) {
            }
            $EnumSwitchMapping$0 = iArr;
            int[] iArr2 = new int[ImageView.ScaleType.values().length];
            try {
                iArr2[ImageView.ScaleType.FIT_START.ordinal()] = 1;
            } catch (NoSuchFieldError unused5) {
            }
            try {
                iArr2[ImageView.ScaleType.FIT_CENTER.ordinal()] = 2;
            } catch (NoSuchFieldError unused6) {
            }
            try {
                iArr2[ImageView.ScaleType.FIT_END.ordinal()] = 3;
            } catch (NoSuchFieldError unused7) {
            }
            try {
                iArr2[ImageView.ScaleType.CENTER_INSIDE.ordinal()] = 4;
            } catch (NoSuchFieldError unused8) {
            }
            $EnumSwitchMapping$1 = iArr2;
            int[] iArr3 = new int[Scale.values().length];
            try {
                iArr3[Scale.FILL.ordinal()] = 1;
            } catch (NoSuchFieldError unused9) {
            }
            try {
                iArr3[Scale.FIT.ordinal()] = 2;
            } catch (NoSuchFieldError unused10) {
            }
            $EnumSwitchMapping$2 = iArr3;
        }
    }

    static {
        int i6 = Build.VERSION.SDK_INT;
        VALID_TRANSFORMATION_CONFIGS = i6 >= 26 ? new Bitmap.Config[]{Bitmap.Config.ARGB_8888, Bitmap.Config.RGBA_F16} : new Bitmap.Config[]{Bitmap.Config.ARGB_8888};
        DEFAULT_BITMAP_CONFIG = i6 >= 26 ? Bitmap.Config.HARDWARE : Bitmap.Config.ARGB_8888;
        EMPTY_HEADERS = new Headers.Builder().e();
    }

    public static final void abortQuietly(DiskCache.Editor editor) {
        try {
            editor.abort();
        } catch (Exception unused) {
        }
    }

    public static final ComponentRegistry.Builder addFirst(ComponentRegistry.Builder builder, k kVar) {
        if (kVar != null) {
            builder.getFetcherFactories$coil_base_release().add(0, kVar);
        }
        return builder;
    }

    public static final Headers.Builder addUnsafeNonAscii(Headers.Builder builder, String str) {
        int iN0 = p.N0(str, ':', 0, 6);
        if (iN0 == -1) {
            throw new IllegalArgumentException("Unexpected header: ".concat(str).toString());
        }
        String strSubstring = str.substring(0, iN0);
        o.g(strSubstring, "substring(...)");
        String string = p.o1(strSubstring).toString();
        String strSubstring2 = str.substring(iN0 + 1);
        o.g(strSubstring2, "substring(...)");
        builder.d(string, strSubstring2);
        return builder;
    }

    public static final int calculateMemoryCacheSize(Context context, double d6) {
        int largeMemoryClass;
        try {
            Object systemService = AbstractC3209a.getSystemService(context, ActivityManager.class);
            o.e(systemService);
            ActivityManager activityManager = (ActivityManager) systemService;
            largeMemoryClass = (context.getApplicationInfo().flags & ProgressiveMediaSource.DEFAULT_LOADING_CHECK_INTERVAL_BYTES) != 0 ? activityManager.getLargeMemoryClass() : activityManager.getMemoryClass();
        } catch (Exception unused) {
            largeMemoryClass = 256;
        }
        double d7 = 1024;
        return (int) (d6 * ((double) largeMemoryClass) * d7 * d7);
    }

    public static final void closeQuietly(Closeable closeable) {
        try {
            closeable.close();
        } catch (RuntimeException e6) {
            throw e6;
        } catch (Exception unused) {
        }
    }

    public static final double defaultMemoryCacheSizePercent(Context context) {
        try {
            Object systemService = AbstractC3209a.getSystemService(context, ActivityManager.class);
            o.e(systemService);
            return ((ActivityManager) systemService).isLowRamDevice() ? LOW_MEMORY_MULTIPLIER : STANDARD_MEMORY_MULTIPLIER;
        } catch (Exception unused) {
            return STANDARD_MEMORY_MULTIPLIER;
        }
    }

    public static final MemoryCache.Value get(MemoryCache memoryCache, MemoryCache.Key key) {
        if (key != null) {
            return memoryCache.get(key);
        }
        return null;
    }

    public static final <T> T getCompletedOrNull(H h5) {
        try {
            return (T) h5.getCompleted();
        } catch (Throwable unused) {
            return null;
        }
    }

    public static final Bitmap.Config getDEFAULT_BITMAP_CONFIG() {
        return DEFAULT_BITMAP_CONFIG;
    }

    public static final Headers getEMPTY_HEADERS() {
        return EMPTY_HEADERS;
    }

    public static final String getEmoji(DataSource dataSource) {
        int i6 = WhenMappings.$EnumSwitchMapping$0[dataSource.ordinal()];
        if (i6 == 1 || i6 == 2) {
            return Emoji.BRAIN;
        }
        if (i6 == 3) {
            return Emoji.FLOPPY;
        }
        if (i6 == 4) {
            return Emoji.CLOUD;
        }
        throw new v();
    }

    public static final EventListener getEventListener(Interceptor.Chain chain) {
        return chain instanceof RealInterceptorChain ? ((RealInterceptorChain) chain).getEventListener() : EventListener.NONE;
    }

    public static final String getFirstPathSegment(Uri uri) {
        return (String) AbstractC3251q.g0(uri.getPathSegments());
    }

    public static final int getHeight(Drawable drawable) {
        Bitmap bitmap;
        BitmapDrawable bitmapDrawable = drawable instanceof BitmapDrawable ? (BitmapDrawable) drawable : null;
        return (bitmapDrawable == null || (bitmap = bitmapDrawable.getBitmap()) == null) ? drawable.getIntrinsicHeight() : bitmap.getHeight();
    }

    public static final int getIdentityHashCode(Object obj) {
        return System.identityHashCode(obj);
    }

    public static final String getMimeTypeFromUrl(MimeTypeMap mimeTypeMap, String str) {
        if (str == null || p.Q0(str)) {
            return null;
        }
        String strL1 = p.l1(p.l1(str, '#'), '?');
        return mimeTypeMap.getMimeTypeFromExtension(p.i1('.', p.i1('/', strL1, strL1), ""));
    }

    public static final ColorSpace getNULL_COLOR_SPACE() {
        return NULL_COLOR_SPACE;
    }

    public static final int getNightMode(Configuration configuration) {
        return configuration.uiMode & 48;
    }

    public static final ViewTargetRequestManager getRequestManager(View view) {
        ViewTargetRequestManager viewTargetRequestManager;
        Object tag = view.getTag(R.id.coil_request_manager);
        ViewTargetRequestManager viewTargetRequestManager2 = tag instanceof ViewTargetRequestManager ? (ViewTargetRequestManager) tag : null;
        if (viewTargetRequestManager2 != null) {
            return viewTargetRequestManager2;
        }
        synchronized (view) {
            try {
                Object tag2 = view.getTag(R.id.coil_request_manager);
                viewTargetRequestManager = tag2 instanceof ViewTargetRequestManager ? (ViewTargetRequestManager) tag2 : null;
                if (viewTargetRequestManager == null) {
                    viewTargetRequestManager = new ViewTargetRequestManager(view);
                    view.addOnAttachStateChangeListener(viewTargetRequestManager);
                    view.setTag(R.id.coil_request_manager, viewTargetRequestManager);
                }
            } finally {
            }
        }
        return viewTargetRequestManager;
    }

    public static final File getSafeCacheDir(Context context) {
        File cacheDir = context.getCacheDir();
        if (cacheDir == null) {
            throw new IllegalStateException("cacheDir == null");
        }
        cacheDir.mkdirs();
        return cacheDir;
    }

    public static final Scale getScale(ImageView imageView) {
        ImageView.ScaleType scaleType = imageView.getScaleType();
        int i6 = scaleType == null ? -1 : WhenMappings.$EnumSwitchMapping$1[scaleType.ordinal()];
        return (i6 == 1 || i6 == 2 || i6 == 3 || i6 == 4) ? Scale.FIT : Scale.FILL;
    }

    public static final Bitmap.Config[] getVALID_TRANSFORMATION_CONFIGS() {
        return VALID_TRANSFORMATION_CONFIGS;
    }

    public static final int getWidth(Drawable drawable) {
        Bitmap bitmap;
        BitmapDrawable bitmapDrawable = drawable instanceof BitmapDrawable ? (BitmapDrawable) drawable : null;
        return (bitmapDrawable == null || (bitmap = bitmapDrawable.getBitmap()) == null) ? drawable.getIntrinsicWidth() : bitmap.getWidth();
    }

    public static final int heightPx(Size size, Scale scale, J4.a aVar) {
        return Sizes.isOriginal(size) ? ((Number) aVar.invoke()).intValue() : toPx(size.getHeight(), scale);
    }

    public static final boolean isAssetUri(Uri uri) {
        return o.c(uri.getScheme(), "file") && o.c(getFirstPathSegment(uri), ASSET_FILE_PATH_ROOT);
    }

    public static final boolean isMainThread() {
        return o.c(Looper.myLooper(), Looper.getMainLooper());
    }

    public static final boolean isMinOrMax(int i6) {
        return i6 == Integer.MIN_VALUE || i6 == Integer.MAX_VALUE;
    }

    public static final boolean isPlaceholderCached(Interceptor.Chain chain) {
        return (chain instanceof RealInterceptorChain) && ((RealInterceptorChain) chain).isPlaceholderCached();
    }

    public static final boolean isVector(Drawable drawable) {
        return (drawable instanceof VectorDrawable) || (drawable instanceof b);
    }

    public static final Headers orEmpty(Headers headers) {
        return headers == null ? EMPTY_HEADERS : headers;
    }

    public static final ResponseBody requireBody(Response response) {
        ResponseBody responseBody = response.f22146j;
        if (responseBody != null) {
            return responseBody;
        }
        throw new IllegalStateException("response body == null");
    }

    public static final int toNonNegativeInt(String str, int i6) {
        Long lC0 = w.C0(str);
        if (lC0 == null) {
            return i6;
        }
        long jLongValue = lC0.longValue();
        if (jLongValue > 2147483647L) {
            return Integer.MAX_VALUE;
        }
        if (jLongValue < 0) {
            return 0;
        }
        return (int) jLongValue;
    }

    public static final int toPx(Dimension dimension, Scale scale) {
        if (dimension instanceof Dimension.Pixels) {
            return ((Dimension.Pixels) dimension).px;
        }
        int i6 = WhenMappings.$EnumSwitchMapping$2[scale.ordinal()];
        if (i6 == 1) {
            return Integer.MIN_VALUE;
        }
        if (i6 == 2) {
            return Integer.MAX_VALUE;
        }
        throw new v();
    }

    public static final Void unsupported() {
        throw new IllegalStateException("Unsupported");
    }

    public static final int widthPx(Size size, Scale scale, J4.a aVar) {
        return Sizes.isOriginal(size) ? ((Number) aVar.invoke()).intValue() : toPx(size.getWidth(), scale);
    }

    public static final ComponentRegistry.Builder addFirst(ComponentRegistry.Builder builder, Decoder.Factory factory) {
        if (factory != null) {
            builder.getDecoderFactories$coil_base_release().add(0, factory);
        }
        return builder;
    }

    public static final Tags orEmpty(Tags tags) {
        return tags == null ? Tags.EMPTY : tags;
    }

    public static final Parameters orEmpty(Parameters parameters) {
        return parameters == null ? Parameters.EMPTY : parameters;
    }
}