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

import g.c0.g;
import g.g0.d;
import g.h0.c.l;
import g.i;
import g.k;
import g.m0.a;
import g.m0.f;
import java.io.BufferedReader;
import java.io.File;
import java.io.FileInputStream;
import java.io.InputStreamReader;
import java.nio.charset.Charset;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;

/* JADX INFO: compiled from: LexicalAnalyzer.kt */
/* JADX INFO: loaded from: classes.dex */
@i
public final class LexicalAnalyzer {
    private Character lastChar;
    public static final Companion Companion = new Companion(null);
    private static final List<Character> WORD_BREAKS = g.u(' ', '\t', '\n', ';');
    private static final List<Character> SIGN = g.u('+', '-', '*', '/', '(', ')', '<', '>', '{', '}', ':', ',');
    private static final Map<String, TokenId> BUILD_IN_TOKEN_MAP = g.v(new k("package", TokenId.TOKEN_ID_PACKAGE), new k("import", TokenId.TOKEN_ID_IMPORT), new k("companion", TokenId.TOKEN_ID_COMPANION), new k("enum", TokenId.TOKEN_ID_ENUM), new k("data", TokenId.TOKEN_ID_DATA), new k("class", TokenId.TOKEN_ID_CLASS), new k("interface", TokenId.TOKEN_ID_INTERFACE), new k("object", TokenId.TOKEN_ID_OBJECT), new k("fun", TokenId.TOKEN_ID_FUN), new k("init", TokenId.TOKEN_ID_INIT), new k("constructor", TokenId.TOKEN_ID_CONSTRUCTOR), new k("by", TokenId.TOKEN_ID_BY), new k("var", TokenId.TOKEN_ID_VAR), new k("val", TokenId.TOKEN_ID_VAL), new k("lateinit", TokenId.TOKEN_ID_LATEINIT), new k("open", TokenId.TOKEN_ID_OPEN), new k("abstract", TokenId.TOKEN_ID_ABSTRACT), new k("private", TokenId.TOKEN_ID_PRIVATE), new k("public", TokenId.TOKEN_ID_PUBLIC), new k("internal", TokenId.TOKEN_ID_INTERNAL), new k("inner", TokenId.TOKEN_ID_INNER), new k("+", TokenId.TOKEN_ID_ADD), new k("-", TokenId.TOKEN_ID_SUBTRACT), new k("*", TokenId.TOKEN_ID_MULTIPLY), new k("/", TokenId.TOKEN_ID_DIVIDE), new k("=", TokenId.TOKEN_ID_EQUAL), new k("(", TokenId.TOKEN_ID_LEFT_ROUND_BRACKET), new k(")", TokenId.TOKEN_ID_RIGHT_ROUND_BRACKET), new k("<", TokenId.TOKEN_ID_LEFT_ANGLE_BRACKET), new k(">", TokenId.TOKEN_ID_RIGHT_ANGLE_BRACKET), new k("{", TokenId.TOKEN_ID_LEFT_CURLY_BRACKET), new k("}", TokenId.TOKEN_ID_RIGHT_CURLY_BRACKET), new k(":", TokenId.TOKEN_ID_COLON), new k(",", TokenId.TOKEN_ID_COMMA));
    private StringBuffer tokenBuffer = new StringBuffer();
    private CodeAnalyzer codeAnalyzer = new CodeAnalyzer();
    private SingleLineCommentAnalyzer singleLineCommentAnalyzer = new SingleLineCommentAnalyzer();
    private MultilineCommentAnalyzer multilineCommentAnalyzer = new MultilineCommentAnalyzer();
    private StringAnalyzer stringAnalyzer = new StringAnalyzer();
    private IInnerAnalyzer analyzer = this.codeAnalyzer;
    private final List<Token> scanningResult = new ArrayList();
    private final Map<Token, Object> digitValueMap = new LinkedHashMap();

    /* JADX INFO: compiled from: LexicalAnalyzer.kt */
    @i
    public final class CodeAnalyzer implements IInnerAnalyzer {
        public CodeAnalyzer() {
        }

        private final void nextToken(String str) {
            if (str.length() == 0) {
                return;
            }
            TokenId tokenId = (TokenId) LexicalAnalyzer.BUILD_IN_TOKEN_MAP.get(str);
            if (tokenId != null) {
                LexicalAnalyzer.this.scanningResult.add(new Token(tokenId, str));
                return;
            }
            Token tokenAnalyseInt = LexicalAnalyzer.this.analyseInt(str);
            if (tokenAnalyseInt == null && (tokenAnalyseInt = LexicalAnalyzer.this.analyseLong(str)) == null && (tokenAnalyseInt = LexicalAnalyzer.this.analyseDouble(str)) == null) {
                tokenAnalyseInt = LexicalAnalyzer.this.analyseFloat(str);
            }
            if (tokenAnalyseInt == null) {
                tokenAnalyseInt = new Token(f.J(str, "@", false, 2) ? TokenId.TOKEN_ID_ANNOTATION : TokenId.TOKEN_ID_LETTER, str);
            }
            LexicalAnalyzer.this.scanningResult.add(tokenAnalyseInt);
        }

        @Override // com.ifpdos.udi.sdk.kotlin.comment.parser.LexicalAnalyzer.IInnerAnalyzer
        public void nextChar(char c2) {
            Character ch;
            Character ch2;
            if (c2 == '\"') {
                LexicalAnalyzer lexicalAnalyzer = LexicalAnalyzer.this;
                lexicalAnalyzer.analyzer = lexicalAnalyzer.stringAnalyzer;
                LexicalAnalyzer.this.analyzer.onChange();
                return;
            }
            if (c2 == '/' && (ch2 = LexicalAnalyzer.this.lastChar) != null && ch2.charValue() == '/') {
                LexicalAnalyzer.this.scanningResult.remove(LexicalAnalyzer.this.scanningResult.size() - 1);
                LexicalAnalyzer lexicalAnalyzer2 = LexicalAnalyzer.this;
                lexicalAnalyzer2.analyzer = lexicalAnalyzer2.singleLineCommentAnalyzer;
                LexicalAnalyzer.this.analyzer.onChange();
                return;
            }
            if (c2 == '*' && (ch = LexicalAnalyzer.this.lastChar) != null && ch.charValue() == '/') {
                LexicalAnalyzer.this.scanningResult.remove(LexicalAnalyzer.this.scanningResult.size() - 1);
                LexicalAnalyzer lexicalAnalyzer3 = LexicalAnalyzer.this;
                lexicalAnalyzer3.analyzer = lexicalAnalyzer3.multilineCommentAnalyzer;
                LexicalAnalyzer.this.analyzer.onChange();
                return;
            }
            if (LexicalAnalyzer.WORD_BREAKS.contains(Character.valueOf(c2))) {
                if (LexicalAnalyzer.this.tokenBuffer.length() > 0) {
                    String string = LexicalAnalyzer.this.tokenBuffer.toString();
                    l.e(string, "tokenBuffer.toString()");
                    nextToken(string);
                    LexicalAnalyzer.this.tokenBuffer = new StringBuffer();
                    return;
                }
                return;
            }
            if (!LexicalAnalyzer.SIGN.contains(Character.valueOf(c2))) {
                LexicalAnalyzer.this.tokenBuffer.append(c2);
                return;
            }
            String string2 = LexicalAnalyzer.this.tokenBuffer.toString();
            l.e(string2, "tokenBuffer.toString()");
            nextToken(string2);
            nextToken(String.valueOf(c2));
            LexicalAnalyzer.this.tokenBuffer = new StringBuffer();
        }

        @Override // com.ifpdos.udi.sdk.kotlin.comment.parser.LexicalAnalyzer.IInnerAnalyzer
        public void onChange() {
            LexicalAnalyzer.this.tokenBuffer = new StringBuffer();
        }
    }

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

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

    /* JADX INFO: compiled from: LexicalAnalyzer.kt */
    @i
    public interface IInnerAnalyzer {
        void nextChar(char c2);

        void onChange();
    }

    /* JADX INFO: compiled from: LexicalAnalyzer.kt */
    @i
    public final class MultilineCommentAnalyzer implements IInnerAnalyzer {
        private boolean newLine = true;

        public MultilineCommentAnalyzer() {
        }

        @Override // com.ifpdos.udi.sdk.kotlin.comment.parser.LexicalAnalyzer.IInnerAnalyzer
        public void nextChar(char c2) {
            Character ch;
            if (c2 == '\n') {
                this.newLine = true;
            }
            if (this.newLine && (c2 == '*' || c2 == ' ' || c2 == '\t')) {
                return;
            }
            if (c2 != '\n') {
                this.newLine = false;
            }
            if (c2 != '/' || (ch = LexicalAnalyzer.this.lastChar) == null || ch.charValue() != '*') {
                LexicalAnalyzer.this.tokenBuffer.append(c2);
                return;
            }
            if (LexicalAnalyzer.this.tokenBuffer.length() > 0) {
                String string = LexicalAnalyzer.this.tokenBuffer.toString();
                l.e(string, "tokenBuffer.toString()");
                LexicalAnalyzer.this.scanningResult.add(new Token(TokenId.TOKEN_ID_COMMENT, f.R(string).toString()));
                LexicalAnalyzer.this.tokenBuffer = new StringBuffer();
            }
            LexicalAnalyzer lexicalAnalyzer = LexicalAnalyzer.this;
            lexicalAnalyzer.analyzer = lexicalAnalyzer.codeAnalyzer;
            LexicalAnalyzer.this.analyzer.onChange();
        }

        @Override // com.ifpdos.udi.sdk.kotlin.comment.parser.LexicalAnalyzer.IInnerAnalyzer
        public void onChange() {
            LexicalAnalyzer.this.tokenBuffer = new StringBuffer();
            LexicalAnalyzer.this.lastChar = null;
            this.newLine = true;
        }
    }

    /* JADX INFO: compiled from: LexicalAnalyzer.kt */
    @i
    public final class SingleLineCommentAnalyzer implements IInnerAnalyzer {
        private boolean begin = true;

        public SingleLineCommentAnalyzer() {
        }

        @Override // com.ifpdos.udi.sdk.kotlin.comment.parser.LexicalAnalyzer.IInnerAnalyzer
        public void nextChar(char c2) {
            if (this.begin && c2 == '/') {
                return;
            }
            this.begin = false;
            if (c2 != '\n') {
                LexicalAnalyzer.this.tokenBuffer.append(c2);
                return;
            }
            if (LexicalAnalyzer.this.tokenBuffer.length() > 0) {
                String string = LexicalAnalyzer.this.tokenBuffer.toString();
                l.e(string, "tokenBuffer.toString()");
                LexicalAnalyzer.this.scanningResult.add(new Token(TokenId.TOKEN_ID_COMMENT, f.R(string).toString()));
                LexicalAnalyzer.this.tokenBuffer = new StringBuffer();
            }
            LexicalAnalyzer lexicalAnalyzer = LexicalAnalyzer.this;
            lexicalAnalyzer.analyzer = lexicalAnalyzer.codeAnalyzer;
            LexicalAnalyzer.this.analyzer.onChange();
        }

        @Override // com.ifpdos.udi.sdk.kotlin.comment.parser.LexicalAnalyzer.IInnerAnalyzer
        public void onChange() {
            LexicalAnalyzer.this.tokenBuffer = new StringBuffer();
            this.begin = true;
        }
    }

    /* JADX INFO: compiled from: LexicalAnalyzer.kt */
    @i
    public final class StringAnalyzer implements IInnerAnalyzer {
        public StringAnalyzer() {
        }

        @Override // com.ifpdos.udi.sdk.kotlin.comment.parser.LexicalAnalyzer.IInnerAnalyzer
        public void nextChar(char c2) {
            Character ch;
            if (c2 != '\"' || ((ch = LexicalAnalyzer.this.lastChar) != null && ch.charValue() == '\\')) {
                LexicalAnalyzer.this.tokenBuffer.append(c2);
                return;
            }
            String string = LexicalAnalyzer.this.tokenBuffer.toString();
            l.e(string, "tokenBuffer.toString()");
            LexicalAnalyzer.this.scanningResult.add(new Token(TokenId.TOKEN_ID_STRING, f.R(string).toString()));
            LexicalAnalyzer.this.tokenBuffer = new StringBuffer();
            LexicalAnalyzer lexicalAnalyzer = LexicalAnalyzer.this;
            lexicalAnalyzer.analyzer = lexicalAnalyzer.codeAnalyzer;
            LexicalAnalyzer.this.analyzer.onChange();
        }

        @Override // com.ifpdos.udi.sdk.kotlin.comment.parser.LexicalAnalyzer.IInnerAnalyzer
        public void onChange() {
            LexicalAnalyzer.this.tokenBuffer = new StringBuffer();
            LexicalAnalyzer.this.lastChar = null;
        }
    }

    /* JADX INFO: Access modifiers changed from: private */
    public final Token analyseDouble(String str) {
        try {
            Token token = new Token(TokenId.TOKEN_ID_DOUBLE, str);
            this.digitValueMap.put(token, Double.valueOf(Double.parseDouble(str)));
            return token;
        } catch (Exception unused) {
            return null;
        }
    }

    /* JADX INFO: Access modifiers changed from: private */
    public final Token analyseFloat(String str) {
        try {
            Token token = new Token(TokenId.TOKEN_ID_FLOAT, str);
            this.digitValueMap.put(token, Float.valueOf(Float.parseFloat(str)));
            return token;
        } catch (Exception unused) {
            return null;
        }
    }

    /* JADX INFO: Access modifiers changed from: private */
    public final Token analyseInt(String str) {
        try {
            Token token = new Token(TokenId.TOKEN_ID_INT, str);
            this.digitValueMap.put(token, Integer.valueOf(Integer.parseInt(str)));
            return token;
        } catch (Exception unused) {
            return null;
        }
    }

    /* JADX INFO: Access modifiers changed from: private */
    public final Token analyseLong(String str) {
        try {
            Token token = new Token(TokenId.TOKEN_ID_LONG, str);
            this.digitValueMap.put(token, Long.valueOf(Long.parseLong(str)));
            return token;
        } catch (Exception unused) {
            return null;
        }
    }

    private final void nextChar(char c2) {
        this.analyzer.nextChar(c2);
        this.lastChar = Character.valueOf(c2);
    }

    private final void nextLine(String str) {
        for (int i2 = 0; i2 < str.length(); i2++) {
            nextChar(str.charAt(i2));
        }
    }

    /* JADX WARN: Multi-variable type inference failed */
    public final List<Token> analyse(File file) {
        l.f(file, "source");
        Charset charset = a.f4156b;
        l.f(file, "<this>");
        l.f(charset, "charset");
        ArrayList arrayList = new ArrayList();
        d dVar = new d(arrayList);
        l.f(file, "<this>");
        l.f(charset, "charset");
        l.f(dVar, "action");
        BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(new FileInputStream(file), charset));
        l.f(bufferedReader, "<this>");
        l.f(dVar, "action");
        try {
            l.f(bufferedReader, "<this>");
            g.l0.d gVar = new g.g0.g(bufferedReader);
            l.f(gVar, "<this>");
            if (!(gVar instanceof g.l0.a)) {
                gVar = new g.l0.a(gVar);
            }
            Iterator it = gVar.iterator();
            while (it.hasNext()) {
                dVar.invoke(it.next());
            }
            f.a.y.a.B(bufferedReader, null);
            Iterator it2 = arrayList.iterator();
            while (it2.hasNext()) {
                nextLine((String) it2.next());
                nextChar('\n');
            }
            return this.scanningResult;
        } finally {
        }
    }
}