package com.google.firebase.firestore.local;

import com.google.firebase.firestore.model.BasePath;
import com.google.firebase.firestore.model.FieldPath;
import com.google.firebase.firestore.model.ResourcePath;
import com.google.firebase.firestore.util.Assert;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

/* JADX INFO: loaded from: classes3.dex */
final class EncodedPath {
    private static final char ENCODED_ESCAPE = 17;
    private static final char ENCODED_NUL = 16;
    private static final char ENCODED_SEPARATOR = 1;
    private static final char ESCAPE = 1;

    private static List<String> decode(String str) {
        int length = str.length();
        boolean z6 = false;
        Assert.hardAssert(length >= 2, "Invalid path \"%s\"", str);
        if (length == 2) {
            if (str.charAt(0) == 1 && str.charAt(1) == 1) {
                z6 = true;
            }
            Assert.hardAssert(z6, "Non-empty path \"%s\" had length 2", str);
            return Collections.EMPTY_LIST;
        }
        int length2 = str.length() - 2;
        ArrayList arrayList = new ArrayList();
        StringBuilder sb = new StringBuilder();
        int i6 = 0;
        while (i6 < length) {
            int iIndexOf = str.indexOf(1, i6);
            if (iIndexOf < 0 || iIndexOf > length2) {
                throw new IllegalArgumentException(Z0.o.o("Invalid encoded resource path: \"", str, "\""));
            }
            int i7 = iIndexOf + 1;
            char cCharAt = str.charAt(i7);
            if (cCharAt == 1) {
                String strSubstring = str.substring(i6, iIndexOf);
                if (sb.length() != 0) {
                    sb.append(strSubstring);
                    strSubstring = sb.toString();
                    sb.setLength(0);
                }
                arrayList.add(strSubstring);
            } else if (cCharAt == 16) {
                sb.append(str.substring(i6, iIndexOf));
                sb.append((char) 0);
            } else {
                if (cCharAt != 17) {
                    throw new IllegalArgumentException(Z0.o.o("Invalid encoded resource path: \"", str, "\""));
                }
                sb.append(str.substring(i6, i7));
            }
            i6 = iIndexOf + 2;
        }
        return arrayList;
    }

    public static FieldPath decodeFieldPath(String str) {
        return FieldPath.fromSegments(decode(str));
    }

    public static ResourcePath decodeResourcePath(String str) {
        return ResourcePath.fromSegments(decode(str));
    }

    public static <B extends BasePath<B>> String encode(B b5) {
        StringBuilder sb = new StringBuilder();
        int length = b5.length();
        for (int i6 = 0; i6 < length; i6++) {
            if (sb.length() > 0) {
                encodeSeparator(sb);
            }
            encodeSegment(b5.getSegment(i6), sb);
        }
        encodeSeparator(sb);
        return sb.toString();
    }

    private static void encodeSegment(String str, StringBuilder sb) {
        int length = str.length();
        for (int i6 = 0; i6 < length; i6++) {
            char cCharAt = str.charAt(i6);
            if (cCharAt == 0) {
                sb.append((char) 1);
                sb.append(ENCODED_NUL);
            } else if (cCharAt != 1) {
                sb.append(cCharAt);
            } else {
                sb.append((char) 1);
                sb.append(ENCODED_ESCAPE);
            }
        }
    }

    private static void encodeSeparator(StringBuilder sb) {
        sb.append((char) 1);
        sb.append((char) 1);
    }

    public static String prefixSuccessor(String str) {
        StringBuilder sb = new StringBuilder(str);
        int length = sb.length() - 1;
        char cCharAt = sb.charAt(length);
        Assert.hardAssert(cCharAt == 1, "successor may only operate on paths generated by encode", new Object[0]);
        sb.setCharAt(length, (char) (cCharAt + 1));
        return sb.toString();
    }
}