package androidx.media3.exoplayer.ima;

import android.content.Context;
import android.os.Looper;
import android.util.Pair;
import android.view.View;
import android.view.ViewGroup;
import androidx.annotation.CheckResult;
import androidx.annotation.Nullable;
import androidx.media3.common.AdPlaybackState;
import androidx.media3.common.AdViewProvider;
import androidx.media3.common.Timeline;
import androidx.media3.common.util.Assertions;
import androidx.media3.common.util.Util;
import androidx.media3.datasource.DataSchemeDataSource;
import androidx.media3.datasource.DataSourceUtil;
import androidx.media3.datasource.DataSpec;
import androidx.media3.exoplayer.ima.ImaServerSideAdInsertionMediaSource;
import androidx.media3.exoplayer.source.ads.ServerSideAdInsertionUtil;
import com.google.ads.interactivemedia.v3.api.AdDisplayContainer;
import com.google.ads.interactivemedia.v3.api.AdError;
import com.google.ads.interactivemedia.v3.api.AdErrorEvent;
import com.google.ads.interactivemedia.v3.api.AdEvent;
import com.google.ads.interactivemedia.v3.api.AdPodInfo;
import com.google.ads.interactivemedia.v3.api.AdsLoader;
import com.google.ads.interactivemedia.v3.api.AdsRenderingSettings;
import com.google.ads.interactivemedia.v3.api.AdsRequest;
import com.google.ads.interactivemedia.v3.api.CompanionAdSlot;
import com.google.ads.interactivemedia.v3.api.FriendlyObstruction;
import com.google.ads.interactivemedia.v3.api.FriendlyObstructionPurpose;
import com.google.ads.interactivemedia.v3.api.ImaSdkSettings;
import com.google.ads.interactivemedia.v3.api.UiElement;
import com.google.ads.interactivemedia.v3.api.player.VideoAdPlayer;
import com.google.ads.interactivemedia.v3.api.player.VideoProgressUpdate;
import com.google.common.collect.ImmutableList;
import com.google.common.collect.ImmutableMap;
import java.io.IOException;
import java.math.BigDecimal;
import java.math.RoundingMode;
import java.util.Arrays;
import java.util.Collection;
import java.util.HashMap;
import java.util.List;
import java.util.Set;

/* JADX INFO: loaded from: classes.dex */
final class ImaUtil {
    public static final int BITRATE_UNSET = -1;
    public static final int TIMEOUT_UNSET = -1;

    public static final class Configuration {

        @Nullable
        public final List<String> adMediaMimeTypes;
        public final long adPreloadTimeoutMs;

        @Nullable
        public final Set<UiElement> adUiElements;

        @Nullable
        public final AdErrorEvent.AdErrorListener applicationAdErrorListener;

        @Nullable
        public final AdEvent.AdEventListener applicationAdEventListener;

        @Nullable
        public final VideoAdPlayer.VideoAdPlayerCallback applicationVideoAdPlayerCallback;

        @Nullable
        public final Collection<CompanionAdSlot> companionAdSlots;
        public final boolean debugModeEnabled;

        @Nullable
        public final Boolean enableContinuousPlayback;
        public final boolean focusSkipButtonWhenAvailable;

        @Nullable
        public final ImaSdkSettings imaSdkSettings;
        public final int mediaBitrate;
        public final int mediaLoadTimeoutMs;
        public final boolean playAdBeforeStartPosition;
        public final int vastLoadTimeoutMs;

        public Configuration(long j10, int i10, int i11, boolean z10, boolean z11, int i12, @Nullable Boolean bool, @Nullable List<String> list, @Nullable Set<UiElement> set, @Nullable Collection<CompanionAdSlot> collection, @Nullable AdErrorEvent.AdErrorListener adErrorListener, @Nullable AdEvent.AdEventListener adEventListener, @Nullable VideoAdPlayer.VideoAdPlayerCallback videoAdPlayerCallback, @Nullable ImaSdkSettings imaSdkSettings, boolean z12) {
            this.adPreloadTimeoutMs = j10;
            this.vastLoadTimeoutMs = i10;
            this.mediaLoadTimeoutMs = i11;
            this.focusSkipButtonWhenAvailable = z10;
            this.playAdBeforeStartPosition = z11;
            this.mediaBitrate = i12;
            this.enableContinuousPlayback = bool;
            this.adMediaMimeTypes = list;
            this.adUiElements = set;
            this.companionAdSlots = collection;
            this.applicationAdErrorListener = adErrorListener;
            this.applicationAdEventListener = adEventListener;
            this.applicationVideoAdPlayerCallback = videoAdPlayerCallback;
            this.imaSdkSettings = imaSdkSettings;
            this.debugModeEnabled = z12;
        }
    }

    public interface ImaFactory {
        AdDisplayContainer createAdDisplayContainer(ViewGroup viewGroup, VideoAdPlayer videoAdPlayer);

        AdsLoader createAdsLoader(Context context, ImaSdkSettings imaSdkSettings, AdDisplayContainer adDisplayContainer);

        AdsRenderingSettings createAdsRenderingSettings();

        AdsRequest createAdsRequest();

        AdDisplayContainer createAudioAdDisplayContainer(Context context, VideoAdPlayer videoAdPlayer);

        FriendlyObstruction createFriendlyObstruction(View view, FriendlyObstructionPurpose friendlyObstructionPurpose, @Nullable String str);

        ImaSdkSettings createImaSdkSettings();
    }

    public static final class ServerSideAdInsertionConfiguration {
        public final AdViewProvider adViewProvider;

        @Nullable
        public final AdErrorEvent.AdErrorListener applicationAdErrorListener;

        @Nullable
        public final AdEvent.AdEventListener applicationAdEventListener;
        public final ImmutableList<CompanionAdSlot> companionAdSlots;
        public final boolean debugModeEnabled;
        public final boolean focusSkipButtonWhenAvailable;
        public final ImaSdkSettings imaSdkSettings;
        public final ImaServerSideAdInsertionMediaSource.StreamEventListener streamEventListener;

        public ServerSideAdInsertionConfiguration(AdViewProvider adViewProvider, ImaSdkSettings imaSdkSettings, ImaServerSideAdInsertionMediaSource.StreamEventListener streamEventListener, @Nullable AdEvent.AdEventListener adEventListener, @Nullable AdErrorEvent.AdErrorListener adErrorListener, List<CompanionAdSlot> list, boolean z10, boolean z11) {
            this.imaSdkSettings = imaSdkSettings;
            this.adViewProvider = adViewProvider;
            this.streamEventListener = streamEventListener;
            this.applicationAdEventListener = adEventListener;
            this.applicationAdErrorListener = adErrorListener;
            this.companionAdSlots = ImmutableList.p(list);
            this.focusSkipButtonWhenAvailable = z10;
            this.debugModeEnabled = z11;
        }
    }

    private ImaUtil() {
    }

    @CheckResult
    public static AdPlaybackState addLiveAdBreak(long j10, long j11, int i10, long j12, int i11, AdPlaybackState adPlaybackState) {
        AdPlaybackState adPlaybackStateWithOriginalAdCount = adPlaybackState;
        Assertions.checkArgument(i10 > 0);
        long mediaPeriodPositionUsForContent = ServerSideAdInsertionUtil.getMediaPeriodPositionUsForContent(j10, -1, adPlaybackStateWithOriginalAdCount);
        int adGroupIndexForPositionUs = adPlaybackStateWithOriginalAdCount.getAdGroupIndexForPositionUs(mediaPeriodPositionUsForContent, -9223372036854775807L);
        if (adGroupIndexForPositionUs == -1) {
            long[] jArrUpdateAdDurationAndPropagate = updateAdDurationAndPropagate(new long[i11 - (i10 - 1)], 0, j11, j12);
            AdPlaybackState adPlaybackStateAddAdGroupToAdPlaybackState = ServerSideAdInsertionUtil.addAdGroupToAdPlaybackState(adPlaybackState, j10, Util.sum(jArrUpdateAdDurationAndPropagate), jArrUpdateAdDurationAndPropagate);
            int adGroupIndexForPositionUs2 = adPlaybackStateAddAdGroupToAdPlaybackState.getAdGroupIndexForPositionUs(mediaPeriodPositionUsForContent, -9223372036854775807L);
            return adGroupIndexForPositionUs2 != -1 ? adPlaybackStateAddAdGroupToAdPlaybackState.withAvailableAd(adGroupIndexForPositionUs2, 0).withOriginalAdCount(adGroupIndexForPositionUs2, i11) : adPlaybackStateAddAdGroupToAdPlaybackState;
        }
        AdPlaybackState.AdGroup adGroup = adPlaybackStateWithOriginalAdCount.getAdGroup(adGroupIndexForPositionUs);
        long[] jArrCopyOf = Arrays.copyOf(adGroup.durationsUs, adGroup.count);
        int nextUnavailableAdIndex = getNextUnavailableAdIndex(adGroup);
        if (adGroup.originalCount < i11 || nextUnavailableAdIndex == adGroup.count) {
            int i12 = nextUnavailableAdIndex + 1;
            int iMax = Math.max(i11, i12);
            adPlaybackStateWithOriginalAdCount = adPlaybackStateWithOriginalAdCount.withAdCount(adGroupIndexForPositionUs, iMax).withOriginalAdCount(adGroupIndexForPositionUs, iMax);
            jArrCopyOf = Arrays.copyOf(jArrCopyOf, iMax);
            jArrCopyOf[nextUnavailableAdIndex] = j12;
            Arrays.fill(jArrCopyOf, i12, iMax, 0L);
        }
        updateAdDurationAndPropagate(jArrCopyOf, nextUnavailableAdIndex, j11, Math.max(j11, jArrCopyOf[nextUnavailableAdIndex]));
        return adPlaybackStateWithOriginalAdCount.withAdDurationsUs(adGroupIndexForPositionUs, jArrCopyOf).withAvailableAd(adGroupIndexForPositionUs, nextUnavailableAdIndex).withContentResumeOffsetUs(adGroupIndexForPositionUs, Util.sum(jArrCopyOf));
    }

    @CheckResult
    public static AdPlaybackState expandAdGroupPlaceholder(int i10, long j10, int i11, long j11, int i12, AdPlaybackState adPlaybackState) {
        Assertions.checkArgument(i11 < i12);
        long[] jArrUpdateAdDurationAndPropagate = updateAdDurationAndPropagate(new long[i12], i11, j11, j10);
        return adPlaybackState.withAdCount(i10, jArrUpdateAdDurationAndPropagate.length).withAdDurationsUs(i10, jArrUpdateAdDurationAndPropagate);
    }

    public static Pair<Integer, Integer> getAdGroupAndIndexInLiveMultiPeriodTimeline(int i10, AdPlaybackState adPlaybackState, Timeline timeline) {
        int i11 = 0;
        Timeline.Window window = timeline.getWindow(0, new Timeline.Window());
        Assertions.checkArgument(window.isLive());
        Timeline.Period period = new Timeline.Period();
        timeline.getPeriod(i10, period, true);
        long windowStartTimeUs = getWindowStartTimeUs(window.windowStartTimeMs, window.positionInFirstPeriodUs) + period.positionInWindowUs;
        int adGroupIndexForPositionUs = adPlaybackState.getAdGroupIndexForPositionUs(windowStartTimeUs, -9223372036854775807L);
        if (adGroupIndexForPositionUs != -1) {
            AdPlaybackState.AdGroup adGroup = adPlaybackState.getAdGroup(adGroupIndexForPositionUs);
            while (true) {
                int[] iArr = adGroup.states;
                if (i11 >= iArr.length) {
                    break;
                }
                int i12 = iArr[i11];
                if (i12 == 1 || i12 == 0) {
                    break;
                }
                i11++;
            }
            return new Pair<>(Integer.valueOf(adGroupIndexForPositionUs), Integer.valueOf(i11));
        }
        throw new IllegalStateException(String.format("No unplayed ad group found before or at the start time us %d of the period with index %d", Long.valueOf(windowStartTimeUs), Integer.valueOf(i10)));
    }

    public static Pair<Integer, Integer> getAdGroupAndIndexInVodMultiPeriodTimeline(int i10, AdPlaybackState adPlaybackState, Timeline timeline) {
        int i11;
        AdPlaybackState adPlaybackState2 = adPlaybackState;
        Timeline timeline2 = timeline;
        int i12 = 0;
        Timeline.Window window = timeline2.getWindow(0, new Timeline.Window());
        Assertions.checkArgument(timeline.getWindowCount() == 1);
        long windowStartTimeUs = window.isLive() ? getWindowStartTimeUs(window.windowStartTimeMs, window.positionInFirstPeriodUs) - window.positionInFirstPeriodUs : 0L;
        Timeline.Period period = new Timeline.Period();
        int i13 = adPlaybackState2.removedAdGroupCount;
        int i14 = 0;
        while (i13 < adPlaybackState2.adGroupCount) {
            AdPlaybackState.AdGroup adGroup = adPlaybackState2.getAdGroup(i13);
            long jSum = Util.sum(adGroup.durationsUs);
            int i15 = i12;
            int i16 = i14;
            long j10 = 0;
            while (true) {
                if (i14 >= Math.min(timeline.getPeriodCount(), i10 + 1)) {
                    i11 = i13;
                    break;
                }
                timeline2.getPeriod(i14, period, true);
                i11 = i13;
                long j11 = adGroup.timeUs;
                if (windowStartTimeUs >= j11) {
                    long j12 = period.durationUs;
                    if (windowStartTimeUs + j10 + j12 > j11 + jSum) {
                        windowStartTimeUs = Math.min(j10, adGroup.contentResumeOffsetUs) + windowStartTimeUs;
                        break;
                    }
                    if (i14 == i10) {
                        return new Pair<>(Integer.valueOf(i11), Integer.valueOf(i15));
                    }
                    j10 += j12;
                    i15++;
                } else {
                    windowStartTimeUs += period.durationUs;
                }
                i16++;
                i14++;
                timeline2 = timeline;
                i13 = i11;
            }
            i13 = i11 + 1;
            adPlaybackState2 = adPlaybackState;
            timeline2 = timeline;
            i14 = i16;
            i12 = 0;
        }
        throw new IllegalStateException();
    }

    public static long getAdGroupDurationUsForLiveAdPeriodIndex(Timeline timeline, AdPodInfo adPodInfo, int i10, Timeline.Window window, Timeline.Period period) {
        long j10;
        timeline.getPeriod(i10, period);
        timeline.getWindow(period.windowIndex, window);
        Assertions.checkArgument(window.isLive());
        int adPosition = i10 - (adPodInfo.getAdPosition() - 1);
        int totalAds = ((adPodInfo.getTotalAds() - r11) - 1) + i10;
        if (window.firstPeriodIndex > adPosition || totalAds >= window.lastPeriodIndex) {
            j10 = -9223372036854775807L;
            break;
        }
        Timeline.Period period2 = new Timeline.Period();
        j10 = 0;
        while (adPosition <= totalAds) {
            long j11 = timeline.getPeriod(adPosition, period2).durationUs;
            if (j11 == -9223372036854775807L) {
                j10 = -9223372036854775807L;
                break;
            }
            j10 += j11;
            adPosition++;
        }
        return j10 != -9223372036854775807L ? j10 : secToUsRounded(adPodInfo.getMaxDuration());
    }

    public static long[] getAdGroupTimesUsForCuePoints(List<Float> list) {
        if (list.isEmpty()) {
            return new long[]{0};
        }
        int size = list.size();
        long[] jArr = new long[size];
        int i10 = 0;
        for (int i11 = 0; i11 < size; i11++) {
            double dFloatValue = list.get(i11).floatValue();
            if (dFloatValue == -1.0d) {
                jArr[size - 1] = Long.MIN_VALUE;
            } else {
                jArr[i10] = Math.round(dFloatValue * 1000000.0d);
                i10++;
            }
        }
        Arrays.sort(jArr, 0, i10);
        return jArr;
    }

    public static AdsRequest getAdsRequestForAdTagDataSpec(ImaFactory imaFactory, DataSpec dataSpec) throws IOException {
        AdsRequest adsRequestCreateAdsRequest = imaFactory.createAdsRequest();
        if ("data".equals(dataSpec.uri.getScheme())) {
            DataSchemeDataSource dataSchemeDataSource = new DataSchemeDataSource();
            try {
                dataSchemeDataSource.open(dataSpec);
                adsRequestCreateAdsRequest.setAdsResponse(Util.fromUtf8Bytes(DataSourceUtil.readToEnd(dataSchemeDataSource)));
            } finally {
                dataSchemeDataSource.close();
            }
        } else {
            adsRequestCreateAdsRequest.setAdTagUrl(dataSpec.uri.toString());
        }
        return adsRequestCreateAdsRequest;
    }

    public static FriendlyObstructionPurpose getFriendlyObstructionPurpose(int i10) {
        return i10 != 1 ? i10 != 2 ? i10 != 4 ? FriendlyObstructionPurpose.OTHER : FriendlyObstructionPurpose.NOT_VISIBLE : FriendlyObstructionPurpose.CLOSE_AD : FriendlyObstructionPurpose.VIDEO_CONTROLS;
    }

    public static Looper getImaLooper() {
        return Looper.getMainLooper();
    }

    private static int getNextUnavailableAdIndex(AdPlaybackState.AdGroup adGroup) {
        int i10 = 0;
        while (true) {
            int[] iArr = adGroup.states;
            if (i10 >= iArr.length) {
                return iArr.length;
            }
            if (iArr[i10] == 0) {
                return i10;
            }
            i10++;
        }
    }

    public static String getStringForVideoProgressUpdate(VideoProgressUpdate videoProgressUpdate) {
        return VideoProgressUpdate.VIDEO_TIME_NOT_READY.equals(videoProgressUpdate) ? "not ready" : Util.formatInvariant("%d ms of %d ms", Long.valueOf(videoProgressUpdate.getCurrentTimeMs()), Long.valueOf(videoProgressUpdate.getDurationMs()));
    }

    public static long getWindowStartTimeUs(long j10, long j11) {
        return (j11 % 1000) + Util.msToUs(j10);
    }

    @CheckResult
    public static AdPlaybackState handleAdPeriodRemovedFromTimeline(int i10, Timeline timeline, AdPlaybackState adPlaybackState) {
        AdPlaybackState adPlaybackStateWithSkippedAd = adPlaybackState;
        Timeline.Period period = timeline.getPeriod(i10, new Timeline.Period());
        Timeline.Window window = timeline.getWindow(period.windowIndex, new Timeline.Window());
        long windowStartTimeUs = getWindowStartTimeUs(window.windowStartTimeMs, window.positionInFirstPeriodUs) + period.positionInWindowUs;
        int adGroupIndexForPositionUs = adPlaybackStateWithSkippedAd.getAdGroupIndexForPositionUs(windowStartTimeUs, -9223372036854775807L);
        int i11 = -1;
        if (adGroupIndexForPositionUs != -1) {
            AdPlaybackState.AdGroup adGroup = adPlaybackStateWithSkippedAd.getAdGroup(adGroupIndexForPositionUs);
            if (adGroup.timeUs + adGroup.contentResumeOffsetUs > windowStartTimeUs) {
                long j10 = 0;
                int i12 = 0;
                while (true) {
                    int[] iArr = adGroup.states;
                    if (i12 >= iArr.length) {
                        break;
                    }
                    int i13 = iArr[i12];
                    if (i13 == 1) {
                        i11 = i12;
                    }
                    long j11 = adGroup.timeUs;
                    if (windowStartTimeUs <= j11 + j10) {
                        if (windowStartTimeUs == j11 + j10) {
                            if (i13 == 1 || i13 == 3) {
                                return adPlaybackStateWithSkippedAd;
                            }
                            if (i13 == 0 && i11 == i12 - 1) {
                                long j12 = period.durationUs;
                                if (j12 == -9223372036854775807L) {
                                    return adPlaybackStateWithSkippedAd;
                                }
                                AdPlaybackState adPlaybackStateUpdateAdDurationInAdGroup = updateAdDurationInAdGroup(adGroupIndexForPositionUs, i12, j12, adPlaybackStateWithSkippedAd);
                                return adPlaybackStateUpdateAdDurationInAdGroup.withContentResumeOffsetUs(adGroupIndexForPositionUs, Util.sum(adPlaybackStateUpdateAdDurationInAdGroup.getAdGroup(adGroupIndexForPositionUs).durationsUs));
                            }
                        }
                        AdPlaybackState adPlaybackStateMarkAdGroupAsPlayed = markAdGroupAsPlayed(adGroupIndexForPositionUs, false, adPlaybackStateWithSkippedAd);
                        long j13 = period.durationUs;
                        return j13 != -9223372036854775807L ? addLiveAdBreak(windowStartTimeUs, j13, 1, j13, 1, adPlaybackStateMarkAdGroupAsPlayed) : adPlaybackStateMarkAdGroupAsPlayed;
                    }
                    if (i13 == 1 || i13 == 0) {
                        adPlaybackStateWithSkippedAd = adPlaybackStateWithSkippedAd.withSkippedAd(adGroupIndexForPositionUs, i12);
                    }
                    j10 += adGroup.durationsUs[i12];
                    i12++;
                }
            } else {
                return markAdGroupAsPlayed(adGroupIndexForPositionUs, true, adPlaybackStateWithSkippedAd);
            }
        }
        return adPlaybackStateWithSkippedAd;
    }

    public static boolean isAdGroupLoadError(AdError adError) {
        return adError.getErrorCode() == AdError.AdErrorCode.VAST_LINEAR_ASSET_MISMATCH || adError.getErrorCode() == AdError.AdErrorCode.UNKNOWN_ERROR;
    }

    private static AdPlaybackState markAdGroupAsPlayed(int i10, boolean z10, AdPlaybackState adPlaybackState) {
        AdPlaybackState.AdGroup adGroup = adPlaybackState.getAdGroup(i10);
        int length = adGroup.durationsUs.length;
        long[] jArr = new long[length];
        for (int i11 = 0; i11 < length; i11++) {
            jArr[i11] = z10 ? adGroup.durationsUs[i11] : 0L;
            int i12 = adGroup.states[i11];
            if (i12 == 1 || i12 == 0) {
                adPlaybackState = adPlaybackState.withSkippedAd(i10, i11);
            }
        }
        return adPlaybackState.withAdDurationsUs(i10, jArr).withContentResumeOffsetUs(i10, Util.sum(jArr));
    }

    public static AdPlaybackState maybeCorrectPreviouslyUnknownAdDurations(Timeline timeline, AdPlaybackState adPlaybackState) {
        int i10;
        Timeline.Window window = timeline.getWindow(0, new Timeline.Window());
        if (window.firstPeriodIndex == window.lastPeriodIndex || adPlaybackState.adGroupCount < 2) {
            return adPlaybackState;
        }
        Timeline.Period period = new Timeline.Period();
        int i11 = window.lastPeriodIndex;
        if (timeline.getPeriod(i11, period).durationUs == -9223372036854775807L) {
            i11--;
            timeline.getPeriod(i11, period);
        }
        long windowStartTimeUs = getWindowStartTimeUs(window.windowStartTimeMs, window.positionInFirstPeriodUs);
        int adGroupIndexForPositionUs = adPlaybackState.getAdGroupIndexForPositionUs(period.positionInWindowUs + windowStartTimeUs, -9223372036854775807L);
        if (adGroupIndexForPositionUs == -1) {
            return adPlaybackState;
        }
        AdPlaybackState.AdGroup adGroup = adPlaybackState.getAdGroup(adGroupIndexForPositionUs);
        long j10 = windowStartTimeUs - window.positionInFirstPeriodUs;
        long j11 = adGroup.timeUs;
        if (adGroup.contentResumeOffsetUs + j11 <= j10) {
            return adPlaybackState;
        }
        int i12 = 0;
        while (j11 < j10) {
            if (adGroup.states[i12] == 1) {
                return adPlaybackState;
            }
            j11 += adGroup.durationsUs[i12];
            i12++;
        }
        int i13 = window.firstPeriodIndex;
        while (true) {
            if (i13 > i11) {
                i13 = -1;
                break;
            }
            if (adGroup.timeUs <= j10) {
                break;
            }
            j10 += timeline.getPeriod(i13, period).durationUs;
            i13++;
        }
        Assertions.checkState(i13 != -1);
        for (int i14 = i12; i14 < adGroup.durationsUs.length && (i10 = (i14 - i12) + i13) <= i11; i14++) {
            timeline.getPeriod(i10, period);
            long j12 = period.durationUs;
            if (j12 != adGroup.durationsUs[i14]) {
                adPlaybackState = updateAdDurationInAdGroup(adGroupIndexForPositionUs, i14, j12, adPlaybackState);
            }
        }
        return adPlaybackState.withContentResumeOffsetUs(adGroupIndexForPositionUs, Util.sum(adPlaybackState.getAdGroup(adGroupIndexForPositionUs).durationsUs));
    }

    public static long secToMsRounded(double d10) {
        return com.google.common.math.c.d(BigDecimal.valueOf(d10).scaleByPowerOfTen(3).doubleValue(), RoundingMode.HALF_UP);
    }

    public static long secToUsRounded(double d10) {
        return com.google.common.math.c.d(BigDecimal.valueOf(d10).scaleByPowerOfTen(6).doubleValue(), RoundingMode.HALF_UP);
    }

    @CheckResult
    public static AdPlaybackState splitAdGroup(AdPlaybackState.AdGroup adGroup, int i10, int i11, AdPlaybackState adPlaybackState) {
        int i12 = 0;
        Assertions.checkArgument(i11 > 0 && i11 < adGroup.count);
        AdPlaybackState adPlaybackStateWithLastAdRemoved = adPlaybackState;
        for (int i13 = 0; i13 < adGroup.count - i11; i13++) {
            adPlaybackStateWithLastAdRemoved = adPlaybackStateWithLastAdRemoved.withLastAdRemoved(i10);
        }
        AdPlaybackState.AdGroup adGroup2 = adPlaybackStateWithLastAdRemoved.getAdGroup(i10);
        long j10 = adGroup2.timeUs + adGroup2.contentResumeOffsetUs;
        int[] iArrCopyOfRange = Arrays.copyOfRange(adGroup.states, i11, adGroup.count);
        long[] jArrCopyOfRange = Arrays.copyOfRange(adGroup.durationsUs, i11, adGroup.count);
        long jSum = Util.sum(jArrCopyOfRange);
        AdPlaybackState adPlaybackStateAddLiveAdBreak = adPlaybackStateWithLastAdRemoved;
        while (i12 < iArrCopyOfRange.length && iArrCopyOfRange[i12] == 1) {
            int i14 = i12 + 1;
            adPlaybackStateAddLiveAdBreak = addLiveAdBreak(j10, jArrCopyOfRange[i12], i14, jSum, jArrCopyOfRange.length, adPlaybackStateAddLiveAdBreak);
            jSum -= jArrCopyOfRange[i12];
            i12 = i14;
        }
        return adPlaybackStateAddLiveAdBreak;
    }

    private static AdPlaybackState splitAdGroupForPeriod(Object obj, AdPlaybackState.AdGroup adGroup, long j10, long j11, boolean z10) {
        AdPlaybackState adPlaybackStateWithAdCount = new AdPlaybackState(Assertions.checkNotNull(obj), 0).withIsServerSideInserted(0, true).withAdCount(0, 1);
        if (z10) {
            adPlaybackStateWithAdCount = adPlaybackStateWithAdCount.withLivePostrollPlaceholderAppended(true);
        }
        long j12 = 0;
        for (int i10 = 0; i10 < adGroup.count; i10++) {
            long j13 = j11 != -9223372036854775807L ? j11 : adGroup.durationsUs[i10];
            long j14 = j10 + j13;
            j12 += adGroup.durationsUs[i10];
            if (j14 <= adGroup.timeUs + j12 + 10000) {
                AdPlaybackState adPlaybackStateWithContentResumeOffsetUs = adPlaybackStateWithAdCount.withAdDurationsUs(0, j13).withContentResumeOffsetUs(0, z10 ? j13 : 0L);
                int i11 = adGroup.states[i10];
                return i11 != 1 ? i11 != 2 ? i11 != 3 ? i11 != 4 ? adPlaybackStateWithContentResumeOffsetUs : adPlaybackStateWithContentResumeOffsetUs.withAdLoadError(0, 0) : adPlaybackStateWithContentResumeOffsetUs.withPlayedAd(0, 0) : adPlaybackStateWithContentResumeOffsetUs.withSkippedAd(0, 0) : adPlaybackStateWithContentResumeOffsetUs.withAvailableAd(0, 0);
            }
        }
        return adPlaybackStateWithAdCount;
    }

    /* JADX WARN: Code restructure failed: missing block: B:37:0x0103, code lost:
    
        if (r4.isLive() == false) goto L39;
     */
    /* JADX WARN: Code restructure failed: missing block: B:38:0x0105, code lost:
    
        r17 = r17 + r19;
     */
    /*
        Code decompiled incorrectly, please refer to instructions dump.
    */
    public static ImmutableMap<Object, AdPlaybackState> splitAdPlaybackStateForPeriods(AdPlaybackState adPlaybackState, Timeline timeline) {
        AdPlaybackState adPlaybackStateWithLivePostrollPlaceholderAppended;
        long windowStartTimeUs;
        Object obj;
        HashMap map;
        int i10;
        AdPlaybackState adPlaybackState2;
        int i11;
        AdPlaybackState.AdGroup adGroup;
        AdPlaybackState adPlaybackState3 = adPlaybackState;
        Timeline timeline2 = timeline;
        boolean z10 = true;
        Assertions.checkArgument(!timeline.isEmpty());
        Timeline.Period period = new Timeline.Period();
        boolean z11 = false;
        Timeline.Window window = timeline2.getWindow(0, new Timeline.Window());
        Object objCheckNotNull = Assertions.checkNotNull(adPlaybackState3.adsId);
        AdPlaybackState adPlaybackState4 = new AdPlaybackState(objCheckNotNull, new long[0]);
        if (window.isLive()) {
            windowStartTimeUs = getWindowStartTimeUs(window.windowStartTimeMs, window.positionInFirstPeriodUs) - window.positionInFirstPeriodUs;
            adPlaybackStateWithLivePostrollPlaceholderAppended = adPlaybackState4.withLivePostrollPlaceholderAppended(true);
        } else {
            adPlaybackStateWithLivePostrollPlaceholderAppended = adPlaybackState4;
            windowStartTimeUs = 0;
        }
        HashMap map2 = new HashMap();
        int i12 = adPlaybackState3.removedAdGroupCount;
        int i13 = 0;
        while (true) {
            if (i12 >= adPlaybackState3.adGroupCount) {
                break;
            }
            AdPlaybackState.AdGroup adGroup2 = adPlaybackState3.getAdGroup(i12);
            if (adGroup2.timeUs == Long.MIN_VALUE) {
                if (i12 == adPlaybackState3.adGroupCount - (z10 ? 1 : 0)) {
                    z11 = z10 ? 1 : 0;
                }
                Assertions.checkState(z11);
            } else {
                long jSum = Util.sum(adGroup2.durationsUs);
                int i14 = z11 ? 1 : 0;
                int i15 = i13;
                long j10 = windowStartTimeUs;
                long j11 = 0;
                int i16 = i15;
                while (true) {
                    if (i16 >= timeline.getPeriodCount()) {
                        obj = objCheckNotNull;
                        break;
                    }
                    timeline2.getPeriod(i16, period, z10);
                    long j12 = adGroup2.timeUs;
                    if (j10 >= j12) {
                        long j13 = j10 + j11;
                        obj = objCheckNotNull;
                        long j14 = period.durationUs;
                        if ((j14 != -9223372036854775807L && j13 + j14 <= j12 + jSum) || (j14 == -9223372036854775807L && j11 < jSum && j13 < j12 + jSum)) {
                            i11 = i16;
                            adGroup = adGroup2;
                            map = map2;
                            i10 = i12;
                            adPlaybackState2 = adPlaybackStateWithLivePostrollPlaceholderAppended;
                            map.put(Assertions.checkNotNull(period.uid), splitAdGroupForPeriod(obj, adGroup2, j13, j14, window.isLive()));
                            i15++;
                            int i17 = (i14 == true ? 1 : 0) + 1;
                            j11 += j14;
                            int i18 = adGroup.originalCount;
                            int i19 = adGroup.count;
                            if ((i18 > i19 && i19 == i17) || j13 + j14 == adGroup.timeUs + jSum) {
                                break;
                            }
                            i14 = i17;
                        } else {
                            break;
                        }
                    } else {
                        map2.put(Assertions.checkNotNull(period.uid), adPlaybackStateWithLivePostrollPlaceholderAppended);
                        j10 += period.durationUs;
                        i15++;
                        obj = objCheckNotNull;
                        i11 = i16;
                        adGroup = adGroup2;
                        map = map2;
                        i10 = i12;
                        adPlaybackState2 = adPlaybackStateWithLivePostrollPlaceholderAppended;
                    }
                    i16 = i11 + 1;
                    adGroup2 = adGroup;
                    map2 = map;
                    objCheckNotNull = obj;
                    i12 = i10;
                    adPlaybackStateWithLivePostrollPlaceholderAppended = adPlaybackState2;
                    z10 = true;
                    timeline2 = timeline;
                }
                map = map2;
                i10 = i12;
                adPlaybackState2 = adPlaybackStateWithLivePostrollPlaceholderAppended;
                i13 = i15;
                windowStartTimeUs = j10;
                i12 = i10 + 1;
                adPlaybackState3 = adPlaybackState;
                map2 = map;
                objCheckNotNull = obj;
                adPlaybackStateWithLivePostrollPlaceholderAppended = adPlaybackState2;
                z10 = true;
                z11 = false;
                timeline2 = timeline;
            }
        }
        HashMap map3 = map2;
        AdPlaybackState adPlaybackState5 = adPlaybackStateWithLivePostrollPlaceholderAppended;
        while (i13 < timeline.getPeriodCount()) {
            HashMap map4 = map3;
            timeline.getPeriod(i13, period, true);
            map4.put(Assertions.checkNotNull(period.uid), adPlaybackState5);
            i13++;
            map3 = map4;
        }
        return ImmutableMap.b(map3);
    }

    private static long[] updateAdDurationAndPropagate(long[] jArr, int i10, long j10, long j11) {
        jArr[i10] = j10;
        int length = (i10 + 1) % jArr.length;
        if (jArr[length] == 0) {
            jArr[length] = Math.max(0L, j11 - j10);
        }
        return jArr;
    }

    @CheckResult
    public static AdPlaybackState updateAdDurationInAdGroup(int i10, int i11, long j10, AdPlaybackState adPlaybackState) {
        AdPlaybackState.AdGroup adGroup = adPlaybackState.getAdGroup(i10);
        Assertions.checkArgument(i11 < adGroup.durationsUs.length);
        long[] jArr = adGroup.durationsUs;
        return adPlaybackState.withAdDurationsUs(i10, updateAdDurationAndPropagate(Arrays.copyOf(jArr, jArr.length), i11, j10, adGroup.durationsUs[i11]));
    }
}