package com.google.android.gms.internal.ads;

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.StyleSpan;
import android.text.style.TypefaceSpan;
import android.text.style.UnderlineSpan;
import androidx.annotation.Nullable;
import androidx.media3.exoplayer.upstream.CmcdData;
import java.nio.charset.Charset;
import java.nio.charset.StandardCharsets;
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: classes2.dex */
public abstract class x9 {

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

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

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

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

    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");
        f18368c = 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");
        f18369d = Collections.unmodifiableMap(map2);
    }

    /* JADX WARN: Can't fix incorrect switch cases order, some code will duplicate */
    public static void a(String str, w9 w9Var) {
        String strSubstring;
        String strSubstring2;
        int i10;
        Matcher matcher = f18367b.matcher(str);
        while (matcher.find()) {
            int i11 = 1;
            String strGroup = matcher.group(1);
            strGroup.getClass();
            String strGroup2 = matcher.group(2);
            strGroup2.getClass();
            try {
                if ("line".equals(strGroup)) {
                    int iIndexOf = strGroup2.indexOf(44);
                    if (iIndexOf != -1) {
                        strSubstring2 = strGroup2.substring(iIndexOf + 1);
                        strSubstring2.getClass();
                        switch (strSubstring2) {
                            case "center":
                            case "middle":
                                i10 = 1;
                                break;
                            case "end":
                                i10 = 2;
                                break;
                            case "start":
                                i10 = 0;
                                break;
                            default:
                                vt0.c("Invalid anchor value: ".concat(strSubstring2));
                                i10 = Integer.MIN_VALUE;
                                break;
                        }
                        w9Var.f17939g = i10;
                        strGroup2 = strGroup2.substring(0, iIndexOf);
                    }
                    if (strGroup2.endsWith("%")) {
                        w9Var.f17937e = za2.q(strGroup2);
                        w9Var.f17938f = 0;
                    } else {
                        w9Var.f17937e = Integer.parseInt(strGroup2);
                        w9Var.f17938f = 1;
                    }
                } else if ("align".equals(strGroup)) {
                    switch (strGroup2) {
                        case "center":
                        case "middle":
                            i11 = 2;
                            break;
                        case "end":
                            i11 = 3;
                            break;
                        case "left":
                            i11 = 4;
                            break;
                        case "right":
                            i11 = 5;
                            break;
                        case "start":
                            break;
                        default:
                            vt0.c("Invalid alignment value: ".concat(strGroup2));
                            i11 = 2;
                            break;
                    }
                    w9Var.f17936d = i11;
                } else if ("position".equals(strGroup)) {
                    int iIndexOf2 = strGroup2.indexOf(44);
                    if (iIndexOf2 != -1) {
                        strSubstring = strGroup2.substring(iIndexOf2 + 1);
                        strSubstring.getClass();
                        switch (strSubstring) {
                            case "line-left":
                            case "start":
                                i11 = 0;
                                break;
                            case "center":
                            case "middle":
                                break;
                            case "line-right":
                            case "end":
                                i11 = 2;
                                break;
                            default:
                                vt0.c("Invalid anchor value: ".concat(strSubstring));
                                i11 = Integer.MIN_VALUE;
                                break;
                        }
                        w9Var.f17941i = i11;
                        strGroup2 = strGroup2.substring(0, iIndexOf2);
                    }
                    w9Var.f17940h = za2.q(strGroup2);
                } else if (InnerConstant.Db.size.equals(strGroup)) {
                    w9Var.f17942j = za2.q(strGroup2);
                } else if ("vertical".equals(strGroup)) {
                    if (!strGroup2.equals("rl")) {
                        if (strGroup2.equals("lr")) {
                            i11 = 2;
                        } else {
                            vt0.c("Invalid 'vertical' value: ".concat(strGroup2));
                            i11 = Integer.MIN_VALUE;
                        }
                    }
                    w9Var.f17943k = i11;
                } else {
                    StringBuilder sb = new StringBuilder(strGroup.length() + 21 + strGroup2.length());
                    sb.append("Unknown cue setting ");
                    sb.append(strGroup);
                    sb.append(":");
                    sb.append(strGroup2);
                    vt0.c(sb.toString());
                }
            } catch (NumberFormatException unused) {
                vt0.c("Skipping bad cue setting: ".concat(String.valueOf(matcher.group())));
            }
        }
    }

    @Nullable
    public static r9 zza(p01 p01Var, List list) {
        Charset charset = StandardCharsets.UTF_8;
        String strZzN = p01Var.zzN(charset);
        if (strZzN != null) {
            Pattern pattern = f18366a;
            Matcher matcher = pattern.matcher(strZzN);
            if (matcher.matches()) {
                return zzd(null, matcher, p01Var, list);
            }
            String strZzN2 = p01Var.zzN(charset);
            if (strZzN2 != null) {
                Matcher matcher2 = pattern.matcher(strZzN2);
                if (matcher2.matches()) {
                    return zzd(strZzN.trim(), matcher2, p01Var, list);
                }
            }
        }
        return null;
    }

    /* JADX WARN: Can't fix incorrect switch cases order, some code will duplicate */
    /* JADX WARN: Removed duplicated region for block: B:34:0x009f A[FALL_THROUGH] */
    /* JADX WARN: Removed duplicated region for block: B:37:0x00c5  */
    /*
        Code decompiled incorrectly, please refer to instructions dump.
    */
    public static SpannedString zzc(@Nullable String str, String str2, List list) {
        String strSubstring;
        String str3;
        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()) {
                    zzf(str, (u9) arrayDeque.pop(), arrayList, spannableStringBuilder, list);
                }
                zzf(str, new u9("", i11, "", Collections.emptySet()), Collections.emptyList(), spannableStringBuilder, list);
                return SpannedString.valueOf(spannableStringBuilder);
            }
            int i13 = i12 + 1;
            char cCharAt = str2.charAt(i12);
            if (cCharAt == '&') {
                int iIndexOf = str2.indexOf(59, i13);
                int iIndexOf2 = str2.indexOf(32, i13);
                if (iIndexOf == -1) {
                    iIndexOf = iIndexOf2;
                } else if (iIndexOf2 != -1) {
                    iIndexOf = Math.min(iIndexOf, iIndexOf2);
                }
                if (iIndexOf != -1) {
                    strSubstring = str2.substring(i13, 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:
                            StringBuilder sb = new StringBuilder(strSubstring.length() + 33);
                            sb.append("ignoring unsupported entity: '&");
                            sb.append(strSubstring);
                            sb.append(";'");
                            vt0.c(sb.toString());
                            break;
                    }
                    if (iIndexOf == iIndexOf2) {
                        spannableStringBuilder.append((CharSequence) " ");
                    }
                    i12 = iIndexOf + 1;
                    i11 = 0;
                } else {
                    spannableStringBuilder.append(cCharAt);
                }
            } else if (cCharAt != '<') {
                spannableStringBuilder.append(cCharAt);
            } else if (i13 < str2.length()) {
                char cCharAt2 = str2.charAt(i13);
                int iIndexOf3 = str2.indexOf(62, i13);
                int length = iIndexOf3 == -1 ? str2.length() : iIndexOf3 + 1;
                int i14 = length - 2;
                boolean z10 = str2.charAt(i14) == '/';
                int i15 = i12 + (cCharAt2 == '/' ? 2 : 1);
                if (!z10) {
                    i14 = length - 1;
                }
                String strSubstring2 = str2.substring(i15, i14);
                if (strSubstring2.trim().isEmpty()) {
                    i10 = 0;
                    i12 = length;
                    i11 = i10;
                } else {
                    String strTrim2 = strSubstring2.trim();
                    ih1.x(!strTrim2.isEmpty());
                    String str4 = bb1.f9474a;
                    str3 = strTrim2.split("[ \\.]", 2)[0];
                    str3.getClass();
                    switch (str3) {
                        case "b":
                        case "c":
                        case "i":
                        case "u":
                        case "v":
                        case "rt":
                        case "lang":
                        case "ruby":
                            if (cCharAt2 != '/') {
                                if (!z10) {
                                    int length2 = spannableStringBuilder.length();
                                    String strTrim3 = strSubstring2.trim();
                                    ih1.x(!strTrim3.isEmpty());
                                    int iIndexOf4 = strTrim3.indexOf(" ");
                                    if (iIndexOf4 == -1) {
                                        i10 = 0;
                                    } else {
                                        strTrim = strTrim3.substring(iIndexOf4).trim();
                                        i10 = 0;
                                        strTrim3 = strTrim3.substring(0, iIndexOf4);
                                    }
                                    String[] strArrSplit = strTrim3.split("\\.", -1);
                                    String str5 = strArrSplit[i10];
                                    HashSet hashSet = new HashSet();
                                    for (int i16 = 1; i16 < strArrSplit.length; i16++) {
                                        hashSet.add(strArrSplit[i16]);
                                    }
                                    arrayDeque.push(new u9(str5, length2, strTrim, hashSet));
                                }
                                break;
                            } else {
                                while (!arrayDeque.isEmpty()) {
                                    u9 u9Var = (u9) arrayDeque.pop();
                                    zzf(str, u9Var, arrayList, spannableStringBuilder, list);
                                    if (arrayDeque.isEmpty()) {
                                        arrayList.clear();
                                    } else {
                                        arrayList.add(new t9(u9Var, spannableStringBuilder.length()));
                                    }
                                    if (u9Var.f17164a.equals(str3)) {
                                        break;
                                    }
                                }
                                break;
                            }
                    }
                    i12 = length;
                    i11 = i10;
                }
            }
            i12 = i13;
            i11 = 0;
        }
    }

    @Nullable
    private static r9 zzd(@Nullable String str, Matcher matcher, p01 p01Var, List list) {
        w9 w9Var = new w9();
        try {
            String strGroup = matcher.group(1);
            strGroup.getClass();
            w9Var.f17933a = za2.c(strGroup);
            String strGroup2 = matcher.group(2);
            strGroup2.getClass();
            w9Var.f17934b = za2.c(strGroup2);
            String strGroup3 = matcher.group(3);
            strGroup3.getClass();
            a(strGroup3, w9Var);
            StringBuilder sb = new StringBuilder();
            String strZzN = p01Var.zzN(StandardCharsets.UTF_8);
            while (!TextUtils.isEmpty(strZzN)) {
                if (sb.length() > 0) {
                    sb.append("\n");
                }
                sb.append(strZzN.trim());
                strZzN = p01Var.zzN(StandardCharsets.UTF_8);
            }
            w9Var.f17935c = zzc(str, sb.toString(), list);
            return new r9(w9Var.a().c(), w9Var.f17933a, w9Var.f17934b);
        } catch (IllegalArgumentException unused) {
            vt0.c("Skipping cue with bad header: ".concat(String.valueOf(matcher.group())));
            return null;
        }
    }

    /* JADX WARN: Removed duplicated region for block: B:43:0x0086  */
    /* JADX WARN: Removed duplicated region for block: B:84:0x0190  */
    /*
        Code decompiled incorrectly, please refer to instructions dump.
    */
    private static void zzf(@Nullable String str, u9 u9Var, List list, SpannableStringBuilder spannableStringBuilder, List list2) {
        byte b10;
        int i10;
        int i11;
        int i12 = u9Var.f17165b;
        int length = spannableStringBuilder.length();
        String str2 = u9Var.f17164a;
        int iHashCode = str2.hashCode();
        int i13 = -1;
        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 = 3;
                                }
                            } else if (str2.equals("c")) {
                                b10 = 4;
                            }
                        } else if (str2.equals("b")) {
                            b10 = 0;
                        }
                    } else if (str2.equals("ruby")) {
                        b10 = 2;
                    }
                } else if (str2.equals("lang")) {
                    b10 = 6;
                }
            } else if (str2.equals(CmcdData.OBJECT_TYPE_INIT_SEGMENT)) {
                b10 = 1;
            }
        } else if (str2.equals("")) {
            b10 = 7;
        }
        switch (b10) {
            case 0:
                spannableStringBuilder.setSpan(new StyleSpan(1), i12, length, 33);
                break;
            case 1:
                spannableStringBuilder.setSpan(new StyleSpan(2), i12, length, 33);
                break;
            case 2:
                int iZzg = zzg(list2, str, u9Var);
                ArrayList arrayList = new ArrayList(list.size());
                arrayList.addAll(list);
                Collections.sort(arrayList, s9.f16363a);
                int i14 = i12;
                int i15 = 0;
                int length2 = 0;
                while (i15 < arrayList.size()) {
                    if ("rt".equals(((t9) arrayList.get(i15)).f16822a.f17164a)) {
                        t9 t9Var = (t9) arrayList.get(i15);
                        int iZzg2 = zzg(list2, str, t9Var.f16822a);
                        if (iZzg2 == i13) {
                            iZzg2 = iZzg != i13 ? iZzg : 1;
                        }
                        int i16 = t9Var.f16822a.f17165b - length2;
                        int i17 = t9Var.f16823b - length2;
                        CharSequence charSequenceSubSequence = spannableStringBuilder.subSequence(i16, i17);
                        spannableStringBuilder.delete(i16, i17);
                        spannableStringBuilder.setSpan(new if0(charSequenceSubSequence.toString(), iZzg2), i14, i16, 33);
                        length2 += charSequenceSubSequence.length();
                        i14 = i16;
                    }
                    i15++;
                    i13 = -1;
                }
                break;
            case 3:
                spannableStringBuilder.setSpan(new UnderlineSpan(), i12, length, 33);
                break;
            case 4:
                for (String str3 : u9Var.f17167d) {
                    Map map = f18368c;
                    if (map.containsKey(str3)) {
                        spannableStringBuilder.setSpan(new ForegroundColorSpan(((Integer) map.get(str3)).intValue()), i12, length, 33);
                    } else {
                        Map map2 = f18369d;
                        if (map2.containsKey(str3)) {
                            spannableStringBuilder.setSpan(new BackgroundColorSpan(((Integer) map2.get(str3)).intValue()), i12, length, 33);
                        }
                    }
                }
                break;
            case 5:
                spannableStringBuilder.setSpan(new lh0(u9Var.f17166c), i12, length, 33);
                break;
            case 6:
            case 7:
                break;
            default:
                return;
        }
        List listZzh = zzh(list2, str, u9Var);
        for (int i18 = 0; i18 < listZzh.size(); i18++) {
            q9 q9Var = ((v9) listZzh.get(i18)).f17572b;
            if (q9Var != null) {
                int i19 = q9Var.f15632j;
                if (i19 != -1 || q9Var.f15633k != -1) {
                    if (((i19 == 1 ? (char) 1 : (char) 0) | (q9Var.f15633k == 1 ? (char) 2 : (char) 0)) != -1) {
                        int i20 = q9Var.f15632j;
                        if (i20 == -1 && q9Var.f15633k == -1) {
                            i11 = -1;
                            i10 = 1;
                        } else {
                            i10 = 1;
                            i11 = (i20 == 1 ? 1 : 0) | (q9Var.f15633k == 1 ? 2 : 0);
                        }
                        ni.j(spannableStringBuilder, new StyleSpan(i11), i12, length);
                    } else {
                        i10 = 1;
                    }
                    if (q9Var.f15631i == i10) {
                        spannableStringBuilder.setSpan(new UnderlineSpan(), i12, length, 33);
                    }
                    if (q9Var.f15628f) {
                        if (!q9Var.f15628f) {
                            throw new IllegalStateException("Font color not defined");
                        }
                        ni.j(spannableStringBuilder, new ForegroundColorSpan(q9Var.f15627e), i12, length);
                    }
                    if (q9Var.f15630h) {
                        if (!q9Var.f15630h) {
                            throw new IllegalStateException("Background color not defined.");
                        }
                        ni.j(spannableStringBuilder, new BackgroundColorSpan(q9Var.f15629g), i12, length);
                    }
                    if (q9Var.zzk() != null) {
                        ni.j(spannableStringBuilder, new TypefaceSpan(q9Var.zzk()), i12, length);
                    }
                    int i21 = q9Var.f15634l;
                    if (i21 == 1) {
                        ni.j(spannableStringBuilder, new AbsoluteSizeSpan((int) q9Var.f15635m, true), i12, length);
                    } else if (i21 == 2) {
                        ni.j(spannableStringBuilder, new RelativeSizeSpan(q9Var.f15635m), i12, length);
                    } else if (i21 == 3) {
                        ni.j(spannableStringBuilder, new RelativeSizeSpan(q9Var.f15635m / 100.0f), i12, length);
                    }
                    if (q9Var.f15637o) {
                        spannableStringBuilder.setSpan(new qe0(), i12, length, 33);
                    }
                }
            }
        }
    }

    private static int zzg(List list, @Nullable String str, u9 u9Var) {
        List listZzh = zzh(list, str, u9Var);
        for (int i10 = 0; i10 < listZzh.size(); i10++) {
            int i11 = ((v9) listZzh.get(i10)).f17572b.f15636n;
            if (i11 != -1) {
                return i11;
            }
        }
        return -1;
    }

    private static List zzh(List list, @Nullable String str, u9 u9Var) {
        ArrayList arrayList = new ArrayList();
        for (int i10 = 0; i10 < list.size(); i10++) {
            q9 q9Var = (q9) list.get(i10);
            int iZze = q9Var.zze(str, u9Var.f17164a, u9Var.f17167d, u9Var.f17166c);
            if (iZze > 0) {
                arrayList.add(new v9(iZze, q9Var));
            }
        }
        Collections.sort(arrayList);
        return arrayList;
    }
}