package w2;

import android.text.SpannableStringBuilder;
import android.text.SpannedString;
import android.text.TextUtils;
import android.text.style.AbsoluteSizeSpan;
import android.text.style.BackgroundColorSpan;
import android.text.style.ForegroundColorSpan;
import android.text.style.RelativeSizeSpan;
import android.text.style.StrikethroughSpan;
import android.text.style.StyleSpan;
import android.text.style.TypefaceSpan;
import android.text.style.UnderlineSpan;
import androidx.annotation.Nullable;
import androidx.media3.common.text.HorizontalTextInVerticalContextSpan;
import androidx.media3.common.text.RubySpan;
import androidx.media3.common.text.SpanUtil;
import androidx.media3.common.text.VoiceSpan;
import androidx.media3.common.util.Assertions;
import androidx.media3.common.util.Log;
import androidx.media3.common.util.ParsableByteArray;
import androidx.media3.common.util.Util;
import androidx.media3.exoplayer.upstream.CmcdData;
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.regex.Matcher;
import java.util.regex.Pattern;
import xyz.stream.download.config.InnerConstant;

/* JADX INFO: loaded from: classes.dex */
public abstract class i {

    /* JADX INFO: renamed from: a, reason: collision with root package name */
    public static final Pattern f34161a = Pattern.compile("^(\\S+)\\s+-->\\s+(\\S+)((?:.|\\f)*)?$");

    /* JADX INFO: renamed from: b, reason: collision with root package name */
    public static final Pattern f34162b = Pattern.compile("(\\S+?):(\\S+)");

    /* JADX INFO: renamed from: c, reason: collision with root package name */
    public static final Map f34163c;

    /* JADX INFO: renamed from: d, reason: collision with root package name */
    public static final Map f34164d;

    static {
        HashMap map = new HashMap();
        u.a.e(255, 255, 255, map, "white");
        u.a.e(0, 255, 0, map, "lime");
        u.a.e(0, 255, 255, map, "cyan");
        u.a.e(255, 0, 0, map, "red");
        u.a.e(255, 255, 0, map, "yellow");
        u.a.e(255, 0, 255, map, "magenta");
        u.a.e(0, 0, 255, map, "blue");
        u.a.e(0, 0, 0, map, "black");
        f34163c = Collections.unmodifiableMap(map);
        HashMap map2 = new HashMap();
        u.a.e(255, 255, 255, map2, "bg_white");
        u.a.e(0, 255, 0, map2, "bg_lime");
        u.a.e(0, 255, 255, map2, "bg_cyan");
        u.a.e(255, 0, 0, map2, "bg_red");
        u.a.e(255, 255, 0, map2, "bg_yellow");
        u.a.e(255, 0, 255, map2, "bg_magenta");
        u.a.e(0, 0, 255, map2, "bg_blue");
        u.a.e(0, 0, 0, map2, "bg_black");
        f34164d = Collections.unmodifiableMap(map2);
    }

    /* JADX WARN: Can't fix incorrect switch cases order, some code will duplicate */
    public static void a(String str, h hVar) {
        int i10;
        String strSubstring;
        int i11;
        Matcher matcher = f34162b.matcher(str);
        while (matcher.find()) {
            String str2 = (String) Assertions.checkNotNull(matcher.group(1));
            int i12 = 2;
            String strSubstring2 = (String) Assertions.checkNotNull(matcher.group(2));
            try {
                if ("line".equals(str2)) {
                    b(strSubstring2, hVar);
                } else {
                    if ("align".equals(str2)) {
                        strSubstring2.getClass();
                        switch (strSubstring2) {
                            case "center":
                            case "middle":
                                i10 = 2;
                                break;
                            case "end":
                                i10 = 3;
                                break;
                            case "left":
                                i10 = 4;
                                break;
                            case "right":
                                i10 = 5;
                                break;
                            case "start":
                                i10 = 1;
                                break;
                            default:
                                Log.w("WebvttCueParser", "Invalid alignment value: ".concat(strSubstring2));
                                i10 = 2;
                                break;
                        }
                        hVar.f34153d = i10;
                    } else if ("position".equals(str2)) {
                        int iIndexOf = strSubstring2.indexOf(44);
                        if (iIndexOf != -1) {
                            strSubstring = strSubstring2.substring(iIndexOf + 1);
                            strSubstring.getClass();
                            switch (strSubstring) {
                                case "line-left":
                                case "start":
                                    i12 = 0;
                                    break;
                                case "center":
                                case "middle":
                                    i12 = 1;
                                    break;
                                case "line-right":
                                case "end":
                                    break;
                                default:
                                    Log.w("WebvttCueParser", "Invalid anchor value: ".concat(strSubstring));
                                    i12 = Integer.MIN_VALUE;
                                    break;
                            }
                            hVar.f34158i = i12;
                            strSubstring2 = strSubstring2.substring(0, iIndexOf);
                        }
                        hVar.f34157h = j.b(strSubstring2);
                    } else if (InnerConstant.Db.size.equals(str2)) {
                        hVar.f34159j = j.b(strSubstring2);
                    } else if ("vertical".equals(str2)) {
                        strSubstring2.getClass();
                        if (strSubstring2.equals("lr")) {
                            i11 = 2;
                        } else if (strSubstring2.equals("rl")) {
                            i11 = 1;
                        } else {
                            Log.w("WebvttCueParser", "Invalid 'vertical' value: ".concat(strSubstring2));
                            i11 = Integer.MIN_VALUE;
                        }
                        hVar.f34160k = i11;
                    } else {
                        Log.w("WebvttCueParser", "Unknown cue setting " + str2 + ":" + strSubstring2);
                    }
                }
            } catch (NumberFormatException unused) {
                Log.w("WebvttCueParser", "Skipping bad cue setting: " + matcher.group());
            }
        }
    }

    private static void applyRubySpans(SpannableStringBuilder spannableStringBuilder, @Nullable String str, f fVar, List<e> list, List<c> list2) {
        int rubyPosition = getRubyPosition(list2, str, fVar);
        ArrayList arrayList = new ArrayList(list.size());
        arrayList.addAll(list);
        Collections.sort(arrayList, e.f34141c);
        int i10 = fVar.f34145b;
        int length = 0;
        for (int i11 = 0; i11 < arrayList.size(); i11++) {
            if ("rt".equals(((e) arrayList.get(i11)).f34142a.f34144a)) {
                e eVar = (e) arrayList.get(i11);
                int rubyPosition2 = getRubyPosition(list2, str, eVar.f34142a);
                if (rubyPosition2 == -1) {
                    rubyPosition2 = rubyPosition != -1 ? rubyPosition : 1;
                }
                int i12 = eVar.f34142a.f34145b - length;
                int i13 = eVar.f34143b - length;
                CharSequence charSequenceSubSequence = spannableStringBuilder.subSequence(i12, i13);
                spannableStringBuilder.delete(i12, i13);
                spannableStringBuilder.setSpan(new RubySpan(charSequenceSubSequence.toString(), rubyPosition2), i10, i12, 33);
                length = charSequenceSubSequence.length() + length;
                i10 = i12;
            }
        }
    }

    /* JADX WARN: Removed duplicated region for block: B:18:0x0034  */
    /*
        Code decompiled incorrectly, please refer to instructions dump.
    */
    private static void applySpansForTag(@Nullable String str, f fVar, List<e> list, SpannableStringBuilder spannableStringBuilder, List<c> list2) {
        byte b10;
        int i10 = fVar.f34145b;
        int length = spannableStringBuilder.length();
        String str2 = fVar.f34144a;
        str2.getClass();
        int iHashCode = str2.hashCode();
        if (iHashCode != 0) {
            if (iHashCode != 105) {
                if (iHashCode != 3314158) {
                    if (iHashCode != 3511770) {
                        if (iHashCode != 98) {
                            if (iHashCode != 99) {
                                if (iHashCode != 117) {
                                    b10 = (iHashCode == 118 && str2.equals("v")) ? (byte) 5 : (byte) -1;
                                } else if (str2.equals("u")) {
                                    b10 = 4;
                                }
                            } else if (str2.equals("c")) {
                                b10 = 2;
                            }
                        } else if (str2.equals("b")) {
                            b10 = 1;
                        }
                    } else if (str2.equals("ruby")) {
                        b10 = 7;
                    }
                } else if (str2.equals("lang")) {
                    b10 = 6;
                }
            } else if (str2.equals(CmcdData.OBJECT_TYPE_INIT_SEGMENT)) {
                b10 = 3;
            }
        } else if (str2.equals("")) {
            b10 = 0;
        }
        switch (b10) {
            case 0:
            case 6:
                break;
            case 1:
                spannableStringBuilder.setSpan(new StyleSpan(1), i10, length, 33);
                break;
            case 2:
                for (String str3 : fVar.f34147d) {
                    Map map = f34163c;
                    if (map.containsKey(str3)) {
                        spannableStringBuilder.setSpan(new ForegroundColorSpan(((Integer) map.get(str3)).intValue()), i10, length, 33);
                    } else {
                        Map map2 = f34164d;
                        if (map2.containsKey(str3)) {
                            spannableStringBuilder.setSpan(new BackgroundColorSpan(((Integer) map2.get(str3)).intValue()), i10, length, 33);
                        }
                    }
                }
                break;
            case 3:
                spannableStringBuilder.setSpan(new StyleSpan(2), i10, length, 33);
                break;
            case 4:
                spannableStringBuilder.setSpan(new UnderlineSpan(), i10, length, 33);
                break;
            case 5:
                spannableStringBuilder.setSpan(new VoiceSpan(fVar.f34146c), i10, length, 33);
                break;
            case 7:
                applyRubySpans(spannableStringBuilder, str, fVar, list, list2);
                break;
            default:
                return;
        }
        List<g> applicableStyles = getApplicableStyles(list2, str, fVar);
        for (int i11 = 0; i11 < applicableStyles.size(); i11++) {
            c cVar = applicableStyles.get(i11).f34149b;
            if (cVar != null) {
                int i12 = cVar.f34132k;
                if (i12 != -1 || cVar.f34133l != -1) {
                    if (((i12 == 1 ? (char) 1 : (char) 0) | (cVar.f34133l == 1 ? (char) 2 : (char) 0)) != -1) {
                        int i13 = cVar.f34132k;
                        SpanUtil.addOrReplaceSpan(spannableStringBuilder, new StyleSpan((i13 == -1 && cVar.f34133l == -1) ? -1 : (i13 == 1 ? 1 : 0) | (cVar.f34133l == 1 ? 2 : 0)), i10, length, 33);
                    }
                }
                if (cVar.f34130i == 1) {
                    spannableStringBuilder.setSpan(new StrikethroughSpan(), i10, length, 33);
                }
                if (cVar.f34131j == 1) {
                    spannableStringBuilder.setSpan(new UnderlineSpan(), i10, length, 33);
                }
                if (cVar.f34127f) {
                    if (!cVar.f34127f) {
                        throw new IllegalStateException("Font color not defined");
                    }
                    SpanUtil.addOrReplaceSpan(spannableStringBuilder, new ForegroundColorSpan(cVar.f34126e), i10, length, 33);
                }
                if (cVar.f34129h) {
                    if (!cVar.f34129h) {
                        throw new IllegalStateException("Background color not defined.");
                    }
                    SpanUtil.addOrReplaceSpan(spannableStringBuilder, new BackgroundColorSpan(cVar.f34128g), i10, length, 33);
                }
                if (cVar.getFontFamily() != null) {
                    SpanUtil.addOrReplaceSpan(spannableStringBuilder, new TypefaceSpan(cVar.getFontFamily()), i10, length, 33);
                }
                int i14 = cVar.f34134m;
                if (i14 == 1) {
                    SpanUtil.addOrReplaceSpan(spannableStringBuilder, new AbsoluteSizeSpan((int) cVar.f34135n, true), i10, length, 33);
                } else if (i14 == 2) {
                    SpanUtil.addOrReplaceSpan(spannableStringBuilder, new RelativeSizeSpan(cVar.f34135n), i10, length, 33);
                } else if (i14 == 3) {
                    SpanUtil.addOrReplaceSpan(spannableStringBuilder, new RelativeSizeSpan(cVar.f34135n / 100.0f), i10, length, 33);
                }
                if (cVar.f34137p) {
                    spannableStringBuilder.setSpan(new HorizontalTextInVerticalContextSpan(), i10, length, 33);
                }
            }
        }
    }

    public static void b(String str, h hVar) {
        String strSubstring;
        int i10;
        int iIndexOf = str.indexOf(44);
        if (iIndexOf != -1) {
            strSubstring = str.substring(iIndexOf + 1);
            strSubstring.getClass();
            i10 = 2;
            switch (strSubstring) {
                case "center":
                case "middle":
                    i10 = 1;
                    break;
                case "end":
                    break;
                case "start":
                    i10 = 0;
                    break;
                default:
                    Log.w("WebvttCueParser", "Invalid anchor value: ".concat(strSubstring));
                    i10 = Integer.MIN_VALUE;
                    break;
            }
            hVar.f34156g = i10;
            str = str.substring(0, iIndexOf);
        }
        if (str.endsWith("%")) {
            hVar.f34154e = j.b(str);
            hVar.f34155f = 0;
        } else {
            hVar.f34154e = Integer.parseInt(str);
            hVar.f34155f = 1;
        }
    }

    private static List<g> getApplicableStyles(List<c> list, @Nullable String str, f fVar) {
        ArrayList arrayList = new ArrayList();
        for (int i10 = 0; i10 < list.size(); i10++) {
            c cVar = list.get(i10);
            int specificityScore = cVar.getSpecificityScore(str, fVar.f34144a, fVar.f34147d, fVar.f34146c);
            if (specificityScore > 0) {
                arrayList.add(new g(specificityScore, cVar));
            }
        }
        Collections.sort(arrayList);
        return arrayList;
    }

    private static int getRubyPosition(List<c> list, @Nullable String str, f fVar) {
        List<g> applicableStyles = getApplicableStyles(list, str, fVar);
        for (int i10 = 0; i10 < applicableStyles.size(); i10++) {
            int i11 = applicableStyles.get(i10).f34149b.f34136o;
            if (i11 != -1) {
                return i11;
            }
        }
        return -1;
    }

    @Nullable
    public static d parseCue(ParsableByteArray parsableByteArray, List<c> list) {
        String line = parsableByteArray.readLine();
        if (line == null) {
            return null;
        }
        Pattern pattern = f34161a;
        Matcher matcher = pattern.matcher(line);
        if (matcher.matches()) {
            return parseCue(null, matcher, parsableByteArray, list);
        }
        String line2 = parsableByteArray.readLine();
        if (line2 == null) {
            return null;
        }
        Matcher matcher2 = pattern.matcher(line2);
        if (matcher2.matches()) {
            return parseCue(line.trim(), matcher2, parsableByteArray, list);
        }
        return null;
    }

    /* JADX WARN: Can't fix incorrect switch cases order, some code will duplicate */
    /* JADX WARN: Failed to find 'out' block for switch in B:69:0x00f9. Please report as an issue. */
    /* JADX WARN: Failed to restore switch over string. Please report as a decompilation issue */
    /* JADX WARN: Removed duplicated region for block: B:36:0x009f  */
    /*
        Code decompiled incorrectly, please refer to instructions dump.
    */
    public static SpannedString parseCueText(@Nullable String str, String str2, List<c> list) {
        String strSubstring;
        int i10;
        SpannableStringBuilder spannableStringBuilder = new SpannableStringBuilder();
        ArrayDeque arrayDeque = new ArrayDeque();
        ArrayList arrayList = new ArrayList();
        int i11 = 0;
        int i12 = 0;
        while (true) {
            String strTrim = "";
            if (i12 >= str2.length()) {
                while (!arrayDeque.isEmpty()) {
                    applySpansForTag(str, (f) arrayDeque.pop(), arrayList, spannableStringBuilder, list);
                }
                applySpansForTag(str, new f("", 0, "", Collections.emptySet()), Collections.emptyList(), spannableStringBuilder, list);
                return SpannedString.valueOf(spannableStringBuilder);
            }
            char cCharAt = str2.charAt(i12);
            if (cCharAt == '&') {
                i12++;
                int iIndexOf = str2.indexOf(59, i12);
                int iIndexOf2 = str2.indexOf(32, i12);
                if (iIndexOf == -1) {
                    iIndexOf = iIndexOf2;
                } else if (iIndexOf2 != -1) {
                    iIndexOf = Math.min(iIndexOf, iIndexOf2);
                }
                if (iIndexOf != -1) {
                    strSubstring = str2.substring(i12, iIndexOf);
                    strSubstring.getClass();
                    switch (strSubstring) {
                        case "gt":
                            spannableStringBuilder.append('>');
                            break;
                        case "lt":
                            spannableStringBuilder.append('<');
                            break;
                        case "amp":
                            spannableStringBuilder.append('&');
                            break;
                        case "nbsp":
                            spannableStringBuilder.append(' ');
                            break;
                        default:
                            Log.w("WebvttCueParser", "ignoring unsupported entity: '&" + strSubstring + ";'");
                            break;
                    }
                    if (iIndexOf == iIndexOf2) {
                        spannableStringBuilder.append((CharSequence) " ");
                    }
                    i12 = iIndexOf + 1;
                } else {
                    spannableStringBuilder.append(cCharAt);
                }
            } else if (cCharAt != '<') {
                spannableStringBuilder.append(cCharAt);
                i12++;
            } else {
                int length = i12 + 1;
                if (length < str2.length()) {
                    int i13 = str2.charAt(length) == '/' ? 1 : i11;
                    int iIndexOf3 = str2.indexOf(62, length);
                    length = iIndexOf3 == -1 ? str2.length() : iIndexOf3 + 1;
                    int i14 = length - 2;
                    int i15 = str2.charAt(i14) == '/' ? 1 : i11;
                    int i16 = i12 + (i13 != 0 ? 2 : 1);
                    if (i15 == 0) {
                        i14 = length - 1;
                    }
                    String strSubstring2 = str2.substring(i16, i14);
                    if (!strSubstring2.trim().isEmpty()) {
                        String strTrim2 = strSubstring2.trim();
                        Assertions.checkArgument(!strTrim2.isEmpty());
                        String str3 = Util.splitAtFirst(strTrim2, "[ \\.]")[i11];
                        str3.getClass();
                        switch (str3.hashCode()) {
                            case 98:
                                i10 = str3.equals("b") ? i11 : -1;
                                break;
                            case 99:
                                if (str3.equals("c")) {
                                    i10 = 1;
                                    break;
                                }
                                break;
                            case 105:
                                if (str3.equals(CmcdData.OBJECT_TYPE_INIT_SEGMENT)) {
                                    i10 = 2;
                                    break;
                                }
                                break;
                            case 117:
                                if (str3.equals("u")) {
                                    i10 = 3;
                                    break;
                                }
                                break;
                            case 118:
                                if (str3.equals("v")) {
                                    i10 = 4;
                                    break;
                                }
                                break;
                            case 3650:
                                if (str3.equals("rt")) {
                                    i10 = 5;
                                    break;
                                }
                                break;
                            case 3314158:
                                if (str3.equals("lang")) {
                                    i10 = 6;
                                    break;
                                }
                                break;
                            case 3511770:
                                if (str3.equals("ruby")) {
                                    i10 = 7;
                                    break;
                                }
                                break;
                        }
                        switch (i10) {
                            case 0:
                            case 1:
                            case 2:
                            case 3:
                            case 4:
                            case 5:
                            case 6:
                            case 7:
                                if (i13 != 0) {
                                    while (!arrayDeque.isEmpty()) {
                                        f fVar = (f) arrayDeque.pop();
                                        applySpansForTag(str, fVar, arrayList, spannableStringBuilder, list);
                                        if (arrayDeque.isEmpty()) {
                                            arrayList.clear();
                                        } else {
                                            arrayList.add(new e(fVar, spannableStringBuilder.length()));
                                        }
                                        if (fVar.f34144a.equals(str3)) {
                                            break;
                                        }
                                    }
                                } else if (i15 == 0) {
                                    int length2 = spannableStringBuilder.length();
                                    String strTrim3 = strSubstring2.trim();
                                    Assertions.checkArgument(!strTrim3.isEmpty());
                                    int iIndexOf4 = strTrim3.indexOf(" ");
                                    if (iIndexOf4 != -1) {
                                        strTrim = strTrim3.substring(iIndexOf4).trim();
                                        strTrim3 = strTrim3.substring(i11, iIndexOf4);
                                    }
                                    String[] strArrSplit = Util.split(strTrim3, "\\.");
                                    String str4 = strArrSplit[i11];
                                    HashSet hashSet = new HashSet();
                                    for (int i17 = 1; i17 < strArrSplit.length; i17++) {
                                        hashSet.add(strArrSplit[i17]);
                                    }
                                    arrayDeque.push(new f(str4, length2, strTrim, hashSet));
                                }
                                break;
                        }
                    }
                    i12 = length;
                }
                i12 = length;
            }
            i11 = 0;
        }
    }

    @Nullable
    private static d parseCue(@Nullable String str, Matcher matcher, ParsableByteArray parsableByteArray, List<c> list) {
        h hVar = new h();
        try {
            hVar.f34150a = j.c((String) Assertions.checkNotNull(matcher.group(1)));
            hVar.f34151b = j.c((String) Assertions.checkNotNull(matcher.group(2)));
            a((String) Assertions.checkNotNull(matcher.group(3)), hVar);
            StringBuilder sb = new StringBuilder();
            String line = parsableByteArray.readLine();
            while (!TextUtils.isEmpty(line)) {
                if (sb.length() > 0) {
                    sb.append("\n");
                }
                sb.append(line.trim());
                line = parsableByteArray.readLine();
            }
            hVar.f34152c = parseCueText(str, sb.toString(), list);
            return new d(hVar.a().build(), hVar.f34150a, hVar.f34151b);
        } catch (IllegalArgumentException unused) {
            Log.w("WebvttCueParser", "Skipping cue with bad header: " + matcher.group());
            return null;
        }
    }
}