package androidx.navigation;

import android.net.Uri;
import android.os.Bundle;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import n2.AbstractC2612c;
import w4.C3137A;
import x4.AbstractC3251q;
import x4.AbstractC3252r;
import x4.AbstractC3253s;
import x4.AbstractC3257w;

/* JADX INFO: renamed from: androidx.navigation.y, reason: case insensitive filesystem */
/* JADX INFO: loaded from: classes.dex */
public final class C1149y {

    /* JADX INFO: renamed from: m, reason: collision with root package name */
    public static final Pattern f12802m = Pattern.compile("^[a-zA-Z]+[+\\w\\-.]*:");

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

    /* JADX INFO: renamed from: a, reason: collision with root package name */
    public final String f12804a;

    /* JADX INFO: renamed from: b, reason: collision with root package name */
    public final ArrayList f12805b;

    /* JADX INFO: renamed from: c, reason: collision with root package name */
    public final String f12806c;

    /* JADX INFO: renamed from: d, reason: collision with root package name */
    public final w4.p f12807d;

    /* JADX INFO: renamed from: e, reason: collision with root package name */
    public final w4.p f12808e;

    /* JADX INFO: renamed from: f, reason: collision with root package name */
    public final Object f12809f;

    /* JADX INFO: renamed from: g, reason: collision with root package name */
    public boolean f12810g;

    /* JADX INFO: renamed from: h, reason: collision with root package name */
    public final Object f12811h;

    /* JADX INFO: renamed from: i, reason: collision with root package name */
    public final Object f12812i;

    /* JADX INFO: renamed from: j, reason: collision with root package name */
    public final Object f12813j;

    /* JADX INFO: renamed from: k, reason: collision with root package name */
    public final w4.p f12814k;
    public final boolean l;

    public C1149y(String str) {
        this.f12804a = str;
        ArrayList arrayList = new ArrayList();
        this.f12805b = arrayList;
        this.f12807d = m1.g.k(new C1147w(this, 6));
        this.f12808e = m1.g.k(new C1147w(this, 4));
        w4.i iVar = w4.i.f25467c;
        this.f12809f = m1.g.j(iVar, new C1147w(this, 7));
        this.f12811h = m1.g.j(iVar, new C1147w(this, 1));
        this.f12812i = m1.g.j(iVar, new C1147w(this, 0));
        this.f12813j = m1.g.j(iVar, new C1147w(this, 3));
        this.f12814k = m1.g.k(new C1147w(this, 2));
        m1.g.k(new C1147w(this, 5));
        StringBuilder sb = new StringBuilder("^");
        if (!f12802m.matcher(str).find()) {
            sb.append("http[s]?://");
        }
        Matcher matcher = Pattern.compile("(\\?|\\#|$)").matcher(str);
        matcher.find();
        boolean z6 = false;
        String strSubstring = str.substring(0, matcher.start());
        kotlin.jvm.internal.o.g(strSubstring, "substring(...)");
        a(strSubstring, arrayList, sb);
        if (!S4.p.D0(sb, ".*", false) && !S4.p.D0(sb, "([^/]+?)", false)) {
            z6 = true;
        }
        this.l = z6;
        sb.append("($|(\\?(.)*)|(\\#(.)*))");
        String string = sb.toString();
        kotlin.jvm.internal.o.g(string, "uriRegex.toString()");
        this.f12806c = S4.w.y0(string, ".*", "\\E.*\\Q");
    }

    public static void a(String str, ArrayList arrayList, StringBuilder sb) {
        Matcher matcher = f12803n.matcher(str);
        int iEnd = 0;
        while (matcher.find()) {
            String strGroup = matcher.group(1);
            kotlin.jvm.internal.o.f(strGroup, "null cannot be cast to non-null type kotlin.String");
            arrayList.add(strGroup);
            if (matcher.start() > iEnd) {
                String strSubstring = str.substring(iEnd, matcher.start());
                kotlin.jvm.internal.o.g(strSubstring, "substring(...)");
                sb.append(Pattern.quote(strSubstring));
            }
            sb.append("([^/]*?|)");
            iEnd = matcher.end();
        }
        if (iEnd < str.length()) {
            String strSubstring2 = str.substring(iEnd);
            kotlin.jvm.internal.o.g(strSubstring2, "substring(...)");
            sb.append(Pattern.quote(strSubstring2));
        }
    }

    public static void g(Bundle bundle, String key, String str, C1132g c1132g) {
        if (c1132g == null) {
            bundle.putString(key, str);
            return;
        }
        U u6 = c1132g.f12748a;
        kotlin.jvm.internal.o.h(key, "key");
        u6.e(bundle, key, u6.d(str));
    }

    public final int b(Uri uri) {
        if (uri == null) {
            return 0;
        }
        String str = this.f12804a;
        List<String> requestedPathSegments = uri.getPathSegments();
        List<String> uriPathSegments = Uri.parse(str).getPathSegments();
        kotlin.jvm.internal.o.g(requestedPathSegments, "requestedPathSegments");
        kotlin.jvm.internal.o.g(uriPathSegments, "uriPathSegments");
        return AbstractC3251q.j0(requestedPathSegments, uriPathSegments).size();
    }

    /* JADX WARN: Type inference failed for: r1v0, types: [java.lang.Object, w4.h] */
    /* JADX WARN: Type inference failed for: r1v6, types: [java.lang.Object, w4.h] */
    public final ArrayList c() {
        ArrayList arrayList = this.f12805b;
        Collection collectionValues = ((Map) this.f12809f.getValue()).values();
        ArrayList arrayList2 = new ArrayList();
        Iterator it = collectionValues.iterator();
        while (it.hasNext()) {
            AbstractC3257w.L(((C1146v) it.next()).f12797b, arrayList2);
        }
        return AbstractC3251q.s0((List) this.f12812i.getValue(), AbstractC3251q.s0(arrayList2, arrayList));
    }

    /* JADX WARN: Type inference failed for: r0v17, types: [java.lang.Object, w4.h] */
    public final Bundle d(Uri deepLink, LinkedHashMap arguments) {
        kotlin.jvm.internal.o.h(deepLink, "deepLink");
        kotlin.jvm.internal.o.h(arguments, "arguments");
        Pattern pattern = (Pattern) this.f12807d.getValue();
        Matcher matcher = pattern != null ? pattern.matcher(deepLink.toString()) : null;
        if (matcher != null && matcher.matches()) {
            Bundle bundle = new Bundle();
            if (e(matcher, bundle, arguments) && (!((Boolean) this.f12808e.getValue()).booleanValue() || f(deepLink, bundle, arguments))) {
                String fragment = deepLink.getFragment();
                Pattern pattern2 = (Pattern) this.f12814k.getValue();
                Matcher matcher2 = pattern2 != null ? pattern2.matcher(String.valueOf(fragment)) : null;
                if (matcher2 != null && matcher2.matches()) {
                    List list = (List) this.f12812i.getValue();
                    ArrayList arrayList = new ArrayList(AbstractC3253s.G(list, 10));
                    int i6 = 0;
                    for (Object obj : list) {
                        int i7 = i6 + 1;
                        if (i6 < 0) {
                            AbstractC3252r.F();
                            throw null;
                        }
                        String str = (String) obj;
                        String value = Uri.decode(matcher2.group(i7));
                        C1132g c1132g = (C1132g) arguments.get(str);
                        try {
                            kotlin.jvm.internal.o.g(value, "value");
                            g(bundle, str, value, c1132g);
                            arrayList.add(C3137A.f25453a);
                            i6 = i7;
                        } catch (IllegalArgumentException unused) {
                        }
                    }
                }
                if (AbstractC1131f.d(arguments, new C1148x(0, bundle)).isEmpty()) {
                    return bundle;
                }
            }
        }
        return null;
    }

    public final boolean e(Matcher matcher, Bundle bundle, LinkedHashMap linkedHashMap) {
        ArrayList arrayList = this.f12805b;
        ArrayList arrayList2 = new ArrayList(AbstractC3253s.G(arrayList, 10));
        int i6 = 0;
        for (Object obj : arrayList) {
            int i7 = i6 + 1;
            if (i6 < 0) {
                AbstractC3252r.F();
                throw null;
            }
            String str = (String) obj;
            String value = Uri.decode(matcher.group(i7));
            C1132g c1132g = (C1132g) linkedHashMap.get(str);
            try {
                kotlin.jvm.internal.o.g(value, "value");
                g(bundle, str, value, c1132g);
                arrayList2.add(C3137A.f25453a);
                i6 = i7;
            } catch (IllegalArgumentException unused) {
                return false;
            }
        }
        return true;
    }

    public final boolean equals(Object obj) {
        if (obj == null || !(obj instanceof C1149y)) {
            return false;
        }
        return this.f12804a.equals(((C1149y) obj).f12804a);
    }

    /* JADX WARN: Multi-variable type inference failed */
    /* JADX WARN: Type inference failed for: r2v0, types: [java.lang.Object, w4.h] */
    public final boolean f(Uri uri, Bundle bundle, LinkedHashMap linkedHashMap) {
        Object objValueOf;
        boolean z6;
        Object obj;
        String query;
        for (Map.Entry entry : ((Map) this.f12809f.getValue()).entrySet()) {
            String str = (String) entry.getKey();
            C1146v c1146v = (C1146v) entry.getValue();
            List<String> inputParams = uri.getQueryParameters(str);
            if (this.f12810g && (query = uri.getQuery()) != null && !query.equals(uri.toString())) {
                inputParams = AbstractC2612c.q(query);
            }
            kotlin.jvm.internal.o.g(inputParams, "inputParams");
            Object obj2 = C3137A.f25453a;
            int i6 = 0;
            Bundle bundleM = e4.C.m(new w4.k[0]);
            for (String str2 : c1146v.f12797b) {
                C1132g c1132g = (C1132g) linkedHashMap.get(str2);
                U u6 = c1132g != null ? c1132g.f12748a : null;
                if ((u6 instanceof M) && !c1132g.f12749b) {
                    switch (((M) u6).f12714k) {
                        case 0:
                            obj = new boolean[0];
                            break;
                        case 1:
                            obj = new float[0];
                            break;
                        case 2:
                            obj = new int[0];
                            break;
                        case 3:
                            obj = new long[0];
                            break;
                        default:
                            obj = new String[0];
                            break;
                    }
                    u6.e(bundleM, str2, obj);
                }
            }
            for (String str3 : inputParams) {
                String str4 = c1146v.f12796a;
                Matcher matcher = str4 != null ? Pattern.compile(str4, 32).matcher(str3) : null;
                if (matcher == null || !matcher.matches()) {
                    return i6;
                }
                ArrayList arrayList = c1146v.f12797b;
                ArrayList arrayList2 = new ArrayList(AbstractC3253s.G(arrayList, 10));
                int i7 = i6;
                for (Object obj3 : arrayList) {
                    int i8 = i7 + 1;
                    if (i7 < 0) {
                        AbstractC3252r.F();
                        throw null;
                    }
                    String str5 = (String) obj3;
                    String strGroup = matcher.group(i8);
                    if (strGroup == null) {
                        strGroup = "";
                    }
                    int i9 = i6;
                    C1132g c1132g2 = (C1132g) linkedHashMap.get(str5);
                    try {
                        if (bundleM.containsKey(str5)) {
                            if (bundleM.containsKey(str5)) {
                                if (c1132g2 != null) {
                                    U u7 = c1132g2.f12748a;
                                    Object objA = u7.a(bundleM, str5);
                                    if (!bundleM.containsKey(str5)) {
                                        throw new IllegalArgumentException("There is no previous value in this bundle.");
                                    }
                                    u7.e(bundleM, str5, u7.c(objA, strGroup));
                                }
                                z6 = i9;
                            } else {
                                z6 = 1;
                            }
                            try {
                                objValueOf = Boolean.valueOf(z6);
                            } catch (IllegalArgumentException unused) {
                                objValueOf = obj2;
                            }
                        } else {
                            g(bundleM, str5, strGroup, c1132g2);
                            objValueOf = obj2;
                        }
                    } catch (IllegalArgumentException unused2) {
                    }
                    arrayList2.add(objValueOf);
                    i7 = i8;
                    i6 = i9;
                }
            }
            bundle.putAll(bundleM);
        }
        return true;
    }

    public final int hashCode() {
        return this.f12804a.hashCode() * 961;
    }
}