package o;

import android.graphics.Color;
import android.os.Process;
import android.os.SystemClock;
import android.util.TypedValue;
import android.view.KeyEvent;
import android.view.View;
import android.view.ViewConfiguration;
import com.google.android.gms.auth.api.credentials.CredentialsApi;
import com.google.android.gms.maps.model.BitmapDescriptorFactory;
import com.huawei.hms.android.HwBuildEx;
import com.huawei.hms.framework.common.ExceptionCode;
import java.lang.reflect.Method;
import java.math.BigDecimal;
import java.math.RoundingMode;
import java.text.DateFormat;
import java.text.SimpleDateFormat;
import java.util.AbstractMap;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashMap;
import java.util.Iterator;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Locale;
import java.util.Map;
import java.util.MissingResourceException;
import java.util.ResourceBundle;
import java.util.Set;
import java.util.TimeZone;
import java.util.TreeMap;
import o.C15563gtx;
import org.bouncycastle.pqc.math.linearalgebra.Matrix;
import org.threeten.bp.DateTimeException;

/* renamed from: o.gtn, reason: case insensitive filesystem */
/* loaded from: classes6.dex */
public final class C15553gtn {
    private static final Map<Character, InterfaceC15537gtP> FIELD_MAP;
    static final Comparator<String> LENGTH_SORT;
    private static final gtQ<AbstractC15502gsH> QUERY_REGION_ONLY = new gtQ<AbstractC15502gsH>() { // from class: o.gtn.3
        @Override // o.gtQ
        public AbstractC15502gsH queryFrom(gtK gtk) {
            AbstractC15502gsH abstractC15502gsH = (AbstractC15502gsH) gtk.query(gtM.zoneId());
            if (abstractC15502gsH == null || (abstractC15502gsH instanceof gsI)) {
                return null;
            }
            return abstractC15502gsH;
        }
    };
    private C15553gtn active;
    private final boolean optional;
    private char padNextChar;
    private int padNextWidth;
    private final C15553gtn parent;
    private final List<RVV> printerParsers;
    private int valueParserIndex;

    /* JADX INFO: Access modifiers changed from: package-private */
    /* renamed from: o.gtn$RVV */
    /* loaded from: classes6.dex */
    public interface RVV {
        int parse(C15561gtv c15561gtv, CharSequence charSequence, int i);

        boolean print(C15560gtu c15560gtu, StringBuilder sb);
    }

    static {
        HashMap hashMap = new HashMap();
        FIELD_MAP = hashMap;
        hashMap.put('G', EnumC15534gtD.ERA);
        hashMap.put('y', EnumC15534gtD.YEAR_OF_ERA);
        hashMap.put('u', EnumC15534gtD.YEAR);
        hashMap.put('Q', gtI.QUARTER_OF_YEAR);
        hashMap.put('q', gtI.QUARTER_OF_YEAR);
        hashMap.put('M', EnumC15534gtD.MONTH_OF_YEAR);
        hashMap.put(Character.valueOf(Matrix.MATRIX_TYPE_RANDOM_LT), EnumC15534gtD.MONTH_OF_YEAR);
        hashMap.put('D', EnumC15534gtD.DAY_OF_YEAR);
        hashMap.put('d', EnumC15534gtD.DAY_OF_MONTH);
        hashMap.put('F', EnumC15534gtD.ALIGNED_DAY_OF_WEEK_IN_MONTH);
        hashMap.put('E', EnumC15534gtD.DAY_OF_WEEK);
        hashMap.put('c', EnumC15534gtD.DAY_OF_WEEK);
        hashMap.put('e', EnumC15534gtD.DAY_OF_WEEK);
        hashMap.put('a', EnumC15534gtD.AMPM_OF_DAY);
        hashMap.put('H', EnumC15534gtD.HOUR_OF_DAY);
        hashMap.put('k', EnumC15534gtD.CLOCK_HOUR_OF_DAY);
        hashMap.put('K', EnumC15534gtD.HOUR_OF_AMPM);
        hashMap.put('h', EnumC15534gtD.CLOCK_HOUR_OF_AMPM);
        hashMap.put('m', EnumC15534gtD.MINUTE_OF_HOUR);
        hashMap.put('s', EnumC15534gtD.SECOND_OF_MINUTE);
        hashMap.put('S', EnumC15534gtD.NANO_OF_SECOND);
        hashMap.put('A', EnumC15534gtD.MILLI_OF_DAY);
        hashMap.put('n', EnumC15534gtD.NANO_OF_SECOND);
        hashMap.put('N', EnumC15534gtD.NANO_OF_DAY);
        LENGTH_SORT = new Comparator<String>() { // from class: o.gtn.4
            @Override // java.util.Comparator
            public final int compare(String str, String str2) {
                return str.length() == str2.length() ? str.compareTo(str2) : str.length() - str2.length();
            }
        };
    }

    public static String getLocalizedDateTimePattern(EnumC15556gtq enumC15556gtq, EnumC15556gtq enumC15556gtq2, gsR gsr, Locale locale) {
        DateFormat timeInstance;
        gtG.requireNonNull(locale, "locale");
        gtG.requireNonNull(gsr, "chrono");
        if (enumC15556gtq == null && enumC15556gtq2 == null) {
            throw new IllegalArgumentException("Either dateStyle or timeStyle must be non-null");
        }
        if (enumC15556gtq == null) {
            timeInstance = DateFormat.getTimeInstance(enumC15556gtq2.ordinal(), locale);
        } else if (enumC15556gtq2 != null) {
            timeInstance = DateFormat.getDateTimeInstance(enumC15556gtq.ordinal(), enumC15556gtq2.ordinal(), locale);
        } else {
            timeInstance = DateFormat.getDateInstance(enumC15556gtq.ordinal(), locale);
        }
        if (timeInstance instanceof SimpleDateFormat) {
            return ((SimpleDateFormat) timeInstance).toPattern();
        }
        throw new IllegalArgumentException("Unable to determine pattern");
    }

    public C15553gtn() {
        this.active = this;
        this.printerParsers = new ArrayList();
        this.valueParserIndex = -1;
        this.parent = null;
        this.optional = false;
    }

    private C15553gtn(C15553gtn c15553gtn, boolean z) {
        this.active = this;
        this.printerParsers = new ArrayList();
        this.valueParserIndex = -1;
        this.parent = c15553gtn;
        this.optional = z;
    }

    public final C15553gtn parseCaseSensitive() {
        appendInternal(ZnX.SENSITIVE);
        return this;
    }

    public final C15553gtn parseCaseInsensitive() {
        appendInternal(ZnX.INSENSITIVE);
        return this;
    }

    public final C15553gtn parseStrict() {
        appendInternal(ZnX.STRICT);
        return this;
    }

    /* JADX INFO: Access modifiers changed from: package-private */
    /* renamed from: o.gtn$jNh */
    /* loaded from: classes6.dex */
    public static final class jNh implements RVV {
        static final jNh INSTANCE_ID;
        static final jNh INSTANCE_ID_ZERO;
        static final String[] PATTERNS;
        private static char[] b;
        private static char c;
        private static int d;
        private final String noOffsetText;
        private final int type;
        private static final byte[] $$a = {0, -67, 121, 0};
        private static final int $$b = 13;
        private static int $10 = 0;
        private static int $11 = 1;
        private static int a = 1;

        /* JADX WARN: Removed duplicated region for block: B:10:0x0025  */
        /* JADX WARN: Removed duplicated region for block: B:7:0x001d  */
        /* JADX WARN: Unsupported multi-entry loop pattern (BACK_EDGE: B:10:0x0025 -> B:4:0x0027). Please report as a decompilation issue!!! */
        /*
            Code decompiled incorrectly, please refer to instructions dump.
            To view partially-correct add '--show-bad-code' argument
        */
        private static void g(short r6, byte r7, int r8, java.lang.Object[] r9) {
            /*
                int r7 = r7 * 2
                int r7 = r7 + 1
                int r8 = 120 - r8
                int r6 = r6 * 3
                int r6 = r6 + 4
                byte[] r0 = o.C15553gtn.jNh.$$a
                byte[] r1 = new byte[r7]
                r2 = 0
                if (r0 != 0) goto L15
                r3 = r8
                r5 = r2
                r8 = r6
                goto L27
            L15:
                r3 = r2
            L16:
                byte r4 = (byte) r8
                int r5 = r3 + 1
                r1[r3] = r4
                if (r5 != r7) goto L25
                java.lang.String r6 = new java.lang.String
                r6.<init>(r1, r2)
                r9[r2] = r6
                return
            L25:
                r3 = r0[r6]
            L27:
                int r6 = r6 + 1
                int r3 = -r3
                int r8 = r8 + r3
                r3 = r5
                goto L16
            */
            throw new UnsupportedOperationException("Method not decompiled: o.C15553gtn.jNh.g(short, byte, int, java.lang.Object[]):void");
        }

        private static void f(int i, char[] cArr, byte b2, Object[] objArr) {
            int i2;
            Object obj;
            int i3 = 2 % 2;
            IRS irs = new IRS();
            char[] cArr2 = b;
            float f = BitmapDescriptorFactory.HUE_RED;
            Object obj2 = null;
            if (cArr2 != null) {
                int length = cArr2.length;
                char[] cArr3 = new char[length];
                int i4 = 0;
                while (i4 < length) {
                    try {
                        Object[] objArr2 = {Integer.valueOf(cArr2[i4])};
                        Object obj3 = xzZ.y.get(-1987398494);
                        if (obj3 == null) {
                            Class cls = (Class) xzZ.c((TypedValue.complexToFloat(0) > f ? 1 : (TypedValue.complexToFloat(0) == f ? 0 : -1)) + 298, 5 - (ViewConfiguration.getKeyRepeatTimeout() >> 16), (char) (1 - (ViewConfiguration.getScrollFriction() > f ? 1 : (ViewConfiguration.getScrollFriction() == f ? 0 : -1))));
                            byte b3 = $$a[0];
                            byte b4 = b3;
                            Object[] objArr3 = new Object[1];
                            g(b3, b4, (byte) (b4 + 3), objArr3);
                            obj3 = cls.getMethod((String) objArr3[0], Integer.TYPE);
                            xzZ.y.put(-1987398494, obj3);
                        }
                        cArr3[i4] = ((Character) ((Method) obj3).invoke(null, objArr2)).charValue();
                        i4++;
                        f = BitmapDescriptorFactory.HUE_RED;
                    } catch (Throwable th) {
                        Throwable cause = th.getCause();
                        if (cause == null) {
                            throw th;
                        }
                        throw cause;
                    }
                }
                cArr2 = cArr3;
            }
            Object[] objArr4 = {Integer.valueOf(c)};
            Object obj4 = xzZ.y.get(-1987398494);
            long j = 0;
            if (obj4 == null) {
                Class cls2 = (Class) xzZ.c(298 - Color.alpha(0), 5 - (ViewConfiguration.getMaximumDrawingCacheSize() >> 24), (char) ((Process.getElapsedCpuTime() > 0L ? 1 : (Process.getElapsedCpuTime() == 0L ? 0 : -1)) - 1));
                byte b5 = $$a[0];
                byte b6 = b5;
                Object[] objArr5 = new Object[1];
                g(b5, b6, (byte) (b6 + 3), objArr5);
                obj4 = cls2.getMethod((String) objArr5[0], Integer.TYPE);
                xzZ.y.put(-1987398494, obj4);
            }
            char charValue = ((Character) ((Method) obj4).invoke(null, objArr4)).charValue();
            char[] cArr4 = new char[i];
            if (i % 2 != 0) {
                int i5 = $11 + 105;
                $10 = i5 % 128;
                int i6 = i5 % 2;
                i2 = i - 1;
                cArr4[i2] = (char) (cArr[i2] - b2);
            } else {
                i2 = i;
            }
            if (i2 > 1) {
                irs.e = 0;
                while (irs.e < i2) {
                    irs.b = cArr[irs.e];
                    irs.c = cArr[irs.e + 1];
                    if (irs.b == irs.c) {
                        int i7 = $10 + 49;
                        $11 = i7 % 128;
                        int i8 = i7 % 2;
                        cArr4[irs.e] = (char) (irs.b - b2);
                        cArr4[irs.e + 1] = (char) (irs.c - b2);
                        obj = obj2;
                    } else {
                        Object[] objArr6 = {irs, irs, Integer.valueOf(charValue), irs, irs, Integer.valueOf(charValue), irs, irs, Integer.valueOf(charValue), irs, irs, Integer.valueOf(charValue), irs};
                        Object obj5 = xzZ.y.get(822107368);
                        if (obj5 == null) {
                            Class cls3 = (Class) xzZ.c((TypedValue.complexToFloat(0) > BitmapDescriptorFactory.HUE_RED ? 1 : (TypedValue.complexToFloat(0) == BitmapDescriptorFactory.HUE_RED ? 0 : -1)) + 233, 6 - (SystemClock.elapsedRealtime() > j ? 1 : (SystemClock.elapsedRealtime() == j ? 0 : -1)), (char) (View.MeasureSpec.getMode(0) + 22024));
                            byte b7 = $$a[0];
                            byte b8 = b7;
                            Object[] objArr7 = new Object[1];
                            g(b7, b8, b8, objArr7);
                            obj5 = cls3.getMethod((String) objArr7[0], Object.class, Object.class, Integer.TYPE, Object.class, Object.class, Integer.TYPE, Object.class, Object.class, Integer.TYPE, Object.class, Object.class, Integer.TYPE, Object.class);
                            xzZ.y.put(822107368, obj5);
                        }
                        if (((Integer) ((Method) obj5).invoke(null, objArr6)).intValue() == irs.j) {
                            Object[] objArr8 = {irs, irs, Integer.valueOf(charValue), Integer.valueOf(charValue), irs, irs, Integer.valueOf(charValue), Integer.valueOf(charValue), irs, Integer.valueOf(charValue), irs};
                            Object obj6 = xzZ.y.get(-1152873385);
                            if (obj6 == null) {
                                Class cls4 = (Class) xzZ.c(((Process.getThreadPriority(0) + 20) >> 6) + 327, (SystemClock.elapsedRealtime() > 0L ? 1 : (SystemClock.elapsedRealtime() == 0L ? 0 : -1)) + 4, (char) KeyEvent.normalizeMetaState(0));
                                byte b9 = $$a[0];
                                byte b10 = b9;
                                Object[] objArr9 = new Object[1];
                                g(b9, b10, (byte) (b10 + 2), objArr9);
                                obj6 = cls4.getMethod((String) objArr9[0], Object.class, Object.class, Integer.TYPE, Integer.TYPE, Object.class, Object.class, Integer.TYPE, Integer.TYPE, Object.class, Integer.TYPE, Object.class);
                                xzZ.y.put(-1152873385, obj6);
                            }
                            obj = null;
                            int intValue = ((Integer) ((Method) obj6).invoke(null, objArr8)).intValue();
                            int i9 = (irs.d * charValue) + irs.j;
                            cArr4[irs.e] = cArr2[intValue];
                            cArr4[irs.e + 1] = cArr2[i9];
                        } else {
                            obj = null;
                            if (irs.a == irs.d) {
                                irs.f = ((irs.f + charValue) - 1) % charValue;
                                irs.j = ((irs.j + charValue) - 1) % charValue;
                                int i10 = (irs.a * charValue) + irs.f;
                                int i11 = (irs.d * charValue) + irs.j;
                                cArr4[irs.e] = cArr2[i10];
                                cArr4[irs.e + 1] = cArr2[i11];
                            } else {
                                int i12 = (irs.a * charValue) + irs.j;
                                int i13 = (irs.d * charValue) + irs.f;
                                cArr4[irs.e] = cArr2[i12];
                                cArr4[irs.e + 1] = cArr2[i13];
                            }
                        }
                    }
                    irs.e += 2;
                    obj2 = obj;
                    j = 0;
                }
            }
            int i14 = $11 + 79;
            $10 = i14 % 128;
            int i15 = i14 % 2;
            int i16 = 0;
            while (i16 < i) {
                int i17 = $11 + 61;
                $10 = i17 % 128;
                if (i17 % 2 != 0) {
                    cArr4[i16] = (char) (cArr4[i16] ^ 21716);
                    i16 += 54;
                } else {
                    cArr4[i16] = (char) (cArr4[i16] ^ 13722);
                    i16++;
                }
            }
            objArr[0] = new String(cArr4);
        }

        static {
            d = 0;
            a();
            PATTERNS = new String[]{"+HH", "+HHmm", "+HH:mm", "+HHMM", "+HH:MM", "+HHMMss", "+HH:MM:ss", "+HHMMSS", "+HH:MM:SS"};
            INSTANCE_ID = new jNh("Z", "+HH:MM:ss");
            Object[] objArr = new Object[1];
            f((ViewConfiguration.getDoubleTapTimeout() >> 16) + 1, new char[]{13838}, (byte) (100 - Color.blue(0)), objArr);
            INSTANCE_ID_ZERO = new jNh(((String) objArr[0]).intern(), "+HH:MM:ss");
            int i = a + 111;
            d = i % 128;
            int i2 = i % 2;
        }

        jNh(String str, String str2) {
            gtG.requireNonNull(str, "noOffsetText");
            gtG.requireNonNull(str2, "pattern");
            this.noOffsetText = str;
            this.type = checkPattern(str2);
        }

        private int checkPattern(String str) {
            int i = 2 % 2;
            int i2 = 0;
            while (true) {
                String[] strArr = PATTERNS;
                if (i2 >= strArr.length) {
                    throw new IllegalArgumentException("Invalid zone offset pattern: ".concat(String.valueOf(str)));
                }
                int i3 = a + 77;
                d = i3 % 128;
                Object obj = null;
                if (i3 % 2 != 0) {
                    strArr[i2].equals(str);
                    throw null;
                }
                if (!(!strArr[i2].equals(str))) {
                    int i4 = a + 23;
                    d = i4 % 128;
                    if (i4 % 2 == 0) {
                        return i2;
                    }
                    obj.hashCode();
                    throw null;
                }
                i2++;
            }
        }

        /* JADX WARN: Code restructure failed: missing block: B:18:0x0075, code lost:
        
            if (r9 > 0) goto L21;
         */
        /* JADX WARN: Code restructure failed: missing block: B:23:0x007a, code lost:
        
            if (r3 <= 0) goto L35;
         */
        /* JADX WARN: Code restructure failed: missing block: B:24:0x0078, code lost:
        
            if (r9 > 0) goto L21;
         */
        /* JADX WARN: Removed duplicated region for block: B:20:0x00c7  */
        /* JADX WARN: Removed duplicated region for block: B:22:? A[RETURN, SYNTHETIC] */
        @Override // o.C15553gtn.RVV
        /*
            Code decompiled incorrectly, please refer to instructions dump.
            To view partially-correct add '--show-bad-code' argument
        */
        public final boolean print(o.C15560gtu r9, java.lang.StringBuilder r10) {
            /*
                Method dump skipped, instructions count: 209
                To view this dump add '--comments-level debug' option
            */
            throw new UnsupportedOperationException("Method not decompiled: o.C15553gtn.jNh.print(o.gtu, java.lang.StringBuilder):boolean");
        }

        /* JADX WARN: Code restructure failed: missing block: B:11:0x0076, code lost:
        
            if (r1 == '-') goto L23;
         */
        @Override // o.C15553gtn.RVV
        /*
            Code decompiled incorrectly, please refer to instructions dump.
            To view partially-correct add '--show-bad-code' argument
        */
        public final int parse(o.C15561gtv r16, java.lang.CharSequence r17, int r18) {
            /*
                Method dump skipped, instructions count: 232
                To view this dump add '--comments-level debug' option
            */
            throw new UnsupportedOperationException("Method not decompiled: o.C15553gtn.jNh.parse(o.gtv, java.lang.CharSequence, int):int");
        }

        private boolean parseNumber(int[] iArr, int i, CharSequence charSequence, boolean z) {
            int i2;
            int i3 = 2 % 2;
            int i4 = this.type;
            if ((i4 + 3) / 2 < i) {
                int i5 = d + 47;
                a = i5 % 128;
                int i6 = i5 % 2;
                return false;
            }
            int i7 = iArr[0];
            if (i4 % 2 == 0 && i > 1) {
                int i8 = i7 + 1;
                if (i8 > charSequence.length() || charSequence.charAt(i7) != ':') {
                    return z;
                }
                i7 = i8;
            }
            int i9 = i7 + 2;
            if (i9 > charSequence.length()) {
                int i10 = d + 11;
                a = i10 % 128;
                int i11 = i10 % 2;
                return z;
            }
            char charAt = charSequence.charAt(i7);
            char charAt2 = charSequence.charAt(i7 + 1);
            if (charAt >= '0' && charAt <= '9') {
                int i12 = a + 125;
                d = i12 % 128;
                if (i12 % 2 == 0 ? charAt2 >= '0' : charAt2 >= 27) {
                    if (charAt2 <= '9' && (i2 = ((charAt - '0') * 10) + (charAt2 - '0')) >= 0 && i2 <= 59) {
                        iArr[i] = i2;
                        iArr[0] = i9;
                        return false;
                    }
                }
            }
            return z;
        }

        public final String toString() {
            int i = 2 % 2;
            String replace = this.noOffsetText.replace("'", "''");
            StringBuilder sb = new StringBuilder("Offset(");
            sb.append(PATTERNS[this.type]);
            sb.append(",'");
            sb.append(replace);
            sb.append("')");
            String obj = sb.toString();
            int i2 = a + 73;
            d = i2 % 128;
            int i3 = i2 % 2;
            return obj;
        }

        static void a() {
            b = new char[]{49027};
            c = (char) 35368;
        }
    }

    public final C15553gtn parseLenient() {
        appendInternal(ZnX.LENIENT);
        return this;
    }

    public final C15553gtn parseDefaulting(InterfaceC15537gtP interfaceC15537gtP, long j) {
        gtG.requireNonNull(interfaceC15537gtP, "field");
        appendInternal(new Sts(interfaceC15537gtP, j));
        return this;
    }

    public final C15553gtn appendValue(InterfaceC15537gtP interfaceC15537gtP) {
        gtG.requireNonNull(interfaceC15537gtP, "field");
        appendValue(new ojQ(interfaceC15537gtP, 1, 19, EnumC15564gty.NORMAL));
        return this;
    }

    public final C15553gtn appendValue(InterfaceC15537gtP interfaceC15537gtP, int i) {
        gtG.requireNonNull(interfaceC15537gtP, "field");
        if (i <= 0 || i > 19) {
            throw new IllegalArgumentException("The width must be from 1 to 19 inclusive but was ".concat(String.valueOf(i)));
        }
        appendValue(new ojQ(interfaceC15537gtP, i, i, EnumC15564gty.NOT_NEGATIVE));
        return this;
    }

    public final C15553gtn appendValue(InterfaceC15537gtP interfaceC15537gtP, int i, int i2, EnumC15564gty enumC15564gty) {
        if (i == i2 && enumC15564gty == EnumC15564gty.NOT_NEGATIVE) {
            return appendValue(interfaceC15537gtP, i2);
        }
        gtG.requireNonNull(interfaceC15537gtP, "field");
        gtG.requireNonNull(enumC15564gty, "signStyle");
        if (i <= 0 || i > 19) {
            throw new IllegalArgumentException("The minimum width must be from 1 to 19 inclusive but was ".concat(String.valueOf(i)));
        }
        if (i2 <= 0 || i2 > 19) {
            throw new IllegalArgumentException("The maximum width must be from 1 to 19 inclusive but was ".concat(String.valueOf(i2)));
        }
        if (i2 < i) {
            StringBuilder sb = new StringBuilder("The maximum width must exceed or equal the minimum width but ");
            sb.append(i2);
            sb.append(" < ");
            sb.append(i);
            throw new IllegalArgumentException(sb.toString());
        }
        appendValue(new ojQ(interfaceC15537gtP, i, i2, enumC15564gty));
        return this;
    }

    public final C15553gtn appendValueReduced(InterfaceC15537gtP interfaceC15537gtP, int i, int i2, int i3) {
        gtG.requireNonNull(interfaceC15537gtP, "field");
        appendValue(new vUG(interfaceC15537gtP, i, i2, i3, null));
        return this;
    }

    public final C15553gtn appendValueReduced(InterfaceC15537gtP interfaceC15537gtP, int i, int i2, gsJ gsj) {
        gtG.requireNonNull(interfaceC15537gtP, "field");
        gtG.requireNonNull(gsj, "baseDate");
        appendValue(new vUG(interfaceC15537gtP, i, i2, 0, gsj));
        return this;
    }

    private C15553gtn appendValue(ojQ ojq) {
        ojQ withFixedWidth;
        C15553gtn c15553gtn = this.active;
        int i = c15553gtn.valueParserIndex;
        if (i >= 0 && (c15553gtn.printerParsers.get(i) instanceof ojQ)) {
            C15553gtn c15553gtn2 = this.active;
            int i2 = c15553gtn2.valueParserIndex;
            ojQ ojq2 = (ojQ) c15553gtn2.printerParsers.get(i2);
            if (ojq.minWidth == ojq.maxWidth && ojq.signStyle == EnumC15564gty.NOT_NEGATIVE) {
                withFixedWidth = ojq2.withSubsequentWidth(ojq.maxWidth);
                appendInternal(ojq.withFixedWidth());
                this.active.valueParserIndex = i2;
            } else {
                withFixedWidth = ojq2.withFixedWidth();
                this.active.valueParserIndex = appendInternal(ojq);
            }
            this.active.printerParsers.set(i2, withFixedWidth);
        } else {
            this.active.valueParserIndex = appendInternal(ojq);
        }
        return this;
    }

    public final C15553gtn appendFraction(InterfaceC15537gtP interfaceC15537gtP, int i, int i2, boolean z) {
        appendInternal(new saX(interfaceC15537gtP, i, i2, z));
        return this;
    }

    public final C15553gtn appendText(InterfaceC15537gtP interfaceC15537gtP) {
        return appendText(interfaceC15537gtP, EnumC15532gtB.FULL);
    }

    public final C15553gtn appendText(InterfaceC15537gtP interfaceC15537gtP, EnumC15532gtB enumC15532gtB) {
        gtG.requireNonNull(interfaceC15537gtP, "field");
        gtG.requireNonNull(enumC15532gtB, "textStyle");
        appendInternal(new Plv(interfaceC15537gtP, enumC15532gtB, AbstractC15557gtr.getInstance()));
        return this;
    }

    public final C15553gtn appendText(InterfaceC15537gtP interfaceC15537gtP, Map<Long, String> map) {
        gtG.requireNonNull(interfaceC15537gtP, "field");
        gtG.requireNonNull(map, "textLookup");
        appendInternal(new Plv(interfaceC15537gtP, EnumC15532gtB.FULL, new AbstractC15557gtr(this, new C15563gtx.LWm(Collections.singletonMap(EnumC15532gtB.FULL, new LinkedHashMap(map)))) { // from class: o.gtn.2
            final C15553gtn this$0;
            final C15563gtx.LWm val$store;

            {
                this.this$0 = this;
                this.val$store = r2;
            }

            @Override // o.AbstractC15557gtr
            public final String getText(InterfaceC15537gtP interfaceC15537gtP2, long j, EnumC15532gtB enumC15532gtB, Locale locale) {
                return this.val$store.getText(j, enumC15532gtB);
            }

            @Override // o.AbstractC15557gtr
            public final Iterator<Map.Entry<String, Long>> getTextIterator(InterfaceC15537gtP interfaceC15537gtP2, EnumC15532gtB enumC15532gtB, Locale locale) {
                return this.val$store.getTextIterator(enumC15532gtB);
            }
        }));
        return this;
    }

    public final C15553gtn appendInstant() {
        appendInternal(new jbe(-2));
        return this;
    }

    public final C15553gtn appendInstant(int i) {
        if (i < -1 || i > 9) {
            throw new IllegalArgumentException("Invalid fractional digits: ".concat(String.valueOf(i)));
        }
        appendInternal(new jbe(i));
        return this;
    }

    public final C15553gtn appendOffsetId() {
        appendInternal(jNh.INSTANCE_ID);
        return this;
    }

    public final C15553gtn appendOffset(String str, String str2) {
        appendInternal(new jNh(str2, str));
        return this;
    }

    public final C15553gtn appendLocalizedOffset(EnumC15532gtB enumC15532gtB) {
        gtG.requireNonNull(enumC15532gtB, "style");
        if (enumC15532gtB != EnumC15532gtB.FULL && enumC15532gtB != EnumC15532gtB.SHORT) {
            throw new IllegalArgumentException("Style must be either full or short");
        }
        appendInternal(new ZqN(enumC15532gtB));
        return this;
    }

    public final C15553gtn appendZoneId() {
        appendInternal(new Heg(gtM.zoneId(), "ZoneId()"));
        return this;
    }

    public final C15553gtn appendZoneRegionId() {
        appendInternal(new Heg(QUERY_REGION_ONLY, "ZoneRegionId()"));
        return this;
    }

    public final C15553gtn appendZoneOrOffsetId() {
        appendInternal(new Heg(gtM.zone(), "ZoneOrOffsetId()"));
        return this;
    }

    public final C15553gtn appendZoneText(EnumC15532gtB enumC15532gtB) {
        appendInternal(new huo(enumC15532gtB));
        return this;
    }

    public final C15553gtn appendZoneText(EnumC15532gtB enumC15532gtB, Set<AbstractC15502gsH> set) {
        gtG.requireNonNull(set, "preferredZones");
        appendInternal(new huo(enumC15532gtB));
        return this;
    }

    public final C15553gtn appendChronologyId() {
        appendInternal(new IeS(null));
        return this;
    }

    public final C15553gtn appendChronologyText(EnumC15532gtB enumC15532gtB) {
        gtG.requireNonNull(enumC15532gtB, "textStyle");
        appendInternal(new IeS(enumC15532gtB));
        return this;
    }

    public final C15553gtn appendLocalized(EnumC15556gtq enumC15556gtq, EnumC15556gtq enumC15556gtq2) {
        if (enumC15556gtq == null && enumC15556gtq2 == null) {
            throw new IllegalArgumentException("Either the date or time style must be non-null");
        }
        appendInternal(new tOB(enumC15556gtq, enumC15556gtq2));
        return this;
    }

    public final C15553gtn appendLiteral(char c) {
        appendInternal(new LWm(c));
        return this;
    }

    public final C15553gtn appendLiteral(String str) {
        gtG.requireNonNull(str, "literal");
        if (str.length() > 0) {
            if (str.length() == 1) {
                appendInternal(new LWm(str.charAt(0)));
            } else {
                appendInternal(new dAO(str));
            }
        }
        return this;
    }

    public final C15553gtn append(C15554gto c15554gto) {
        gtG.requireNonNull(c15554gto, "formatter");
        appendInternal(c15554gto.toPrinterParser(false));
        return this;
    }

    public final C15553gtn appendOptional(C15554gto c15554gto) {
        gtG.requireNonNull(c15554gto, "formatter");
        appendInternal(c15554gto.toPrinterParser(true));
        return this;
    }

    public final C15553gtn appendPattern(String str) {
        gtG.requireNonNull(str, "pattern");
        parsePattern(str);
        return this;
    }

    private void parsePattern(String str) {
        int i;
        int i2 = 0;
        while (i2 < str.length()) {
            char charAt = str.charAt(i2);
            if ((charAt >= 'A' && charAt <= 'Z') || (charAt >= 'a' && charAt <= 'z')) {
                int i3 = i2 + 1;
                while (i3 < str.length() && str.charAt(i3) == charAt) {
                    i3++;
                }
                int i4 = i3 - i2;
                if (charAt == 'p') {
                    if (i3 >= str.length() || (((charAt = str.charAt(i3)) < 'A' || charAt > 'Z') && (charAt < 'a' || charAt > 'z'))) {
                        i = i4;
                        i4 = 0;
                    } else {
                        int i5 = i3 + 1;
                        while (i5 < str.length() && str.charAt(i5) == charAt) {
                            i5++;
                        }
                        i = i5 - i3;
                        i3 = i5;
                    }
                    if (i4 == 0) {
                        throw new IllegalArgumentException("Pad letter 'p' must be followed by valid pad pattern: ".concat(String.valueOf(str)));
                    }
                    padNext(i4);
                    i4 = i;
                }
                InterfaceC15537gtP interfaceC15537gtP = FIELD_MAP.get(Character.valueOf(charAt));
                if (interfaceC15537gtP != null) {
                    parseField(charAt, i4, interfaceC15537gtP);
                } else if (charAt == 'z') {
                    if (i4 > 4) {
                        throw new IllegalArgumentException("Too many pattern letters: ".concat(String.valueOf(charAt)));
                    }
                    if (i4 == 4) {
                        appendZoneText(EnumC15532gtB.FULL);
                    } else {
                        appendZoneText(EnumC15532gtB.SHORT);
                    }
                } else if (charAt != 'V') {
                    String str2 = "+0000";
                    if (charAt == 'Z') {
                        if (i4 < 4) {
                            appendOffset("+HHMM", "+0000");
                        } else if (i4 == 4) {
                            appendLocalizedOffset(EnumC15532gtB.FULL);
                        } else if (i4 == 5) {
                            appendOffset("+HH:MM:ss", "Z");
                        } else {
                            throw new IllegalArgumentException("Too many pattern letters: ".concat(String.valueOf(charAt)));
                        }
                    } else if (charAt == 'O') {
                        if (i4 == 1) {
                            appendLocalizedOffset(EnumC15532gtB.SHORT);
                        } else if (i4 == 4) {
                            appendLocalizedOffset(EnumC15532gtB.FULL);
                        } else {
                            throw new IllegalArgumentException("Pattern letter count must be 1 or 4: ".concat(String.valueOf(charAt)));
                        }
                    } else if (charAt == 'X') {
                        if (i4 > 5) {
                            throw new IllegalArgumentException("Too many pattern letters: ".concat(String.valueOf(charAt)));
                        }
                        appendOffset(jNh.PATTERNS[i4 + (i4 == 1 ? 0 : 1)], "Z");
                    } else if (charAt == 'x') {
                        if (i4 > 5) {
                            throw new IllegalArgumentException("Too many pattern letters: ".concat(String.valueOf(charAt)));
                        }
                        if (i4 == 1) {
                            str2 = "+00";
                        } else if (i4 % 2 != 0) {
                            str2 = "+00:00";
                        }
                        appendOffset(jNh.PATTERNS[i4 + (i4 == 1 ? 0 : 1)], str2);
                    } else if (charAt == 'W') {
                        if (i4 > 1) {
                            throw new IllegalArgumentException("Too many pattern letters: ".concat(String.valueOf(charAt)));
                        }
                        appendInternal(new mxa('W', i4));
                    } else if (charAt == 'w') {
                        if (i4 > 2) {
                            throw new IllegalArgumentException("Too many pattern letters: ".concat(String.valueOf(charAt)));
                        }
                        appendInternal(new mxa('w', i4));
                    } else if (charAt == 'Y') {
                        appendInternal(new mxa('Y', i4));
                    } else {
                        throw new IllegalArgumentException("Unknown pattern letter: ".concat(String.valueOf(charAt)));
                    }
                } else {
                    if (i4 != 2) {
                        throw new IllegalArgumentException("Pattern letter count must be 2: ".concat(String.valueOf(charAt)));
                    }
                    appendZoneId();
                }
                i2 = i3 - 1;
            } else if (charAt == '\'') {
                int i6 = i2 + 1;
                int i7 = i6;
                while (i7 < str.length()) {
                    if (str.charAt(i7) == '\'') {
                        int i8 = i7 + 1;
                        if (i8 >= str.length() || str.charAt(i8) != '\'') {
                            break;
                        } else {
                            i7 = i8;
                        }
                    }
                    i7++;
                }
                if (i7 >= str.length()) {
                    throw new IllegalArgumentException("Pattern ends with an incomplete string literal: ".concat(String.valueOf(str)));
                }
                String substring = str.substring(i6, i7);
                if (substring.length() == 0) {
                    appendLiteral('\'');
                } else {
                    appendLiteral(substring.replace("''", "'"));
                }
                i2 = i7;
            } else if (charAt == '[') {
                optionalStart();
            } else if (charAt == ']') {
                if (this.active.parent == null) {
                    throw new IllegalArgumentException("Pattern invalid as it contains ] without previous [");
                }
                optionalEnd();
            } else {
                if (charAt == '{' || charAt == '}' || charAt == '#') {
                    StringBuilder sb = new StringBuilder("Pattern includes reserved character: '");
                    sb.append(charAt);
                    sb.append("'");
                    throw new IllegalArgumentException(sb.toString());
                }
                appendLiteral(charAt);
            }
            i2++;
        }
    }

    /* JADX WARN: Failed to find 'out' block for switch in B:21:0x002f. Please report as an issue. */
    /* JADX WARN: Removed duplicated region for block: B:115:0x0160  */
    /* JADX WARN: Removed duplicated region for block: B:117:0x0164  */
    /*
        Code decompiled incorrectly, please refer to instructions dump.
        To view partially-correct add '--show-bad-code' argument
    */
    private void parseField(char r8, int r9, o.InterfaceC15537gtP r10) {
        /*
            Method dump skipped, instructions count: 490
            To view this dump add '--comments-level debug' option
        */
        throw new UnsupportedOperationException("Method not decompiled: o.C15553gtn.parseField(char, int, o.gtP):void");
    }

    public final C15553gtn padNext(int i) {
        return padNext(i, ' ');
    }

    public final C15553gtn padNext(int i, char c) {
        if (i <= 0) {
            throw new IllegalArgumentException("The pad width must be at least one but was ".concat(String.valueOf(i)));
        }
        C15553gtn c15553gtn = this.active;
        c15553gtn.padNextWidth = i;
        c15553gtn.padNextChar = c;
        c15553gtn.valueParserIndex = -1;
        return this;
    }

    public final C15553gtn optionalStart() {
        C15553gtn c15553gtn = this.active;
        c15553gtn.valueParserIndex = -1;
        this.active = new C15553gtn(c15553gtn, true);
        return this;
    }

    public final C15553gtn optionalEnd() {
        C15553gtn c15553gtn = this.active;
        if (c15553gtn.parent == null) {
            throw new IllegalStateException("Cannot call optionalEnd() as there was no previous call to optionalStart()");
        }
        if (c15553gtn.printerParsers.size() > 0) {
            C15553gtn c15553gtn2 = this.active;
            HBt hBt = new HBt(c15553gtn2.printerParsers, c15553gtn2.optional);
            this.active = this.active.parent;
            appendInternal(hBt);
        } else {
            this.active = this.active.parent;
        }
        return this;
    }

    private int appendInternal(RVV rvv) {
        gtG.requireNonNull(rvv, "pp");
        C15553gtn c15553gtn = this.active;
        int i = c15553gtn.padNextWidth;
        if (i > 0) {
            if (rvv != null) {
                rvv = new NHB(rvv, i, c15553gtn.padNextChar);
            }
            C15553gtn c15553gtn2 = this.active;
            c15553gtn2.padNextWidth = 0;
            c15553gtn2.padNextChar = (char) 0;
        }
        this.active.printerParsers.add(rvv);
        this.active.valueParserIndex = -1;
        return r4.printerParsers.size() - 1;
    }

    public final C15554gto toFormatter() {
        return toFormatter(Locale.getDefault());
    }

    public final C15554gto toFormatter(Locale locale) {
        gtG.requireNonNull(locale, "locale");
        while (this.active.parent != null) {
            optionalEnd();
        }
        return new C15554gto(new HBt(this.printerParsers, false), locale, C15559gtt.STANDARD, gtA.SMART, null, null, null);
    }

    /* JADX INFO: Access modifiers changed from: package-private */
    public final C15554gto toFormatter(gtA gta) {
        return toFormatter().withResolverStyle(gta);
    }

    /* JADX INFO: Access modifiers changed from: package-private */
    /* renamed from: o.gtn$HBt */
    /* loaded from: classes6.dex */
    public static final class HBt implements RVV {
        private final boolean optional;
        private final RVV[] printerParsers;

        HBt(List<RVV> list, boolean z) {
            this((RVV[]) list.toArray(new RVV[list.size()]), z);
        }

        HBt(RVV[] rvvArr, boolean z) {
            this.printerParsers = rvvArr;
            this.optional = z;
        }

        public final HBt withOptional(boolean z) {
            return z == this.optional ? this : new HBt(this.printerParsers, z);
        }

        @Override // o.C15553gtn.RVV
        public final boolean print(C15560gtu c15560gtu, StringBuilder sb) {
            int length = sb.length();
            if (this.optional) {
                c15560gtu.startOptional();
            }
            try {
                for (RVV rvv : this.printerParsers) {
                    if (!rvv.print(c15560gtu, sb)) {
                        sb.setLength(length);
                        return true;
                    }
                }
                if (this.optional) {
                    c15560gtu.endOptional();
                }
                return true;
            } finally {
                if (this.optional) {
                    c15560gtu.endOptional();
                }
            }
        }

        @Override // o.C15553gtn.RVV
        public final int parse(C15561gtv c15561gtv, CharSequence charSequence, int i) {
            if (this.optional) {
                c15561gtv.startOptional();
                int i2 = i;
                for (RVV rvv : this.printerParsers) {
                    i2 = rvv.parse(c15561gtv, charSequence, i2);
                    if (i2 < 0) {
                        c15561gtv.endOptional(false);
                        return i;
                    }
                }
                c15561gtv.endOptional(true);
                return i2;
            }
            for (RVV rvv2 : this.printerParsers) {
                i = rvv2.parse(c15561gtv, charSequence, i);
                if (i < 0) {
                    break;
                }
            }
            return i;
        }

        public final String toString() {
            StringBuilder sb = new StringBuilder();
            if (this.printerParsers != null) {
                sb.append(this.optional ? "[" : "(");
                for (RVV rvv : this.printerParsers) {
                    sb.append(rvv);
                }
                sb.append(this.optional ? "]" : ")");
            }
            return sb.toString();
        }
    }

    /* JADX INFO: Access modifiers changed from: package-private */
    /* renamed from: o.gtn$NHB */
    /* loaded from: classes6.dex */
    public static final class NHB implements RVV {
        private final char padChar;
        private final int padWidth;
        private final RVV printerParser;

        NHB(RVV rvv, int i, char c) {
            this.printerParser = rvv;
            this.padWidth = i;
            this.padChar = c;
        }

        @Override // o.C15553gtn.RVV
        public final boolean print(C15560gtu c15560gtu, StringBuilder sb) {
            int length = sb.length();
            if (!this.printerParser.print(c15560gtu, sb)) {
                return false;
            }
            int length2 = sb.length() - length;
            if (length2 <= this.padWidth) {
                for (int i = 0; i < this.padWidth - length2; i++) {
                    sb.insert(length, this.padChar);
                }
                return true;
            }
            StringBuilder sb2 = new StringBuilder("Cannot print as output of ");
            sb2.append(length2);
            sb2.append(" characters exceeds pad width of ");
            sb2.append(this.padWidth);
            throw new DateTimeException(sb2.toString());
        }

        @Override // o.C15553gtn.RVV
        public final int parse(C15561gtv c15561gtv, CharSequence charSequence, int i) {
            boolean isStrict = c15561gtv.isStrict();
            boolean isCaseSensitive = c15561gtv.isCaseSensitive();
            if (i > charSequence.length()) {
                throw new IndexOutOfBoundsException();
            }
            if (i == charSequence.length()) {
                return ~i;
            }
            int i2 = this.padWidth + i;
            if (i2 > charSequence.length()) {
                if (isStrict) {
                    return ~i;
                }
                i2 = charSequence.length();
            }
            int i3 = i;
            while (i3 < i2) {
                if (!isCaseSensitive) {
                    if (!c15561gtv.charEquals(charSequence.charAt(i3), this.padChar)) {
                        break;
                    }
                    i3++;
                } else {
                    if (charSequence.charAt(i3) != this.padChar) {
                        break;
                    }
                    i3++;
                }
            }
            int parse = this.printerParser.parse(c15561gtv, charSequence.subSequence(0, i2), i3);
            return (parse == i2 || !isStrict) ? parse : ~(i + i3);
        }

        public final String toString() {
            String obj;
            StringBuilder sb = new StringBuilder("Pad(");
            sb.append(this.printerParser);
            sb.append(",");
            sb.append(this.padWidth);
            if (this.padChar == ' ') {
                obj = ")";
            } else {
                StringBuilder sb2 = new StringBuilder(",'");
                sb2.append(this.padChar);
                sb2.append("')");
                obj = sb2.toString();
            }
            sb.append(obj);
            return sb.toString();
        }
    }

    /* renamed from: o.gtn$ZnX */
    /* loaded from: classes6.dex */
    enum ZnX implements RVV {
        SENSITIVE,
        INSENSITIVE,
        STRICT,
        LENIENT;

        @Override // o.C15553gtn.RVV
        public final boolean print(C15560gtu c15560gtu, StringBuilder sb) {
            return true;
        }

        @Override // o.C15553gtn.RVV
        public final int parse(C15561gtv c15561gtv, CharSequence charSequence, int i) {
            int ordinal = ordinal();
            if (ordinal == 0) {
                c15561gtv.setCaseSensitive(true);
            } else if (ordinal == 1) {
                c15561gtv.setCaseSensitive(false);
            } else if (ordinal == 2) {
                c15561gtv.setStrict(true);
            } else if (ordinal == 3) {
                c15561gtv.setStrict(false);
            }
            return i;
        }

        @Override // java.lang.Enum
        public final String toString() {
            int ordinal = ordinal();
            if (ordinal == 0) {
                return "ParseCaseSensitive(true)";
            }
            if (ordinal == 1) {
                return "ParseCaseSensitive(false)";
            }
            if (ordinal == 2) {
                return "ParseStrict(true)";
            }
            if (ordinal == 3) {
                return "ParseStrict(false)";
            }
            throw new IllegalStateException("Unreachable");
        }
    }

    /* JADX INFO: Access modifiers changed from: package-private */
    /* renamed from: o.gtn$Sts */
    /* loaded from: classes6.dex */
    public static class Sts implements RVV {
        private final InterfaceC15537gtP field;
        private final long value;

        @Override // o.C15553gtn.RVV
        public final boolean print(C15560gtu c15560gtu, StringBuilder sb) {
            return true;
        }

        Sts(InterfaceC15537gtP interfaceC15537gtP, long j) {
            this.field = interfaceC15537gtP;
            this.value = j;
        }

        @Override // o.C15553gtn.RVV
        public final int parse(C15561gtv c15561gtv, CharSequence charSequence, int i) {
            if (c15561gtv.getParsed(this.field) == null) {
                c15561gtv.setParsedField(this.field, this.value, i, i);
            }
            return i;
        }
    }

    /* JADX INFO: Access modifiers changed from: package-private */
    /* renamed from: o.gtn$LWm */
    /* loaded from: classes6.dex */
    public static final class LWm implements RVV {
        private final char literal;

        LWm(char c) {
            this.literal = c;
        }

        @Override // o.C15553gtn.RVV
        public final boolean print(C15560gtu c15560gtu, StringBuilder sb) {
            sb.append(this.literal);
            return true;
        }

        @Override // o.C15553gtn.RVV
        public final int parse(C15561gtv c15561gtv, CharSequence charSequence, int i) {
            if (i == charSequence.length()) {
                return ~i;
            }
            return !c15561gtv.charEquals(this.literal, charSequence.charAt(i)) ? ~i : i + 1;
        }

        public final String toString() {
            if (this.literal == '\'') {
                return "''";
            }
            StringBuilder sb = new StringBuilder("'");
            sb.append(this.literal);
            sb.append("'");
            return sb.toString();
        }
    }

    /* JADX INFO: Access modifiers changed from: package-private */
    /* renamed from: o.gtn$dAO */
    /* loaded from: classes6.dex */
    public static final class dAO implements RVV {
        private final String literal;

        dAO(String str) {
            this.literal = str;
        }

        @Override // o.C15553gtn.RVV
        public final boolean print(C15560gtu c15560gtu, StringBuilder sb) {
            sb.append(this.literal);
            return true;
        }

        @Override // o.C15553gtn.RVV
        public final int parse(C15561gtv c15561gtv, CharSequence charSequence, int i) {
            if (i > charSequence.length() || i < 0) {
                throw new IndexOutOfBoundsException();
            }
            String str = this.literal;
            return !c15561gtv.subSequenceEquals(charSequence, i, str, 0, str.length()) ? ~i : i + this.literal.length();
        }

        public final String toString() {
            String replace = this.literal.replace("'", "''");
            StringBuilder sb = new StringBuilder("'");
            sb.append(replace);
            sb.append("'");
            return sb.toString();
        }
    }

    /* JADX INFO: Access modifiers changed from: package-private */
    /* renamed from: o.gtn$ojQ */
    /* loaded from: classes6.dex */
    public static class ojQ implements RVV {
        static final int[] EXCEED_POINTS = {0, 10, 100, 1000, HwBuildEx.VersionCodes.CUR_DEVELOPMENT, 100000, 1000000, ExceptionCode.CRASH_EXCEPTION, 100000000, 1000000000};
        final InterfaceC15537gtP field;
        final int maxWidth;
        final int minWidth;
        final EnumC15564gty signStyle;
        final int subsequentWidth;

        long getValue(C15560gtu c15560gtu, long j) {
            return j;
        }

        ojQ(InterfaceC15537gtP interfaceC15537gtP, int i, int i2, EnumC15564gty enumC15564gty) {
            this.field = interfaceC15537gtP;
            this.minWidth = i;
            this.maxWidth = i2;
            this.signStyle = enumC15564gty;
            this.subsequentWidth = 0;
        }

        private ojQ(InterfaceC15537gtP interfaceC15537gtP, int i, int i2, EnumC15564gty enumC15564gty, int i3) {
            this.field = interfaceC15537gtP;
            this.minWidth = i;
            this.maxWidth = i2;
            this.signStyle = enumC15564gty;
            this.subsequentWidth = i3;
        }

        ojQ withFixedWidth() {
            return this.subsequentWidth == -1 ? this : new ojQ(this.field, this.minWidth, this.maxWidth, this.signStyle, -1);
        }

        ojQ withSubsequentWidth(int i) {
            return new ojQ(this.field, this.minWidth, this.maxWidth, this.signStyle, this.subsequentWidth + i);
        }

        @Override // o.C15553gtn.RVV
        public boolean print(C15560gtu c15560gtu, StringBuilder sb) {
            Long value = c15560gtu.getValue(this.field);
            if (value == null) {
                return false;
            }
            long value2 = getValue(c15560gtu, value.longValue());
            C15559gtt symbols = c15560gtu.getSymbols();
            String l = value2 == Long.MIN_VALUE ? "9223372036854775808" : Long.toString(Math.abs(value2));
            if (l.length() > this.maxWidth) {
                StringBuilder sb2 = new StringBuilder("Field ");
                sb2.append(this.field);
                sb2.append(" cannot be printed as the value ");
                sb2.append(value2);
                sb2.append(" exceeds the maximum print width of ");
                sb2.append(this.maxWidth);
                throw new DateTimeException(sb2.toString());
            }
            String convertNumberToI18N = symbols.convertNumberToI18N(l);
            if (value2 >= 0) {
                int i = AnonymousClass1.$SwitchMap$org$threeten$bp$format$SignStyle[this.signStyle.ordinal()];
                if (i == 1) {
                    if (this.minWidth < 19 && value2 >= EXCEED_POINTS[r4]) {
                        sb.append(symbols.getPositiveSign());
                    }
                } else if (i == 2) {
                    sb.append(symbols.getPositiveSign());
                }
            } else {
                int i2 = AnonymousClass1.$SwitchMap$org$threeten$bp$format$SignStyle[this.signStyle.ordinal()];
                if (i2 == 1 || i2 == 2 || i2 == 3) {
                    sb.append(symbols.getNegativeSign());
                } else if (i2 == 4) {
                    StringBuilder sb3 = new StringBuilder("Field ");
                    sb3.append(this.field);
                    sb3.append(" cannot be printed as the value ");
                    sb3.append(value2);
                    sb3.append(" cannot be negative according to the SignStyle");
                    throw new DateTimeException(sb3.toString());
                }
            }
            for (int i3 = 0; i3 < this.minWidth - convertNumberToI18N.length(); i3++) {
                sb.append(symbols.getZeroDigit());
            }
            sb.append(convertNumberToI18N);
            return true;
        }

        boolean isFixedWidth(C15561gtv c15561gtv) {
            int i = this.subsequentWidth;
            return i == -1 || (i > 0 && this.minWidth == this.maxWidth && this.signStyle == EnumC15564gty.NOT_NEGATIVE);
        }

        /* JADX WARN: Code restructure failed: missing block: B:53:0x0107, code lost:
        
            r5 = r10;
         */
        /* JADX WARN: Code restructure failed: missing block: B:54:0x010c, code lost:
        
            if (r0 == false) goto L91;
         */
        /* JADX WARN: Code restructure failed: missing block: B:55:0x010e, code lost:
        
            if (r11 == null) goto L84;
         */
        /* JADX WARN: Code restructure failed: missing block: B:57:0x0116, code lost:
        
            if (r11.equals(java.math.BigInteger.ZERO) == false) goto L83;
         */
        /* JADX WARN: Code restructure failed: missing block: B:59:0x011c, code lost:
        
            if (r18.isStrict() == false) goto L83;
         */
        /* JADX WARN: Code restructure failed: missing block: B:61:0x0121, code lost:
        
            return ~(r7 - 1);
         */
        /* JADX WARN: Code restructure failed: missing block: B:62:0x0122, code lost:
        
            r11 = r11.negate();
         */
        /* JADX WARN: Code restructure failed: missing block: B:63:0x0157, code lost:
        
            r2 = r14;
         */
        /* JADX WARN: Code restructure failed: missing block: B:64:0x0158, code lost:
        
            if (r11 == null) goto L110;
         */
        /* JADX WARN: Code restructure failed: missing block: B:66:0x0160, code lost:
        
            if (r11.bitLength() <= 63) goto L108;
         */
        /* JADX WARN: Code restructure failed: missing block: B:67:0x0162, code lost:
        
            r11 = r11.divide(java.math.BigInteger.TEN);
            r5 = r5 - 1;
         */
        /* JADX WARN: Code restructure failed: missing block: B:69:0x0177, code lost:
        
            return setValue(r18, r11.longValue(), r7, r5);
         */
        /* JADX WARN: Code restructure failed: missing block: B:71:0x0181, code lost:
        
            return setValue(r18, r2, r7, r5);
         */
        /* JADX WARN: Code restructure failed: missing block: B:73:0x012d, code lost:
        
            if (r14 != 0) goto L90;
         */
        /* JADX WARN: Code restructure failed: missing block: B:75:0x0133, code lost:
        
            if (r18.isStrict() == false) goto L90;
         */
        /* JADX WARN: Code restructure failed: missing block: B:77:0x0137, code lost:
        
            return ~(r7 - 1);
         */
        /* JADX WARN: Code restructure failed: missing block: B:78:0x0138, code lost:
        
            r2 = -r14;
         */
        /* JADX WARN: Code restructure failed: missing block: B:80:0x013f, code lost:
        
            if (r17.signStyle != o.EnumC15564gty.EXCEEDS_PAD) goto L103;
         */
        /* JADX WARN: Code restructure failed: missing block: B:82:0x0145, code lost:
        
            if (r18.isStrict() == false) goto L103;
         */
        /* JADX WARN: Code restructure failed: missing block: B:83:0x0147, code lost:
        
            r0 = r5 - r7;
            r1 = r17.minWidth;
         */
        /* JADX WARN: Code restructure failed: missing block: B:84:0x014b, code lost:
        
            if (r2 == false) goto L100;
         */
        /* JADX WARN: Code restructure failed: missing block: B:85:0x014d, code lost:
        
            if (r0 > r1) goto L103;
         */
        /* JADX WARN: Code restructure failed: missing block: B:87:0x0152, code lost:
        
            return ~(r7 - 1);
         */
        /* JADX WARN: Code restructure failed: missing block: B:88:0x0153, code lost:
        
            if (r0 <= r1) goto L103;
         */
        /* JADX WARN: Code restructure failed: missing block: B:90:0x0156, code lost:
        
            return ~r7;
         */
        @Override // o.C15553gtn.RVV
        /*
            Code decompiled incorrectly, please refer to instructions dump.
            To view partially-correct add '--show-bad-code' argument
        */
        public int parse(o.C15561gtv r18, java.lang.CharSequence r19, int r20) {
            /*
                Method dump skipped, instructions count: 386
                To view this dump add '--comments-level debug' option
            */
            throw new UnsupportedOperationException("Method not decompiled: o.C15553gtn.ojQ.parse(o.gtv, java.lang.CharSequence, int):int");
        }

        int setValue(C15561gtv c15561gtv, long j, int i, int i2) {
            return c15561gtv.setParsedField(this.field, j, i, i2);
        }

        public String toString() {
            if (this.minWidth == 1 && this.maxWidth == 19 && this.signStyle == EnumC15564gty.NORMAL) {
                StringBuilder sb = new StringBuilder("Value(");
                sb.append(this.field);
                sb.append(")");
                return sb.toString();
            }
            if (this.minWidth == this.maxWidth && this.signStyle == EnumC15564gty.NOT_NEGATIVE) {
                StringBuilder sb2 = new StringBuilder("Value(");
                sb2.append(this.field);
                sb2.append(",");
                sb2.append(this.minWidth);
                sb2.append(")");
                return sb2.toString();
            }
            StringBuilder sb3 = new StringBuilder("Value(");
            sb3.append(this.field);
            sb3.append(",");
            sb3.append(this.minWidth);
            sb3.append(",");
            sb3.append(this.maxWidth);
            sb3.append(",");
            sb3.append(this.signStyle);
            sb3.append(")");
            return sb3.toString();
        }
    }

    /* JADX INFO: Access modifiers changed from: package-private */
    /* renamed from: o.gtn$1, reason: invalid class name */
    /* loaded from: classes6.dex */
    public static /* synthetic */ class AnonymousClass1 {
        static final int[] $SwitchMap$org$threeten$bp$format$SignStyle;

        static {
            int[] iArr = new int[EnumC15564gty.values().length];
            $SwitchMap$org$threeten$bp$format$SignStyle = iArr;
            try {
                iArr[EnumC15564gty.EXCEEDS_PAD.ordinal()] = 1;
            } catch (NoSuchFieldError unused) {
            }
            try {
                $SwitchMap$org$threeten$bp$format$SignStyle[EnumC15564gty.ALWAYS.ordinal()] = 2;
            } catch (NoSuchFieldError unused2) {
            }
            try {
                $SwitchMap$org$threeten$bp$format$SignStyle[EnumC15564gty.NORMAL.ordinal()] = 3;
            } catch (NoSuchFieldError unused3) {
            }
            try {
                $SwitchMap$org$threeten$bp$format$SignStyle[EnumC15564gty.NOT_NEGATIVE.ordinal()] = 4;
            } catch (NoSuchFieldError unused4) {
            }
        }
    }

    /* JADX INFO: Access modifiers changed from: package-private */
    /* renamed from: o.gtn$vUG */
    /* loaded from: classes6.dex */
    public static final class vUG extends ojQ {
        static final C15520gsp BASE_DATE = C15520gsp.of(CredentialsApi.CREDENTIAL_PICKER_REQUEST_CODE, 1, 1);
        private final gsJ baseDate;
        private final int baseValue;

        vUG(InterfaceC15537gtP interfaceC15537gtP, int i, int i2, int i3, gsJ gsj) {
            super(interfaceC15537gtP, i, i2, EnumC15564gty.NOT_NEGATIVE);
            if (i <= 0 || i > 10) {
                throw new IllegalArgumentException("The width must be from 1 to 10 inclusive but was ".concat(String.valueOf(i)));
            }
            if (i2 <= 0 || i2 > 10) {
                throw new IllegalArgumentException("The maxWidth must be from 1 to 10 inclusive but was ".concat(String.valueOf(i2)));
            }
            if (i2 < i) {
                throw new IllegalArgumentException("The maxWidth must be greater than the width");
            }
            if (gsj == null) {
                long j = i3;
                if (!interfaceC15537gtP.range().isValidValue(j)) {
                    throw new IllegalArgumentException("The base value must be within the range of the field");
                }
                if (j + EXCEED_POINTS[i] > 2147483647L) {
                    throw new DateTimeException("Unable to add printer-parser as the range exceeds the capacity of an int");
                }
            }
            this.baseValue = i3;
            this.baseDate = gsj;
        }

        private vUG(InterfaceC15537gtP interfaceC15537gtP, int i, int i2, int i3, gsJ gsj, int i4) {
            super(interfaceC15537gtP, i, i2, EnumC15564gty.NOT_NEGATIVE, i4);
            this.baseValue = i3;
            this.baseDate = gsj;
        }

        @Override // o.C15553gtn.ojQ
        final long getValue(C15560gtu c15560gtu, long j) {
            long abs = Math.abs(j);
            int i = this.baseValue;
            if (this.baseDate != null) {
                i = gsR.from(c15560gtu.getTemporal()).date(this.baseDate).get(this.field);
            }
            if (j >= i && j < i + EXCEED_POINTS[this.minWidth]) {
                return abs % EXCEED_POINTS[this.minWidth];
            }
            return abs % EXCEED_POINTS[this.maxWidth];
        }

        /* JADX INFO: Access modifiers changed from: package-private */
        @Override // o.C15553gtn.ojQ
        public final int setValue(C15561gtv c15561gtv, long j, int i, int i2) {
            int i3 = this.baseValue;
            if (this.baseDate != null) {
                i3 = c15561gtv.getEffectiveChronology().date(this.baseDate).get(this.field);
                c15561gtv.addChronologyChangedParser(this, j, i, i2);
            }
            if (i2 - i == this.minWidth && j >= 0) {
                long j2 = EXCEED_POINTS[this.minWidth];
                long j3 = i3;
                long j4 = j3 - (j3 % j2);
                j = i3 > 0 ? j4 + j : j4 - j;
                if (j < j3) {
                    j += j2;
                }
            }
            return c15561gtv.setParsedField(this.field, j, i, i2);
        }

        @Override // o.C15553gtn.ojQ
        final ojQ withFixedWidth() {
            return this.subsequentWidth == -1 ? this : new vUG(this.field, this.minWidth, this.maxWidth, this.baseValue, this.baseDate, -1);
        }

        /* JADX INFO: Access modifiers changed from: package-private */
        @Override // o.C15553gtn.ojQ
        public final vUG withSubsequentWidth(int i) {
            return new vUG(this.field, this.minWidth, this.maxWidth, this.baseValue, this.baseDate, this.subsequentWidth + i);
        }

        @Override // o.C15553gtn.ojQ
        final boolean isFixedWidth(C15561gtv c15561gtv) {
            if (c15561gtv.isStrict()) {
                return super.isFixedWidth(c15561gtv);
            }
            return false;
        }

        @Override // o.C15553gtn.ojQ
        public final String toString() {
            StringBuilder sb = new StringBuilder("ReducedValue(");
            sb.append(this.field);
            sb.append(",");
            sb.append(this.minWidth);
            sb.append(",");
            sb.append(this.maxWidth);
            sb.append(",");
            Object obj = this.baseDate;
            if (obj == null) {
                obj = Integer.valueOf(this.baseValue);
            }
            sb.append(obj);
            sb.append(")");
            return sb.toString();
        }
    }

    /* JADX INFO: Access modifiers changed from: package-private */
    /* renamed from: o.gtn$saX */
    /* loaded from: classes6.dex */
    public static final class saX implements RVV {
        private final boolean decimalPoint;
        private final InterfaceC15537gtP field;
        private final int maxWidth;
        private final int minWidth;

        saX(InterfaceC15537gtP interfaceC15537gtP, int i, int i2, boolean z) {
            gtG.requireNonNull(interfaceC15537gtP, "field");
            if (!interfaceC15537gtP.range().isFixed()) {
                throw new IllegalArgumentException("Field must have a fixed set of values: ".concat(String.valueOf(interfaceC15537gtP)));
            }
            if (i < 0 || i > 9) {
                throw new IllegalArgumentException("Minimum width must be from 0 to 9 inclusive but was ".concat(String.valueOf(i)));
            }
            if (i2 <= 0 || i2 > 9) {
                throw new IllegalArgumentException("Maximum width must be from 1 to 9 inclusive but was ".concat(String.valueOf(i2)));
            }
            if (i2 >= i) {
                this.field = interfaceC15537gtP;
                this.minWidth = i;
                this.maxWidth = i2;
                this.decimalPoint = z;
                return;
            }
            StringBuilder sb = new StringBuilder("Maximum width must exceed or equal the minimum width but ");
            sb.append(i2);
            sb.append(" < ");
            sb.append(i);
            throw new IllegalArgumentException(sb.toString());
        }

        @Override // o.C15553gtn.RVV
        public final boolean print(C15560gtu c15560gtu, StringBuilder sb) {
            Long value = c15560gtu.getValue(this.field);
            if (value == null) {
                return false;
            }
            C15559gtt symbols = c15560gtu.getSymbols();
            BigDecimal convertToFraction = convertToFraction(value.longValue());
            if (convertToFraction.scale() != 0) {
                String convertNumberToI18N = symbols.convertNumberToI18N(convertToFraction.setScale(Math.min(Math.max(convertToFraction.scale(), this.minWidth), this.maxWidth), RoundingMode.FLOOR).toPlainString().substring(2));
                if (this.decimalPoint) {
                    sb.append(symbols.getDecimalSeparator());
                }
                sb.append(convertNumberToI18N);
                return true;
            }
            if (this.minWidth <= 0) {
                return true;
            }
            if (this.decimalPoint) {
                sb.append(symbols.getDecimalSeparator());
            }
            for (int i = 0; i < this.minWidth; i++) {
                sb.append(symbols.getZeroDigit());
            }
            return true;
        }

        @Override // o.C15553gtn.RVV
        public final int parse(C15561gtv c15561gtv, CharSequence charSequence, int i) {
            int i2 = 0;
            int i3 = c15561gtv.isStrict() ? this.minWidth : 0;
            int i4 = c15561gtv.isStrict() ? this.maxWidth : 9;
            int length = charSequence.length();
            if (i == length) {
                return i3 > 0 ? ~i : i;
            }
            if (this.decimalPoint) {
                if (charSequence.charAt(i) != c15561gtv.getSymbols().getDecimalSeparator()) {
                    return i3 > 0 ? ~i : i;
                }
                i++;
            }
            int i5 = i;
            int i6 = i3 + i5;
            if (i6 > length) {
                return ~i5;
            }
            int min = Math.min(i4 + i5, length);
            int i7 = i5;
            while (true) {
                if (i7 >= min) {
                    break;
                }
                int i8 = i7 + 1;
                int convertToDigit = c15561gtv.getSymbols().convertToDigit(charSequence.charAt(i7));
                if (convertToDigit >= 0) {
                    i2 = (i2 * 10) + convertToDigit;
                    i7 = i8;
                } else if (i8 < i6) {
                    return ~i5;
                }
            }
            return c15561gtv.setParsedField(this.field, convertFromFraction(new BigDecimal(i2).movePointLeft(i7 - i5)), i5, i7);
        }

        private BigDecimal convertToFraction(long j) {
            gtT range = this.field.range();
            range.checkValidValue(j, this.field);
            BigDecimal valueOf = BigDecimal.valueOf(range.getMinimum());
            BigDecimal divide = BigDecimal.valueOf(j).subtract(valueOf).divide(BigDecimal.valueOf(range.getMaximum()).subtract(valueOf).add(BigDecimal.ONE), 9, RoundingMode.FLOOR);
            return divide.compareTo(BigDecimal.ZERO) == 0 ? BigDecimal.ZERO : divide.stripTrailingZeros();
        }

        private long convertFromFraction(BigDecimal bigDecimal) {
            gtT range = this.field.range();
            BigDecimal valueOf = BigDecimal.valueOf(range.getMinimum());
            return bigDecimal.multiply(BigDecimal.valueOf(range.getMaximum()).subtract(valueOf).add(BigDecimal.ONE)).setScale(0, RoundingMode.FLOOR).add(valueOf).longValueExact();
        }

        public final String toString() {
            String str = this.decimalPoint ? ",DecimalPoint" : "";
            StringBuilder sb = new StringBuilder("Fraction(");
            sb.append(this.field);
            sb.append(",");
            sb.append(this.minWidth);
            sb.append(",");
            sb.append(this.maxWidth);
            sb.append(str);
            sb.append(")");
            return sb.toString();
        }
    }

    /* JADX INFO: Access modifiers changed from: package-private */
    /* renamed from: o.gtn$Plv */
    /* loaded from: classes6.dex */
    public static final class Plv implements RVV {
        private final InterfaceC15537gtP field;
        private volatile ojQ numberPrinterParser;
        private final AbstractC15557gtr provider;
        private final EnumC15532gtB textStyle;

        Plv(InterfaceC15537gtP interfaceC15537gtP, EnumC15532gtB enumC15532gtB, AbstractC15557gtr abstractC15557gtr) {
            this.field = interfaceC15537gtP;
            this.textStyle = enumC15532gtB;
            this.provider = abstractC15557gtr;
        }

        @Override // o.C15553gtn.RVV
        public final boolean print(C15560gtu c15560gtu, StringBuilder sb) {
            Long value = c15560gtu.getValue(this.field);
            if (value == null) {
                return false;
            }
            String text = this.provider.getText(this.field, value.longValue(), this.textStyle, c15560gtu.getLocale());
            if (text == null) {
                return numberPrinterParser().print(c15560gtu, sb);
            }
            sb.append(text);
            return true;
        }

        /* JADX WARN: Code restructure failed: missing block: B:10:0x0024, code lost:
        
            if (r0.hasNext() == false) goto L25;
         */
        /* JADX WARN: Code restructure failed: missing block: B:11:0x0026, code lost:
        
            r1 = r0.next();
            r2 = r1.getKey();
         */
        /* JADX WARN: Code restructure failed: missing block: B:12:0x003f, code lost:
        
            if (r11.subSequenceEquals(r2, 0, r12, r13, r2.length()) == false) goto L27;
         */
        /* JADX WARN: Code restructure failed: missing block: B:15:0x0059, code lost:
        
            return r11.setParsedField(r10.field, r1.getValue().longValue(), r13, r13 + r2.length());
         */
        /* JADX WARN: Code restructure failed: missing block: B:20:0x005e, code lost:
        
            if (r11.isStrict() == false) goto L21;
         */
        /* JADX WARN: Code restructure failed: missing block: B:22:0x0061, code lost:
        
            return ~r13;
         */
        /* JADX WARN: Code restructure failed: missing block: B:24:0x006a, code lost:
        
            return numberPrinterParser().parse(r11, r12, r13);
         */
        /* JADX WARN: Code restructure failed: missing block: B:8:0x001e, code lost:
        
            if (r0 != null) goto L11;
         */
        @Override // o.C15553gtn.RVV
        /*
            Code decompiled incorrectly, please refer to instructions dump.
            To view partially-correct add '--show-bad-code' argument
        */
        public final int parse(o.C15561gtv r11, java.lang.CharSequence r12, int r13) {
            /*
                r10 = this;
                int r0 = r12.length()
                if (r13 < 0) goto L6b
                if (r13 > r0) goto L6b
                boolean r0 = r11.isStrict()
                if (r0 == 0) goto L11
                o.gtB r0 = r10.textStyle
                goto L12
            L11:
                r0 = 0
            L12:
                o.gtr r1 = r10.provider
                o.gtP r2 = r10.field
                java.util.Locale r3 = r11.getLocale()
                java.util.Iterator r0 = r1.getTextIterator(r2, r0, r3)
                if (r0 == 0) goto L62
            L20:
                boolean r1 = r0.hasNext()
                if (r1 == 0) goto L5a
                java.lang.Object r1 = r0.next()
                java.util.Map$Entry r1 = (java.util.Map.Entry) r1
                java.lang.Object r2 = r1.getKey()
                java.lang.String r2 = (java.lang.String) r2
                r5 = 0
                int r8 = r2.length()
                r3 = r11
                r4 = r2
                r6 = r12
                r7 = r13
                boolean r3 = r3.subSequenceEquals(r4, r5, r6, r7, r8)
                if (r3 == 0) goto L20
                o.gtP r5 = r10.field
                java.lang.Object r12 = r1.getValue()
                java.lang.Long r12 = (java.lang.Long) r12
                long r6 = r12.longValue()
                int r12 = r2.length()
                int r9 = r13 + r12
                r4 = r11
                r8 = r13
                int r11 = r4.setParsedField(r5, r6, r8, r9)
                return r11
            L5a:
                boolean r0 = r11.isStrict()
                if (r0 == 0) goto L62
                int r11 = ~r13
                return r11
            L62:
                o.gtn$ojQ r0 = r10.numberPrinterParser()
                int r11 = r0.parse(r11, r12, r13)
                return r11
            L6b:
                java.lang.IndexOutOfBoundsException r11 = new java.lang.IndexOutOfBoundsException
                r11.<init>()
                throw r11
            */
            throw new UnsupportedOperationException("Method not decompiled: o.C15553gtn.Plv.parse(o.gtv, java.lang.CharSequence, int):int");
        }

        private ojQ numberPrinterParser() {
            if (this.numberPrinterParser == null) {
                this.numberPrinterParser = new ojQ(this.field, 1, 19, EnumC15564gty.NORMAL);
            }
            return this.numberPrinterParser;
        }

        public final String toString() {
            if (this.textStyle == EnumC15532gtB.FULL) {
                StringBuilder sb = new StringBuilder("Text(");
                sb.append(this.field);
                sb.append(")");
                return sb.toString();
            }
            StringBuilder sb2 = new StringBuilder("Text(");
            sb2.append(this.field);
            sb2.append(",");
            sb2.append(this.textStyle);
            sb2.append(")");
            return sb2.toString();
        }
    }

    /* renamed from: o.gtn$jbe */
    /* loaded from: classes6.dex */
    static final class jbe implements RVV {
        private static final long SECONDS_0000_TO_1970 = 62167219200L;
        private static final long SECONDS_PER_10000_YEARS = 315569520000L;
        private final int fractionalDigits;

        jbe(int i) {
            this.fractionalDigits = i;
        }

        @Override // o.C15553gtn.RVV
        public final boolean print(C15560gtu c15560gtu, StringBuilder sb) {
            Long value = c15560gtu.getValue(EnumC15534gtD.INSTANT_SECONDS);
            Long l = 0L;
            if (c15560gtu.getTemporal().isSupported(EnumC15534gtD.NANO_OF_SECOND)) {
                l = Long.valueOf(c15560gtu.getTemporal().getLong(EnumC15534gtD.NANO_OF_SECOND));
            }
            int i = 0;
            if (value == null) {
                return false;
            }
            long longValue = value.longValue();
            int checkValidIntValue = EnumC15534gtD.NANO_OF_SECOND.checkValidIntValue(l.longValue());
            if (longValue >= -62167219200L) {
                long j = longValue - 253402300800L;
                long floorDiv = gtG.floorDiv(j, SECONDS_PER_10000_YEARS) + 1;
                C15522gsr ofEpochSecond = C15522gsr.ofEpochSecond(gtG.floorMod(j, SECONDS_PER_10000_YEARS) - SECONDS_0000_TO_1970, 0, gsI.UTC);
                if (floorDiv > 0) {
                    sb.append('+');
                    sb.append(floorDiv);
                }
                sb.append(ofEpochSecond);
                if (ofEpochSecond.getSecond() == 0) {
                    sb.append(":00");
                }
            } else {
                long j2 = longValue + SECONDS_0000_TO_1970;
                long j3 = j2 / SECONDS_PER_10000_YEARS;
                long j4 = j2 % SECONDS_PER_10000_YEARS;
                C15522gsr ofEpochSecond2 = C15522gsr.ofEpochSecond(j4 - SECONDS_0000_TO_1970, 0, gsI.UTC);
                int length = sb.length();
                sb.append(ofEpochSecond2);
                if (ofEpochSecond2.getSecond() == 0) {
                    sb.append(":00");
                }
                if (j3 < 0) {
                    if (ofEpochSecond2.getYear() == -10000) {
                        sb.replace(length, length + 2, Long.toString(j3 - 1));
                    } else if (j4 == 0) {
                        sb.insert(length, j3);
                    } else {
                        sb.insert(length + 1, Math.abs(j3));
                    }
                }
            }
            int i2 = this.fractionalDigits;
            if (i2 == -2) {
                if (checkValidIntValue != 0) {
                    sb.append('.');
                    if (checkValidIntValue % 1000000 == 0) {
                        sb.append(Integer.toString((checkValidIntValue / 1000000) + 1000).substring(1));
                    } else if (checkValidIntValue % 1000 == 0) {
                        sb.append(Integer.toString((checkValidIntValue / 1000) + 1000000).substring(1));
                    } else {
                        sb.append(Integer.toString(checkValidIntValue + 1000000000).substring(1));
                    }
                }
            } else if (i2 > 0 || (i2 == -1 && checkValidIntValue > 0)) {
                sb.append('.');
                int i3 = 100000000;
                while (true) {
                    int i4 = this.fractionalDigits;
                    if ((i4 != -1 || checkValidIntValue <= 0) && i >= i4) {
                        break;
                    }
                    int i5 = checkValidIntValue / i3;
                    sb.append((char) (i5 + 48));
                    checkValidIntValue -= i5 * i3;
                    i3 /= 10;
                    i++;
                }
            }
            sb.append(Matrix.MATRIX_TYPE_ZERO);
            return true;
        }

        @Override // o.C15553gtn.RVV
        public final int parse(C15561gtv c15561gtv, CharSequence charSequence, int i) {
            int i2;
            C15561gtv copy = c15561gtv.copy();
            int i3 = this.fractionalDigits;
            int i4 = 0;
            int i5 = i3 < 0 ? 0 : i3;
            if (i3 < 0) {
                i3 = 9;
            }
            int parse = new C15553gtn().append(C15554gto.ISO_LOCAL_DATE).appendLiteral('T').appendValue(EnumC15534gtD.HOUR_OF_DAY, 2).appendLiteral(':').appendValue(EnumC15534gtD.MINUTE_OF_HOUR, 2).appendLiteral(':').appendValue(EnumC15534gtD.SECOND_OF_MINUTE, 2).appendFraction(EnumC15534gtD.NANO_OF_SECOND, i5, i3, true).appendLiteral(Matrix.MATRIX_TYPE_ZERO).toFormatter().toPrinterParser(false).parse(copy, charSequence, i);
            if (parse < 0) {
                return parse;
            }
            long longValue = copy.getParsed(EnumC15534gtD.YEAR).longValue();
            int intValue = copy.getParsed(EnumC15534gtD.MONTH_OF_YEAR).intValue();
            int intValue2 = copy.getParsed(EnumC15534gtD.DAY_OF_MONTH).intValue();
            int intValue3 = copy.getParsed(EnumC15534gtD.HOUR_OF_DAY).intValue();
            int intValue4 = copy.getParsed(EnumC15534gtD.MINUTE_OF_HOUR).intValue();
            Long parsed = copy.getParsed(EnumC15534gtD.SECOND_OF_MINUTE);
            Long parsed2 = copy.getParsed(EnumC15534gtD.NANO_OF_SECOND);
            int intValue5 = parsed != null ? parsed.intValue() : 0;
            int intValue6 = parsed2 != null ? parsed2.intValue() : 0;
            int i6 = (int) longValue;
            try {
                if (intValue3 == 24 && intValue4 == 0 && intValue5 == 0 && intValue6 == 0) {
                    intValue3 = 0;
                    i4 = 1;
                } else if (intValue3 == 23 && intValue4 == 59 && intValue5 == 60) {
                    c15561gtv.setParsedLeapSecond();
                    i2 = 59;
                    return c15561gtv.setParsedField(EnumC15534gtD.NANO_OF_SECOND, intValue6, i, c15561gtv.setParsedField(EnumC15534gtD.INSTANT_SECONDS, C15522gsr.of(i6 % HwBuildEx.VersionCodes.CUR_DEVELOPMENT, intValue, intValue2, intValue3, intValue4, i2, 0).plusDays(i4).toEpochSecond(gsI.UTC) + gtG.safeMultiply(longValue / 10000, SECONDS_PER_10000_YEARS), i, parse));
                }
                return c15561gtv.setParsedField(EnumC15534gtD.NANO_OF_SECOND, intValue6, i, c15561gtv.setParsedField(EnumC15534gtD.INSTANT_SECONDS, C15522gsr.of(i6 % HwBuildEx.VersionCodes.CUR_DEVELOPMENT, intValue, intValue2, intValue3, intValue4, i2, 0).plusDays(i4).toEpochSecond(gsI.UTC) + gtG.safeMultiply(longValue / 10000, SECONDS_PER_10000_YEARS), i, parse));
            } catch (RuntimeException unused) {
                return ~i;
            }
            i2 = intValue5;
        }

        public final String toString() {
            return "Instant()";
        }
    }

    /* JADX INFO: Access modifiers changed from: package-private */
    /* renamed from: o.gtn$ZqN */
    /* loaded from: classes6.dex */
    public static final class ZqN implements RVV {
        private final EnumC15532gtB style;

        public ZqN(EnumC15532gtB enumC15532gtB) {
            this.style = enumC15532gtB;
        }

        @Override // o.C15553gtn.RVV
        public final boolean print(C15560gtu c15560gtu, StringBuilder sb) {
            Long value = c15560gtu.getValue(EnumC15534gtD.OFFSET_SECONDS);
            if (value == null) {
                return false;
            }
            sb.append("GMT");
            if (this.style == EnumC15532gtB.FULL) {
                return new jNh("", "+HH:MM:ss").print(c15560gtu, sb);
            }
            int safeToInt = gtG.safeToInt(value.longValue());
            if (safeToInt == 0) {
                return true;
            }
            int abs = Math.abs((safeToInt / 3600) % 100);
            int abs2 = Math.abs((safeToInt / 60) % 60);
            int abs3 = Math.abs(safeToInt % 60);
            sb.append(safeToInt < 0 ? "-" : "+");
            sb.append(abs);
            if (abs2 <= 0 && abs3 <= 0) {
                return true;
            }
            sb.append(":");
            sb.append((char) ((abs2 / 10) + 48));
            sb.append((char) ((abs2 % 10) + 48));
            if (abs3 <= 0) {
                return true;
            }
            sb.append(":");
            sb.append((char) ((abs3 / 10) + 48));
            sb.append((char) ((abs3 % 10) + 48));
            return true;
        }

        @Override // o.C15553gtn.RVV
        public final int parse(C15561gtv c15561gtv, CharSequence charSequence, int i) {
            char charAt;
            if (!c15561gtv.subSequenceEquals(charSequence, i, "GMT", 0, 3)) {
                return ~i;
            }
            int i2 = i + 3;
            if (this.style == EnumC15532gtB.FULL) {
                return new jNh("", "+HH:MM:ss").parse(c15561gtv, charSequence, i2);
            }
            int length = charSequence.length();
            if (i2 == length) {
                return c15561gtv.setParsedField(EnumC15534gtD.OFFSET_SECONDS, 0L, i2, i2);
            }
            char charAt2 = charSequence.charAt(i2);
            if (charAt2 != '+' && charAt2 != '-') {
                return c15561gtv.setParsedField(EnumC15534gtD.OFFSET_SECONDS, 0L, i2, i2);
            }
            int i3 = charAt2 == '-' ? -1 : 1;
            if (i2 == length) {
                return ~i2;
            }
            int i4 = i + 4;
            char charAt3 = charSequence.charAt(i4);
            if (charAt3 < '0' || charAt3 > '9') {
                return ~i4;
            }
            int i5 = i + 5;
            int i6 = charAt3 - '0';
            if (i5 != length && (charAt = charSequence.charAt(i5)) >= '0' && charAt <= '9') {
                i6 = (i6 * 10) + (charAt - '0');
                if (i6 > 23) {
                    return ~i5;
                }
                i5 = i + 6;
            }
            int i7 = i5;
            if (i7 == length || charSequence.charAt(i7) != ':') {
                return c15561gtv.setParsedField(EnumC15534gtD.OFFSET_SECONDS, i3 * 3600 * i6, i7, i7);
            }
            int i8 = i7 + 1;
            int i9 = length - 2;
            if (i8 > i9) {
                return ~i8;
            }
            char charAt4 = charSequence.charAt(i8);
            if (charAt4 < '0' || charAt4 > '9') {
                return ~i8;
            }
            int i10 = i7 + 2;
            char charAt5 = charSequence.charAt(i10);
            if (charAt5 < '0' || charAt5 > '9') {
                return ~i10;
            }
            int i11 = i7 + 3;
            if (((charAt4 - '0') * 10) + (charAt5 - '0') > 59) {
                return ~i11;
            }
            if (i11 == length || charSequence.charAt(i11) != ':') {
                return c15561gtv.setParsedField(EnumC15534gtD.OFFSET_SECONDS, i3 * ((i6 * 3600) + (r11 * 60)), i11, i11);
            }
            int i12 = i7 + 4;
            if (i12 > i9) {
                return ~i12;
            }
            char charAt6 = charSequence.charAt(i12);
            if (charAt6 < '0' || charAt6 > '9') {
                return ~i12;
            }
            int i13 = i7 + 5;
            char charAt7 = charSequence.charAt(i13);
            if (charAt7 < '0' || charAt7 > '9') {
                return ~i13;
            }
            int i14 = i7 + 6;
            return ((charAt6 - '0') * 10) + (charAt7 - '0') > 59 ? ~i14 : c15561gtv.setParsedField(EnumC15534gtD.OFFSET_SECONDS, i3 * ((i6 * 3600) + (r11 * 60) + r1), i14, i14);
        }
    }

    /* JADX INFO: Access modifiers changed from: package-private */
    /* renamed from: o.gtn$huo */
    /* loaded from: classes6.dex */
    public static final class huo implements RVV {
        private static final Comparator<String> LENGTH_COMPARATOR = new Comparator<String>() { // from class: o.gtn.huo.5
            @Override // java.util.Comparator
            public final int compare(String str, String str2) {
                int length = str2.length() - str.length();
                return length == 0 ? str.compareTo(str2) : length;
            }
        };
        private final EnumC15532gtB textStyle;

        huo(EnumC15532gtB enumC15532gtB) {
            this.textStyle = (EnumC15532gtB) gtG.requireNonNull(enumC15532gtB, "textStyle");
        }

        @Override // o.C15553gtn.RVV
        public final boolean print(C15560gtu c15560gtu, StringBuilder sb) {
            AbstractC15502gsH abstractC15502gsH = (AbstractC15502gsH) c15560gtu.getValue(gtM.zoneId());
            if (abstractC15502gsH == null) {
                return false;
            }
            if (abstractC15502gsH.normalized() instanceof gsI) {
                sb.append(abstractC15502gsH.getId());
                return true;
            }
            gtK temporal = c15560gtu.getTemporal();
            sb.append(TimeZone.getTimeZone(abstractC15502gsH.getId()).getDisplayName(temporal.isSupported(EnumC15534gtD.INSTANT_SECONDS) ? abstractC15502gsH.getRules().isDaylightSavings(C15523gss.ofEpochSecond(temporal.getLong(EnumC15534gtD.INSTANT_SECONDS))) : false, this.textStyle.asNormal() == EnumC15532gtB.FULL ? 1 : 0, c15560gtu.getLocale()));
            return true;
        }

        @Override // o.C15553gtn.RVV
        public final int parse(C15561gtv c15561gtv, CharSequence charSequence, int i) {
            int length = charSequence.length();
            if (i > length) {
                throw new IndexOutOfBoundsException();
            }
            if (i == length) {
                return ~i;
            }
            char charAt = charSequence.charAt(i);
            if (charAt == '+' || charAt == '-') {
                return i + 6 > length ? ~i : parseOffset(c15561gtv, charSequence, i, "");
            }
            if (c15561gtv.subSequenceEquals(charSequence, i, "GMT", 0, 3)) {
                return parseOffset(c15561gtv, charSequence, i, "GMT");
            }
            if (c15561gtv.subSequenceEquals(charSequence, i, "UTC", 0, 3)) {
                return parseOffset(c15561gtv, charSequence, i, "UTC");
            }
            if (c15561gtv.subSequenceEquals(charSequence, i, "UT", 0, 2)) {
                return parseOffset(c15561gtv, charSequence, i, "UT");
            }
            TreeMap treeMap = new TreeMap(LENGTH_COMPARATOR);
            for (String str : AbstractC15502gsH.getAvailableZoneIds()) {
                treeMap.put(str, str);
                TimeZone timeZone = TimeZone.getTimeZone(str);
                int i2 = this.textStyle.asNormal() == EnumC15532gtB.FULL ? 1 : 0;
                String displayName = timeZone.getDisplayName(false, i2, c15561gtv.getLocale());
                if (str.startsWith("Etc/") || (!displayName.startsWith("GMT+") && !displayName.startsWith("GMT+"))) {
                    treeMap.put(displayName, str);
                }
                String displayName2 = timeZone.getDisplayName(true, i2, c15561gtv.getLocale());
                if (str.startsWith("Etc/") || (!displayName2.startsWith("GMT+") && !displayName2.startsWith("GMT+"))) {
                    treeMap.put(displayName2, str);
                }
            }
            for (Map.Entry entry : treeMap.entrySet()) {
                String str2 = (String) entry.getKey();
                if (c15561gtv.subSequenceEquals(charSequence, i, str2, 0, str2.length())) {
                    c15561gtv.setParsed(AbstractC15502gsH.of((String) entry.getValue()));
                    return i + str2.length();
                }
            }
            if (charAt != 'Z') {
                return ~i;
            }
            c15561gtv.setParsed(gsI.UTC);
            return i + 1;
        }

        private int parseOffset(C15561gtv c15561gtv, CharSequence charSequence, int i, String str) {
            int length = str.length();
            int i2 = i + length;
            if (i2 >= charSequence.length()) {
                c15561gtv.setParsed(AbstractC15502gsH.of(str));
                return i2;
            }
            char charAt = charSequence.charAt(i2);
            if (charAt != '+' && charAt != '-') {
                c15561gtv.setParsed(AbstractC15502gsH.of(str));
                return i2;
            }
            C15561gtv copy = c15561gtv.copy();
            try {
                int parse = jNh.INSTANCE_ID_ZERO.parse(copy, charSequence, i2);
                if (parse < 0) {
                    c15561gtv.setParsed(AbstractC15502gsH.of(str));
                    return i2;
                }
                gsI ofTotalSeconds = gsI.ofTotalSeconds((int) copy.getParsed(EnumC15534gtD.OFFSET_SECONDS).longValue());
                AbstractC15502gsH abstractC15502gsH = ofTotalSeconds;
                if (length != 0) {
                    abstractC15502gsH = AbstractC15502gsH.ofOffset(str, ofTotalSeconds);
                }
                c15561gtv.setParsed(abstractC15502gsH);
                return parse;
            } catch (DateTimeException unused) {
                return ~i;
            }
        }

        public final String toString() {
            StringBuilder sb = new StringBuilder("ZoneText(");
            sb.append(this.textStyle);
            sb.append(")");
            return sb.toString();
        }
    }

    /* JADX INFO: Access modifiers changed from: package-private */
    /* renamed from: o.gtn$Heg */
    /* loaded from: classes6.dex */
    public static final class Heg implements RVV {
        private static volatile Map.Entry<Integer, HBt> cachedSubstringTree;
        private final String description;
        private final gtQ<AbstractC15502gsH> query;

        Heg(gtQ<AbstractC15502gsH> gtq, String str) {
            this.query = gtq;
            this.description = str;
        }

        @Override // o.C15553gtn.RVV
        public final boolean print(C15560gtu c15560gtu, StringBuilder sb) {
            AbstractC15502gsH abstractC15502gsH = (AbstractC15502gsH) c15560gtu.getValue(this.query);
            if (abstractC15502gsH == null) {
                return false;
            }
            sb.append(abstractC15502gsH.getId());
            return true;
        }

        @Override // o.C15553gtn.RVV
        public final int parse(C15561gtv c15561gtv, CharSequence charSequence, int i) {
            int i2;
            int length = charSequence.length();
            if (i > length) {
                throw new IndexOutOfBoundsException();
            }
            if (i == length) {
                return ~i;
            }
            char charAt = charSequence.charAt(i);
            if (charAt == '+' || charAt == '-') {
                C15561gtv copy = c15561gtv.copy();
                int parse = jNh.INSTANCE_ID.parse(copy, charSequence, i);
                if (parse < 0) {
                    return parse;
                }
                c15561gtv.setParsed(gsI.ofTotalSeconds((int) copy.getParsed(EnumC15534gtD.OFFSET_SECONDS).longValue()));
                return parse;
            }
            int i3 = i + 2;
            if (length >= i3) {
                char charAt2 = charSequence.charAt(i + 1);
                if (c15561gtv.charEquals(charAt, Matrix.MATRIX_TYPE_RANDOM_UT) && c15561gtv.charEquals(charAt2, 'T')) {
                    int i4 = i + 3;
                    if (length >= i4 && c15561gtv.charEquals(charSequence.charAt(i3), 'C')) {
                        return parsePrefixedOffset(c15561gtv, charSequence, i, i4);
                    }
                    return parsePrefixedOffset(c15561gtv, charSequence, i, i3);
                }
                if (c15561gtv.charEquals(charAt, 'G') && length >= (i2 = i + 3) && c15561gtv.charEquals(charAt2, 'M') && c15561gtv.charEquals(charSequence.charAt(i3), 'T')) {
                    return parsePrefixedOffset(c15561gtv, charSequence, i, i2);
                }
            }
            Set<String> availableZoneIds = AbstractC15576guc.getAvailableZoneIds();
            int size = availableZoneIds.size();
            Map.Entry<Integer, HBt> entry = cachedSubstringTree;
            if (entry == null || entry.getKey().intValue() != size) {
                synchronized (this) {
                    entry = cachedSubstringTree;
                    if (entry == null || entry.getKey().intValue() != size) {
                        entry = new AbstractMap.SimpleImmutableEntry<>(Integer.valueOf(size), prepareParser(availableZoneIds));
                        cachedSubstringTree = entry;
                    }
                }
            }
            HBt value = entry.getValue();
            String str = null;
            String str2 = null;
            while (value != null) {
                int i5 = value.length + i;
                if (i5 > length) {
                    break;
                }
                String obj = charSequence.subSequence(i, i5).toString();
                value = value.get(obj, c15561gtv.isCaseSensitive());
                str2 = str;
                str = obj;
            }
            AbstractC15502gsH convertToZone = convertToZone(availableZoneIds, str, c15561gtv.isCaseSensitive());
            if (convertToZone == null) {
                convertToZone = convertToZone(availableZoneIds, str2, c15561gtv.isCaseSensitive());
                if (convertToZone == null) {
                    if (!c15561gtv.charEquals(charAt, Matrix.MATRIX_TYPE_ZERO)) {
                        return ~i;
                    }
                    c15561gtv.setParsed(gsI.UTC);
                    return i + 1;
                }
                str = str2;
            }
            c15561gtv.setParsed(convertToZone);
            return i + str.length();
        }

        private AbstractC15502gsH convertToZone(Set<String> set, String str, boolean z) {
            if (str == null) {
                return null;
            }
            if (z) {
                if (set.contains(str)) {
                    return AbstractC15502gsH.of(str);
                }
                return null;
            }
            for (String str2 : set) {
                if (str2.equalsIgnoreCase(str)) {
                    return AbstractC15502gsH.of(str2);
                }
            }
            return null;
        }

        private int parsePrefixedOffset(C15561gtv c15561gtv, CharSequence charSequence, int i, int i2) {
            String upperCase = charSequence.subSequence(i, i2).toString().toUpperCase();
            C15561gtv copy = c15561gtv.copy();
            if (i2 < charSequence.length() && c15561gtv.charEquals(charSequence.charAt(i2), Matrix.MATRIX_TYPE_ZERO)) {
                c15561gtv.setParsed(AbstractC15502gsH.ofOffset(upperCase, gsI.UTC));
                return i2;
            }
            int parse = jNh.INSTANCE_ID.parse(copy, charSequence, i2);
            if (parse < 0) {
                c15561gtv.setParsed(AbstractC15502gsH.ofOffset(upperCase, gsI.UTC));
                return i2;
            }
            c15561gtv.setParsed(AbstractC15502gsH.ofOffset(upperCase, gsI.ofTotalSeconds((int) copy.getParsed(EnumC15534gtD.OFFSET_SECONDS).longValue())));
            return parse;
        }

        /* JADX INFO: Access modifiers changed from: package-private */
        /* renamed from: o.gtn$Heg$HBt */
        /* loaded from: classes6.dex */
        public static final class HBt {
            final int length;
            private final Map<CharSequence, HBt> substringMap;
            private final Map<String, HBt> substringMapCI;

            private HBt(int i) {
                this.substringMap = new HashMap();
                this.substringMapCI = new HashMap();
                this.length = i;
            }

            /* JADX INFO: Access modifiers changed from: private */
            public HBt get(CharSequence charSequence, boolean z) {
                if (z) {
                    return this.substringMap.get(charSequence);
                }
                return this.substringMapCI.get(charSequence.toString().toLowerCase(Locale.ENGLISH));
            }

            /* JADX INFO: Access modifiers changed from: private */
            public void add(String str) {
                HBt hBt = this;
                while (true) {
                    int length = str.length();
                    int i = hBt.length;
                    if (length == i) {
                        hBt.substringMap.put(str, null);
                        hBt.substringMapCI.put(str.toLowerCase(Locale.ENGLISH), null);
                        return;
                    } else {
                        if (length <= i) {
                            return;
                        }
                        String substring = str.substring(0, i);
                        HBt hBt2 = hBt.substringMap.get(substring);
                        if (hBt2 == null) {
                            hBt2 = new HBt(length);
                            hBt.substringMap.put(substring, hBt2);
                            hBt.substringMapCI.put(substring.toLowerCase(Locale.ENGLISH), hBt2);
                        }
                        hBt = hBt2;
                    }
                }
            }
        }

        private static HBt prepareParser(Set<String> set) {
            ArrayList arrayList = new ArrayList(set);
            Collections.sort(arrayList, C15553gtn.LENGTH_SORT);
            HBt hBt = new HBt(((String) arrayList.get(0)).length());
            Iterator it = arrayList.iterator();
            while (it.hasNext()) {
                hBt.add((String) it.next());
            }
            return hBt;
        }

        public final String toString() {
            return this.description;
        }
    }

    /* renamed from: o.gtn$IeS */
    /* loaded from: classes6.dex */
    static final class IeS implements RVV {
        private final EnumC15532gtB textStyle;

        IeS(EnumC15532gtB enumC15532gtB) {
            this.textStyle = enumC15532gtB;
        }

        @Override // o.C15553gtn.RVV
        public final boolean print(C15560gtu c15560gtu, StringBuilder sb) {
            gsR gsr = (gsR) c15560gtu.getValue(gtM.chronology());
            if (gsr == null) {
                return false;
            }
            if (this.textStyle == null) {
                sb.append(gsr.getId());
                return true;
            }
            try {
                sb.append(ResourceBundle.getBundle("org.threeten.bp.format.ChronologyText", c15560gtu.getLocale(), C15553gtn.class.getClassLoader()).getString(gsr.getId()));
                return true;
            } catch (MissingResourceException unused) {
                sb.append(gsr.getId());
                return true;
            }
        }

        @Override // o.C15553gtn.RVV
        public final int parse(C15561gtv c15561gtv, CharSequence charSequence, int i) {
            if (i < 0 || i > charSequence.length()) {
                throw new IndexOutOfBoundsException();
            }
            gsR gsr = null;
            int i2 = -1;
            for (gsR gsr2 : gsR.getAvailableChronologies()) {
                String id = gsr2.getId();
                int length = id.length();
                if (length > i2 && c15561gtv.subSequenceEquals(charSequence, i, id, 0, length)) {
                    gsr = gsr2;
                    i2 = length;
                }
            }
            if (gsr == null) {
                return ~i;
            }
            c15561gtv.setParsed(gsr);
            return i + i2;
        }
    }

    /* renamed from: o.gtn$tOB */
    /* loaded from: classes6.dex */
    static final class tOB implements RVV {
        private final EnumC15556gtq dateStyle;
        private final EnumC15556gtq timeStyle;

        tOB(EnumC15556gtq enumC15556gtq, EnumC15556gtq enumC15556gtq2) {
            this.dateStyle = enumC15556gtq;
            this.timeStyle = enumC15556gtq2;
        }

        @Override // o.C15553gtn.RVV
        public final boolean print(C15560gtu c15560gtu, StringBuilder sb) {
            return formatter(c15560gtu.getLocale(), gsR.from(c15560gtu.getTemporal())).toPrinterParser(false).print(c15560gtu, sb);
        }

        @Override // o.C15553gtn.RVV
        public final int parse(C15561gtv c15561gtv, CharSequence charSequence, int i) {
            return formatter(c15561gtv.getLocale(), c15561gtv.getEffectiveChronology()).toPrinterParser(false).parse(c15561gtv, charSequence, i);
        }

        private C15554gto formatter(Locale locale, gsR gsr) {
            return AbstractC15551gtl.getInstance().getFormatter(this.dateStyle, this.timeStyle, gsr, locale);
        }

        public final String toString() {
            StringBuilder sb = new StringBuilder("Localized(");
            Object obj = this.dateStyle;
            if (obj == null) {
                obj = "";
            }
            sb.append(obj);
            sb.append(",");
            EnumC15556gtq enumC15556gtq = this.timeStyle;
            sb.append(enumC15556gtq != null ? enumC15556gtq : "");
            sb.append(")");
            return sb.toString();
        }
    }

    /* JADX INFO: Access modifiers changed from: package-private */
    /* renamed from: o.gtn$mxa */
    /* loaded from: classes6.dex */
    public static final class mxa implements RVV {
        private final int count;
        private final char letter;

        public mxa(char c, int i) {
            this.letter = c;
            this.count = i;
        }

        @Override // o.C15553gtn.RVV
        public final boolean print(C15560gtu c15560gtu, StringBuilder sb) {
            return evaluate(gtS.of(c15560gtu.getLocale())).print(c15560gtu, sb);
        }

        @Override // o.C15553gtn.RVV
        public final int parse(C15561gtv c15561gtv, CharSequence charSequence, int i) {
            return evaluate(gtS.of(c15561gtv.getLocale())).parse(c15561gtv, charSequence, i);
        }

        private RVV evaluate(gtS gts) {
            char c = this.letter;
            if (c == 'W') {
                return new ojQ(gts.weekOfMonth(), 1, 2, EnumC15564gty.NOT_NEGATIVE);
            }
            if (c == 'Y') {
                if (this.count == 2) {
                    return new vUG(gts.weekBasedYear(), 2, 2, 0, vUG.BASE_DATE);
                }
                InterfaceC15537gtP weekBasedYear = gts.weekBasedYear();
                int i = this.count;
                return new ojQ(weekBasedYear, i, 19, i < 4 ? EnumC15564gty.NORMAL : EnumC15564gty.EXCEEDS_PAD, -1);
            }
            if (c == 'c') {
                return new ojQ(gts.dayOfWeek(), this.count, 2, EnumC15564gty.NOT_NEGATIVE);
            }
            if (c == 'e') {
                return new ojQ(gts.dayOfWeek(), this.count, 2, EnumC15564gty.NOT_NEGATIVE);
            }
            if (c != 'w') {
                return null;
            }
            return new ojQ(gts.weekOfWeekBasedYear(), this.count, 2, EnumC15564gty.NOT_NEGATIVE);
        }

        public final String toString() {
            StringBuilder sb = new StringBuilder(30);
            sb.append("Localized(");
            char c = this.letter;
            if (c == 'Y') {
                int i = this.count;
                if (i == 1) {
                    sb.append("WeekBasedYear");
                } else if (i == 2) {
                    sb.append("ReducedValue(WeekBasedYear,2,2,2000-01-01)");
                } else {
                    sb.append("WeekBasedYear,");
                    sb.append(this.count);
                    sb.append(",19,");
                    sb.append(this.count < 4 ? EnumC15564gty.NORMAL : EnumC15564gty.EXCEEDS_PAD);
                }
            } else {
                if (c == 'c' || c == 'e') {
                    sb.append("DayOfWeek");
                } else if (c == 'w') {
                    sb.append("WeekOfWeekBasedYear");
                } else if (c == 'W') {
                    sb.append("WeekOfMonth");
                }
                sb.append(",");
                sb.append(this.count);
            }
            sb.append(")");
            return sb.toString();
        }
    }
}