package androidx.media3.exoplayer.hls.playlist;

import F3.AbstractC0220u;
import android.net.Uri;
import android.text.TextUtils;
import android.util.Base64;
import androidx.media3.common.C;
import androidx.media3.common.DrmInitData;
import androidx.media3.common.Format;
import androidx.media3.common.Metadata;
import androidx.media3.common.MimeTypes;
import androidx.media3.common.ParserException;
import androidx.media3.common.util.Assertions;
import androidx.media3.common.util.Log;
import androidx.media3.common.util.UnstableApi;
import androidx.media3.common.util.UriUtil;
import androidx.media3.common.util.Util;
import androidx.media3.exoplayer.hls.HlsTrackMetadataEntry;
import androidx.media3.exoplayer.hls.playlist.HlsMediaPlaylist;
import androidx.media3.exoplayer.hls.playlist.HlsMultivariantPlaylist;
import androidx.media3.exoplayer.upstream.ParsingLoadable;
import androidx.media3.extractor.mp4.PsshAtomUtil;
import com.google.firebase.sessions.settings.RemoteSettings;
import com.revenuecat.purchases.common.Constants;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.math.BigDecimal;
import java.util.ArrayDeque;
import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.NoSuchElementException;
import java.util.Queue;
import java.util.TreeMap;
import java.util.UUID;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

/* JADX INFO: loaded from: classes.dex */
@UnstableApi
public final class HlsPlaylistParser implements ParsingLoadable.Parser<HlsPlaylist> {
    private static final String ATTR_CLOSED_CAPTIONS_NONE = "CLOSED-CAPTIONS=NONE";
    private static final String BOOLEAN_FALSE = "NO";
    private static final String BOOLEAN_TRUE = "YES";
    private static final String KEYFORMAT_IDENTITY = "identity";
    private static final String KEYFORMAT_PLAYREADY = "com.microsoft.playready";
    private static final String KEYFORMAT_WIDEVINE_PSSH_BINARY = "urn:uuid:edef8ba9-79d6-4ace-a3c8-27dcd51d21ed";
    private static final String KEYFORMAT_WIDEVINE_PSSH_JSON = "com.widevine";
    private static final String LOG_TAG = "HlsPlaylistParser";
    private static final String METHOD_AES_128 = "AES-128";
    private static final String METHOD_NONE = "NONE";
    private static final String METHOD_SAMPLE_AES = "SAMPLE-AES";
    private static final String METHOD_SAMPLE_AES_CENC = "SAMPLE-AES-CENC";
    private static final String METHOD_SAMPLE_AES_CTR = "SAMPLE-AES-CTR";
    private static final String PLAYLIST_HEADER = "#EXTM3U";
    private static final String TAG_BYTERANGE = "#EXT-X-BYTERANGE";
    private static final String TAG_DEFINE = "#EXT-X-DEFINE";
    private static final String TAG_DISCONTINUITY = "#EXT-X-DISCONTINUITY";
    private static final String TAG_DISCONTINUITY_SEQUENCE = "#EXT-X-DISCONTINUITY-SEQUENCE";
    private static final String TAG_ENDLIST = "#EXT-X-ENDLIST";
    private static final String TAG_GAP = "#EXT-X-GAP";
    private static final String TAG_IFRAME = "#EXT-X-I-FRAMES-ONLY";
    private static final String TAG_INDEPENDENT_SEGMENTS = "#EXT-X-INDEPENDENT-SEGMENTS";
    private static final String TAG_INIT_SEGMENT = "#EXT-X-MAP";
    private static final String TAG_I_FRAME_STREAM_INF = "#EXT-X-I-FRAME-STREAM-INF";
    private static final String TAG_KEY = "#EXT-X-KEY";
    private static final String TAG_MEDIA = "#EXT-X-MEDIA";
    private static final String TAG_MEDIA_DURATION = "#EXTINF";
    private static final String TAG_MEDIA_SEQUENCE = "#EXT-X-MEDIA-SEQUENCE";
    private static final String TAG_PART = "#EXT-X-PART";
    private static final String TAG_PART_INF = "#EXT-X-PART-INF";
    private static final String TAG_PLAYLIST_TYPE = "#EXT-X-PLAYLIST-TYPE";
    private static final String TAG_PREFIX = "#EXT";
    private static final String TAG_PRELOAD_HINT = "#EXT-X-PRELOAD-HINT";
    private static final String TAG_PROGRAM_DATE_TIME = "#EXT-X-PROGRAM-DATE-TIME";
    private static final String TAG_RENDITION_REPORT = "#EXT-X-RENDITION-REPORT";
    private static final String TAG_SERVER_CONTROL = "#EXT-X-SERVER-CONTROL";
    private static final String TAG_SESSION_KEY = "#EXT-X-SESSION-KEY";
    private static final String TAG_SKIP = "#EXT-X-SKIP";
    private static final String TAG_START = "#EXT-X-START";
    private static final String TAG_STREAM_INF = "#EXT-X-STREAM-INF";
    private static final String TAG_TARGET_DURATION = "#EXT-X-TARGETDURATION";
    private static final String TAG_VERSION = "#EXT-X-VERSION";
    private static final String TYPE_AUDIO = "AUDIO";
    private static final String TYPE_CLOSED_CAPTIONS = "CLOSED-CAPTIONS";
    private static final String TYPE_MAP = "MAP";
    private static final String TYPE_PART = "PART";
    private static final String TYPE_SUBTITLES = "SUBTITLES";
    private static final String TYPE_VIDEO = "VIDEO";
    private final HlsMultivariantPlaylist multivariantPlaylist;
    private final HlsMediaPlaylist previousMediaPlaylist;
    private static final Pattern REGEX_AVERAGE_BANDWIDTH = Pattern.compile("AVERAGE-BANDWIDTH=(\\d+)\\b");
    private static final Pattern REGEX_VIDEO = Pattern.compile("VIDEO=\"(.+?)\"");
    private static final Pattern REGEX_AUDIO = Pattern.compile("AUDIO=\"(.+?)\"");
    private static final Pattern REGEX_SUBTITLES = Pattern.compile("SUBTITLES=\"(.+?)\"");
    private static final Pattern REGEX_CLOSED_CAPTIONS = Pattern.compile("CLOSED-CAPTIONS=\"(.+?)\"");
    private static final Pattern REGEX_BANDWIDTH = Pattern.compile("[^-]BANDWIDTH=(\\d+)\\b");
    private static final Pattern REGEX_CHANNELS = Pattern.compile("CHANNELS=\"(.+?)\"");
    private static final Pattern REGEX_CODECS = Pattern.compile("CODECS=\"(.+?)\"");
    private static final Pattern REGEX_RESOLUTION = Pattern.compile("RESOLUTION=(\\d+x\\d+)");
    private static final Pattern REGEX_FRAME_RATE = Pattern.compile("FRAME-RATE=([\\d\\.]+)\\b");
    private static final Pattern REGEX_TARGET_DURATION = Pattern.compile("#EXT-X-TARGETDURATION:(\\d+)\\b");
    private static final Pattern REGEX_ATTR_DURATION = Pattern.compile("DURATION=([\\d\\.]+)\\b");
    private static final Pattern REGEX_PART_TARGET_DURATION = Pattern.compile("PART-TARGET=([\\d\\.]+)\\b");
    private static final Pattern REGEX_VERSION = Pattern.compile("#EXT-X-VERSION:(\\d+)\\b");
    private static final Pattern REGEX_PLAYLIST_TYPE = Pattern.compile("#EXT-X-PLAYLIST-TYPE:(.+)\\b");
    private static final Pattern REGEX_CAN_SKIP_UNTIL = Pattern.compile("CAN-SKIP-UNTIL=([\\d\\.]+)\\b");
    private static final Pattern REGEX_CAN_SKIP_DATE_RANGES = compileBooleanAttrPattern("CAN-SKIP-DATERANGES");
    private static final Pattern REGEX_SKIPPED_SEGMENTS = Pattern.compile("SKIPPED-SEGMENTS=(\\d+)\\b");
    private static final Pattern REGEX_HOLD_BACK = Pattern.compile("[:|,]HOLD-BACK=([\\d\\.]+)\\b");
    private static final Pattern REGEX_PART_HOLD_BACK = Pattern.compile("PART-HOLD-BACK=([\\d\\.]+)\\b");
    private static final Pattern REGEX_CAN_BLOCK_RELOAD = compileBooleanAttrPattern("CAN-BLOCK-RELOAD");
    private static final Pattern REGEX_MEDIA_SEQUENCE = Pattern.compile("#EXT-X-MEDIA-SEQUENCE:(\\d+)\\b");
    private static final Pattern REGEX_MEDIA_DURATION = Pattern.compile("#EXTINF:([\\d\\.]+)\\b");
    private static final Pattern REGEX_MEDIA_TITLE = Pattern.compile("#EXTINF:[\\d\\.]+\\b,(.+)");
    private static final Pattern REGEX_LAST_MSN = Pattern.compile("LAST-MSN=(\\d+)\\b");
    private static final Pattern REGEX_LAST_PART = Pattern.compile("LAST-PART=(\\d+)\\b");
    private static final Pattern REGEX_TIME_OFFSET = Pattern.compile("TIME-OFFSET=(-?[\\d\\.]+)\\b");
    private static final Pattern REGEX_BYTERANGE = Pattern.compile("#EXT-X-BYTERANGE:(\\d+(?:@\\d+)?)\\b");
    private static final Pattern REGEX_ATTR_BYTERANGE = Pattern.compile("BYTERANGE=\"(\\d+(?:@\\d+)?)\\b\"");
    private static final Pattern REGEX_BYTERANGE_START = Pattern.compile("BYTERANGE-START=(\\d+)\\b");
    private static final Pattern REGEX_BYTERANGE_LENGTH = Pattern.compile("BYTERANGE-LENGTH=(\\d+)\\b");
    private static final Pattern REGEX_METHOD = Pattern.compile("METHOD=(NONE|AES-128|SAMPLE-AES|SAMPLE-AES-CENC|SAMPLE-AES-CTR)\\s*(?:,|$)");
    private static final Pattern REGEX_KEYFORMAT = Pattern.compile("KEYFORMAT=\"(.+?)\"");
    private static final Pattern REGEX_KEYFORMATVERSIONS = Pattern.compile("KEYFORMATVERSIONS=\"(.+?)\"");
    private static final Pattern REGEX_URI = Pattern.compile("URI=\"(.+?)\"");
    private static final Pattern REGEX_IV = Pattern.compile("IV=([^,.*]+)");
    private static final Pattern REGEX_TYPE = Pattern.compile("TYPE=(AUDIO|VIDEO|SUBTITLES|CLOSED-CAPTIONS)");
    private static final Pattern REGEX_PRELOAD_HINT_TYPE = Pattern.compile("TYPE=(PART|MAP)");
    private static final Pattern REGEX_LANGUAGE = Pattern.compile("LANGUAGE=\"(.+?)\"");
    private static final Pattern REGEX_NAME = Pattern.compile("NAME=\"(.+?)\"");
    private static final Pattern REGEX_GROUP_ID = Pattern.compile("GROUP-ID=\"(.+?)\"");
    private static final Pattern REGEX_CHARACTERISTICS = Pattern.compile("CHARACTERISTICS=\"(.+?)\"");
    private static final Pattern REGEX_INSTREAM_ID = Pattern.compile("INSTREAM-ID=\"((?:CC|SERVICE)\\d+)\"");
    private static final Pattern REGEX_AUTOSELECT = compileBooleanAttrPattern("AUTOSELECT");
    private static final Pattern REGEX_DEFAULT = compileBooleanAttrPattern("DEFAULT");
    private static final Pattern REGEX_FORCED = compileBooleanAttrPattern("FORCED");
    private static final Pattern REGEX_INDEPENDENT = compileBooleanAttrPattern("INDEPENDENT");
    private static final Pattern REGEX_GAP = compileBooleanAttrPattern("GAP");
    private static final Pattern REGEX_PRECISE = compileBooleanAttrPattern("PRECISE");
    private static final Pattern REGEX_VALUE = Pattern.compile("VALUE=\"(.+?)\"");
    private static final Pattern REGEX_IMPORT = Pattern.compile("IMPORT=\"(.+?)\"");
    private static final Pattern REGEX_VARIABLE_REFERENCE = Pattern.compile("\\{\\$([a-zA-Z0-9\\-_]+)\\}");

    public static final class DeltaUpdateException extends IOException {
    }

    public static class LineIterator {
        private final Queue<String> extraLines;
        private String next;
        private final BufferedReader reader;

        public LineIterator(Queue<String> queue, BufferedReader bufferedReader) {
            this.extraLines = queue;
            this.reader = bufferedReader;
        }

        public boolean hasNext() throws IOException {
            String strTrim;
            if (this.next != null) {
                return true;
            }
            if (!this.extraLines.isEmpty()) {
                this.next = (String) Assertions.checkNotNull(this.extraLines.poll());
                return true;
            }
            do {
                String line = this.reader.readLine();
                this.next = line;
                if (line == null) {
                    return false;
                }
                strTrim = line.trim();
                this.next = strTrim;
            } while (strTrim.isEmpty());
            return true;
        }

        public String next() {
            if (!hasNext()) {
                throw new NoSuchElementException();
            }
            String str = this.next;
            this.next = null;
            return str;
        }
    }

    public HlsPlaylistParser() {
        this(HlsMultivariantPlaylist.EMPTY, null);
    }

    private static boolean checkPlaylistHeader(BufferedReader bufferedReader) throws IOException {
        int i6 = bufferedReader.read();
        if (i6 == 239) {
            if (bufferedReader.read() != 187 || bufferedReader.read() != 191) {
                return false;
            }
            i6 = bufferedReader.read();
        }
        int iSkipIgnorableWhitespace = skipIgnorableWhitespace(bufferedReader, true, i6);
        for (int i7 = 0; i7 < 7; i7++) {
            if (iSkipIgnorableWhitespace != PLAYLIST_HEADER.charAt(i7)) {
                return false;
            }
            iSkipIgnorableWhitespace = bufferedReader.read();
        }
        return Util.isLinebreak(skipIgnorableWhitespace(bufferedReader, false, iSkipIgnorableWhitespace));
    }

    private static Pattern compileBooleanAttrPattern(String str) {
        return Pattern.compile(str + "=(NO|YES)");
    }

    private static DrmInitData getPlaylistProtectionSchemes(String str, DrmInitData.SchemeData[] schemeDataArr) {
        DrmInitData.SchemeData[] schemeDataArr2 = new DrmInitData.SchemeData[schemeDataArr.length];
        for (int i6 = 0; i6 < schemeDataArr.length; i6++) {
            schemeDataArr2[i6] = schemeDataArr[i6].copyWithData(null);
        }
        return new DrmInitData(str, schemeDataArr2);
    }

    private static String getSegmentEncryptionIV(long j4, String str, String str2) {
        if (str == null) {
            return null;
        }
        return str2 != null ? str2 : Long.toHexString(j4);
    }

    private static HlsMultivariantPlaylist.Variant getVariantWithAudioGroup(ArrayList<HlsMultivariantPlaylist.Variant> arrayList, String str) {
        for (int i6 = 0; i6 < arrayList.size(); i6++) {
            HlsMultivariantPlaylist.Variant variant = arrayList.get(i6);
            if (str.equals(variant.audioGroupId)) {
                return variant;
            }
        }
        return null;
    }

    private static HlsMultivariantPlaylist.Variant getVariantWithSubtitleGroup(ArrayList<HlsMultivariantPlaylist.Variant> arrayList, String str) {
        for (int i6 = 0; i6 < arrayList.size(); i6++) {
            HlsMultivariantPlaylist.Variant variant = arrayList.get(i6);
            if (str.equals(variant.subtitleGroupId)) {
                return variant;
            }
        }
        return null;
    }

    private static HlsMultivariantPlaylist.Variant getVariantWithVideoGroup(ArrayList<HlsMultivariantPlaylist.Variant> arrayList, String str) {
        for (int i6 = 0; i6 < arrayList.size(); i6++) {
            HlsMultivariantPlaylist.Variant variant = arrayList.get(i6);
            if (str.equals(variant.videoGroupId)) {
                return variant;
            }
        }
        return null;
    }

    private static double parseDoubleAttr(String str, Pattern pattern) {
        return Double.parseDouble(parseStringAttr(str, pattern, Collections.EMPTY_MAP));
    }

    private static DrmInitData.SchemeData parseDrmSchemeData(String str, String str2, Map<String, String> map) throws ParserException {
        String optionalStringAttr = parseOptionalStringAttr(str, REGEX_KEYFORMATVERSIONS, "1", map);
        if (KEYFORMAT_WIDEVINE_PSSH_BINARY.equals(str2)) {
            String stringAttr = parseStringAttr(str, REGEX_URI, map);
            return new DrmInitData.SchemeData(C.WIDEVINE_UUID, MimeTypes.VIDEO_MP4, Base64.decode(stringAttr.substring(stringAttr.indexOf(44)), 0));
        }
        if (KEYFORMAT_WIDEVINE_PSSH_JSON.equals(str2)) {
            return new DrmInitData.SchemeData(C.WIDEVINE_UUID, "hls", Util.getUtf8Bytes(str));
        }
        if (!KEYFORMAT_PLAYREADY.equals(str2) || !"1".equals(optionalStringAttr)) {
            return null;
        }
        String stringAttr2 = parseStringAttr(str, REGEX_URI, map);
        byte[] bArrDecode = Base64.decode(stringAttr2.substring(stringAttr2.indexOf(44)), 0);
        UUID uuid = C.PLAYREADY_UUID;
        return new DrmInitData.SchemeData(uuid, MimeTypes.VIDEO_MP4, PsshAtomUtil.buildPsshAtom(uuid, bArrDecode));
    }

    private static String parseEncryptionScheme(String str) {
        return (METHOD_SAMPLE_AES_CENC.equals(str) || METHOD_SAMPLE_AES_CTR.equals(str)) ? C.CENC_TYPE_cenc : C.CENC_TYPE_cbcs;
    }

    private static int parseIntAttr(String str, Pattern pattern) {
        return Integer.parseInt(parseStringAttr(str, pattern, Collections.EMPTY_MAP));
    }

    private static long parseLongAttr(String str, Pattern pattern) {
        return Long.parseLong(parseStringAttr(str, pattern, Collections.EMPTY_MAP));
    }

    /* JADX WARN: Removed duplicated region for block: B:113:0x031a A[PHI: r13
      0x031a: PHI (r13v7 java.lang.String) = (r13v5 java.lang.String), (r13v2 java.lang.String) binds: [B:117:0x0329, B:111:0x030d] A[DONT_GENERATE, DONT_INLINE]] */
    /* JADX WARN: Removed duplicated region for block: B:226:0x0608  */
    /* JADX WARN: Removed duplicated region for block: B:228:0x0615  */
    /* JADX WARN: Removed duplicated region for block: B:231:0x062b  */
    /*
        Code decompiled incorrectly, please refer to instructions dump.
    */
    private static HlsMediaPlaylist parseMediaPlaylist(HlsMultivariantPlaylist hlsMultivariantPlaylist, HlsMediaPlaylist hlsMediaPlaylist, LineIterator lineIterator, String str) throws DeltaUpdateException, ParserException {
        HlsMediaPlaylist.ServerControl serverControl;
        TreeMap treeMap;
        long j4;
        HlsMediaPlaylist.Segment segment;
        int i6;
        long j6;
        long j7;
        long j8;
        long j9;
        long j10;
        HlsMediaPlaylist.Segment segment2;
        long j11;
        boolean z6;
        DrmInitData drmInitData;
        DrmInitData playlistProtectionSchemes;
        HlsMultivariantPlaylist hlsMultivariantPlaylist2 = hlsMultivariantPlaylist;
        HlsMediaPlaylist hlsMediaPlaylist2 = hlsMediaPlaylist;
        boolean z7 = hlsMultivariantPlaylist2.hasIndependentSegments;
        HashMap map = new HashMap();
        HashMap map2 = new HashMap();
        ArrayList arrayList = new ArrayList();
        ArrayList arrayList2 = new ArrayList();
        ArrayList arrayList3 = new ArrayList();
        ArrayList arrayList4 = new ArrayList();
        HlsMediaPlaylist.ServerControl serverControl2 = new HlsMediaPlaylist.ServerControl(C.TIME_UNSET, false, C.TIME_UNSET, C.TIME_UNSET, false);
        TreeMap treeMap2 = new TreeMap();
        boolean z8 = z7;
        long j12 = -9223372036854775807L;
        long doubleAttr = -9223372036854775807L;
        long j13 = 0;
        long j14 = 0;
        long jMsToUs = 0;
        long j15 = 0;
        long longAttr = 0;
        long timeSecondsToUs = 0;
        long j16 = 0;
        String str2 = "";
        String optionalStringAttr = str2;
        boolean optionalBooleanAttribute = false;
        String encryptionScheme = null;
        DrmInitData drmInitData2 = null;
        HlsMediaPlaylist.Part part = null;
        int i7 = 0;
        DrmInitData playlistProtectionSchemes2 = null;
        String str3 = null;
        long j17 = -1;
        boolean z9 = false;
        boolean z10 = false;
        boolean z11 = false;
        int i8 = 0;
        HlsMediaPlaylist.Segment segment3 = null;
        int i9 = 0;
        String stringAttr = null;
        long j18 = -1;
        boolean z12 = false;
        long intAttr = -9223372036854775807L;
        long j19 = 0;
        int intAttr2 = 1;
        while (lineIterator.hasNext()) {
            String next = lineIterator.next();
            if (next.startsWith(TAG_PREFIX)) {
                arrayList4.add(next);
            }
            if (next.startsWith(TAG_PLAYLIST_TYPE)) {
                String stringAttr2 = parseStringAttr(next, REGEX_PLAYLIST_TYPE, map);
                if ("VOD".equals(stringAttr2)) {
                    i7 = 1;
                } else if ("EVENT".equals(stringAttr2)) {
                    i7 = 2;
                }
            } else if (next.equals(TAG_IFRAME)) {
                z12 = true;
            } else {
                if (next.startsWith(TAG_START)) {
                    ArrayList arrayList5 = arrayList4;
                    serverControl = serverControl2;
                    long doubleAttr2 = (long) (parseDoubleAttr(next, REGEX_TIME_OFFSET) * 1000000.0d);
                    optionalBooleanAttribute = parseOptionalBooleanAttribute(next, REGEX_PRECISE, false);
                    arrayList4 = arrayList5;
                    j12 = doubleAttr2;
                } else {
                    ArrayList arrayList6 = arrayList4;
                    serverControl = serverControl2;
                    if (next.startsWith(TAG_SERVER_CONTROL)) {
                        serverControl2 = parseServerControl(next);
                        arrayList4 = arrayList6;
                    } else if (next.startsWith(TAG_PART_INF)) {
                        doubleAttr = (long) (parseDoubleAttr(next, REGEX_PART_TARGET_DURATION) * 1000000.0d);
                        arrayList4 = arrayList6;
                    } else if (next.startsWith(TAG_INIT_SEGMENT)) {
                        String stringAttr3 = parseStringAttr(next, REGEX_URI, map);
                        boolean z13 = optionalBooleanAttribute;
                        String optionalStringAttr2 = parseOptionalStringAttr(next, REGEX_ATTR_BYTERANGE, map);
                        if (optionalStringAttr2 != null) {
                            String[] strArrSplit = Util.split(optionalStringAttr2, "@");
                            j17 = Long.parseLong(strArrSplit[0]);
                            if (strArrSplit.length > 1) {
                                j13 = Long.parseLong(strArrSplit[1]);
                            }
                        }
                        long j20 = j17;
                        long j21 = j20 == j18 ? 0L : j13;
                        if (stringAttr != null && str3 == null) {
                            throw ParserException.createForMalformedManifest("The encryption IV attribute must be present when an initialization segment is encrypted with METHOD=AES-128.", null);
                        }
                        HlsMediaPlaylist.Segment segment4 = new HlsMediaPlaylist.Segment(stringAttr3, j21, j20, stringAttr, str3);
                        String str4 = str3;
                        if (j20 != j18) {
                            j21 += j20;
                        }
                        str3 = str4;
                        arrayList4 = arrayList6;
                        segment3 = segment4;
                        j13 = j21;
                        j17 = j18;
                        serverControl2 = serverControl;
                        optionalBooleanAttribute = z13;
                    } else {
                        boolean z14 = optionalBooleanAttribute;
                        String str5 = str3;
                        String str6 = stringAttr;
                        if (next.startsWith(TAG_TARGET_DURATION)) {
                            intAttr = 1000000 * ((long) parseIntAttr(next, REGEX_TARGET_DURATION));
                        } else {
                            if (next.startsWith(TAG_MEDIA_SEQUENCE)) {
                                longAttr = parseLongAttr(next, REGEX_MEDIA_SEQUENCE);
                                stringAttr = str6;
                                str3 = str5;
                                j19 = longAttr;
                            } else if (next.startsWith(TAG_VERSION)) {
                                intAttr2 = parseIntAttr(next, REGEX_VERSION);
                            } else {
                                if (next.startsWith(TAG_DEFINE)) {
                                    String optionalStringAttr3 = parseOptionalStringAttr(next, REGEX_IMPORT, map);
                                    if (optionalStringAttr3 != null) {
                                        String str7 = hlsMultivariantPlaylist2.variableDefinitions.get(optionalStringAttr3);
                                        if (str7 != null) {
                                            map.put(optionalStringAttr3, str7);
                                        }
                                    } else {
                                        map.put(parseStringAttr(next, REGEX_NAME, map), parseStringAttr(next, REGEX_VALUE, map));
                                    }
                                } else if (next.startsWith(TAG_MEDIA_DURATION)) {
                                    timeSecondsToUs = parseTimeSecondsToUs(next, REGEX_MEDIA_DURATION);
                                    optionalStringAttr = parseOptionalStringAttr(next, REGEX_MEDIA_TITLE, str2, map);
                                } else {
                                    String str8 = str2;
                                    if (next.startsWith(TAG_SKIP)) {
                                        int intAttr3 = parseIntAttr(next, REGEX_SKIPPED_SEGMENTS);
                                        Assertions.checkState(hlsMediaPlaylist2 != null && arrayList.isEmpty());
                                        str2 = str8;
                                        int i10 = (int) (j19 - ((HlsMediaPlaylist) Util.castNonNull(hlsMediaPlaylist2)).mediaSequence);
                                        int i11 = intAttr3 + i10;
                                        if (i10 < 0 || i11 > hlsMediaPlaylist2.segments.size()) {
                                            throw new DeltaUpdateException();
                                        }
                                        stringAttr = str6;
                                        str3 = str5;
                                        long j22 = j14;
                                        while (i10 < i11) {
                                            HlsMediaPlaylist.Segment segmentCopyWith = hlsMediaPlaylist2.segments.get(i10);
                                            int i12 = i10;
                                            if (j19 != hlsMediaPlaylist2.mediaSequence) {
                                                segmentCopyWith = segmentCopyWith.copyWith(j22, (hlsMediaPlaylist2.discontinuitySequence - i8) + segmentCopyWith.relativeDiscontinuitySequence);
                                            }
                                            arrayList.add(segmentCopyWith);
                                            j15 = j22 + segmentCopyWith.durationUs;
                                            long j23 = segmentCopyWith.byteRangeLength;
                                            if (j23 != j18) {
                                                j13 = segmentCopyWith.byteRangeOffset + j23;
                                            }
                                            int i13 = segmentCopyWith.relativeDiscontinuitySequence;
                                            HlsMediaPlaylist.Segment segment5 = segmentCopyWith.initializationSegment;
                                            drmInitData2 = segmentCopyWith.drmInitData;
                                            String str9 = segmentCopyWith.fullSegmentEncryptionKeyUri;
                                            String str10 = segmentCopyWith.encryptionIV;
                                            int i14 = i11;
                                            if (str10 == null || !str10.equals(Long.toHexString(longAttr))) {
                                                str3 = segmentCopyWith.encryptionIV;
                                            }
                                            longAttr++;
                                            i9 = i13;
                                            segment3 = segment5;
                                            stringAttr = str9;
                                            j22 = j15;
                                            i10 = i12 + 1;
                                            i11 = i14;
                                        }
                                        hlsMultivariantPlaylist2 = hlsMultivariantPlaylist;
                                        j14 = j22;
                                    } else {
                                        str2 = str8;
                                        if (next.startsWith(TAG_KEY)) {
                                            String stringAttr4 = parseStringAttr(next, REGEX_METHOD, map);
                                            String optionalStringAttr4 = parseOptionalStringAttr(next, REGEX_KEYFORMAT, KEYFORMAT_IDENTITY, map);
                                            if (METHOD_NONE.equals(stringAttr4)) {
                                                treeMap2.clear();
                                                drmInitData2 = null;
                                                str3 = null;
                                                stringAttr = null;
                                            } else {
                                                String optionalStringAttr5 = parseOptionalStringAttr(next, REGEX_IV, map);
                                                if (!KEYFORMAT_IDENTITY.equals(optionalStringAttr4)) {
                                                    if (encryptionScheme == null) {
                                                        encryptionScheme = parseEncryptionScheme(stringAttr4);
                                                    }
                                                    DrmInitData.SchemeData drmSchemeData = parseDrmSchemeData(next, optionalStringAttr4, map);
                                                    if (drmSchemeData != null) {
                                                        treeMap2.put(optionalStringAttr4, drmSchemeData);
                                                        str3 = optionalStringAttr5;
                                                        drmInitData2 = null;
                                                        stringAttr = null;
                                                    }
                                                } else if (METHOD_AES_128.equals(stringAttr4)) {
                                                    stringAttr = parseStringAttr(next, REGEX_URI, map);
                                                    str3 = optionalStringAttr5;
                                                } else {
                                                    str3 = optionalStringAttr5;
                                                    stringAttr = null;
                                                }
                                            }
                                            hlsMultivariantPlaylist2 = hlsMultivariantPlaylist;
                                        } else {
                                            if (next.startsWith(TAG_BYTERANGE)) {
                                                String[] strArrSplit2 = Util.split(parseStringAttr(next, REGEX_BYTERANGE, map), "@");
                                                j17 = Long.parseLong(strArrSplit2[0]);
                                                if (strArrSplit2.length > 1) {
                                                    j13 = Long.parseLong(strArrSplit2[1]);
                                                }
                                            } else if (next.startsWith(TAG_DISCONTINUITY_SEQUENCE)) {
                                                i8 = Integer.parseInt(next.substring(next.indexOf(58) + 1));
                                                hlsMultivariantPlaylist2 = hlsMultivariantPlaylist;
                                                stringAttr = str6;
                                                str3 = str5;
                                                serverControl2 = serverControl;
                                                optionalBooleanAttribute = z14;
                                                arrayList4 = arrayList6;
                                                z11 = true;
                                            } else if (next.equals(TAG_DISCONTINUITY)) {
                                                i9++;
                                            } else if (next.startsWith(TAG_PROGRAM_DATE_TIME)) {
                                                if (jMsToUs == 0) {
                                                    jMsToUs = Util.msToUs(Util.parseXsDateTime(next.substring(next.indexOf(58) + 1))) - j14;
                                                }
                                            } else if (next.equals(TAG_GAP)) {
                                                hlsMultivariantPlaylist2 = hlsMultivariantPlaylist;
                                                stringAttr = str6;
                                                str3 = str5;
                                                serverControl2 = serverControl;
                                                optionalBooleanAttribute = z14;
                                                arrayList4 = arrayList6;
                                                z9 = true;
                                            } else if (next.equals(TAG_INDEPENDENT_SEGMENTS)) {
                                                hlsMultivariantPlaylist2 = hlsMultivariantPlaylist;
                                                stringAttr = str6;
                                                str3 = str5;
                                                serverControl2 = serverControl;
                                                optionalBooleanAttribute = z14;
                                                arrayList4 = arrayList6;
                                                z8 = true;
                                            } else if (next.equals(TAG_ENDLIST)) {
                                                hlsMultivariantPlaylist2 = hlsMultivariantPlaylist;
                                                stringAttr = str6;
                                                str3 = str5;
                                                serverControl2 = serverControl;
                                                optionalBooleanAttribute = z14;
                                                arrayList4 = arrayList6;
                                                z10 = true;
                                            } else {
                                                if (next.startsWith(TAG_RENDITION_REPORT)) {
                                                    treeMap = treeMap2;
                                                    arrayList3.add(new HlsMediaPlaylist.RenditionReport(Uri.parse(UriUtil.resolve(str, parseStringAttr(next, REGEX_URI, map))), parseOptionalLongAttr(next, REGEX_LAST_MSN, j18), parseOptionalIntAttr(next, REGEX_LAST_PART, -1)));
                                                } else {
                                                    treeMap = treeMap2;
                                                    if (!next.startsWith(TAG_PRELOAD_HINT)) {
                                                        j6 = longAttr;
                                                        if (next.startsWith(TAG_PART)) {
                                                            String segmentEncryptionIV = getSegmentEncryptionIV(j6, str6, str5);
                                                            String stringAttr5 = parseStringAttr(next, REGEX_URI, map);
                                                            long doubleAttr3 = (long) (parseDoubleAttr(next, REGEX_ATTR_DURATION) * 1000000.0d);
                                                            boolean optionalBooleanAttribute2 = parseOptionalBooleanAttribute(next, REGEX_INDEPENDENT, false) | (z8 && arrayList2.isEmpty());
                                                            boolean optionalBooleanAttribute3 = parseOptionalBooleanAttribute(next, REGEX_GAP, false);
                                                            String optionalStringAttr6 = parseOptionalStringAttr(next, REGEX_ATTR_BYTERANGE, map);
                                                            if (optionalStringAttr6 != null) {
                                                                String[] strArrSplit3 = Util.split(optionalStringAttr6, "@");
                                                                long j24 = Long.parseLong(strArrSplit3[0]);
                                                                if (strArrSplit3.length > 1) {
                                                                    j16 = Long.parseLong(strArrSplit3[1]);
                                                                }
                                                                j9 = j24;
                                                            } else {
                                                                j9 = -1;
                                                            }
                                                            long j25 = j9 == -1 ? 0L : j16;
                                                            if (drmInitData2 == null && !treeMap.isEmpty()) {
                                                                DrmInitData.SchemeData[] schemeDataArr = (DrmInitData.SchemeData[]) treeMap.values().toArray(new DrmInitData.SchemeData[0]);
                                                                drmInitData2 = new DrmInitData(encryptionScheme, schemeDataArr);
                                                                if (playlistProtectionSchemes2 == null) {
                                                                    playlistProtectionSchemes2 = getPlaylistProtectionSchemes(encryptionScheme, schemeDataArr);
                                                                }
                                                            }
                                                            DrmInitData drmInitData3 = drmInitData2;
                                                            HlsMediaPlaylist.Segment segment6 = segment3;
                                                            int i15 = i9;
                                                            arrayList2.add(new HlsMediaPlaylist.Part(stringAttr5, segment3, doubleAttr3, i9, j15, drmInitData3, str6, segmentEncryptionIV, j25, j9, optionalBooleanAttribute3, optionalBooleanAttribute2, false));
                                                            j15 += doubleAttr3;
                                                            if (j9 != -1) {
                                                                j25 += j9;
                                                            }
                                                            j16 = j25;
                                                            hlsMultivariantPlaylist2 = hlsMultivariantPlaylist;
                                                            segment3 = segment6;
                                                            stringAttr = str6;
                                                            str3 = str5;
                                                            longAttr = j6;
                                                            i9 = i15;
                                                            drmInitData2 = drmInitData3;
                                                            serverControl2 = serverControl;
                                                            optionalBooleanAttribute = z14;
                                                            arrayList4 = arrayList6;
                                                            treeMap2 = treeMap;
                                                        } else {
                                                            segment = segment3;
                                                            i6 = i9;
                                                            if (next.startsWith("#")) {
                                                                stringAttr = str6;
                                                                j7 = j13;
                                                                j4 = j14;
                                                                j8 = timeSecondsToUs;
                                                                hlsMultivariantPlaylist2 = hlsMultivariantPlaylist;
                                                                segment3 = segment;
                                                                str3 = str5;
                                                                longAttr = j6;
                                                                optionalStringAttr = optionalStringAttr;
                                                                timeSecondsToUs = j8;
                                                                j14 = j4;
                                                                j13 = j7;
                                                                serverControl2 = serverControl;
                                                                optionalBooleanAttribute = z14;
                                                                arrayList4 = arrayList6;
                                                                treeMap2 = treeMap;
                                                                j18 = -1;
                                                                hlsMediaPlaylist2 = hlsMediaPlaylist;
                                                                i9 = i6;
                                                            } else {
                                                                long j26 = j14;
                                                                String segmentEncryptionIV2 = getSegmentEncryptionIV(j6, str6, str5);
                                                                longAttr = j6 + 1;
                                                                String strReplaceVariableReferences = replaceVariableReferences(next, map);
                                                                HlsMediaPlaylist.Segment segment7 = (HlsMediaPlaylist.Segment) map2.get(strReplaceVariableReferences);
                                                                if (j17 == -1) {
                                                                    segment2 = segment7;
                                                                    j11 = 0;
                                                                } else {
                                                                    if (z12 && segment == null && segment7 == null) {
                                                                        j10 = j13;
                                                                        segment7 = new HlsMediaPlaylist.Segment(strReplaceVariableReferences, 0L, j10, null, null);
                                                                        map2.put(strReplaceVariableReferences, segment7);
                                                                    } else {
                                                                        j10 = j13;
                                                                    }
                                                                    segment2 = segment7;
                                                                    j11 = j10;
                                                                }
                                                                if (drmInitData2 != null || treeMap.isEmpty()) {
                                                                    z6 = false;
                                                                } else {
                                                                    z6 = false;
                                                                    DrmInitData.SchemeData[] schemeDataArr2 = (DrmInitData.SchemeData[]) treeMap.values().toArray(new DrmInitData.SchemeData[0]);
                                                                    drmInitData2 = new DrmInitData(encryptionScheme, schemeDataArr2);
                                                                    if (playlistProtectionSchemes2 == null) {
                                                                        playlistProtectionSchemes = getPlaylistProtectionSchemes(encryptionScheme, schemeDataArr2);
                                                                        drmInitData = drmInitData2;
                                                                    }
                                                                    long j27 = timeSecondsToUs;
                                                                    stringAttr = str6;
                                                                    arrayList.add(new HlsMediaPlaylist.Segment(strReplaceVariableReferences, segment == null ? segment : segment2, optionalStringAttr, j27, i6, j26, drmInitData, str6, segmentEncryptionIV2, j11, j17, z9, arrayList2));
                                                                    j15 = j26 + j27;
                                                                    arrayList2 = new ArrayList();
                                                                    if (j17 != -1) {
                                                                        j11 += j17;
                                                                    }
                                                                    j13 = j11;
                                                                    hlsMultivariantPlaylist2 = hlsMultivariantPlaylist;
                                                                    segment3 = segment;
                                                                    str3 = str5;
                                                                    playlistProtectionSchemes2 = playlistProtectionSchemes;
                                                                    z9 = z6;
                                                                    optionalStringAttr = str2;
                                                                    i9 = i6;
                                                                    drmInitData2 = drmInitData;
                                                                    timeSecondsToUs = 0;
                                                                    j14 = j15;
                                                                    serverControl2 = serverControl;
                                                                    optionalBooleanAttribute = z14;
                                                                    arrayList4 = arrayList6;
                                                                    treeMap2 = treeMap;
                                                                    j17 = -1;
                                                                }
                                                                drmInitData = drmInitData2;
                                                                playlistProtectionSchemes = playlistProtectionSchemes2;
                                                                long j272 = timeSecondsToUs;
                                                                stringAttr = str6;
                                                                arrayList.add(new HlsMediaPlaylist.Segment(strReplaceVariableReferences, segment == null ? segment : segment2, optionalStringAttr, j272, i6, j26, drmInitData, str6, segmentEncryptionIV2, j11, j17, z9, arrayList2));
                                                                j15 = j26 + j272;
                                                                arrayList2 = new ArrayList();
                                                                if (j17 != -1) {
                                                                }
                                                                j13 = j11;
                                                                hlsMultivariantPlaylist2 = hlsMultivariantPlaylist;
                                                                segment3 = segment;
                                                                str3 = str5;
                                                                playlistProtectionSchemes2 = playlistProtectionSchemes;
                                                                z9 = z6;
                                                                optionalStringAttr = str2;
                                                                i9 = i6;
                                                                drmInitData2 = drmInitData;
                                                                timeSecondsToUs = 0;
                                                                j14 = j15;
                                                                serverControl2 = serverControl;
                                                                optionalBooleanAttribute = z14;
                                                                arrayList4 = arrayList6;
                                                                treeMap2 = treeMap;
                                                                j17 = -1;
                                                            }
                                                        }
                                                        j18 = -1;
                                                        hlsMediaPlaylist2 = hlsMediaPlaylist;
                                                    } else if (part == null && TYPE_PART.equals(parseStringAttr(next, REGEX_PRELOAD_HINT_TYPE, map))) {
                                                        String stringAttr6 = parseStringAttr(next, REGEX_URI, map);
                                                        long optionalLongAttr = parseOptionalLongAttr(next, REGEX_BYTERANGE_START, -1L);
                                                        long optionalLongAttr2 = parseOptionalLongAttr(next, REGEX_BYTERANGE_LENGTH, -1L);
                                                        long j28 = longAttr;
                                                        String segmentEncryptionIV3 = getSegmentEncryptionIV(j28, str6, str5);
                                                        if (drmInitData2 == null && !treeMap.isEmpty()) {
                                                            DrmInitData.SchemeData[] schemeDataArr3 = (DrmInitData.SchemeData[]) treeMap.values().toArray(new DrmInitData.SchemeData[0]);
                                                            drmInitData2 = new DrmInitData(encryptionScheme, schemeDataArr3);
                                                            if (playlistProtectionSchemes2 == null) {
                                                                playlistProtectionSchemes2 = getPlaylistProtectionSchemes(encryptionScheme, schemeDataArr3);
                                                            }
                                                        }
                                                        DrmInitData drmInitData4 = drmInitData2;
                                                        if (optionalLongAttr == -1 || optionalLongAttr2 != -1) {
                                                            part = new HlsMediaPlaylist.Part(stringAttr6, segment3, 0L, i9, j15, drmInitData4, str6, segmentEncryptionIV3, optionalLongAttr != -1 ? optionalLongAttr : 0L, optionalLongAttr2, false, false, true);
                                                        }
                                                        hlsMultivariantPlaylist2 = hlsMultivariantPlaylist;
                                                        hlsMediaPlaylist2 = hlsMediaPlaylist;
                                                        stringAttr = str6;
                                                        str3 = str5;
                                                        longAttr = j28;
                                                        drmInitData2 = drmInitData4;
                                                        serverControl2 = serverControl;
                                                        optionalBooleanAttribute = z14;
                                                        arrayList4 = arrayList6;
                                                        treeMap2 = treeMap;
                                                        j18 = -1;
                                                    }
                                                }
                                                stringAttr = str6;
                                                j4 = j14;
                                                segment = segment3;
                                                i6 = i9;
                                                j6 = longAttr;
                                                j7 = j13;
                                                j8 = timeSecondsToUs;
                                                hlsMultivariantPlaylist2 = hlsMultivariantPlaylist;
                                                segment3 = segment;
                                                str3 = str5;
                                                longAttr = j6;
                                                optionalStringAttr = optionalStringAttr;
                                                timeSecondsToUs = j8;
                                                j14 = j4;
                                                j13 = j7;
                                                serverControl2 = serverControl;
                                                optionalBooleanAttribute = z14;
                                                arrayList4 = arrayList6;
                                                treeMap2 = treeMap;
                                                j18 = -1;
                                                hlsMediaPlaylist2 = hlsMediaPlaylist;
                                                i9 = i6;
                                            }
                                            hlsMultivariantPlaylist2 = hlsMultivariantPlaylist;
                                        }
                                    }
                                }
                                stringAttr = str6;
                                treeMap = treeMap2;
                                j4 = j14;
                                segment = segment3;
                                i6 = i9;
                                j6 = longAttr;
                                j7 = j13;
                                j8 = timeSecondsToUs;
                                hlsMultivariantPlaylist2 = hlsMultivariantPlaylist;
                                segment3 = segment;
                                str3 = str5;
                                longAttr = j6;
                                optionalStringAttr = optionalStringAttr;
                                timeSecondsToUs = j8;
                                j14 = j4;
                                j13 = j7;
                                serverControl2 = serverControl;
                                optionalBooleanAttribute = z14;
                                arrayList4 = arrayList6;
                                treeMap2 = treeMap;
                                j18 = -1;
                                hlsMediaPlaylist2 = hlsMediaPlaylist;
                                i9 = i6;
                            }
                            serverControl2 = serverControl;
                            optionalBooleanAttribute = z14;
                            arrayList4 = arrayList6;
                        }
                        stringAttr = str6;
                        str3 = str5;
                        serverControl2 = serverControl;
                        optionalBooleanAttribute = z14;
                        arrayList4 = arrayList6;
                    }
                }
                serverControl2 = serverControl;
            }
        }
        boolean z15 = optionalBooleanAttribute;
        ArrayList arrayList7 = arrayList4;
        HlsMediaPlaylist.ServerControl serverControl3 = serverControl2;
        HashMap map3 = new HashMap();
        for (int i16 = 0; i16 < arrayList3.size(); i16++) {
            HlsMediaPlaylist.RenditionReport renditionReport = (HlsMediaPlaylist.RenditionReport) arrayList3.get(i16);
            long size = renditionReport.lastMediaSequence;
            if (size == -1) {
                size = (j19 + ((long) arrayList.size())) - (arrayList2.isEmpty() ? 1L : 0L);
            }
            int size2 = renditionReport.lastPartIndex;
            if (size2 == -1 && doubleAttr != C.TIME_UNSET) {
                size2 = (arrayList2.isEmpty() ? ((HlsMediaPlaylist.Segment) AbstractC0220u.k(arrayList)).parts : arrayList2).size() - 1;
            }
            Uri uri = renditionReport.playlistUri;
            map3.put(uri, new HlsMediaPlaylist.RenditionReport(uri, size, size2));
        }
        if (part != null) {
            arrayList2.add(part);
        }
        return new HlsMediaPlaylist(i7, str, arrayList7, j12, z15, jMsToUs, z11, i8, j19, intAttr2, intAttr, doubleAttr, z8, z10, jMsToUs != 0, playlistProtectionSchemes2, arrayList, arrayList2, serverControl3, map3);
    }

    /* JADX WARN: Can't fix incorrect switch cases order, some code will duplicate */
    /* JADX WARN: Multi-variable type inference failed */
    /* JADX WARN: Removed duplicated region for block: B:42:0x012d  */
    /* JADX WARN: Removed duplicated region for block: B:44:0x0134  */
    /* JADX WARN: Removed duplicated region for block: B:47:0x0151  */
    /* JADX WARN: Removed duplicated region for block: B:49:0x015e  */
    /* JADX WARN: Removed duplicated region for block: B:54:0x01b8  */
    /* JADX WARN: Removed duplicated region for block: B:80:0x02ed  */
    /*
        Code decompiled incorrectly, please refer to instructions dump.
    */
    private static HlsMultivariantPlaylist parseMultivariantPlaylist(LineIterator lineIterator, String str) throws ParserException {
        String str2;
        String stringAttr;
        String stringAttr2;
        Format.Builder language;
        Uri uriResolveToUri;
        Metadata metadata;
        ArrayList arrayList;
        ArrayList arrayList2;
        String mediaMimeType;
        ArrayList arrayList3;
        int i6;
        String str3;
        HlsMultivariantPlaylist.Variant variant;
        String mediaMimeType2;
        int i7;
        ArrayList arrayList4;
        ArrayList arrayList5;
        int i8;
        int i9;
        ArrayList arrayList6;
        ArrayList arrayList7;
        Uri uriResolveToUri2;
        ArrayList arrayList8;
        String str4 = str;
        HashMap map = new HashMap();
        HashMap map2 = new HashMap();
        ArrayList arrayList9 = new ArrayList();
        ArrayList arrayList10 = new ArrayList();
        ArrayList arrayList11 = new ArrayList();
        ArrayList arrayList12 = new ArrayList();
        ArrayList arrayList13 = new ArrayList();
        ArrayList arrayList14 = new ArrayList();
        ArrayList arrayList15 = new ArrayList();
        ArrayList arrayList16 = new ArrayList();
        boolean z6 = false;
        boolean zContains = false;
        while (lineIterator.hasNext()) {
            String next = lineIterator.next();
            if (next.startsWith(TAG_PREFIX)) {
                arrayList16.add(next);
            }
            boolean zStartsWith = next.startsWith(TAG_I_FRAME_STREAM_INF);
            if (next.startsWith(TAG_DEFINE)) {
                map2.put(parseStringAttr(next, REGEX_NAME, map2), parseStringAttr(next, REGEX_VALUE, map2));
            } else {
                if (next.equals(TAG_INDEPENDENT_SEGMENTS)) {
                    arrayList7 = arrayList11;
                    arrayList6 = arrayList12;
                    arrayList4 = arrayList15;
                    arrayList5 = arrayList16;
                    z6 = true;
                } else if (next.startsWith(TAG_MEDIA)) {
                    arrayList14.add(next);
                } else if (next.startsWith(TAG_SESSION_KEY)) {
                    DrmInitData.SchemeData drmSchemeData = parseDrmSchemeData(next, parseOptionalStringAttr(next, REGEX_KEYFORMAT, KEYFORMAT_IDENTITY, map2), map2);
                    if (drmSchemeData != null) {
                        arrayList15.add(new DrmInitData(parseEncryptionScheme(parseStringAttr(next, REGEX_METHOD, map2)), drmSchemeData));
                    }
                } else if (next.startsWith(TAG_STREAM_INF) || zStartsWith) {
                    zContains |= next.contains(ATTR_CLOSED_CAPTIONS_NONE);
                    int i10 = zStartsWith ? 16384 : 0;
                    int intAttr = parseIntAttr(next, REGEX_BANDWIDTH);
                    boolean z7 = z6;
                    int optionalIntAttr = parseOptionalIntAttr(next, REGEX_AVERAGE_BANDWIDTH, -1);
                    String optionalStringAttr = parseOptionalStringAttr(next, REGEX_CODECS, map2);
                    arrayList4 = arrayList15;
                    String optionalStringAttr2 = parseOptionalStringAttr(next, REGEX_RESOLUTION, map2);
                    if (optionalStringAttr2 != null) {
                        arrayList5 = arrayList16;
                        String[] strArrSplit = Util.split(optionalStringAttr2, "x");
                        i9 = Integer.parseInt(strArrSplit[0]);
                        i8 = Integer.parseInt(strArrSplit[1]);
                        if (i9 <= 0 || i8 <= 0) {
                        }
                        arrayList6 = arrayList12;
                        String optionalStringAttr3 = parseOptionalStringAttr(next, REGEX_FRAME_RATE, map2);
                        float f6 = optionalStringAttr3 == null ? Float.parseFloat(optionalStringAttr3) : -1.0f;
                        arrayList7 = arrayList11;
                        String optionalStringAttr4 = parseOptionalStringAttr(next, REGEX_VIDEO, map2);
                        String optionalStringAttr5 = parseOptionalStringAttr(next, REGEX_AUDIO, map2);
                        String optionalStringAttr6 = parseOptionalStringAttr(next, REGEX_SUBTITLES, map2);
                        String optionalStringAttr7 = parseOptionalStringAttr(next, REGEX_CLOSED_CAPTIONS, map2);
                        if (!zStartsWith) {
                            uriResolveToUri2 = UriUtil.resolveToUri(str4, parseStringAttr(next, REGEX_URI, map2));
                        } else {
                            if (!lineIterator.hasNext()) {
                                throw ParserException.createForMalformedManifest("#EXT-X-STREAM-INF must be followed by another line", null);
                            }
                            uriResolveToUri2 = UriUtil.resolveToUri(str4, replaceVariableReferences(lineIterator.next(), map2));
                        }
                        Uri uri = uriResolveToUri2;
                        arrayList9.add(new HlsMultivariantPlaylist.Variant(uri, new Format.Builder().setId(arrayList9.size()).setContainerMimeType(MimeTypes.APPLICATION_M3U8).setCodecs(optionalStringAttr).setAverageBitrate(optionalIntAttr).setPeakBitrate(intAttr).setWidth(i9).setHeight(i8).setFrameRate(f6).setRoleFlags(i10).build(), optionalStringAttr4, optionalStringAttr5, optionalStringAttr6, optionalStringAttr7));
                        arrayList8 = (ArrayList) map.get(uri);
                        if (arrayList8 == null) {
                            arrayList8 = new ArrayList();
                            map.put(uri, arrayList8);
                        }
                        arrayList8.add(new HlsTrackMetadataEntry.VariantInfo(optionalIntAttr, intAttr, optionalStringAttr4, optionalStringAttr5, optionalStringAttr6, optionalStringAttr7));
                        z6 = z7;
                    } else {
                        arrayList5 = arrayList16;
                    }
                    i8 = -1;
                    i9 = -1;
                    arrayList6 = arrayList12;
                    String optionalStringAttr32 = parseOptionalStringAttr(next, REGEX_FRAME_RATE, map2);
                    if (optionalStringAttr32 == null) {
                    }
                    arrayList7 = arrayList11;
                    String optionalStringAttr42 = parseOptionalStringAttr(next, REGEX_VIDEO, map2);
                    String optionalStringAttr52 = parseOptionalStringAttr(next, REGEX_AUDIO, map2);
                    String optionalStringAttr62 = parseOptionalStringAttr(next, REGEX_SUBTITLES, map2);
                    String optionalStringAttr72 = parseOptionalStringAttr(next, REGEX_CLOSED_CAPTIONS, map2);
                    if (!zStartsWith) {
                    }
                    Uri uri2 = uriResolveToUri2;
                    arrayList9.add(new HlsMultivariantPlaylist.Variant(uri2, new Format.Builder().setId(arrayList9.size()).setContainerMimeType(MimeTypes.APPLICATION_M3U8).setCodecs(optionalStringAttr).setAverageBitrate(optionalIntAttr).setPeakBitrate(intAttr).setWidth(i9).setHeight(i8).setFrameRate(f6).setRoleFlags(i10).build(), optionalStringAttr42, optionalStringAttr52, optionalStringAttr62, optionalStringAttr72));
                    arrayList8 = (ArrayList) map.get(uri2);
                    if (arrayList8 == null) {
                    }
                    arrayList8.add(new HlsTrackMetadataEntry.VariantInfo(optionalIntAttr, intAttr, optionalStringAttr42, optionalStringAttr52, optionalStringAttr62, optionalStringAttr72));
                    z6 = z7;
                }
                arrayList15 = arrayList4;
                arrayList16 = arrayList5;
                arrayList12 = arrayList6;
                arrayList11 = arrayList7;
            }
            arrayList7 = arrayList11;
            arrayList6 = arrayList12;
            arrayList4 = arrayList15;
            arrayList5 = arrayList16;
            arrayList15 = arrayList4;
            arrayList16 = arrayList5;
            arrayList12 = arrayList6;
            arrayList11 = arrayList7;
        }
        ArrayList arrayList17 = arrayList11;
        ArrayList arrayList18 = arrayList12;
        boolean z8 = z6;
        ArrayList arrayList19 = arrayList15;
        ArrayList arrayList20 = arrayList16;
        int i11 = 1;
        ArrayList arrayList21 = new ArrayList();
        HashSet hashSet = new HashSet();
        int i12 = 0;
        while (i12 < arrayList9.size()) {
            HlsMultivariantPlaylist.Variant variant2 = (HlsMultivariantPlaylist.Variant) arrayList9.get(i12);
            if (hashSet.add(variant2.url)) {
                Assertions.checkState(variant2.format.metadata == null ? i11 : 0);
                i7 = i11;
                Metadata.Entry[] entryArr = new Metadata.Entry[i7];
                entryArr[0] = new HlsTrackMetadataEntry(null, null, (List) Assertions.checkNotNull((ArrayList) map.get(variant2.url)));
                arrayList21.add(variant2.copyWithFormat(variant2.format.buildUpon().setMetadata(new Metadata(entryArr)).build()));
            } else {
                i7 = i11;
            }
            i12 += i7;
            i11 = i7;
        }
        ArrayList arrayList22 = null;
        Format formatBuild = null;
        int i13 = 0;
        while (i13 < arrayList14.size()) {
            str2 = (String) arrayList14.get(i13);
            stringAttr = parseStringAttr(str2, REGEX_GROUP_ID, map2);
            stringAttr2 = parseStringAttr(str2, REGEX_NAME, map2);
            language = new Format.Builder().setId(stringAttr + Constants.SUBS_ID_BASE_PLAN_ID_SEPARATOR + stringAttr2).setLabel(stringAttr2).setContainerMimeType(MimeTypes.APPLICATION_M3U8).setSelectionFlags(parseSelectionFlags(str2)).setRoleFlags(parseRoleFlags(str2, map2)).setLanguage(parseOptionalStringAttr(str2, REGEX_LANGUAGE, map2));
            String optionalStringAttr8 = parseOptionalStringAttr(str2, REGEX_URI, map2);
            uriResolveToUri = optionalStringAttr8 == null ? null : UriUtil.resolveToUri(str4, optionalStringAttr8);
            arrayList = arrayList22;
            metadata = new Metadata(new HlsTrackMetadataEntry(stringAttr, stringAttr2, Collections.EMPTY_LIST));
            String stringAttr3 = parseStringAttr(str2, REGEX_TYPE, map2);
            stringAttr3.getClass();
            switch (stringAttr3) {
                case "SUBTITLES":
                    arrayList2 = arrayList17;
                    HlsMultivariantPlaylist.Variant variantWithSubtitleGroup = getVariantWithSubtitleGroup(arrayList9, stringAttr);
                    if (variantWithSubtitleGroup != null) {
                        String codecsOfType = Util.getCodecsOfType(variantWithSubtitleGroup.format.codecs, 3);
                        language.setCodecs(codecsOfType);
                        mediaMimeType = MimeTypes.getMediaMimeType(codecsOfType);
                    } else {
                        mediaMimeType = null;
                    }
                    if (mediaMimeType == null) {
                        mediaMimeType = MimeTypes.TEXT_VTT;
                    }
                    language.setSampleMimeType(mediaMimeType).setMetadata(metadata);
                    if (uriResolveToUri != null) {
                        HlsMultivariantPlaylist.Rendition rendition = new HlsMultivariantPlaylist.Rendition(uriResolveToUri, language.build(), stringAttr, stringAttr2);
                        arrayList3 = arrayList18;
                        arrayList3.add(rendition);
                    } else {
                        arrayList3 = arrayList18;
                        Log.w(LOG_TAG, "EXT-X-MEDIA tag with missing mandatory URI attribute: skipping");
                    }
                    arrayList22 = arrayList;
                    break;
                case "CLOSED-CAPTIONS":
                    arrayList2 = arrayList17;
                    String stringAttr4 = parseStringAttr(str2, REGEX_INSTREAM_ID, map2);
                    if (stringAttr4.startsWith("CC")) {
                        i6 = Integer.parseInt(stringAttr4.substring(2));
                        str3 = MimeTypes.APPLICATION_CEA608;
                    } else {
                        i6 = Integer.parseInt(stringAttr4.substring(7));
                        str3 = MimeTypes.APPLICATION_CEA708;
                    }
                    ArrayList arrayList23 = arrayList == null ? new ArrayList() : arrayList;
                    language.setSampleMimeType(str3).setAccessibilityChannel(i6);
                    arrayList23.add(language.build());
                    arrayList22 = arrayList23;
                    arrayList3 = arrayList18;
                    break;
                case "AUDIO":
                    HlsMultivariantPlaylist.Variant variantWithAudioGroup = getVariantWithAudioGroup(arrayList9, stringAttr);
                    if (variantWithAudioGroup != null) {
                        variant = variantWithAudioGroup;
                        String codecsOfType2 = Util.getCodecsOfType(variantWithAudioGroup.format.codecs, 1);
                        language.setCodecs(codecsOfType2);
                        mediaMimeType2 = MimeTypes.getMediaMimeType(codecsOfType2);
                    } else {
                        variant = variantWithAudioGroup;
                        mediaMimeType2 = null;
                    }
                    String optionalStringAttr9 = parseOptionalStringAttr(str2, REGEX_CHANNELS, map2);
                    if (optionalStringAttr9 != null) {
                        language.setChannelCount(Integer.parseInt(Util.splitAtFirst(optionalStringAttr9, RemoteSettings.FORWARD_SLASH_STRING)[0]));
                        if (MimeTypes.AUDIO_E_AC3.equals(mediaMimeType2) && optionalStringAttr9.endsWith("/JOC")) {
                            language.setCodecs(MimeTypes.CODEC_E_AC3_JOC);
                            mediaMimeType2 = MimeTypes.AUDIO_E_AC3_JOC;
                        }
                    }
                    language.setSampleMimeType(mediaMimeType2);
                    if (uriResolveToUri == null) {
                        arrayList2 = arrayList17;
                        if (variant != null) {
                            formatBuild = language.build();
                            arrayList3 = arrayList18;
                            arrayList22 = arrayList;
                        }
                        break;
                    } else {
                        language.setMetadata(metadata);
                        arrayList2 = arrayList17;
                        arrayList2.add(new HlsMultivariantPlaylist.Rendition(uriResolveToUri, language.build(), stringAttr, stringAttr2));
                    }
                    arrayList3 = arrayList18;
                    arrayList22 = arrayList;
                    break;
                case "VIDEO":
                    HlsMultivariantPlaylist.Variant variantWithVideoGroup = getVariantWithVideoGroup(arrayList9, stringAttr);
                    if (variantWithVideoGroup != null) {
                        Format format = variantWithVideoGroup.format;
                        String codecsOfType3 = Util.getCodecsOfType(format.codecs, 2);
                        language.setCodecs(codecsOfType3).setSampleMimeType(MimeTypes.getMediaMimeType(codecsOfType3)).setWidth(format.width).setHeight(format.height).setFrameRate(format.frameRate);
                    }
                    if (uriResolveToUri != null) {
                        language.setMetadata(metadata);
                        arrayList10.add(new HlsMultivariantPlaylist.Rendition(uriResolveToUri, language.build(), stringAttr, stringAttr2));
                        break;
                    }
                default:
                    arrayList3 = arrayList18;
                    arrayList2 = arrayList17;
                    arrayList22 = arrayList;
                    break;
            }
            i13++;
            arrayList17 = arrayList2;
            arrayList18 = arrayList3;
            str4 = str;
        }
        return new HlsMultivariantPlaylist(str, arrayList20, arrayList21, arrayList10, arrayList17, arrayList18, arrayList13, formatBuild, zContains ? Collections.EMPTY_LIST : arrayList22, z8, map2, arrayList19);
    }

    private static boolean parseOptionalBooleanAttribute(String str, Pattern pattern, boolean z6) {
        Matcher matcher = pattern.matcher(str);
        return matcher.find() ? BOOLEAN_TRUE.equals(matcher.group(1)) : z6;
    }

    private static double parseOptionalDoubleAttr(String str, Pattern pattern, double d6) {
        Matcher matcher = pattern.matcher(str);
        return matcher.find() ? Double.parseDouble((String) Assertions.checkNotNull(matcher.group(1))) : d6;
    }

    private static int parseOptionalIntAttr(String str, Pattern pattern, int i6) {
        Matcher matcher = pattern.matcher(str);
        return matcher.find() ? Integer.parseInt((String) Assertions.checkNotNull(matcher.group(1))) : i6;
    }

    private static long parseOptionalLongAttr(String str, Pattern pattern, long j4) {
        Matcher matcher = pattern.matcher(str);
        return matcher.find() ? Long.parseLong((String) Assertions.checkNotNull(matcher.group(1))) : j4;
    }

    private static String parseOptionalStringAttr(String str, Pattern pattern, Map<String, String> map) {
        return parseOptionalStringAttr(str, pattern, null, map);
    }

    private static int parseRoleFlags(String str, Map<String, String> map) {
        String optionalStringAttr = parseOptionalStringAttr(str, REGEX_CHARACTERISTICS, map);
        if (TextUtils.isEmpty(optionalStringAttr)) {
            return 0;
        }
        String[] strArrSplit = Util.split(optionalStringAttr, ",");
        int i6 = Util.contains(strArrSplit, "public.accessibility.describes-video") ? 512 : 0;
        if (Util.contains(strArrSplit, "public.accessibility.transcribes-spoken-dialog")) {
            i6 |= 4096;
        }
        if (Util.contains(strArrSplit, "public.accessibility.describes-music-and-sound")) {
            i6 |= 1024;
        }
        return Util.contains(strArrSplit, "public.easy-to-read") ? i6 | 8192 : i6;
    }

    /* JADX WARN: Multi-variable type inference failed */
    /* JADX WARN: Type inference failed for: r0v2, types: [int] */
    /* JADX WARN: Type inference failed for: r0v5 */
    /* JADX WARN: Type inference failed for: r0v6 */
    private static int parseSelectionFlags(String str) {
        boolean optionalBooleanAttribute = parseOptionalBooleanAttribute(str, REGEX_DEFAULT, false);
        ?? r02 = optionalBooleanAttribute;
        if (parseOptionalBooleanAttribute(str, REGEX_FORCED, false)) {
            r02 = (optionalBooleanAttribute ? 1 : 0) | 2;
        }
        return parseOptionalBooleanAttribute(str, REGEX_AUTOSELECT, false) ? r02 | 4 : r02;
    }

    private static HlsMediaPlaylist.ServerControl parseServerControl(String str) {
        double optionalDoubleAttr = parseOptionalDoubleAttr(str, REGEX_CAN_SKIP_UNTIL, -9.223372036854776E18d);
        long j4 = C.TIME_UNSET;
        long j6 = optionalDoubleAttr == -9.223372036854776E18d ? -9223372036854775807L : (long) (optionalDoubleAttr * 1000000.0d);
        boolean optionalBooleanAttribute = parseOptionalBooleanAttribute(str, REGEX_CAN_SKIP_DATE_RANGES, false);
        double optionalDoubleAttr2 = parseOptionalDoubleAttr(str, REGEX_HOLD_BACK, -9.223372036854776E18d);
        long j7 = optionalDoubleAttr2 == -9.223372036854776E18d ? -9223372036854775807L : (long) (optionalDoubleAttr2 * 1000000.0d);
        double optionalDoubleAttr3 = parseOptionalDoubleAttr(str, REGEX_PART_HOLD_BACK, -9.223372036854776E18d);
        if (optionalDoubleAttr3 != -9.223372036854776E18d) {
            j4 = (long) (optionalDoubleAttr3 * 1000000.0d);
        }
        return new HlsMediaPlaylist.ServerControl(j6, optionalBooleanAttribute, j7, j4, parseOptionalBooleanAttribute(str, REGEX_CAN_BLOCK_RELOAD, false));
    }

    private static String parseStringAttr(String str, Pattern pattern, Map<String, String> map) throws ParserException {
        String optionalStringAttr = parseOptionalStringAttr(str, pattern, map);
        if (optionalStringAttr != null) {
            return optionalStringAttr;
        }
        throw ParserException.createForMalformedManifest("Couldn't match " + pattern.pattern() + " in " + str, null);
    }

    private static long parseTimeSecondsToUs(String str, Pattern pattern) {
        return new BigDecimal(parseStringAttr(str, pattern, Collections.EMPTY_MAP)).multiply(new BigDecimal(1000000L)).longValue();
    }

    private static String replaceVariableReferences(String str, Map<String, String> map) {
        Matcher matcher = REGEX_VARIABLE_REFERENCE.matcher(str);
        StringBuffer stringBuffer = new StringBuffer();
        while (matcher.find()) {
            String strGroup = matcher.group(1);
            if (map.containsKey(strGroup)) {
                matcher.appendReplacement(stringBuffer, Matcher.quoteReplacement(map.get(strGroup)));
            }
        }
        matcher.appendTail(stringBuffer);
        return stringBuffer.toString();
    }

    private static int skipIgnorableWhitespace(BufferedReader bufferedReader, boolean z6, int i6) throws IOException {
        while (i6 != -1 && Character.isWhitespace(i6) && (z6 || !Util.isLinebreak(i6))) {
            i6 = bufferedReader.read();
        }
        return i6;
    }

    public HlsPlaylistParser(HlsMultivariantPlaylist hlsMultivariantPlaylist, HlsMediaPlaylist hlsMediaPlaylist) {
        this.multivariantPlaylist = hlsMultivariantPlaylist;
        this.previousMediaPlaylist = hlsMediaPlaylist;
    }

    private static String parseOptionalStringAttr(String str, Pattern pattern, String str2, Map<String, String> map) {
        Matcher matcher = pattern.matcher(str);
        if (matcher.find()) {
            str2 = (String) Assertions.checkNotNull(matcher.group(1));
        }
        return (map.isEmpty() || str2 == null) ? str2 : replaceVariableReferences(str2, map);
    }

    /* JADX WARN: Can't rename method to resolve collision */
    @Override // androidx.media3.exoplayer.upstream.ParsingLoadable.Parser
    public HlsPlaylist parse(Uri uri, InputStream inputStream) throws ParserException {
        String strTrim;
        BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(inputStream));
        ArrayDeque arrayDeque = new ArrayDeque();
        try {
            if (!checkPlaylistHeader(bufferedReader)) {
                throw ParserException.createForMalformedManifest("Input does not start with the #EXTM3U header.", null);
            }
            while (true) {
                String line = bufferedReader.readLine();
                if (line == null) {
                    Util.closeQuietly(bufferedReader);
                    throw ParserException.createForMalformedManifest("Failed to parse the playlist, could not identify any tags.", null);
                }
                strTrim = line.trim();
                if (!strTrim.isEmpty()) {
                    if (!strTrim.startsWith(TAG_STREAM_INF)) {
                        if (strTrim.startsWith(TAG_TARGET_DURATION) || strTrim.startsWith(TAG_MEDIA_SEQUENCE) || strTrim.startsWith(TAG_MEDIA_DURATION) || strTrim.startsWith(TAG_KEY) || strTrim.startsWith(TAG_BYTERANGE) || strTrim.equals(TAG_DISCONTINUITY) || strTrim.equals(TAG_DISCONTINUITY_SEQUENCE) || strTrim.equals(TAG_ENDLIST)) {
                            break;
                        }
                        arrayDeque.add(strTrim);
                    } else {
                        arrayDeque.add(strTrim);
                        return parseMultivariantPlaylist(new LineIterator(arrayDeque, bufferedReader), uri.toString());
                    }
                }
            }
            arrayDeque.add(strTrim);
            return parseMediaPlaylist(this.multivariantPlaylist, this.previousMediaPlaylist, new LineIterator(arrayDeque, bufferedReader), uri.toString());
        } finally {
            Util.closeQuietly(bufferedReader);
        }
    }
}