package com.ifpdos.udi.sdk.service.doc.base;

import com.ifpdos.udi.sdk.kotlin.comment.parser.CommentDetails;
import d.b.a.a.a;
import g.c0.g;
import g.h0.b.l;
import g.h0.c.a0;
import g.h0.c.m;
import g.i;
import g.m0.f;
import java.lang.annotation.Annotation;
import java.lang.reflect.AnnotatedElement;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.List;
import java.util.Locale;
import java.util.Objects;
import javax.lang.model.element.Element;
import okhttp3.HttpUrl;

/* JADX INFO: compiled from: Utils.kt */
/* JADX INFO: loaded from: classes.dex */
@i
public final class Utils {
    private static final String CLASS_LIST = "java.util.List";
    public static final String EMPTY_BODY = "com.ifpdos.udi.sdk.service.sdk.protocol.EmptyBody";
    public static final String NO_NOTIFY = "com.ifpdos.udi.sdk.service.compile.NoNotify";
    private static final Class<Annotation> PARAM_NAME_CLASS;
    private static final Method PARAM_NAME_VALUE_METHOD;
    public static final String PROTOCOL_PACKAGE = "com.ifpdos.udi.sdk.service.sdk.protocol";
    public static final String UDI_REQUEST = "com.ifpdos.udi.sdk.service.sdk.server.UdiRequest";
    public static final Utils INSTANCE = new Utils();
    private static final List<String> RAW_BUILD_IN_TYPES = g.u("byte", "int", "short", "long", "float", "double", "boolean");
    private static final List<String> BUILD_IN_TYPES = g.w("byte", "int", "short", "long", "float", "double", "boolean", "Byte", "Int", "Short", "UShort", "Integer", "Long", "Float", "Double", "Boolean", "String");

    /* JADX INFO: renamed from: com.ifpdos.udi.sdk.service.doc.base.Utils$addTab$1, reason: invalid class name */
    /* JADX INFO: compiled from: Utils.kt */
    @i
    public static final class AnonymousClass1 extends m implements l<String, CharSequence> {
        public final /* synthetic */ a0<String> $tab;

        /* JADX WARN: 'super' call moved to the top of the method (can break code semantics) */
        public AnonymousClass1(a0<String> a0Var) {
            super(1);
            this.$tab = a0Var;
        }

        @Override // g.h0.b.l
        public final CharSequence invoke(String str) {
            g.h0.c.l.f(str, "it");
            return a.v(new StringBuilder(), this.$tab.f4099b, str);
        }
    }

    static {
        Class cls = Class.forName("com.ifpdos.udi.sdk.service.compile.ParamName");
        PARAM_NAME_CLASS = cls;
        PARAM_NAME_VALUE_METHOD = cls.getMethod("value", new Class[0]);
    }

    private Utils() {
    }

    public static /* synthetic */ String addTab$default(Utils utils, String str, int i2, int i3, Object obj) {
        if ((i3 & 2) != 0) {
            i2 = 1;
        }
        return utils.addTab(str, i2);
    }

    /* JADX WARN: Multi-variable type inference failed */
    /* JADX WARN: Type inference failed for: r3v2, types: [T, java.lang.String] */
    public final String addTab(String str, int i2) {
        g.h0.c.l.f(str, "lines");
        a0 a0Var = new a0();
        a0Var.f4099b = "";
        for (int i3 = 0; i3 < i2; i3++) {
            a0Var.f4099b = a.u(new StringBuilder(), (String) a0Var.f4099b, '\t');
        }
        return g.r(f.E(f.R(str).toString(), new String[]{"\n"}, false, 0, 6), "\n", null, null, 0, null, new AnonymousClass1(a0Var), 30);
    }

    public final String filterJavaLangBuildType(String str) {
        g.h0.c.l.f(str, "className");
        if (f.J(str, "java.lang.", false, 2)) {
            String strSubstring = str.substring(10);
            g.h0.c.l.e(strSubstring, "this as java.lang.String).substring(startIndex)");
            return strSubstring;
        }
        if (!f.J(str, "kotlin.", false, 2) || f.E(str, new String[]{"."}, false, 0, 6).size() != 2) {
            return str;
        }
        String strSubstring2 = str.substring(7);
        g.h0.c.l.e(strSubstring2, "this as java.lang.String).substring(startIndex)");
        return strSubstring2;
    }

    public final String getGenericClassName(String str) {
        g.h0.c.l.f(str, "fullName");
        if (!hasGenericParam(str)) {
            return str;
        }
        String strSubstring = str.substring(0, f.m(str, "<", 0, false, 6));
        g.h0.c.l.e(strSubstring, "this as java.lang.String…ing(startIndex, endIndex)");
        return strSubstring;
    }

    public final List<String> getGenericParameterTypes(String str) {
        g.h0.c.l.f(str, "fullName");
        ArrayList arrayList = new ArrayList();
        int iM = f.m(str, "<", 0, false, 6) + 1;
        int length = str.length() - 1;
        StringBuilder sb = new StringBuilder();
        String strSubstring = str.substring(iM, length);
        g.h0.c.l.e(strSubstring, "this as java.lang.String…ing(startIndex, endIndex)");
        char[] charArray = strSubstring.toCharArray();
        g.h0.c.l.e(charArray, "this as java.lang.String).toCharArray()");
        int i2 = 0;
        for (char c2 : charArray) {
            if (c2 == ',' && i2 == 0) {
                String string = sb.toString();
                g.h0.c.l.e(string, "sb.toString()");
                arrayList.add(string);
                g.h0.c.l.f(sb, "<this>");
                sb.setLength(0);
            } else {
                if (c2 == '<') {
                    i2++;
                } else if (c2 == '>') {
                    i2--;
                }
                sb.append(c2);
            }
        }
        String string2 = sb.toString();
        g.h0.c.l.e(string2, "sb.toString()");
        arrayList.add(string2);
        return arrayList;
    }

    public final String getParamName(Element element, String str) throws IllegalAccessException, InvocationTargetException {
        g.h0.c.l.f(element, "element");
        g.h0.c.l.f(str, "default");
        Annotation annotation = element.getAnnotation(PARAM_NAME_CLASS);
        if (annotation == null) {
            return str;
        }
        Object objInvoke = PARAM_NAME_VALUE_METHOD.invoke(annotation, new Object[0]);
        Objects.requireNonNull(objInvoke, "null cannot be cast to non-null type kotlin.String");
        return (String) objInvoke;
    }

    public final String getServiceName(CommentDetails commentDetails) {
        String str;
        g.h0.c.l.f(commentDetails, "serviceComment");
        List<String> list = commentDetails.getAnnotations().get("name");
        if (list == null || (str = list.get(0)) == null) {
            String summary = commentDetails.getSummary();
            return summary == null ? "service" : summary;
        }
        String lowerCase = str.toLowerCase(Locale.ROOT);
        g.h0.c.l.e(lowerCase, "this as java.lang.String).toLowerCase(Locale.ROOT)");
        return lowerCase;
    }

    public final String getTypeByList(String str) {
        String strTitleCase;
        g.h0.c.l.f(str, "clazz");
        if (f.d(str, HttpUrl.PATH_SEGMENT_ENCODE_SET_URI, false, 2)) {
            String strSubstring = str.substring(0, str.length() - 2);
            g.h0.c.l.e(strSubstring, "this as java.lang.String…ing(startIndex, endIndex)");
            strTitleCase = titleCase(strSubstring);
        } else {
            strTitleCase = getGenericParameterTypes(str).get(0);
        }
        return filterJavaLangBuildType(strTitleCase);
    }

    public final boolean hasGenericParam(String str) {
        g.h0.c.l.f(str, "className");
        return f.b(str, "<", false, 2);
    }

    public final boolean isBuildType(String str) {
        g.h0.c.l.f(str, "type");
        return BUILD_IN_TYPES.contains(str);
    }

    public final boolean isListType(String str) {
        g.h0.c.l.f(str, "fullName");
        return f.J(str, CLASS_LIST, false, 2) || f.d(str, HttpUrl.PATH_SEGMENT_ENCODE_SET_URI, false, 2);
    }

    public final String removeJsonFormat(String str) {
        g.h0.c.l.f(str, "json");
        return f.A(f.A(f.A(str, "\"", "\\\"", false, 4), "\n", "", false, 4), "\t", "", false, 4);
    }

    public final String strTitleCase(String str) {
        g.h0.c.l.f(str, "str");
        if (!(str.length() > 0)) {
            return str;
        }
        StringBuilder sb = new StringBuilder();
        char cCharAt = str.charAt(0);
        Locale locale = Locale.ROOT;
        g.h0.c.l.e(locale, "ROOT");
        g.h0.c.l.f(locale, "locale");
        g.h0.c.l.f(locale, "locale");
        String strValueOf = String.valueOf(cCharAt);
        g.h0.c.l.d(strValueOf, "null cannot be cast to non-null type java.lang.String");
        String upperCase = strValueOf.toUpperCase(locale);
        g.h0.c.l.e(upperCase, "this as java.lang.String).toUpperCase(locale)");
        if (upperCase.length() <= 1) {
            String strValueOf2 = String.valueOf(cCharAt);
            g.h0.c.l.d(strValueOf2, "null cannot be cast to non-null type java.lang.String");
            String upperCase2 = strValueOf2.toUpperCase(locale);
            g.h0.c.l.e(upperCase2, "this as java.lang.String).toUpperCase(Locale.ROOT)");
            if (g.h0.c.l.a(upperCase, upperCase2)) {
                upperCase = String.valueOf(Character.toTitleCase(cCharAt));
            }
        } else if (cCharAt != 329) {
            char cCharAt2 = upperCase.charAt(0);
            g.h0.c.l.d(upperCase, "null cannot be cast to non-null type java.lang.String");
            String strSubstring = upperCase.substring(1);
            g.h0.c.l.e(strSubstring, "this as java.lang.String).substring(startIndex)");
            g.h0.c.l.d(strSubstring, "null cannot be cast to non-null type java.lang.String");
            String lowerCase = strSubstring.toLowerCase(locale);
            g.h0.c.l.e(lowerCase, "this as java.lang.String).toLowerCase(Locale.ROOT)");
            upperCase = cCharAt2 + lowerCase;
        }
        sb.append((Object) upperCase);
        String strSubstring2 = str.substring(1);
        g.h0.c.l.e(strSubstring2, "this as java.lang.String).substring(startIndex)");
        sb.append(strSubstring2);
        return sb.toString();
    }

    public final String titleCase(String str) {
        if (str == null) {
            return "";
        }
        StringBuilder sb = new StringBuilder();
        sb.append(Character.toUpperCase(str.charAt(0)));
        String strSubstring = str.substring(1);
        g.h0.c.l.e(strSubstring, "this as java.lang.String).substring(startIndex)");
        sb.append(strSubstring);
        return sb.toString();
    }

    public final String toWrapperTypeIfIsRawBuildInType(String str) {
        g.h0.c.l.f(str, "type");
        return RAW_BUILD_IN_TYPES.contains(str) ? titleCase(str) : str;
    }

    public final String getParamName(AnnotatedElement annotatedElement, String str) throws IllegalAccessException, InvocationTargetException {
        g.h0.c.l.f(annotatedElement, "element");
        g.h0.c.l.f(str, "default");
        Annotation annotation = annotatedElement.getAnnotation(PARAM_NAME_CLASS);
        if (annotation == null) {
            return str;
        }
        Object objInvoke = PARAM_NAME_VALUE_METHOD.invoke(annotation, new Object[0]);
        Objects.requireNonNull(objInvoke, "null cannot be cast to non-null type kotlin.String");
        return (String) objInvoke;
    }
}