package com.ifpdos.udi.sdk.kotlin.comment.parser;

import g.c0.g;
import g.h0.c.l;
import g.i;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;

/* JADX INFO: compiled from: SyntacticAnalyzer.kt */
/* JADX INFO: loaded from: classes.dex */
@i
public final class SyntacticAnalyzer {
    public static final Companion Companion = new Companion(null);
    private static final List<TokenId> TOKEN_ID_FOR_NAMESPACE = g.u(TokenId.TOKEN_ID_CLASS, TokenId.TOKEN_ID_OBJECT, TokenId.TOKEN_ID_INTERFACE);
    private static final List<TokenId> TOKEN_ID_FOR_VALUE = g.u(TokenId.TOKEN_ID_VAR, TokenId.TOKEN_ID_VAL);
    private String documentComment;
    private final LinkedHashMap<String, String> elementComments = new LinkedHashMap<>();
    private String lastComment;

    /* JADX INFO: compiled from: SyntacticAnalyzer.kt */
    @i
    public final class AnnotationAnalyzer extends AbstractAnalyzer {
        public final /* synthetic */ SyntacticAnalyzer this$0;

        /* JADX WARN: 'super' call moved to the top of the method (can break code semantics) */
        public AnnotationAnalyzer(SyntacticAnalyzer syntacticAnalyzer, String str, List<Token> list, int i2) {
            super(syntacticAnalyzer, str, list, i2);
            l.f(str, "nameSpace");
            l.f(list, "tokens");
            this.this$0 = syntacticAnalyzer;
        }

        @Override // com.ifpdos.udi.sdk.kotlin.comment.parser.SyntacticAnalyzer.AbstractAnalyzer
        public void doAnalyse() throws Exception {
            if (getToken().getType() != TokenId.TOKEN_ID_LEFT_ROUND_BRACKET) {
                return;
            }
            int i2 = 1;
            while (hasToken() && i2 > 0) {
                nextToken();
                Token token = getToken();
                if (token.getType() == TokenId.TOKEN_ID_LEFT_ROUND_BRACKET) {
                    i2++;
                } else if (token.getType() == TokenId.TOKEN_ID_RIGHT_ROUND_BRACKET) {
                    i2--;
                }
            }
            nextToken();
        }
    }

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

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

    /* JADX INFO: compiled from: SyntacticAnalyzer.kt */
    @i
    public final class NameSpaceAnalyzer extends AbstractAnalyzer {
        public final /* synthetic */ SyntacticAnalyzer this$0;

        /* JADX WARN: 'super' call moved to the top of the method (can break code semantics) */
        public NameSpaceAnalyzer(SyntacticAnalyzer syntacticAnalyzer, String str, List<Token> list, int i2) {
            super(syntacticAnalyzer, str, list, i2);
            l.f(str, "nameSpace");
            l.f(list, "tokens");
            this.this$0 = syntacticAnalyzer;
        }

        private final void doAnalyseNameSpace() throws Exception {
            nextToken();
            String str = getNameSpace() + '.' + getToken().getSemantic();
            addElementComment(str);
            nextToken();
            if (hasToken()) {
                if (getToken().getType() == TokenId.TOKEN_ID_LEFT_ROUND_BRACKET) {
                    nextToken();
                    setIndex(new ParamAnalyzer(this.this$0, str, getTokens(), getIndex()).analyse());
                }
                while (hasToken() && getToken().getType() != TokenId.TOKEN_ID_LEFT_CURLY_BRACKET && getToken().getType() != TokenId.TOKEN_ID_RIGHT_CURLY_BRACKET && getToken().getType() != TokenId.TOKEN_ID_ANNOTATION && !SyntacticAnalyzer.TOKEN_ID_FOR_VALUE.contains(getToken().getType()) && !SyntacticAnalyzer.TOKEN_ID_FOR_NAMESPACE.contains(getToken().getType())) {
                    nextToken();
                }
                if (hasToken() && getToken().getType() == TokenId.TOKEN_ID_LEFT_CURLY_BRACKET) {
                    clearComment();
                    nextToken();
                    setIndex(new NameSpaceAnalyzer(this.this$0, str, getTokens(), getIndex()).analyse());
                }
            }
        }

        @Override // com.ifpdos.udi.sdk.kotlin.comment.parser.SyntacticAnalyzer.AbstractAnalyzer
        public void doAnalyse() throws Exception {
            while (hasToken()) {
                Token token = getToken();
                if (token.getType() == TokenId.TOKEN_ID_LETTER) {
                    addElementComment(token);
                    nextToken();
                } else if (token.getType() == TokenId.TOKEN_ID_ANNOTATION) {
                    nextToken();
                    setIndex(new AnnotationAnalyzer(this.this$0, getNameSpace(), getTokens(), getIndex()).analyse());
                } else if (SyntacticAnalyzer.TOKEN_ID_FOR_NAMESPACE.contains(token.getType())) {
                    doAnalyseNameSpace();
                } else {
                    if (token.getType() == TokenId.TOKEN_ID_RIGHT_CURLY_BRACKET) {
                        nextToken();
                        return;
                    }
                    nextToken();
                }
            }
        }
    }

    /* JADX INFO: compiled from: SyntacticAnalyzer.kt */
    @i
    public final class PackageAnalyzer extends AbstractAnalyzer {
        public final /* synthetic */ SyntacticAnalyzer this$0;

        /* JADX WARN: 'super' call moved to the top of the method (can break code semantics) */
        public PackageAnalyzer(SyntacticAnalyzer syntacticAnalyzer, List<Token> list, int i2) {
            super(syntacticAnalyzer, "", list, i2);
            l.f(list, "tokens");
            this.this$0 = syntacticAnalyzer;
        }

        @Override // com.ifpdos.udi.sdk.kotlin.comment.parser.SyntacticAnalyzer.AbstractAnalyzer
        public void doAnalyse() throws Exception {
            while (hasToken() && getToken().getType() != TokenId.TOKEN_ID_PACKAGE) {
                if (getToken().getType() == TokenId.TOKEN_ID_COMMENT) {
                    this.this$0.documentComment = getToken().getSemantic();
                }
                nextToken();
            }
            if (hasToken() && getToken().getType() == TokenId.TOKEN_ID_PACKAGE) {
                nextToken();
                String semantic = getToken().getSemantic();
                nextToken();
                new NameSpaceAnalyzer(this.this$0, semantic, getTokens(), getIndex()).analyse();
            }
        }
    }

    /* JADX INFO: compiled from: SyntacticAnalyzer.kt */
    @i
    public final class ParamAnalyzer extends AbstractAnalyzer {
        public final /* synthetic */ SyntacticAnalyzer this$0;

        /* JADX INFO: compiled from: SyntacticAnalyzer.kt */
        @i
        public /* synthetic */ class WhenMappings {
            public static final /* synthetic */ int[] $EnumSwitchMapping$0;

            static {
                TokenId.values();
                int[] iArr = new int[42];
                iArr[TokenId.TOKEN_ID_LEFT_ROUND_BRACKET.ordinal()] = 1;
                iArr[TokenId.TOKEN_ID_RIGHT_ROUND_BRACKET.ordinal()] = 2;
                $EnumSwitchMapping$0 = iArr;
            }
        }

        /* JADX WARN: 'super' call moved to the top of the method (can break code semantics) */
        public ParamAnalyzer(SyntacticAnalyzer syntacticAnalyzer, String str, List<Token> list, int i2) {
            super(syntacticAnalyzer, str, list, i2);
            l.f(str, "nameSpace");
            l.f(list, "tokens");
            this.this$0 = syntacticAnalyzer;
        }

        @Override // com.ifpdos.udi.sdk.kotlin.comment.parser.SyntacticAnalyzer.AbstractAnalyzer
        public void doAnalyse() throws Exception {
            int i2 = 1;
            boolean z = true;
            while (hasToken() && i2 > 0) {
                if (!z) {
                    nextToken();
                }
                z = false;
                TokenId type = getToken().getType();
                int i3 = WhenMappings.$EnumSwitchMapping$0[type.ordinal()];
                if (i3 == 1) {
                    i2++;
                } else if (i3 == 2) {
                    i2--;
                } else if (SyntacticAnalyzer.TOKEN_ID_FOR_VALUE.contains(type)) {
                    nextToken();
                    addElementComment(getToken());
                }
            }
            clearComment();
            nextToken();
        }
    }

    public final void analyse(List<Token> list) {
        l.f(list, "tokens");
        this.lastComment = null;
        this.documentComment = null;
        this.elementComments.clear();
        new PackageAnalyzer(this, list, 0).analyse();
    }

    public final String getDocumentComment() {
        return this.documentComment;
    }

    public final Map<String, String> getElementComments() {
        return this.elementComments;
    }

    /* JADX INFO: compiled from: SyntacticAnalyzer.kt */
    @i
    public abstract class AbstractAnalyzer {
        private int index;
        private final String nameSpace;
        public final /* synthetic */ SyntacticAnalyzer this$0;
        private final List<Token> tokens;

        public AbstractAnalyzer(SyntacticAnalyzer syntacticAnalyzer, String str, List<Token> list, int i2) {
            l.f(str, "nameSpace");
            l.f(list, "tokens");
            this.this$0 = syntacticAnalyzer;
            this.nameSpace = str;
            this.tokens = list;
            this.index = i2;
        }

        public final void addElementComment(Token token) {
            l.f(token, "token");
            String str = this.this$0.lastComment;
            if (str != null) {
                SyntacticAnalyzer syntacticAnalyzer = this.this$0;
                syntacticAnalyzer.elementComments.put(this.nameSpace + '.' + token.getSemantic(), str);
                syntacticAnalyzer.lastComment = null;
            }
        }

        public final int analyse() {
            doAnalyse();
            return this.index;
        }

        public final void clearComment() {
            this.this$0.lastComment = null;
        }

        public abstract void doAnalyse();

        public final int getIndex() {
            return this.index;
        }

        public final String getNameSpace() {
            return this.nameSpace;
        }

        public final Token getToken() {
            return this.tokens.get(this.index);
        }

        public final List<Token> getTokens() {
            return this.tokens;
        }

        public final boolean hasToken() {
            return this.index < this.tokens.size();
        }

        public final boolean nextToken() throws Exception {
            this.index++;
            while (this.index < this.tokens.size() && this.tokens.get(this.index).getType() == TokenId.TOKEN_ID_COMMENT) {
                this.this$0.lastComment = this.tokens.get(this.index).getSemantic();
                this.index++;
            }
            if (this.index >= this.tokens.size()) {
                return false;
            }
            if (this.tokens.get(this.index).getType() == TokenId.TOKEN_ID_FUN) {
                throw new Exception("ProtocolDefine.kt 不支持定义方法");
            }
            if (this.tokens.get(this.index).getType() == TokenId.TOKEN_ID_COMPANION) {
                this.index++;
                skipCompanionObject();
            }
            return true;
        }

        public final void setIndex(int i2) {
            this.index = i2;
        }

        public final void skipCompanionObject() {
            nextToken();
            if (this.tokens.get(this.index).getType() == TokenId.TOKEN_ID_LEFT_CURLY_BRACKET) {
                int i2 = 1;
                while (i2 > 0) {
                    int i3 = this.index + 1;
                    this.index = i3;
                    if (this.tokens.get(i3).getType() == TokenId.TOKEN_ID_LEFT_CURLY_BRACKET) {
                        i2++;
                    } else if (this.tokens.get(this.index).getType() == TokenId.TOKEN_ID_RIGHT_CURLY_BRACKET) {
                        i2--;
                    }
                }
                nextToken();
            }
        }

        public final void addElementComment(String str) {
            l.f(str, "name");
            String str2 = this.this$0.lastComment;
            if (str2 != null) {
                SyntacticAnalyzer syntacticAnalyzer = this.this$0;
                syntacticAnalyzer.elementComments.put(str, str2);
                syntacticAnalyzer.lastComment = null;
            }
        }
    }
}