package com.ifpdos.udi.sdk.service.compile;

import com.ifpdos.udi.sdk.kotlin.comment.parser.Comment;
import com.ifpdos.udi.sdk.kotlin.comment.parser.CommentDetails;
import com.ifpdos.udi.sdk.kotlin.comment.parser.CommentParser;
import com.ifpdos.udi.sdk.service.doc.base.ApiInfo;
import com.ifpdos.udi.sdk.service.doc.base.ClassParser;
import com.ifpdos.udi.sdk.service.doc.base.IClassWrapper;
import com.ifpdos.udi.sdk.service.doc.base.IDocGenerator;
import com.ifpdos.udi.sdk.service.doc.base.IFieldWrapper;
import com.ifpdos.udi.sdk.service.doc.base.Request;
import com.ifpdos.udi.sdk.service.doc.base.Uri;
import com.ifpdos.udi.sdk.service.doc.base.Utils;
import g.h0.c.f0;
import g.h0.c.g;
import g.h0.c.l;
import g.i;
import g.k;
import g.m0.a;
import g.m0.f;
import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.io.StringReader;
import java.io.StringWriter;
import java.io.Writer;
import java.lang.annotation.Annotation;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Iterator;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.Objects;
import java.util.Set;
import javax.annotation.processing.AbstractProcessor;
import javax.annotation.processing.Filer;
import javax.annotation.processing.Messager;
import javax.annotation.processing.ProcessingEnvironment;
import javax.annotation.processing.RoundEnvironment;
import javax.annotation.processing.SupportedAnnotationTypes;
import javax.annotation.processing.SupportedSourceVersion;
import javax.lang.model.SourceVersion;
import javax.lang.model.element.Element;
import javax.lang.model.element.ExecutableElement;
import javax.lang.model.element.TypeElement;
import javax.lang.model.element.VariableElement;
import javax.lang.model.type.DeclaredType;
import javax.lang.model.type.TypeKind;
import javax.lang.model.type.TypeMirror;
import javax.lang.model.util.Elements;
import javax.tools.Diagnostic;

/* JADX INFO: compiled from: ApiProcessor.kt */
/* JADX INFO: loaded from: classes.dex */
@i
@SupportedSourceVersion(SourceVersion.RELEASE_8)
@SupportedAnnotationTypes({"com.ifpdos.udi.sdk.service.compile.GetterHandler", "com.ifpdos.udi.sdk.service.compile.SetterHandler", "com.ifpdos.udi.sdk.service.compile.Api"})
public final class ApiProcessor extends AbstractProcessor {
    public static final Companion Companion = new Companion(null);
    private static final String KAPT_KOTLIN_GENERATED_OPTION = "kapt.kotlin.generated";
    private static final String PROTOCOL_DEFINE_FILE = "ProtocolDefine.kt";
    private static final String UDI_STATIC_API_XML_FILE = "udi_service_apis.xml";
    private final ClassParser classParser = new ClassParser();
    private CommentProvider commentProvider;
    private Elements elementUtils;
    private Filer filer;
    private File kotlinGenerated;
    private Messager messager;
    private File projectDir;

    /* JADX INFO: compiled from: ApiProcessor.kt */
    @i
    public static final class Companion {
        private Companion() {
        }

        public /* synthetic */ Companion(g gVar) {
            this();
        }
    }

    private final String covertToKotlinType(String str) {
        return f.A(f.A(f.A(f.A(f.A(f.A(str, "java.lang.Integer", "Int", false, 4), "java.lang.Long", "Long", false, 4), "java.lang.Float", "Float", false, 4), "java.lang.Double", "Double", false, 4), "java.lang.Boolean", "Boolean", false, 4), "java.lang.String", "String", false, 4);
    }

    private final boolean doProcess(RoundEnvironment roundEnvironment) throws Exception {
        Class<?> cls;
        Object obj = this.processingEnv.getOptions().get(KAPT_KOTLIN_GENERATED_OPTION);
        l.c(obj);
        this.kotlinGenerated = new File((String) obj);
        File docDir = getDocDir();
        Map<String, CommentDetails> commentFromDependentModules = getCommentFromDependentModules();
        l.c(roundEnvironment);
        Set<? extends Element> elementsAnnotatedWith = roundEnvironment.getElementsAnnotatedWith(Api.class);
        if (elementsAnnotatedWith.isEmpty()) {
            return true;
        }
        File fileSearchCodeFile = searchCodeFile(PROTOCOL_DEFINE_FILE, getCurrentModuleDir(), "src", "main");
        l.c(fileSearchCodeFile);
        Comment rVar = CommentParser.INSTANCE.parser(fileSearchCodeFile);
        Map<String, Integer> linkedHashMap = new LinkedHashMap<>();
        int i2 = 0;
        for (Object obj2 : rVar.getElementComments().keySet()) {
            int i3 = i2 + 1;
            if (i2 < 0) {
                g.c0.g.D();
                throw null;
            }
            linkedHashMap.put((String) obj2, Integer.valueOf(i2));
            i2 = i3;
        }
        l.e(elementsAnnotatedWith, "apis");
        for (Element element : elementsAnnotatedWith) {
            if (!linkedHashMap.containsKey(element.toString())) {
                linkedHashMap.put(element.toString(), Integer.valueOf(linkedHashMap.size()));
            }
        }
        Map<Element, ApiInfo> allApiInfo = getAllApiInfo(elementsAnnotatedWith, linkedHashMap);
        CommentProvider commentProvider = this.commentProvider;
        if (commentProvider == null) {
            l.m("commentProvider");
            throw null;
        }
        LinkedHashMap linkedHashMap2 = new LinkedHashMap();
        linkedHashMap2.putAll(commentFromDependentModules);
        linkedHashMap2.putAll(rVar.getElementComments());
        commentProvider.init(linkedHashMap2);
        String str = getPackage(fileSearchCodeFile);
        Set<? extends Element> elementsAnnotatedWith2 = roundEnvironment.getElementsAnnotatedWith(GetterHandler.class);
        Set<? extends Element> elementsAnnotatedWith3 = roundEnvironment.getElementsAnnotatedWith(SetterHandler.class);
        genOnlyNotifyApiBinder(str, allApiInfo.values());
        l.e(elementsAnnotatedWith2, "getters");
        l.e(elementsAnnotatedWith3, "setters");
        genApiBinder(str, elementsAnnotatedWith2, elementsAnnotatedWith3);
        genApi(str, allApiInfo, elementsAnnotatedWith2, elementsAnnotatedWith3);
        genUtilsCode(str);
        Collection<ApiInfo> collectionValues = allApiInfo.values();
        ArrayList arrayList = new ArrayList();
        for (Object obj3 : collectionValues) {
            if (((ApiInfo) obj3).getStaticCall()) {
                arrayList.add(obj3);
            }
        }
        genXml(arrayList);
        String str2 = (String) this.processingEnv.getOptions().get("udi.doc.generators");
        if (str2 == null) {
            str2 = "simple.SimpleDocGenerator";
        }
        for (String str3 : f.E(str2, new String[]{","}, false, 0, 6)) {
            try {
                cls = Class.forName("com.ifpdos.udi.sdk.service.doc." + str3);
            } catch (ClassNotFoundException unused) {
                cls = Class.forName(str3);
            }
            Object objNewInstance = cls.getConstructor(new Class[0]).newInstance(new Object[0]);
            Objects.requireNonNull(objNewInstance, "null cannot be cast to non-null type com.ifpdos.udi.sdk.service.doc.base.IDocGenerator");
            ((IDocGenerator) objNewInstance).genDoc(g.c0.g.F(allApiInfo.values()), rVar.getDocumentComment(), this.classParser, docDir);
        }
        return false;
    }

    private final void genApi(String str, Map<Element, ApiInfo> map, Set<? extends Element> set, Set<? extends Element> set2) {
        for (Map.Entry<Element, Map<Element, ApiHandlerInfo>> entry : getApiReceivers(map, set, set2).entrySet()) {
            Element key = entry.getKey();
            Map<Element, ApiHandlerInfo> value = entry.getValue();
            ApiInfo apiInfo = map.get(key);
            l.c(apiInfo);
            ApiInfo apiInfo2 = apiInfo;
            ArrayList arrayList = new ArrayList();
            ArrayList arrayList2 = new ArrayList();
            for (Map.Entry<Element, ApiHandlerInfo> entry2 : value.entrySet()) {
                Element key2 = entry2.getKey();
                ApiHandlerInfo value2 = entry2.getValue();
                Request getterRequest = apiInfo2.getGetterRequest();
                if (getterRequest != null) {
                    arrayList.add(getRequestAdapterCode(value2.getGetter(), apiInfo2.getUri(), apiInfo2.getApiName() + "Api.GetterRequest", apiInfo2.getApiName() + "Api.GetterResponse", getterRequest, key2.toString()));
                }
                Request setterRequest = apiInfo2.getSetterRequest();
                if (setterRequest != null) {
                    arrayList2.add(getRequestAdapterCode(value2.getSetter(), apiInfo2.getUri(), apiInfo2.getApiName() + "Api.SetterRequest", apiInfo2.getApiName() + "Api.SetterResponse", setterRequest, key2.toString()));
                }
            }
            Map mapX = g.c0.g.x(new k("package", str), new k("api", apiInfo2), new k("getterAdapters", arrayList), new k("setterAdapters", arrayList2), new k("receivers", value.entrySet().iterator()));
            Request getterRequest2 = apiInfo2.getGetterRequest();
            if (getterRequest2 != null) {
                mapX.put("getterRequest", genRequestCode("Getter", getterRequest2));
                mapX.put("getterResponse", genResponseCode("Getter", getterRequest2));
            }
            Request setterRequest2 = apiInfo2.getSetterRequest();
            if (setterRequest2 != null) {
                mapX.put("setterRequest", genRequestCode("Setter", setterRequest2));
                mapX.put("setterResponse", genResponseCode("Setter", setterRequest2));
            }
            if (apiInfo2.getNotify() != null) {
                LinkedHashMap linkedHashMap = new LinkedHashMap();
                Request getterRequest3 = apiInfo2.getGetterRequest();
                if (getterRequest3 != null) {
                    linkedHashMap.putAll(getFieldsTypeMap(getterRequest3.getRequestClass()));
                }
                Request setterRequest3 = apiInfo2.getSetterRequest();
                if (setterRequest3 != null) {
                    linkedHashMap.putAll(getFieldsTypeMap(setterRequest3.getRequestClass()));
                }
                mapX.put("notifyParams", getNotifyFuncParams(apiInfo2.getUri().getMqttTopic(), linkedHashMap));
                mapX.put("notifyUri", getNotifyUri(apiInfo2.getUri().getMqttTopic(), linkedHashMap));
                Uri alias = apiInfo2.getAlias();
                if (alias != null) {
                    mapX.put("notifyAliasUri", getNotifyUri(alias.getMqttTopic(), linkedHashMap));
                }
            }
            File file = this.kotlinGenerated;
            if (file == null) {
                l.m("kotlinGenerated");
                throw null;
            }
            OutputStreamWriter outputStreamWriter = new OutputStreamWriter(new FileOutputStream(new File(file, key.getSimpleName() + "Api.kt")), a.f4156b);
            try {
                new d.e.a.f().a(new StringReader(CodeTemplate.API), "code").g(outputStreamWriter, mapX);
                f.a.y.a.B(outputStreamWriter, null);
            } finally {
            }
        }
    }

    private final void genApiBinder(String str, Set<? extends Element> set, Set<? extends Element> set2) {
        LinkedHashMap linkedHashMap = new LinkedHashMap();
        for (Element element : set) {
            Annotation annotation = element.getAnnotation(GetterHandler.class);
            l.e(annotation, "it.getAnnotation(GetterHandler::class.java)");
            String api = getApi((GetterHandler) annotation);
            String string = element.getEnclosingElement().toString();
            Object arrayList = linkedHashMap.get(string);
            if (arrayList == null) {
                arrayList = new ArrayList();
                linkedHashMap.put(string, arrayList);
            }
            ((List) arrayList).add(api);
        }
        for (Element element2 : set2) {
            Annotation annotation2 = element2.getAnnotation(SetterHandler.class);
            l.e(annotation2, "it.getAnnotation(SetterHandler::class.java)");
            String api2 = getApi((SetterHandler) annotation2);
            String string2 = element2.getEnclosingElement().toString();
            Object arrayList2 = linkedHashMap.get(string2);
            if (arrayList2 == null) {
                arrayList2 = new ArrayList();
                linkedHashMap.put(string2, arrayList2);
            }
            ((List) arrayList2).add(api2);
        }
        genCode(CodeTemplate.API_BINDER, g.c0.g.v(new k("package", str), new k("receivers", linkedHashMap.entrySet().iterator())), "ApiBinder.kt");
    }

    private final String genCode(String str, Object obj) throws IOException {
        ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream(1024);
        OutputStreamWriter outputStreamWriter = new OutputStreamWriter(byteArrayOutputStream);
        new d.e.a.f().a(new StringReader(str), "code").g(outputStreamWriter, obj);
        outputStreamWriter.flush();
        String string = byteArrayOutputStream.toString();
        l.e(string, "out.toString()");
        return string;
    }

    private final void genOnlyNotifyApiBinder(String str, Collection<ApiInfo> collection) {
        genCode(CodeTemplate.ONLY_NOTIFY_API_BINDER, g.c0.g.v(new k("package", str), new k("apis", getOnlyNotifyApi(collection))), "OnlyNotifyApiBinder.kt");
    }

    private final String genRequestCode(String str, Request request) {
        Map mapX = g.c0.g.x(new k("type", str));
        if (!l.a(Utils.EMPTY_BODY, request.getRequestClass())) {
            mapX.put("requestClass", request.getRequestClass());
        }
        return genCode(CodeTemplate.REQUEST, mapX);
    }

    private final String genResponseCode(String str, Request request) {
        Map mapX = g.c0.g.x(new k("type", str));
        if (!l.a(Utils.EMPTY_BODY, request.getResponseClass())) {
            mapX.put("responseClass", request.getResponseClass());
        }
        return genCode(CodeTemplate.RESPONSE, mapX);
    }

    private final void genUtilsCode(String str) {
        Map mapX = g.c0.g.x(new k("package", str));
        File file = this.kotlinGenerated;
        if (file == null) {
            l.m("kotlinGenerated");
            throw null;
        }
        OutputStreamWriter outputStreamWriter = new OutputStreamWriter(new FileOutputStream(new File(file, "UdiCompileUtils.kt")), a.f4156b);
        try {
            new d.e.a.f().a(new StringReader(CodeTemplate.UDI_COMPILE_UTILS), "code").g(outputStreamWriter, mapX);
            f.a.y.a.B(outputStreamWriter, null);
        } finally {
        }
    }

    private final void genXml(Collection<ApiInfo> collection) {
        Map mapY0 = f.a.y.a.y0(new k("apis", collection.iterator()));
        File fileSearchCodeFile = searchCodeFile(UDI_STATIC_API_XML_FILE, getCurrentModuleDir(), "src", "main");
        if (fileSearchCodeFile != null) {
            OutputStreamWriter outputStreamWriter = new OutputStreamWriter(new FileOutputStream(fileSearchCodeFile), a.f4156b);
            try {
                new d.e.a.f().a(new StringReader(CodeTemplate.API_XML), "code").g(outputStreamWriter, mapY0);
                f.a.y.a.B(outputStreamWriter, null);
            } catch (Throwable th) {
                try {
                    throw th;
                } catch (Throwable th2) {
                    f.a.y.a.B(outputStreamWriter, th);
                    throw th2;
                }
            }
        }
    }

    /* JADX WARN: Removed duplicated region for block: B:26:0x009d A[LOOP:1: B:24:0x0097->B:26:0x009d, LOOP_END] */
    /* JADX WARN: Removed duplicated region for block: B:29:0x00ae  */
    /* JADX WARN: Removed duplicated region for block: B:30:0x00d4  */
    /* JADX WARN: Removed duplicated region for block: B:32:0x00d8  */
    /* JADX WARN: Removed duplicated region for block: B:33:0x0100  */
    /* JADX WARN: Removed duplicated region for block: B:36:0x010d  */
    /* JADX WARN: Removed duplicated region for block: B:37:0x0122  */
    /*
        Code decompiled incorrectly, please refer to instructions dump.
        To view partially-correct add '--show-bad-code' argument
    */
    private final java.util.Map<javax.lang.model.element.Element, com.ifpdos.udi.sdk.service.doc.base.ApiInfo> getAllApiInfo(java.util.Set<? extends javax.lang.model.element.Element> r26, final java.util.Map<java.lang.String, java.lang.Integer> r27) throws java.lang.Exception {
        /*
            Method dump skipped, instruction units count: 400
            To view this dump add '--comments-level debug' option
        */
        throw new UnsupportedOperationException("Method not decompiled: com.ifpdos.udi.sdk.service.compile.ApiProcessor.getAllApiInfo(java.util.Set, java.util.Map):java.util.Map");
    }

    /* JADX INFO: Access modifiers changed from: private */
    /* JADX INFO: renamed from: getAllApiInfo$lambda-40, reason: not valid java name */
    public static final int m7getAllApiInfo$lambda40(Map map, Element element, Element element2) {
        l.f(map, "$orders");
        Object obj = map.get(element.toString());
        l.c(obj);
        int iIntValue = ((Number) obj).intValue();
        Object obj2 = map.get(element2.toString());
        l.c(obj2);
        return iIntValue > ((Number) obj2).intValue() ? 1 : -1;
    }

    private final Map<Element, Map<Element, ApiHandlerInfo>> getApiReceivers(Map<Element, ApiInfo> map, Set<? extends Element> set, Set<? extends Element> set2) {
        LinkedHashMap linkedHashMap;
        Iterator it;
        LinkedHashMap linkedHashMap2;
        Object obj;
        Iterator it2;
        Iterator it3;
        String str;
        Request setterRequest;
        Request getterRequest;
        Map<Element, ApiInfo> map2 = map;
        LinkedHashMap linkedHashMap3 = new LinkedHashMap();
        Iterator<T> it4 = set.iterator();
        while (true) {
            String str2 = "null cannot be cast to non-null type javax.lang.model.type.DeclaredType";
            int i2 = 0;
            if (!it4.hasNext()) {
                LinkedHashMap linkedHashMap4 = new LinkedHashMap();
                Iterator it5 = set2.iterator();
                while (it5.hasNext()) {
                    Element element = (Element) it5.next();
                    Annotation annotation = element.getAnnotation(SetterHandler.class);
                    l.e(annotation, "it.getAnnotation(SetterHandler::class.java)");
                    String api = getApi((SetterHandler) annotation);
                    Elements elements = this.elementUtils;
                    if (elements == null) {
                        l.m("elementUtils");
                        throw null;
                    }
                    ApiInfo apiInfo = map2.get(elements.getTypeElement(api));
                    Set<Request.Handler> handlers = (apiInfo == null || (setterRequest = apiInfo.getSetterRequest()) == null) ? null : setterRequest.getHandlers();
                    if (handlers == null) {
                        Elements elements2 = this.elementUtils;
                        if (elements2 == null) {
                            l.m("elementUtils");
                            throw null;
                        }
                        TypeElement typeElement = elements2.getTypeElement(api);
                        Objects.requireNonNull(typeElement, "null cannot be cast to non-null type javax.lang.model.element.TypeElement");
                        Object obj2 = typeElement.getInterfaces().get(i2);
                        Objects.requireNonNull(obj2, str2);
                        DeclaredType declaredType = (DeclaredType) obj2;
                        Messager messager = this.messager;
                        if (messager == null) {
                            l.m("messager");
                            throw null;
                        }
                        Diagnostic.Kind kind = Diagnostic.Kind.ERROR;
                        it3 = it5;
                        StringBuilder sb = new StringBuilder();
                        str = str2;
                        sb.append(element.getEnclosingElement());
                        sb.append('.');
                        sb.append(element.getSimpleName());
                        sb.append(" want handle setter request, but ");
                        sb.append(api);
                        sb.append(" is ");
                        sb.append(declaredType.asElement().getSimpleName());
                        sb.append(" don't support setter");
                        messager.printMessage(kind, sb.toString());
                    } else {
                        it3 = it5;
                        str = str2;
                    }
                    Objects.requireNonNull(handlers, "null cannot be cast to non-null type kotlin.collections.MutableSet<com.ifpdos.udi.sdk.service.doc.base.Request.Handler>");
                    f0.b(handlers).add(handlerFromElement((ExecutableElement) element));
                    Object arrayList = linkedHashMap4.get(api);
                    if (arrayList == null) {
                        arrayList = new ArrayList();
                        linkedHashMap4.put(api, arrayList);
                    }
                    ((List) arrayList).add(element);
                    map2 = map;
                    it5 = it3;
                    str2 = str;
                    i2 = 0;
                }
                LinkedHashMap linkedHashMap5 = new LinkedHashMap(f.a.y.a.x0(map.size()));
                Iterator it6 = map.entrySet().iterator();
                while (it6.hasNext()) {
                    Map.Entry entry = (Map.Entry) it6.next();
                    Object key = entry.getKey();
                    Element element2 = (Element) entry.getKey();
                    ApiInfo apiInfo2 = (ApiInfo) entry.getValue();
                    LinkedHashMap linkedHashMap6 = new LinkedHashMap();
                    List list = (List) linkedHashMap3.get(element2.toString());
                    int i3 = 3;
                    if (list != null) {
                        Iterator it7 = list.iterator();
                        while (it7.hasNext()) {
                            Element element3 = (Element) it7.next();
                            Element enclosingElement = element3.getEnclosingElement();
                            l.e(enclosingElement, "receiver");
                            Object obj3 = linkedHashMap6.get(enclosingElement);
                            if (obj3 == null) {
                                linkedHashMap = linkedHashMap3;
                                it = it6;
                                Element element4 = null;
                                ApiHandlerInfo apiHandlerInfo = new ApiHandlerInfo(element4, element4, i3, element4);
                                linkedHashMap6.put(enclosingElement, apiHandlerInfo);
                                obj3 = apiHandlerInfo;
                            } else {
                                linkedHashMap = linkedHashMap3;
                                it = it6;
                            }
                            ApiHandlerInfo apiHandlerInfo2 = (ApiHandlerInfo) obj3;
                            if (apiHandlerInfo2.getGetter() != null) {
                                StringBuilder sb2 = new StringBuilder();
                                sb2.append(enclosingElement);
                                sb2.append('.');
                                Element getter = apiHandlerInfo2.getGetter();
                                sb2.append(getter != null ? getter.getSimpleName() : null);
                                String string = sb2.toString();
                                StringBuilder sb3 = new StringBuilder();
                                sb3.append(enclosingElement);
                                sb3.append('.');
                                sb3.append(element3.getSimpleName());
                                String string2 = sb3.toString();
                                Messager messager2 = this.messager;
                                if (messager2 == null) {
                                    l.m("messager");
                                    throw null;
                                }
                                it2 = it7;
                                Diagnostic.Kind kind2 = Diagnostic.Kind.ERROR;
                                linkedHashMap2 = linkedHashMap5;
                                StringBuilder sb4 = new StringBuilder();
                                obj = key;
                                sb4.append(apiInfo2.getUri());
                                sb4.append(" getter can't bound to ");
                                sb4.append(string2);
                                sb4.append(" because is already bound to ");
                                sb4.append(string);
                                messager2.printMessage(kind2, sb4.toString());
                            } else {
                                linkedHashMap2 = linkedHashMap5;
                                obj = key;
                                it2 = it7;
                            }
                            apiHandlerInfo2.setGetter(element3);
                            it6 = it;
                            it7 = it2;
                            linkedHashMap3 = linkedHashMap;
                            linkedHashMap5 = linkedHashMap2;
                            key = obj;
                            i3 = 3;
                        }
                    }
                    LinkedHashMap linkedHashMap7 = linkedHashMap5;
                    LinkedHashMap linkedHashMap8 = linkedHashMap3;
                    Iterator it8 = it6;
                    Object obj4 = key;
                    List<Element> list2 = (List) linkedHashMap4.get(element2.toString());
                    if (list2 != null) {
                        for (Element element5 : list2) {
                            Element enclosingElement2 = element5.getEnclosingElement();
                            l.e(enclosingElement2, "receiver");
                            Object apiHandlerInfo3 = linkedHashMap6.get(enclosingElement2);
                            if (apiHandlerInfo3 == null) {
                                Element element6 = null;
                                apiHandlerInfo3 = new ApiHandlerInfo(element6, element6, 3, element6);
                                linkedHashMap6.put(enclosingElement2, apiHandlerInfo3);
                            }
                            ApiHandlerInfo apiHandlerInfo4 = (ApiHandlerInfo) apiHandlerInfo3;
                            if (apiHandlerInfo4.getSetter() != null) {
                                StringBuilder sb5 = new StringBuilder();
                                sb5.append(enclosingElement2);
                                sb5.append('.');
                                Element setter = apiHandlerInfo4.getSetter();
                                sb5.append(setter != null ? setter.getSimpleName() : null);
                                String string3 = sb5.toString();
                                StringBuilder sb6 = new StringBuilder();
                                sb6.append(enclosingElement2);
                                sb6.append('.');
                                sb6.append(element5.getSimpleName());
                                String string4 = sb6.toString();
                                Messager messager3 = this.messager;
                                if (messager3 == null) {
                                    l.m("messager");
                                    throw null;
                                }
                                messager3.printMessage(Diagnostic.Kind.ERROR, apiInfo2.getUri() + " setter can't bound to " + string4 + " because is already bound to " + string3);
                            }
                            apiHandlerInfo4.setSetter(element5);
                        }
                    }
                    linkedHashMap5 = linkedHashMap7;
                    linkedHashMap5.put(obj4, linkedHashMap6);
                    it6 = it8;
                    linkedHashMap3 = linkedHashMap8;
                }
                return linkedHashMap5;
            }
            Element element7 = (Element) it4.next();
            Annotation annotation2 = element7.getAnnotation(GetterHandler.class);
            l.e(annotation2, "it.getAnnotation(GetterHandler::class.java)");
            String api2 = getApi((GetterHandler) annotation2);
            Elements elements3 = this.elementUtils;
            if (elements3 == null) {
                l.m("elementUtils");
                throw null;
            }
            ApiInfo apiInfo3 = map2.get(elements3.getTypeElement(api2));
            Set<Request.Handler> handlers2 = (apiInfo3 == null || (getterRequest = apiInfo3.getGetterRequest()) == null) ? null : getterRequest.getHandlers();
            if (handlers2 == null) {
                Elements elements4 = this.elementUtils;
                if (elements4 == null) {
                    l.m("elementUtils");
                    throw null;
                }
                TypeElement typeElement2 = elements4.getTypeElement(api2);
                Objects.requireNonNull(typeElement2, "null cannot be cast to non-null type javax.lang.model.element.TypeElement");
                Object obj5 = typeElement2.getInterfaces().get(0);
                Objects.requireNonNull(obj5, "null cannot be cast to non-null type javax.lang.model.type.DeclaredType");
                DeclaredType declaredType2 = (DeclaredType) obj5;
                Messager messager4 = this.messager;
                if (messager4 == null) {
                    l.m("messager");
                    throw null;
                }
                messager4.printMessage(Diagnostic.Kind.ERROR, element7.getEnclosingElement() + '.' + element7.getSimpleName() + " want handle getter request, but " + api2 + " is " + declaredType2.asElement().getSimpleName() + " don't support getter");
            }
            Objects.requireNonNull(handlers2, "null cannot be cast to non-null type kotlin.collections.MutableSet<com.ifpdos.udi.sdk.service.doc.base.Request.Handler>");
            f0.b(handlers2).add(handlerFromElement((ExecutableElement) element7));
            Object arrayList2 = linkedHashMap3.get(api2);
            if (arrayList2 == null) {
                arrayList2 = new ArrayList();
                linkedHashMap3.put(api2, arrayList2);
            }
            ((List) arrayList2).add(element7);
        }
    }

    private final File getChildFile(File file, String... strArr) {
        int length = strArr.length;
        int i2 = 0;
        while (i2 < length) {
            File file2 = new File(file, strArr[i2]);
            i2++;
            file = file2;
        }
        return file;
    }

    private final Map<String, CommentDetails> getCommentFromDependentModules() {
        List listE;
        LinkedHashMap linkedHashMap = new LinkedHashMap();
        String str = (String) this.processingEnv.getOptions().get("udi.dependence.modules");
        List<String> listE2 = str != null ? f.E(str, new String[]{","}, false, 0, 6) : null;
        if (listE2 != null) {
            for (String str2 : listE2) {
                if (f.J(str2, ":", false, 2)) {
                    String strSubstring = str2.substring(1);
                    l.e(strSubstring, "this as java.lang.String).substring(startIndex)");
                    listE = f.E(strSubstring, new String[]{":"}, false, 0, 6);
                } else {
                    listE = f.E(str2, new String[]{":"}, false, 0, 6);
                }
                File file = this.projectDir;
                if (file == null) {
                    l.m("projectDir");
                    throw null;
                }
                Object[] array = listE.toArray(new String[0]);
                Objects.requireNonNull(array, "null cannot be cast to non-null type kotlin.Array<T of kotlin.collections.ArraysKt__ArraysJVMKt.toTypedArray>");
                String[] strArr = (String[]) array;
                File fileSearchCodeFile = searchCodeFile(PROTOCOL_DEFINE_FILE, getChildFile(file, (String[]) Arrays.copyOf(strArr, strArr.length)), "src", "main");
                if (fileSearchCodeFile != null) {
                    linkedHashMap.putAll(CommentParser.INSTANCE.parser(fileSearchCodeFile).getElementComments());
                }
            }
        }
        return linkedHashMap;
    }

    private final File getCurrentModuleDir() {
        File parentFile = this.kotlinGenerated;
        if (parentFile == null) {
            l.m("kotlinGenerated");
            throw null;
        }
        while (!new File(parentFile, "build.gradle").exists()) {
            parentFile = parentFile.getParentFile();
            l.e(parentFile, "dir.parentFile");
        }
        return parentFile;
    }

    private final File getDocDir() {
        File file = this.projectDir;
        if (file == null) {
            l.m("projectDir");
            throw null;
        }
        String str = (String) this.processingEnv.getOptions().get("udi.doc.dir");
        if (str == null) {
            str = "doc";
        }
        File file2 = new File(file, str);
        if (!file2.exists()) {
            file2.mkdirs();
        }
        return file2;
    }

    private final Map<String, String> getFieldsTypeMap(String str) {
        List<IFieldWrapper> fields;
        LinkedHashMap linkedHashMap = new LinkedHashMap();
        IClassWrapper rVar = this.classParser.parser(str);
        if (rVar != null && (fields = rVar.getFields()) != null) {
            for (IFieldWrapper iFieldWrapper : fields) {
                String name = iFieldWrapper.getName();
                Utils utils = Utils.INSTANCE;
                linkedHashMap.put(name, utils.isBuildType(iFieldWrapper.getType()) ? utils.strTitleCase(iFieldWrapper.getType()) : iFieldWrapper.getType());
            }
        }
        return linkedHashMap;
    }

    private final List<String> getGenericParameterTypes(Element element) throws Exception {
        Object obj = ((TypeElement) element).getInterfaces().get(0);
        Objects.requireNonNull(obj, "null cannot be cast to non-null type javax.lang.model.type.DeclaredType");
        DeclaredType declaredType = (DeclaredType) obj;
        List typeArguments = declaredType.getTypeArguments();
        l.e(typeArguments, "protocol.typeArguments");
        ArrayList arrayList = new ArrayList(f.a.y.a.C(typeArguments, 10));
        Iterator it = typeArguments.iterator();
        while (it.hasNext()) {
            arrayList.add(((TypeMirror) it.next()).toString());
        }
        TypeMirror typeMirror = (TypeMirror) declaredType;
        if (isProtocolInterface(typeMirror)) {
            return arrayList;
        }
        if (isOnlySetterProtocolInterface(typeMirror)) {
            return g.c0.g.z(g.c0.g.u(Utils.EMPTY_BODY, Utils.EMPTY_BODY), arrayList);
        }
        if (isOnlyGetterProtocolInterface(typeMirror)) {
            return g.c0.g.z(arrayList, g.c0.g.u(Utils.EMPTY_BODY, Utils.EMPTY_BODY));
        }
        if (isNotifyProtocolInterface(typeMirror)) {
            return g.c0.g.u(Utils.EMPTY_BODY, Utils.EMPTY_BODY, Utils.EMPTY_BODY, Utils.EMPTY_BODY);
        }
        throw new Exception(element + " is not IProtocol");
    }

    private final String getJsonFromUriQueryPart(Uri uri, String str) {
        k kVar;
        List listU = g.c0.g.u("String", "Int", "Integer", "Float", "Double", "Boolean");
        IClassWrapper rVar = this.classParser.parser(str);
        if (rVar == null) {
            throw new RuntimeException(d.b.a.a.a.q("parser ", str, " failed"));
        }
        List<IFieldWrapper> fields = rVar.getFields();
        int iX0 = f.a.y.a.x0(f.a.y.a.C(fields, 10));
        if (iX0 < 16) {
            iX0 = 16;
        }
        LinkedHashMap linkedHashMap = new LinkedHashMap(iX0);
        Iterator<T> it = fields.iterator();
        while (true) {
            if (!it.hasNext()) {
                StringBuilder sbB = d.b.a.a.a.B("listOf<Pair<String, String>>(");
                String query = uri.getQuery();
                l.c(query);
                Iterator it2 = f.E(query, new String[]{"&"}, false, 0, 6).iterator();
                while (it2.hasNext()) {
                    List listE = f.E((String) it2.next(), new String[]{"="}, false, 0, 6);
                    if (listE.size() == 2 && l.a(listE.get(1), "{}")) {
                        StringBuilder sbB2 = d.b.a.a.a.B("Pair(\"");
                        sbB2.append((String) listE.get(0));
                        sbB2.append("\", \"");
                        sbB2.append((String) linkedHashMap.get(listE.get(0)));
                        sbB2.append("\"),");
                        sbB.append(sbB2.toString());
                    }
                }
                return sbB.substring(0, sbB.length() - 1) + ')';
            }
            IFieldWrapper iFieldWrapper = (IFieldWrapper) it.next();
            String strStrTitleCase = Utils.INSTANCE.strTitleCase(iFieldWrapper.getType());
            IClassWrapper rVar2 = this.classParser.parser(iFieldWrapper.getType());
            if (rVar2 != null && rVar2.isEnum()) {
                kVar = new k(iFieldWrapper.getName(), iFieldWrapper.getType());
            } else {
                if (!listU.contains(strStrTitleCase)) {
                    throw new RuntimeException(uri + " : " + iFieldWrapper.getName() + " param has a not support type : " + strStrTitleCase);
                }
                kVar = new k(iFieldWrapper.getName(), strStrTitleCase);
            }
            linkedHashMap.put(kVar.f4139b, kVar.f4140e);
        }
    }

    private final String getNotify(Api api) {
        String strSubstring;
        String string = api.toString();
        int iM = f.m(string, "notice=", 0, false, 6) + 7;
        int iM2 = f.m(string, ",", iM, false, 4);
        if (iM != iM2) {
            strSubstring = string.substring(iM, iM2);
            l.e(strSubstring, "this as java.lang.String…ing(startIndex, endIndex)");
        } else {
            strSubstring = null;
        }
        if (l.a(Utils.NO_NOTIFY, strSubstring)) {
            return null;
        }
        return strSubstring;
    }

    private final String getNotifyFuncParams(String str, Map<String, String> map) throws IOException {
        List listE = f.E(str, new String[]{"/"}, false, 0, 6);
        ArrayList arrayList = new ArrayList();
        for (Object obj : listE) {
            if (f.J((String) obj, "{", false, 2)) {
                arrayList.add(obj);
            }
        }
        String strR = g.c0.g.r(arrayList, ", ", null, null, 0, null, new ApiProcessor$getNotifyFuncParams$params$2(map), 30);
        return strR.length() > 0 ? d.b.a.a.a.p(strR, ", ") : strR;
    }

    private final String getNotifyUri(String str, Map<String, String> map) {
        List<String> listE = f.E(str, new String[]{"/"}, false, 0, 6);
        ArrayList arrayList = new ArrayList(f.a.y.a.C(listE, 10));
        for (String strQ : listE) {
            if (f.J(strQ, "{", false, 2)) {
                String strSubstring = strQ.substring(1, strQ.length() - 1);
                l.e(strSubstring, "this as java.lang.String…ing(startIndex, endIndex)");
                String str2 = map.get(strSubstring);
                if (str2 == null) {
                    throw new RuntimeException("can't find param for " + str + ": " + strSubstring + ' ');
                }
                if (Utils.INSTANCE.isBuildType(str2)) {
                    strQ = "${" + strSubstring + '}';
                } else {
                    strQ = d.b.a.a.a.q("${UdiCompileUtils.getJsonKey(", strSubstring, ")}");
                }
            }
            arrayList.add(strQ);
        }
        return g.c0.g.r(arrayList, "/", null, null, 0, null, null, 62);
    }

    private final Collection<ApiInfo> getOnlyNotifyApi(Collection<ApiInfo> collection) {
        ArrayList arrayList = new ArrayList();
        for (Object obj : collection) {
            ApiInfo apiInfo = (ApiInfo) obj;
            if (apiInfo.getSetterRequest() == null && apiInfo.getGetterRequest() == null && apiInfo.getNotify() != null) {
                arrayList.add(obj);
            }
        }
        return arrayList;
    }

    private final String getPackage(File file) {
        ArrayList arrayList = new ArrayList();
        for (File parentFile = file.getParentFile(); !l.a(parentFile.getName(), "java"); parentFile = parentFile.getParentFile()) {
            String name = parentFile.getName();
            l.e(name, "dir.name");
            arrayList.add(0, name);
        }
        return g.c0.g.r(arrayList, ".", null, null, 0, null, null, 62);
    }

    private final File getProjectDir(ProcessingEnvironment processingEnvironment) {
        File file = new File((String) processingEnvironment.getOptions().get(KAPT_KOTLIN_GENERATED_OPTION));
        while (true) {
            String[] list = file.list();
            l.e(list, "dir.list()");
            l.f(list, "<this>");
            if (f.a.y.a.l0(list, "settings.gradle") >= 0) {
                return file;
            }
            file = file.getParentFile();
            l.e(file, "dir.parentFile");
        }
    }

    private final String getRequestAdapterCode(Element element, Uri uri, String str, String str2, Request request, String str3) {
        if (element == null) {
            return "";
        }
        Map mapX = g.c0.g.x(new k("funcName", element.getSimpleName()), new k("receiverName", element.getEnclosingElement().getSimpleName()), new k("wrapperRequestClass", str), new k("wrapperResponseClass", str2), new k("request", request), new k("receiverClass", str3));
        ExecutableElement executableElement = (ExecutableElement) element;
        List parameters = executableElement.getParameters();
        if (parameters.size() > 0) {
            String string = ((VariableElement) parameters.get(0)).asType().toString();
            if (l.a(string, "error.NonExistentClass")) {
                mapX.put("apiParam", Boolean.TRUE);
            } else if (f.J(string, Utils.UDI_REQUEST, false, 2)) {
                mapX.put("requestParam", Boolean.TRUE);
            } else {
                mapX.put("bodyParam", Boolean.TRUE);
            }
        } else {
            mapX.put("noParam", Boolean.TRUE);
        }
        mapX.put("noReturn", Boolean.valueOf(executableElement.getReturnType().getKind() == TypeKind.VOID));
        if (l.a(Utils.EMPTY_BODY, request.getRequestClass())) {
            return genCode(CodeTemplate.EMPTY_BODY_REQUEST_ADAPTER, mapX);
        }
        if (uri.getQuery() == null && !uri.isRestfulUri()) {
            return genCode(CodeTemplate.NORMAL_REQUEST_ADAPTER, mapX);
        }
        if (uri.getQuery() != null) {
            mapX.put("queryKeys", getJsonFromUriQueryPart(uri, request.getRequestClass()));
        }
        if (uri.isRestfulUri()) {
            mapX.put("restfulKeys", getUriParamsCodeFromRestfulUri(uri, request.getRequestClass()));
        }
        return genCode(CodeTemplate.URL_URI_REQUEST_ADAPTER, mapX);
    }

    private final String getUriParamsCodeFromRestfulUri(Uri uri, String str) {
        k kVar;
        List listU = g.c0.g.u("String", "Int", "Integer", "Float", "Double", "Boolean");
        IClassWrapper rVar = this.classParser.parser(str);
        if (rVar == null) {
            throw new RuntimeException(d.b.a.a.a.q("parser ", str, " failed"));
        }
        List listE = f.E(uri.getMqttTopic(), new String[]{"/"}, false, 0, 6);
        ArrayList<String> arrayList = new ArrayList();
        Iterator it = listE.iterator();
        while (true) {
            if (!it.hasNext()) {
                break;
            }
            Object next = it.next();
            String str2 = (String) next;
            if (f.J(str2, "{", false, 2) && f.d(str2, "}", false, 2)) {
                arrayList.add(next);
            }
        }
        ArrayList arrayList2 = new ArrayList(f.a.y.a.C(arrayList, 10));
        for (String str3 : arrayList) {
            String strSubstring = str3.substring(1, str3.length() - 1);
            l.e(strSubstring, "this as java.lang.String…ing(startIndex, endIndex)");
            arrayList2.add(strSubstring);
        }
        List<IFieldWrapper> fields = rVar.getFields();
        ArrayList<IFieldWrapper> arrayList3 = new ArrayList();
        for (Object obj : fields) {
            if (arrayList2.contains(((IFieldWrapper) obj).getName())) {
                arrayList3.add(obj);
            }
        }
        int iX0 = f.a.y.a.x0(f.a.y.a.C(arrayList3, 10));
        if (iX0 < 16) {
            iX0 = 16;
        }
        LinkedHashMap linkedHashMap = new LinkedHashMap(iX0);
        for (IFieldWrapper iFieldWrapper : arrayList3) {
            String strStrTitleCase = Utils.INSTANCE.strTitleCase(iFieldWrapper.getType());
            IClassWrapper rVar2 = this.classParser.parser(iFieldWrapper.getType());
            if (rVar2 != null && rVar2.isEnum()) {
                kVar = new k(iFieldWrapper.getName(), iFieldWrapper.getType());
            } else {
                if (!listU.contains(strStrTitleCase)) {
                    throw new RuntimeException(uri + " : " + iFieldWrapper.getName() + " param has a not support type : " + strStrTitleCase);
                }
                kVar = new k(iFieldWrapper.getName(), strStrTitleCase);
            }
            linkedHashMap.put(kVar.f4139b, kVar.f4140e);
        }
        StringBuilder sbB = d.b.a.a.a.B("mapOf<String, Pair<String, String>> (");
        int i2 = 0;
        for (Object obj2 : f.E(uri.getMqttTopic(), new String[]{"/"}, false, 0, 6)) {
            int i3 = i2 + 1;
            if (i2 < 0) {
                g.c0.g.D();
                throw null;
            }
            String str4 = (String) obj2;
            if (f.J(str4, "{", false, 2) & f.d(str4, "}", false, 2)) {
                String string = str4.subSequence(1, str4.length() - 1).toString();
                sbB.append('\"' + string + "\" to Pair(parts[" + i2 + "], \"" + ((String) linkedHashMap.get(string)) + "\"),");
            }
            i2 = i3;
        }
        sbB.replace(sbB.length() - 1, sbB.length(), ")");
        String string2 = sbB.toString();
        l.e(string2, "codeBuilder.toString()");
        return string2;
    }

    private final Request.Handler handlerFromElement(ExecutableElement executableElement) {
        return new Request.Handler(executableElement.getSimpleName().toString());
    }

    private final boolean isNotifyProtocolInterface(TypeMirror typeMirror) {
        return f.J(typeMirror.toString(), "com.ifpdos.udi.sdk.service.sdk.protocol.INotifyProtocol", false, 2);
    }

    private final boolean isOnlyGetterProtocolInterface(TypeMirror typeMirror) {
        return f.J(typeMirror.toString(), "com.ifpdos.udi.sdk.service.sdk.protocol.IOnlyGetterProtocol", false, 2);
    }

    private final boolean isOnlySetterProtocolInterface(TypeMirror typeMirror) {
        return f.J(typeMirror.toString(), "com.ifpdos.udi.sdk.service.sdk.protocol.IOnlySetterProtocol", false, 2);
    }

    private final boolean isProtocolInterface(TypeMirror typeMirror) {
        return f.J(typeMirror.toString(), "com.ifpdos.udi.sdk.service.sdk.protocol.IProtocol", false, 2);
    }

    private final File searchCodeFile(String str, File file, String... strArr) {
        File file2 = new File(file, str);
        if (file2.exists()) {
            return file2;
        }
        File[] fileArrListFiles = getChildFile(file, (String[]) Arrays.copyOf(strArr, strArr.length)).listFiles();
        if (fileArrListFiles == null) {
            return null;
        }
        for (File file3 : fileArrListFiles) {
            l.e(file3, "it");
            File fileSearchCodeFile = searchCodeFile(str, file3, new String[0]);
            if (fileSearchCodeFile != null) {
                return fileSearchCodeFile;
            }
        }
        return null;
    }

    public final String getApi(GetterHandler getterHandler) {
        l.f(getterHandler, "handler");
        String string = getterHandler.toString();
        String strSubstring = string.substring(f.q(string, "=", 0, false, 6) + 1, string.length() - 1);
        l.e(strSubstring, "this as java.lang.String…ing(startIndex, endIndex)");
        return strSubstring;
    }

    public synchronized void init(ProcessingEnvironment processingEnvironment) {
        l.f(processingEnvironment, "processingEnvironment");
        super.init(processingEnvironment);
        this.projectDir = getProjectDir(processingEnvironment);
        Elements elementUtils = this.processingEnv.getElementUtils();
        l.e(elementUtils, "processingEnv.elementUtils");
        this.elementUtils = elementUtils;
        Filer filer = this.processingEnv.getFiler();
        l.e(filer, "processingEnv.filer");
        this.filer = filer;
        Messager messager = this.processingEnv.getMessager();
        l.e(messager, "processingEnv.messager");
        this.messager = messager;
        Elements elements = this.elementUtils;
        if (elements == null) {
            l.m("elementUtils");
            throw null;
        }
        CommentProvider commentProvider = new CommentProvider(elements);
        this.commentProvider = commentProvider;
        ClassParser classParser = this.classParser;
        Elements elements2 = this.elementUtils;
        if (elements2 == null) {
            l.m("elementUtils");
            throw null;
        }
        if (commentProvider == null) {
            l.m("commentProvider");
            throw null;
        }
        classParser.init(elements2, commentProvider);
    }

    public boolean process(Set<? extends TypeElement> set, RoundEnvironment roundEnvironment) {
        try {
            return doProcess(roundEnvironment);
        } catch (Exception e2) {
            StringWriter stringWriter = new StringWriter();
            e2.printStackTrace(new PrintWriter((Writer) stringWriter, true));
            Messager messager = this.messager;
            if (messager != null) {
                messager.printMessage(Diagnostic.Kind.ERROR, stringWriter.toString());
                return true;
            }
            l.m("messager");
            throw null;
        }
    }

    /* JADX INFO: compiled from: ApiProcessor.kt */
    @i
    public static final class ApiHandlerInfo {
        private Element getter;
        private Element setter;

        /* JADX WARN: Illegal instructions before constructor call */
        public ApiHandlerInfo() {
            Element element = null;
            this(element, element, 3, element);
        }

        public ApiHandlerInfo(Element element, Element element2) {
            this.getter = element;
            this.setter = element2;
        }

        public static /* synthetic */ ApiHandlerInfo copy$default(ApiHandlerInfo apiHandlerInfo, Element element, Element element2, int i2, Object obj) {
            if ((i2 & 1) != 0) {
                element = apiHandlerInfo.getter;
            }
            if ((i2 & 2) != 0) {
                element2 = apiHandlerInfo.setter;
            }
            return apiHandlerInfo.copy(element, element2);
        }

        public final Element component1() {
            return this.getter;
        }

        public final Element component2() {
            return this.setter;
        }

        public final ApiHandlerInfo copy(Element element, Element element2) {
            return new ApiHandlerInfo(element, element2);
        }

        public boolean equals(Object obj) {
            if (this == obj) {
                return true;
            }
            if (!(obj instanceof ApiHandlerInfo)) {
                return false;
            }
            ApiHandlerInfo apiHandlerInfo = (ApiHandlerInfo) obj;
            return l.a(this.getter, apiHandlerInfo.getter) && l.a(this.setter, apiHandlerInfo.setter);
        }

        public final Element getGetter() {
            return this.getter;
        }

        public final Element getSetter() {
            return this.setter;
        }

        public int hashCode() {
            Element element = this.getter;
            int iHashCode = (element == null ? 0 : element.hashCode()) * 31;
            Element element2 = this.setter;
            return iHashCode + (element2 != null ? element2.hashCode() : 0);
        }

        public final void setGetter(Element element) {
            this.getter = element;
        }

        public final void setSetter(Element element) {
            this.setter = element;
        }

        public String toString() {
            StringBuilder sbB = d.b.a.a.a.B("ApiHandlerInfo(getter=");
            sbB.append(this.getter);
            sbB.append(", setter=");
            sbB.append(this.setter);
            sbB.append(')');
            return sbB.toString();
        }

        public /* synthetic */ ApiHandlerInfo(Element element, Element element2, int i2, g gVar) {
            this((i2 & 1) != 0 ? null : element, (i2 & 2) != 0 ? null : element2);
        }
    }

    public final String getApi(SetterHandler setterHandler) {
        l.f(setterHandler, "handler");
        String string = setterHandler.toString();
        String strSubstring = string.substring(f.q(string, "=", 0, false, 6) + 1, string.length() - 1);
        l.e(strSubstring, "this as java.lang.String…ing(startIndex, endIndex)");
        return strSubstring;
    }

    private final void genCode(String str, Object obj, String str2) {
        File file = this.kotlinGenerated;
        if (file != null) {
            File file2 = new File(file, str2);
            OutputStreamWriter outputStreamWriter = new OutputStreamWriter(new FileOutputStream(file2), a.f4156b);
            try {
                new d.e.a.f().a(new StringReader(str), "code").g(outputStreamWriter, obj);
                f.a.y.a.B(outputStreamWriter, null);
            } finally {
            }
        } else {
            l.m("kotlinGenerated");
            throw null;
        }
    }
}