package m4;

import java.io.OutputStream;
import java.nio.ByteBuffer;
import java.util.Random;
import java.util.concurrent.Executor;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;

/* JADX INFO: loaded from: classes3.dex */
public final class i2 implements InterfaceC2562z, e2, k4.c0, k4.f0 {

    /* JADX INFO: renamed from: b, reason: collision with root package name */
    public static final i2 f21060b = new i2(0);

    /* JADX INFO: renamed from: a, reason: collision with root package name */
    public final /* synthetic */ int f21061a;

    public /* synthetic */ i2(int i6) {
        this.f21061a = i6;
    }

    public static W g() {
        W w6 = new W();
        w6.f20890a = new Random();
        long nanos = TimeUnit.SECONDS.toNanos(1L);
        w6.f20891b = TimeUnit.MINUTES.toNanos(2L);
        w6.f20892c = 1.6d;
        w6.f20893d = 0.2d;
        w6.f20894e = nanos;
        return w6;
    }

    @Override // k4.f0
    /* JADX INFO: renamed from: a */
    public byte[] mo1203a(Object obj) {
        switch (this.f21061a) {
            case 10:
                return (byte[]) obj;
            default:
                throw new UnsupportedOperationException();
        }
    }

    @Override // m4.e2
    public Object b() {
        switch (this.f21061a) {
            case 8:
                return Executors.newCachedThreadPool(AbstractC2504f0.e("grpc-default-executor-%d"));
            default:
                ScheduledExecutorService scheduledExecutorServiceNewScheduledThreadPool = Executors.newScheduledThreadPool(1, AbstractC2504f0.e("grpc-timer-%d"));
                try {
                    scheduledExecutorServiceNewScheduledThreadPool.getClass().getMethod("setRemoveOnCancelPolicy", Boolean.TYPE).invoke(scheduledExecutorServiceNewScheduledThreadPool, Boolean.TRUE);
                    break;
                } catch (NoSuchMethodException unused) {
                } catch (RuntimeException e6) {
                    throw e6;
                } catch (Exception e7) {
                    throw new RuntimeException(e7);
                }
                return Executors.unconfigurableScheduledExecutorService(scheduledExecutorServiceNewScheduledThreadPool);
        }
    }

    @Override // m4.InterfaceC2562z
    public int c(AbstractC2494c abstractC2494c, int i6, Object obj, int i7) {
        switch (this.f21061a) {
            case 2:
                break;
            case 3:
                abstractC2494c.A(i6);
                break;
            case 4:
                abstractC2494c.i((byte[]) obj, i7, i6);
                break;
            case 5:
                ByteBuffer byteBuffer = (ByteBuffer) obj;
                int iLimit = byteBuffer.limit();
                byteBuffer.limit(byteBuffer.position() + i6);
                abstractC2494c.g(byteBuffer);
                byteBuffer.limit(iLimit);
                break;
            default:
                abstractC2494c.f((OutputStream) obj, i6);
                break;
        }
        return 0;
    }

    @Override // m4.e2
    public void d(Object obj) {
        switch (this.f21061a) {
            case 8:
                ((ExecutorService) ((Executor) obj)).shutdown();
                break;
            default:
                ((ScheduledExecutorService) obj).shutdown();
                break;
        }
    }

    public long e() {
        return TimeUnit.MILLISECONDS.toNanos(System.currentTimeMillis());
    }

    @Override // k4.c0
    public Object f(String str) {
        A4.g.l(str.length() > 0, "empty timeout");
        A4.g.l(str.length() <= 9, "bad timeout format");
        long j4 = Long.parseLong(str.substring(0, str.length() - 1));
        char cCharAt = str.charAt(str.length() - 1);
        if (cCharAt == 'H') {
            return Long.valueOf(TimeUnit.HOURS.toNanos(j4));
        }
        if (cCharAt == 'M') {
            return Long.valueOf(TimeUnit.MINUTES.toNanos(j4));
        }
        if (cCharAt == 'S') {
            return Long.valueOf(TimeUnit.SECONDS.toNanos(j4));
        }
        if (cCharAt == 'u') {
            return Long.valueOf(TimeUnit.MICROSECONDS.toNanos(j4));
        }
        if (cCharAt == 'm') {
            return Long.valueOf(TimeUnit.MILLISECONDS.toNanos(j4));
        }
        if (cCharAt == 'n') {
            return Long.valueOf(j4);
        }
        throw new IllegalArgumentException("Invalid timeout unit: " + cCharAt);
    }

    @Override // k4.f0
    public Object h(byte[] bArr) {
        switch (this.f21061a) {
            case 10:
                return bArr;
            default:
                if (bArr.length < 3) {
                    throw new NumberFormatException("Malformed status code ".concat(new String(bArr, k4.K.f19810a)));
                }
                return Integer.valueOf((bArr[2] - 48) + ((bArr[1] - 48) * 10) + ((bArr[0] - 48) * 100));
        }
    }

    public String toString() {
        switch (this.f21061a) {
            case 8:
                return "grpc-default-executor";
            default:
                return super.toString();
        }
    }

    @Override // k4.c0
    public String a(Object obj) {
        Long l = (Long) obj;
        TimeUnit timeUnit = TimeUnit.NANOSECONDS;
        if (l.longValue() < 0) {
            throw new IllegalArgumentException("Timeout too small");
        }
        if (l.longValue() < 100000000) {
            return l + "n";
        }
        if (l.longValue() < 100000000000L) {
            return timeUnit.toMicros(l.longValue()) + "u";
        }
        if (l.longValue() < 100000000000000L) {
            return timeUnit.toMillis(l.longValue()) + "m";
        }
        if (l.longValue() < 100000000000000000L) {
            return timeUnit.toSeconds(l.longValue()) + "S";
        }
        if (l.longValue() < 6000000000000000000L) {
            return timeUnit.toMinutes(l.longValue()) + "M";
        }
        return timeUnit.toHours(l.longValue()) + "H";
    }
}