package kotlin.time;

import kotlin.jvm.internal.DefaultConstructorMarker;
import kotlin.jvm.internal.Intrinsics;
import kotlin.ranges.LongRange;
import kotlin.ranges.RangesKt___RangesKt;
import kotlin.text.StringsKt__StringsKt;

/* loaded from: classes5.dex */
public final class Duration implements Comparable {
    public static final long INFINITE;
    public static final long NEG_INFINITE;
    public final long rawValue;
    public static final Companion Companion = new Companion(null);
    public static final long ZERO = m4075constructorimpl(0);

    /* renamed from: box-impl, reason: not valid java name */
    public static final /* synthetic */ Duration m4073boximpl(long j) {
        return new Duration(j);
    }

    /* renamed from: equals-impl, reason: not valid java name */
    public static boolean m4076equalsimpl(long j, Object obj) {
        return (obj instanceof Duration) && j == ((Duration) obj).m4102unboximpl();
    }

    /* renamed from: getValue-impl, reason: not valid java name */
    public static final long m4088getValueimpl(long j) {
        return j >> 1;
    }

    /* renamed from: hashCode-impl, reason: not valid java name */
    public static int m4089hashCodeimpl(long j) {
        return Long.hashCode(j);
    }

    /* renamed from: isInMillis-impl, reason: not valid java name */
    public static final boolean m4091isInMillisimpl(long j) {
        return (((int) j) & 1) == 1;
    }

    /* renamed from: isInNanos-impl, reason: not valid java name */
    public static final boolean m4092isInNanosimpl(long j) {
        return (((int) j) & 1) == 0;
    }

    /* renamed from: isInfinite-impl, reason: not valid java name */
    public static final boolean m4093isInfiniteimpl(long j) {
        return j == INFINITE || j == NEG_INFINITE;
    }

    /* renamed from: isNegative-impl, reason: not valid java name */
    public static final boolean m4094isNegativeimpl(long j) {
        return j < 0;
    }

    /* renamed from: isPositive-impl, reason: not valid java name */
    public static final boolean m4095isPositiveimpl(long j) {
        return j > 0;
    }

    public boolean equals(Object obj) {
        return m4076equalsimpl(this.rawValue, obj);
    }

    public int hashCode() {
        return m4089hashCodeimpl(this.rawValue);
    }

    /* renamed from: unbox-impl, reason: not valid java name */
    public final /* synthetic */ long m4102unboximpl() {
        return this.rawValue;
    }

    @Override // java.lang.Comparable
    public /* bridge */ /* synthetic */ int compareTo(Object obj) {
        return m4101compareToLRDsOJo(((Duration) obj).m4102unboximpl());
    }

    public /* synthetic */ Duration(long j) {
        this.rawValue = j;
    }

    /* renamed from: getStorageUnit-impl, reason: not valid java name */
    public static final DurationUnit m4087getStorageUnitimpl(long j) {
        return m4092isInNanosimpl(j) ? DurationUnit.NANOSECONDS : DurationUnit.MILLISECONDS;
    }

    /* renamed from: constructor-impl, reason: not valid java name */
    public static long m4075constructorimpl(long j) {
        if (DurationJvmKt.getDurationAssertionsEnabled()) {
            if (m4092isInNanosimpl(j)) {
                if (!new LongRange(-4611686018426999999L, 4611686018426999999L).contains(m4088getValueimpl(j))) {
                    throw new AssertionError(m4088getValueimpl(j) + " ns is out of nanoseconds range");
                }
            } else {
                if (!new LongRange(-4611686018427387903L, 4611686018427387903L).contains(m4088getValueimpl(j))) {
                    throw new AssertionError(m4088getValueimpl(j) + " ms is out of milliseconds range");
                }
                if (new LongRange(-4611686018426L, 4611686018426L).contains(m4088getValueimpl(j))) {
                    throw new AssertionError(m4088getValueimpl(j) + " ms is denormalized");
                }
            }
        }
        return j;
    }

    public static final class Companion {
        public /* synthetic */ Companion(DefaultConstructorMarker defaultConstructorMarker) {
            this();
        }

        public Companion() {
        }

        /* renamed from: getZERO-UwyO8pc, reason: not valid java name */
        public final long m4105getZEROUwyO8pc() {
            return Duration.ZERO;
        }

        /* renamed from: getINFINITE-UwyO8pc, reason: not valid java name */
        public final long m4103getINFINITEUwyO8pc() {
            return Duration.INFINITE;
        }

        /* renamed from: getNEG_INFINITE-UwyO8pc$kotlin_stdlib, reason: not valid java name */
        public final long m4104getNEG_INFINITEUwyO8pc$kotlin_stdlib() {
            return Duration.NEG_INFINITE;
        }
    }

    static {
        long durationOfMillis;
        long durationOfMillis2;
        durationOfMillis = DurationKt.durationOfMillis(4611686018427387903L);
        INFINITE = durationOfMillis;
        durationOfMillis2 = DurationKt.durationOfMillis(-4611686018427387903L);
        NEG_INFINITE = durationOfMillis2;
    }

    /* renamed from: unaryMinus-UwyO8pc, reason: not valid java name */
    public static final long m4100unaryMinusUwyO8pc(long j) {
        long durationOf;
        durationOf = DurationKt.durationOf(-m4088getValueimpl(j), ((int) j) & 1);
        return durationOf;
    }

    /* renamed from: plus-LRDsOJo, reason: not valid java name */
    public static final long m4096plusLRDsOJo(long j, long j2) {
        long durationOfMillisNormalized;
        long durationOfNanosNormalized;
        if (m4093isInfiniteimpl(j)) {
            if (m4090isFiniteimpl(j2) || (j2 ^ j) >= 0) {
                return j;
            }
            throw new IllegalArgumentException("Summing infinite durations of different signs yields an undefined result.");
        }
        if (m4093isInfiniteimpl(j2)) {
            return j2;
        }
        if ((((int) j) & 1) == (((int) j2) & 1)) {
            long m4088getValueimpl = m4088getValueimpl(j) + m4088getValueimpl(j2);
            if (m4092isInNanosimpl(j)) {
                durationOfNanosNormalized = DurationKt.durationOfNanosNormalized(m4088getValueimpl);
                return durationOfNanosNormalized;
            }
            durationOfMillisNormalized = DurationKt.durationOfMillisNormalized(m4088getValueimpl);
            return durationOfMillisNormalized;
        }
        if (m4091isInMillisimpl(j)) {
            return m4071addValuesMixedRangesUwyO8pc(j, m4088getValueimpl(j), m4088getValueimpl(j2));
        }
        return m4071addValuesMixedRangesUwyO8pc(j, m4088getValueimpl(j2), m4088getValueimpl(j));
    }

    /* renamed from: addValuesMixedRanges-UwyO8pc, reason: not valid java name */
    public static final long m4071addValuesMixedRangesUwyO8pc(long j, long j2, long j3) {
        long nanosToMillis;
        long coerceIn;
        long durationOfMillis;
        long millisToNanos;
        long millisToNanos2;
        long durationOfNanos;
        nanosToMillis = DurationKt.nanosToMillis(j3);
        long j4 = j2 + nanosToMillis;
        if (new LongRange(-4611686018426L, 4611686018426L).contains(j4)) {
            millisToNanos = DurationKt.millisToNanos(nanosToMillis);
            long j5 = j3 - millisToNanos;
            millisToNanos2 = DurationKt.millisToNanos(j4);
            durationOfNanos = DurationKt.durationOfNanos(millisToNanos2 + j5);
            return durationOfNanos;
        }
        coerceIn = RangesKt___RangesKt.coerceIn(j4, -4611686018427387903L, 4611686018427387903L);
        durationOfMillis = DurationKt.durationOfMillis(coerceIn);
        return durationOfMillis;
    }

    /* renamed from: isFinite-impl, reason: not valid java name */
    public static final boolean m4090isFiniteimpl(long j) {
        return !m4093isInfiniteimpl(j);
    }

    /* renamed from: getAbsoluteValue-UwyO8pc, reason: not valid java name */
    public static final long m4077getAbsoluteValueUwyO8pc(long j) {
        return m4094isNegativeimpl(j) ? m4100unaryMinusUwyO8pc(j) : j;
    }

    /* renamed from: compareTo-LRDsOJo, reason: not valid java name */
    public int m4101compareToLRDsOJo(long j) {
        return m4074compareToLRDsOJo(this.rawValue, j);
    }

    /* renamed from: compareTo-LRDsOJo, reason: not valid java name */
    public static int m4074compareToLRDsOJo(long j, long j2) {
        long j3 = j ^ j2;
        if (j3 < 0 || (((int) j3) & 1) == 0) {
            return Intrinsics.compare(j, j2);
        }
        int i = (((int) j) & 1) - (((int) j2) & 1);
        return m4094isNegativeimpl(j) ? -i : i;
    }

    /* renamed from: getHoursComponent-impl, reason: not valid java name */
    public static final int m4078getHoursComponentimpl(long j) {
        if (m4093isInfiniteimpl(j)) {
            return 0;
        }
        return (int) (m4080getInWholeHoursimpl(j) % 24);
    }

    /* renamed from: getMinutesComponent-impl, reason: not valid java name */
    public static final int m4084getMinutesComponentimpl(long j) {
        if (m4093isInfiniteimpl(j)) {
            return 0;
        }
        return (int) (m4082getInWholeMinutesimpl(j) % 60);
    }

    /* renamed from: getSecondsComponent-impl, reason: not valid java name */
    public static final int m4086getSecondsComponentimpl(long j) {
        if (m4093isInfiniteimpl(j)) {
            return 0;
        }
        return (int) (m4083getInWholeSecondsimpl(j) % 60);
    }

    /* renamed from: getNanosecondsComponent-impl, reason: not valid java name */
    public static final int m4085getNanosecondsComponentimpl(long j) {
        long m4088getValueimpl;
        if (m4093isInfiniteimpl(j)) {
            return 0;
        }
        if (m4091isInMillisimpl(j)) {
            m4088getValueimpl = DurationKt.millisToNanos(m4088getValueimpl(j) % 1000);
        } else {
            m4088getValueimpl = m4088getValueimpl(j) % 1000000000;
        }
        return (int) m4088getValueimpl;
    }

    /* renamed from: toDouble-impl, reason: not valid java name */
    public static final double m4097toDoubleimpl(long j, DurationUnit unit) {
        Intrinsics.checkNotNullParameter(unit, "unit");
        if (j == INFINITE) {
            return Double.POSITIVE_INFINITY;
        }
        if (j == NEG_INFINITE) {
            return Double.NEGATIVE_INFINITY;
        }
        return DurationUnitKt__DurationUnitJvmKt.convertDurationUnit(m4088getValueimpl(j), m4087getStorageUnitimpl(j), unit);
    }

    /* renamed from: toLong-impl, reason: not valid java name */
    public static final long m4098toLongimpl(long j, DurationUnit unit) {
        Intrinsics.checkNotNullParameter(unit, "unit");
        if (j == INFINITE) {
            return Long.MAX_VALUE;
        }
        if (j == NEG_INFINITE) {
            return Long.MIN_VALUE;
        }
        return DurationUnitKt__DurationUnitJvmKt.convertDurationUnit(m4088getValueimpl(j), m4087getStorageUnitimpl(j), unit);
    }

    /* renamed from: getInWholeDays-impl, reason: not valid java name */
    public static final long m4079getInWholeDaysimpl(long j) {
        return m4098toLongimpl(j, DurationUnit.DAYS);
    }

    /* renamed from: getInWholeHours-impl, reason: not valid java name */
    public static final long m4080getInWholeHoursimpl(long j) {
        return m4098toLongimpl(j, DurationUnit.HOURS);
    }

    /* renamed from: getInWholeMinutes-impl, reason: not valid java name */
    public static final long m4082getInWholeMinutesimpl(long j) {
        return m4098toLongimpl(j, DurationUnit.MINUTES);
    }

    /* renamed from: getInWholeSeconds-impl, reason: not valid java name */
    public static final long m4083getInWholeSecondsimpl(long j) {
        return m4098toLongimpl(j, DurationUnit.SECONDS);
    }

    /* renamed from: getInWholeMilliseconds-impl, reason: not valid java name */
    public static final long m4081getInWholeMillisecondsimpl(long j) {
        return (m4091isInMillisimpl(j) && m4090isFiniteimpl(j)) ? m4088getValueimpl(j) : m4098toLongimpl(j, DurationUnit.MILLISECONDS);
    }

    public String toString() {
        return m4099toStringimpl(this.rawValue);
    }

    /* renamed from: toString-impl, reason: not valid java name */
    public static String m4099toStringimpl(long j) {
        if (j == 0) {
            return "0s";
        }
        if (j == INFINITE) {
            return "Infinity";
        }
        if (j == NEG_INFINITE) {
            return "-Infinity";
        }
        boolean m4094isNegativeimpl = m4094isNegativeimpl(j);
        StringBuilder sb = new StringBuilder();
        if (m4094isNegativeimpl) {
            sb.append('-');
        }
        long m4077getAbsoluteValueUwyO8pc = m4077getAbsoluteValueUwyO8pc(j);
        long m4079getInWholeDaysimpl = m4079getInWholeDaysimpl(m4077getAbsoluteValueUwyO8pc);
        int m4078getHoursComponentimpl = m4078getHoursComponentimpl(m4077getAbsoluteValueUwyO8pc);
        int m4084getMinutesComponentimpl = m4084getMinutesComponentimpl(m4077getAbsoluteValueUwyO8pc);
        int m4086getSecondsComponentimpl = m4086getSecondsComponentimpl(m4077getAbsoluteValueUwyO8pc);
        int m4085getNanosecondsComponentimpl = m4085getNanosecondsComponentimpl(m4077getAbsoluteValueUwyO8pc);
        int i = 0;
        boolean z = m4079getInWholeDaysimpl != 0;
        boolean z2 = m4078getHoursComponentimpl != 0;
        boolean z3 = m4084getMinutesComponentimpl != 0;
        boolean z4 = (m4086getSecondsComponentimpl == 0 && m4085getNanosecondsComponentimpl == 0) ? false : true;
        if (z) {
            sb.append(m4079getInWholeDaysimpl);
            sb.append('d');
            i = 1;
        }
        if (z2 || (z && (z3 || z4))) {
            int i2 = i + 1;
            if (i > 0) {
                sb.append(' ');
            }
            sb.append(m4078getHoursComponentimpl);
            sb.append('h');
            i = i2;
        }
        if (z3 || (z4 && (z2 || z))) {
            int i3 = i + 1;
            if (i > 0) {
                sb.append(' ');
            }
            sb.append(m4084getMinutesComponentimpl);
            sb.append('m');
            i = i3;
        }
        if (z4) {
            int i4 = i + 1;
            if (i > 0) {
                sb.append(' ');
            }
            if (m4086getSecondsComponentimpl != 0 || z || z2 || z3) {
                m4072appendFractionalimpl(j, sb, m4086getSecondsComponentimpl, m4085getNanosecondsComponentimpl, 9, "s", false);
            } else if (m4085getNanosecondsComponentimpl >= 1000000) {
                m4072appendFractionalimpl(j, sb, m4085getNanosecondsComponentimpl / 1000000, m4085getNanosecondsComponentimpl % 1000000, 6, "ms", false);
            } else if (m4085getNanosecondsComponentimpl >= 1000) {
                m4072appendFractionalimpl(j, sb, m4085getNanosecondsComponentimpl / 1000, m4085getNanosecondsComponentimpl % 1000, 3, "us", false);
            } else {
                sb.append(m4085getNanosecondsComponentimpl);
                sb.append("ns");
            }
            i = i4;
        }
        if (m4094isNegativeimpl && i > 1) {
            sb.insert(1, '(').append(')');
        }
        String sb2 = sb.toString();
        Intrinsics.checkNotNullExpressionValue(sb2, "toString(...)");
        return sb2;
    }

    /* renamed from: appendFractional-impl, reason: not valid java name */
    public static final void m4072appendFractionalimpl(long j, StringBuilder sb, int i, int i2, int i3, String str, boolean z) {
        String padStart;
        sb.append(i);
        if (i2 != 0) {
            sb.append('.');
            padStart = StringsKt__StringsKt.padStart(String.valueOf(i2), i3, '0');
            int i4 = -1;
            int length = padStart.length() - 1;
            if (length >= 0) {
                while (true) {
                    int i5 = length - 1;
                    if (padStart.charAt(length) != '0') {
                        i4 = length;
                        break;
                    } else if (i5 < 0) {
                        break;
                    } else {
                        length = i5;
                    }
                }
            }
            int i6 = i4 + 1;
            if (!z && i6 < 3) {
                sb.append((CharSequence) padStart, 0, i6);
                Intrinsics.checkNotNullExpressionValue(sb, "append(...)");
            } else {
                sb.append((CharSequence) padStart, 0, ((i4 + 3) / 3) * 3);
                Intrinsics.checkNotNullExpressionValue(sb, "append(...)");
            }
        }
        sb.append(str);
    }
}