package w2;

import android.text.TextUtils;
import androidx.annotation.Nullable;
import androidx.media3.common.util.Assertions;
import androidx.media3.common.util.ColorParser;
import androidx.media3.common.util.Log;
import androidx.media3.common.util.ParsableByteArray;
import androidx.media3.common.util.Util;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashSet;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

/* JADX INFO: loaded from: classes.dex */
public final class b {

    /* JADX INFO: renamed from: c, reason: collision with root package name */
    public static final Pattern f34118c = Pattern.compile("\\[voice=\"([^\"]*)\"\\]");

    /* JADX INFO: renamed from: d, reason: collision with root package name */
    public static final Pattern f34119d = Pattern.compile("^((?:[0-9]*\\.)?[0-9]+)(px|em|%)$");

    /* JADX INFO: renamed from: a, reason: collision with root package name */
    public final ParsableByteArray f34120a = new ParsableByteArray();

    /* JADX INFO: renamed from: b, reason: collision with root package name */
    public final StringBuilder f34121b = new StringBuilder();

    public static String b(ParsableByteArray parsableByteArray, StringBuilder sb) {
        boolean z10 = false;
        sb.setLength(0);
        int position = parsableByteArray.getPosition();
        int iLimit = parsableByteArray.limit();
        while (position < iLimit && !z10) {
            char c6 = (char) parsableByteArray.getData()[position];
            if ((c6 < 'A' || c6 > 'Z') && ((c6 < 'a' || c6 > 'z') && !((c6 >= '0' && c6 <= '9') || c6 == '#' || c6 == '-' || c6 == '.' || c6 == '_'))) {
                z10 = true;
            } else {
                position++;
                sb.append(c6);
            }
        }
        parsableByteArray.skipBytes(position - parsableByteArray.getPosition());
        return sb.toString();
    }

    public static void c(ParsableByteArray parsableByteArray) {
        while (true) {
            for (boolean z10 = true; parsableByteArray.bytesLeft() > 0 && z10; z10 = false) {
                char c6 = (char) parsableByteArray.getData()[parsableByteArray.getPosition()];
                if (c6 == '\t' || c6 == '\n' || c6 == '\f' || c6 == '\r' || c6 == ' ') {
                    parsableByteArray.skipBytes(1);
                } else {
                    int position = parsableByteArray.getPosition();
                    int iLimit = parsableByteArray.limit();
                    byte[] data = parsableByteArray.getData();
                    int i10 = position + 2;
                    if (i10 <= iLimit) {
                        int i11 = position + 1;
                        if (data[position] == 47 && data[i11] == 42) {
                            while (true) {
                                int i12 = i10 + 1;
                                if (i12 >= iLimit) {
                                    break;
                                }
                                if (((char) data[i10]) == '*' && ((char) data[i12]) == '/') {
                                    i10 += 2;
                                    iLimit = i10;
                                } else {
                                    i10 = i12;
                                }
                            }
                            parsableByteArray.skipBytes(iLimit - parsableByteArray.getPosition());
                        }
                    }
                }
            }
            return;
        }
    }

    @Nullable
    public static String parseNextToken(ParsableByteArray parsableByteArray, StringBuilder sb) {
        c(parsableByteArray);
        if (parsableByteArray.bytesLeft() == 0) {
            return null;
        }
        String strB = b(parsableByteArray, sb);
        if (!strB.isEmpty()) {
            return strB;
        }
        return "" + ((char) parsableByteArray.readUnsignedByte());
    }

    @Nullable
    private static String parsePropertyValue(ParsableByteArray parsableByteArray, StringBuilder sb) {
        StringBuilder sb2 = new StringBuilder();
        boolean z10 = false;
        while (!z10) {
            int position = parsableByteArray.getPosition();
            String nextToken = parseNextToken(parsableByteArray, sb);
            if (nextToken == null) {
                return null;
            }
            if ("}".equals(nextToken) || ";".equals(nextToken)) {
                parsableByteArray.setPosition(position);
                z10 = true;
            } else {
                sb2.append(nextToken);
            }
        }
        return sb2.toString();
    }

    @Nullable
    private static String parseSelector(ParsableByteArray parsableByteArray, StringBuilder sb) {
        String strTrim;
        c(parsableByteArray);
        if (parsableByteArray.bytesLeft() < 5 || !"::cue".equals(parsableByteArray.readString(5))) {
            return null;
        }
        int position = parsableByteArray.getPosition();
        String nextToken = parseNextToken(parsableByteArray, sb);
        if (nextToken == null) {
            return null;
        }
        if ("{".equals(nextToken)) {
            parsableByteArray.setPosition(position);
            return "";
        }
        if ("(".equals(nextToken)) {
            int position2 = parsableByteArray.getPosition();
            int iLimit = parsableByteArray.limit();
            boolean z10 = false;
            while (position2 < iLimit && !z10) {
                int i10 = position2 + 1;
                z10 = ((char) parsableByteArray.getData()[position2]) == ')';
                position2 = i10;
            }
            strTrim = parsableByteArray.readString((position2 - 1) - parsableByteArray.getPosition()).trim();
        } else {
            strTrim = null;
        }
        if (")".equals(parseNextToken(parsableByteArray, sb))) {
            return strTrim;
        }
        return null;
    }

    /* JADX WARN: Removed duplicated region for block: B:57:0x0117  */
    /* JADX WARN: Removed duplicated region for block: B:58:0x0121  */
    /*
        Code decompiled incorrectly, please refer to instructions dump.
    */
    public final ArrayList a(ParsableByteArray parsableByteArray) {
        StringBuilder sb = this.f34121b;
        sb.setLength(0);
        int position = parsableByteArray.getPosition();
        while (!TextUtils.isEmpty(parsableByteArray.readLine())) {
        }
        byte[] data = parsableByteArray.getData();
        int position2 = parsableByteArray.getPosition();
        ParsableByteArray parsableByteArray2 = this.f34120a;
        parsableByteArray2.reset(data, position2);
        parsableByteArray2.setPosition(position);
        ArrayList arrayList = new ArrayList();
        while (true) {
            String selector = parseSelector(parsableByteArray2, sb);
            if (selector == null) {
                return arrayList;
            }
            if (!"{".equals(parseNextToken(parsableByteArray2, sb))) {
                return arrayList;
            }
            c cVar = new c();
            if (!selector.isEmpty()) {
                int iIndexOf = selector.indexOf(91);
                if (iIndexOf != -1) {
                    Matcher matcher = f34118c.matcher(selector.substring(iIndexOf));
                    if (matcher.matches()) {
                        cVar.f34125d = (String) Assertions.checkNotNull(matcher.group(1));
                    }
                    selector = selector.substring(0, iIndexOf);
                }
                String[] strArrSplit = Util.split(selector, "\\.");
                String str = strArrSplit[0];
                int iIndexOf2 = str.indexOf(35);
                if (iIndexOf2 != -1) {
                    cVar.f34123b = str.substring(0, iIndexOf2);
                    cVar.f34122a = str.substring(iIndexOf2 + 1);
                } else {
                    cVar.f34123b = str;
                }
                if (strArrSplit.length > 1) {
                    cVar.f34124c = new HashSet(Arrays.asList((String[]) Util.nullSafeArrayCopyOfRange(strArrSplit, 1, strArrSplit.length)));
                }
            }
            String str2 = null;
            boolean z10 = false;
            while (!z10) {
                int position3 = parsableByteArray2.getPosition();
                String nextToken = parseNextToken(parsableByteArray2, sb);
                boolean z11 = nextToken == null || "}".equals(nextToken);
                if (!z11) {
                    parsableByteArray2.setPosition(position3);
                    c(parsableByteArray2);
                    String strB = b(parsableByteArray2, sb);
                    if (!strB.isEmpty() && ":".equals(parseNextToken(parsableByteArray2, sb))) {
                        c(parsableByteArray2);
                        String propertyValue = parsePropertyValue(parsableByteArray2, sb);
                        if (propertyValue != null && !propertyValue.isEmpty()) {
                            int position4 = parsableByteArray2.getPosition();
                            String nextToken2 = parseNextToken(parsableByteArray2, sb);
                            if (";".equals(nextToken2)) {
                                if (!"color".equals(strB)) {
                                }
                            } else if ("}".equals(nextToken2)) {
                                parsableByteArray2.setPosition(position4);
                                if (!"color".equals(strB)) {
                                    cVar.f34126e = ColorParser.parseCssColor(propertyValue);
                                    cVar.f34127f = true;
                                } else if ("background-color".equals(strB)) {
                                    cVar.f34128g = ColorParser.parseCssColor(propertyValue);
                                    cVar.f34129h = true;
                                } else if ("ruby-position".equals(strB)) {
                                    if ("over".equals(propertyValue)) {
                                        cVar.f34136o = 1;
                                    } else if ("under".equals(propertyValue)) {
                                        cVar.f34136o = 2;
                                    }
                                } else if ("text-combine-upright".equals(strB)) {
                                    cVar.f34137p = "all".equals(propertyValue) || propertyValue.startsWith("digits");
                                } else if ("text-decoration".equals(strB)) {
                                    if ("underline".equals(propertyValue)) {
                                        cVar.f34131j = 1;
                                    }
                                } else if ("font-family".equals(strB)) {
                                    cVar.setFontFamily(propertyValue);
                                } else if ("font-weight".equals(strB)) {
                                    if ("bold".equals(propertyValue)) {
                                        cVar.f34132k = 1;
                                    }
                                } else if ("font-style".equals(strB)) {
                                    if ("italic".equals(propertyValue)) {
                                        cVar.f34133l = 1;
                                    }
                                } else if ("font-size".equals(strB)) {
                                    Matcher matcher2 = f34119d.matcher(com.google.common.base.h.q(propertyValue));
                                    if (matcher2.matches()) {
                                        String str3 = (String) Assertions.checkNotNull(matcher2.group(2));
                                        str3.getClass();
                                        switch (str3) {
                                            case "%":
                                                cVar.f34134m = 3;
                                                break;
                                            case "em":
                                                cVar.f34134m = 2;
                                                break;
                                            case "px":
                                                cVar.f34134m = 1;
                                                break;
                                            default:
                                                throw new IllegalStateException();
                                        }
                                        cVar.f34135n = Float.parseFloat((String) Assertions.checkNotNull(matcher2.group(1)));
                                    } else {
                                        Log.w("WebvttCssParser", "Invalid font-size: '" + propertyValue + "'.");
                                    }
                                } else {
                                    continue;
                                }
                            } else {
                                continue;
                            }
                        }
                    }
                }
                str2 = nextToken;
                z10 = z11;
            }
            if ("}".equals(str2)) {
                arrayList.add(cVar);
            }
        }
    }
}