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

import com.ifpdos.udi.sdk.kotlin.comment.parser.CommentDetails;
import f.a.y.a;
import g.c0.g;
import g.h0.c.l;
import g.i;
import g.m0.f;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import javax.lang.model.element.Element;
import javax.lang.model.element.Modifier;
import javax.lang.model.element.TypeElement;
import javax.lang.model.element.TypeParameterElement;
import javax.lang.model.type.TypeKind;

/* JADX INFO: compiled from: ClassParser.kt */
/* JADX INFO: loaded from: classes.dex */
@i
public class GenericClassWrapper implements IClassWrapper {
    private final ICommentProvider commentProvider;
    private final Element element;
    private final String fullName;
    private final Map<String, String> genericMap;

    public GenericClassWrapper(Element element, String str, ICommentProvider iCommentProvider) {
        l.f(element, "element");
        l.f(str, "fullName");
        l.f(iCommentProvider, "commentProvider");
        this.element = element;
        this.fullName = str;
        this.commentProvider = iCommentProvider;
        this.genericMap = new LinkedHashMap();
        List typeParameters = ((TypeElement) element).getTypeParameters();
        l.e(typeParameters, "element as TypeElement).typeParameters");
        ArrayList arrayList = new ArrayList(a.C(typeParameters, 10));
        Iterator it = typeParameters.iterator();
        while (it.hasNext()) {
            arrayList.add(((TypeParameterElement) it.next()).toString());
        }
        initRealType(arrayList, Utils.INSTANCE.getGenericParameterTypes(this.fullName));
    }

    private final String getRealType(String str) {
        if (this.genericMap.containsKey(str)) {
            String str2 = this.genericMap.get(str);
            l.c(str2);
            return str2;
        }
        if (f.b(str, "<", false, 2)) {
            int iM = f.m(str, "<", 0, false, 6) + 1;
            int iM2 = f.m(str, ">", 0, false, 6);
            CharSequence charSequenceSubSequence = str.subSequence(iM, iM2);
            if (this.genericMap.containsKey(charSequenceSubSequence)) {
                String str3 = this.genericMap.get(charSequenceSubSequence);
                l.c(str3);
                String str4 = str3;
                l.f(str, "<this>");
                l.f(str4, "replacement");
                if (iM2 >= iM) {
                    StringBuilder sb = new StringBuilder();
                    sb.append((CharSequence) str, 0, iM);
                    l.e(sb, "this.append(value, startIndex, endIndex)");
                    sb.append((CharSequence) str4);
                    sb.append((CharSequence) str, iM2, str.length());
                    l.e(sb, "this.append(value, startIndex, endIndex)");
                    return sb.toString();
                }
                throw new IndexOutOfBoundsException("End index (" + iM2 + ") is less than start index (" + iM + ").");
            }
        }
        return str;
    }

    private final void initRealType(List<String> list, List<String> list2) {
        int i2 = 0;
        for (Object obj : list2) {
            int i3 = i2 + 1;
            if (i2 < 0) {
                g.D();
                throw null;
            }
            this.genericMap.put(list.get(i2), (String) obj);
            i2 = i3;
        }
    }

    @Override // com.ifpdos.udi.sdk.service.doc.base.IClassWrapper
    public CommentDetails getComment() {
        return this.commentProvider.getComment(this);
    }

    @Override // com.ifpdos.udi.sdk.service.doc.base.IClassWrapper
    public Element getElement() {
        return this.element;
    }

    @Override // com.ifpdos.udi.sdk.service.doc.base.IClassWrapper
    public List<IFieldWrapper> getFields() {
        IFieldWrapper elementFieldWrapper;
        List enclosedElements = this.element.getEnclosedElements();
        l.e(enclosedElements, "element.enclosedElements");
        ArrayList<Element> arrayList = new ArrayList();
        for (Object obj : enclosedElements) {
            Element element = (Element) obj;
            if (element.getKind().isField() && !element.getModifiers().contains(Modifier.STATIC)) {
                arrayList.add(obj);
            }
        }
        ArrayList arrayList2 = new ArrayList(a.C(arrayList, 10));
        for (Element element2 : arrayList) {
            if (element2.asType().getKind() == TypeKind.TYPEVAR) {
                String string = element2.asType().toString();
                l.e(element2, "it");
                elementFieldWrapper = new GenericFieldWrapper(this, element2, getRealType(string), this.commentProvider);
            } else {
                l.e(element2, "it");
                elementFieldWrapper = new ElementFieldWrapper(this, element2, this.commentProvider);
            }
            arrayList2.add(elementFieldWrapper);
        }
        return arrayList2;
    }

    public final String getRawType() {
        StringBuilder sb = new StringBuilder();
        sb.append(this.element);
        sb.append('<');
        List typeParameters = this.element.getTypeParameters();
        l.e(typeParameters, "element as TypeElement).typeParameters");
        return d.b.a.a.a.u(sb, g.r(typeParameters, ",", null, null, 0, null, null, 62), '>');
    }

    @Override // com.ifpdos.udi.sdk.service.doc.base.IClassWrapper
    public String getType() {
        return this.fullName;
    }

    @Override // com.ifpdos.udi.sdk.service.doc.base.IClassWrapper
    public boolean isEnum() {
        return false;
    }
}