package com.textparser;

import java.io.IOException;

import java.nio.file.Files;

import java.nio.file.Path;

import java.util.*;

import java.util.regex.Matcher;

import java.util.regex.Pattern;

import java.util.regex.PatternSyntaxException;

public class TextParser {

public Definition definition;

private final Map<String, Pattern> patternCache = new HashMap<>();

public TextParser(Definition definition) {

this.definition = definition;

initializeDefaults();

}

public TextParser(String definitionJson) {

@SuppressWarnings("unchecked")

Map<String, Object> map = (Map<String, Object>) JsonUtils.parseJson(definitionJson);

this.definition = Definition.fromJson(map);

initializeDefaults();

}

public static TextParser fromFile(String filePath) throws IOException {

String content = Files.readString(Path.of(filePath));

return new TextParser(content);

}

private void initializeDefaults() {

if (definition.tokens != null) {

for (Map.Entry<String, Definition.TokenDef> entry : definition.tokens.entrySet()) {

Definition.TokenDef token = entry.getValue();

if (token.id == null) {

token.id = entry.getKey();

}

if (token.otherTextInside == null) {

token.otherTextInside = false;

}

}

}

}

private Pattern getCompiledPattern(String regexStr) {

if (regexStr == null) return null;

return patternCache.computeIfAbsent(regexStr, r -> {

try {

return Pattern.compile(r, Pattern.CASE_INSENSITIVE | Pattern.DOTALL);

} catch (PatternSyntaxException e) {

String fixed = fixRegexPattern(r);

try {

return Pattern.compile(fixed, Pattern.CASE_INSENSITIVE | Pattern.DOTALL);

} catch (Exception e2) {

throw new RuntimeException("Failed to compile regex pattern: " + r, e);

}

} catch (Exception e) {

throw new RuntimeException("Failed to compile regex pattern: " + r, e);

}

});

}

private String fixRegexPattern(String r) {

StringBuilder sb = new StringBuilder();

for (int i = 0; i < r.length(); i++) {

char c = r.charAt(i);

if ((c == '{' || c == '}') && (i == 0 || r.charAt(i - 1) != '\\')) {

sb.append('\\');

}

sb.append(c);

}

return sb.toString();

}

private int skipWhitespace(String text, int pos) {

while (pos < text.length()) {

char c = text.charAt(pos);

if (c == ' ' || c == '\t' || c == '\n' || c == '\r') {

pos++;

} else {

break;

}

}

return pos;

}

private Integer findToken(String text, int pos, Definition.TokenDef token, boolean otherTextInside) {

if (token == null || token.type == null) return null;

switch (token.type) {

case "Group", "GroupOneChildOnly" -> {

if (token.nestedTokens == null) return null;

int closestChildPos = Integer.MAX_VALUE;

for (String childTokenName : token.nestedTokens) {

Definition.TokenDef childDef = definition.tokens.get(childTokenName);

Integer childPos = findToken(text, pos, childDef, otherTextInside);

if (childPos != null && childPos < closestChildPos) {

closestChildPos = childPos;

}

}

return closestChildPos == Integer.MAX_VALUE ? null : closestChildPos;

}

case "GroupAllChildrenInSameOrder" -> {

if (token.nestedTokens == null || token.nestedTokens.isEmpty()) return null;

Definition.TokenDef childDef = definition.tokens.get(token.nestedTokens.get(0));

return findToken(text, pos, childDef, otherTextInside);

}

case "SimpleToken", "StartStop", "StartOptStop" -> {

if (token.startRegex == null) return null;

Pattern p = getCompiledPattern(token.startRegex);

Matcher m = p.matcher(text.substring(pos));

if (!m.find()) return null;

int group = m.groupCount();

int matchStart = m.start(group);

int matchEnd = m.end(group);

if (matchEnd - matchStart == 0) return null;

if (!otherTextInside && m.start() != 0) return null;

return matchStart;

}

default -> throw new RuntimeException("Unknown token type: " + token.type);

}

}

private TokenItem parseSimpleToken(String text, String tokenName, Definition.TokenDef token, int pos) {

pos = skipWhitespace(text, pos);

Pattern p = getCompiledPattern(token.startRegex);

Matcher m = p.matcher(text.substring(pos));

if (!m.lookingAt()) {

throw new RuntimeException("Expected " + token.startRegex + " at position: " + pos);

}

int group = m.groupCount();

int matchStart = m.start(group);

int matchEnd = m.end(group);

TokenItem item = new TokenItem(tokenName, pos + matchStart, matchEnd - matchStart);

return item;

}

private TokenItem parseGroup(String text, String tokenName, Definition.TokenDef token, String parentRegex, int pos) {

pos = skipWhitespace(text, pos);

TokenItem ret = new TokenItem(tokenName, pos, 0);

while (pos < text.length()) {

int endTokenPos = Integer.MAX_VALUE;

pos = skipWhitespace(text, pos);

int closestChildTokenPos = Integer.MAX_VALUE;

String closestChildTokenName = null;

if (!token.searchParentEndTokenLast && parentRegex != null) {

Pattern p = getCompiledPattern(parentRegex);

Matcher m = p.matcher(text.substring(pos));

if (m.find()) {

int group = m.groupCount();

endTokenPos = m.start(group);

}

}

if (token.nestedTokens != null) {

for (String childTokenName : token.nestedTokens) {

Definition.TokenDef childDef = definition.tokens.get(childTokenName);

Integer childPos = findToken(text, pos, childDef, definition.otherTextInside);

if (childPos != null && childPos < closestChildTokenPos) {

closestChildTokenPos = childPos;

closestChildTokenName = childTokenName;

if (closestChildTokenPos == 0) break;

}

}

}

if (closestChildTokenPos > 0 && token.searchParentEndTokenLast && parentRegex != null) {

Pattern p = getCompiledPattern(parentRegex);

Matcher m = p.matcher(text.substring(pos));

if (m.find()) {

int group = m.groupCount();

endTokenPos = m.start(group);

}

}

if (endTokenPos != Integer.MAX_VALUE && endTokenPos <= closestChildTokenPos) {

ret.length = pos + endTokenPos - ret.position;

break;

}

if (closestChildTokenPos == Integer.MAX_VALUE || closestChildTokenName == null) {

break;

}

if (closestChildTokenPos > 0 && !definition.tokens.get(tokenName).otherTextInside) {

throw new RuntimeException("Child token " + closestChildTokenName + " has illegal position!");

}

pos += closestChildTokenPos;

Definition.TokenDef childDef = definition.tokens.get(closestChildTokenName);

TokenItem child = parseToken(text, closestChildTokenName, childDef, parentRegex, pos);

if (child.position < pos) {

throw new RuntimeException("Child token " + closestChildTokenName + " has illegal position!");

}

if (child.length <= 0) {

throw new RuntimeException("Child token " + closestChildTokenName + " has illegal length!");

}

ret.length = child.position + child.length - ret.position;

if (ret.length <= 0) {

throw new RuntimeException("Child token " + closestChildTokenName + " has illegal length!");

}

ret.children.add(child);

pos = child.position + child.length;

}

return ret;

}

private TokenItem parseGroupOneChildOnly(String text, String tokenName, Definition.TokenDef token, String parentRegex, int pos) {

pos = skipWhitespace(text, pos);

TokenItem ret = new TokenItem(tokenName, pos, 0);

if (token.nestedTokens == null || token.nestedTokens.isEmpty()) {

throw new RuntimeException("GroupOneChildOnly token type nested_tokens list is empty!");

}

int closestChildTokenPos = Integer.MAX_VALUE;

String closestChildTokenName = null;

for (String childTokenName : token.nestedTokens) {

Definition.TokenDef childDef = definition.tokens.get(childTokenName);

Integer childPos = findToken(text, pos, childDef, token.otherTextInside);

if (childPos != null && childPos >= 0 && childPos < closestChildTokenPos) {

closestChildTokenPos = childPos;

closestChildTokenName = childTokenName;

}

}

if (closestChildTokenName == null) {

throw new RuntimeException("Search for GroupOneChildOnly token type failed. Can't find one child.");

}

Definition.TokenDef childDef = definition.tokens.get(closestChildTokenName);

TokenItem child = parseToken(text, closestChildTokenName, childDef, parentRegex, pos);

ret.position = child.position;

ret.length = child.length;

ret.children.add(child);

return ret;

}

private TokenItem parseGroupAllChildrenInSameOrder(String text, String tokenName, Definition.TokenDef token, String parentRegex, int pos) {

pos = skipWhitespace(text, pos);

TokenItem ret = new TokenItem(tokenName, pos, 0);

if (token.nestedTokens == null || token.nestedTokens.size() != 3) {

throw new RuntimeException("GroupAllChildrenInSameOrder should have exactly 3 nested tokens, but " +

(token.nestedTokens == null ? 0 : token.nestedTokens.size()) + " were found");

}

String startToken = token.nestedTokens.get(0);

String innerToken = token.nestedTokens.get(1);

String endToken = token.nestedTokens.get(2);

Integer startTokenPos = findToken(text, pos, definition.tokens.get(startToken), definition.otherTextInside);

if (startTokenPos == null) {

throw new RuntimeException("Expected " + startToken + " at position: " + pos);

}

TokenItem child = parseToken(text, startToken, definition.tokens.get(startToken), parentRegex, pos);

ret.length = child.position + child.length - ret.position;

ret.children.add(child);

pos = child.position + child.length;

parentRegex = definition.tokens.get(endToken).startRegex;

int endTokenPos = 0;

while (pos < text.length()) {

Integer innerTokenPos = findToken(text, pos, definition.tokens.get(innerToken), definition.otherTextInside);

Integer endTokenPosOpt = findToken(text, pos, definition.tokens.get(endToken), definition.otherTextInside);

if (endTokenPosOpt == null) {

throw new RuntimeException("GroupAllChildrenInSameOrder end token " + endToken + " not found");

}

endTokenPos = endTokenPosOpt;

if (innerTokenPos == null || endTokenPos < innerTokenPos) {

break;

}

if (endTokenPos == innerTokenPos && !token.searchParentEndTokenLast) {

break;

}

pos += innerTokenPos;

child = parseToken(text, innerToken, definition.tokens.get(innerToken), parentRegex, pos);

ret.length = child.position + child.length - ret.position;

ret.children.add(child);

pos = child.position + child.length;

}

pos += endTokenPos;

TokenItem endItem = parseToken(text, endToken, definition.tokens.get(endToken), parentRegex, pos);

ret.length = endItem.position + endItem.length - ret.position;

ret.children.add(endItem);

return ret;

}

private TokenItem parseStartStop(String text, String tokenName, Definition.TokenDef token, String parentRegex, int pos, boolean endRequired) {

String myEndRegex = token.endRegex;

pos = skipWhitespace(text, pos);

Pattern startP = getCompiledPattern(token.startRegex);

Matcher startM = startP.matcher(text.substring(pos));

if (!startM.lookingAt()) {

throw new RuntimeException("Expected " + token.startRegex + " at position: " + pos);

}

int startGroup = startM.groupCount();

int startMatchStart = startM.start(startGroup);

int startMatchEnd = startM.end(startGroup);

pos += startMatchStart;

TokenItem ret = new TokenItem(tokenName, pos, 0);

pos += (startMatchEnd - startMatchStart);

if (token.nestedTokens == null) {

Pattern endP = getCompiledPattern(myEndRegex);

Matcher endM = endP.matcher(text.substring(pos));

if (!endM.find()) {

throw new RuntimeException("Expected " + myEndRegex + " at position: " + pos);

}

int endGroup = endM.groupCount();

int endTokenPos = endM.start(endGroup);

int endTokenLength = endM.end(endGroup) - endTokenPos;

ret.length = pos + endTokenPos + endTokenLength - ret.position;

return ret;

}

while (pos <= text.length()) {

int endTokenPos = Integer.MAX_VALUE;

int endTokenLength = 0;

pos = skipWhitespace(text, pos);

String checkRegex = (token.searchParentEndTokenLast && parentRegex != null) ? parentRegex : myEndRegex;

if (!token.searchParentEndTokenLast && checkRegex != null) {

Pattern endP = getCompiledPattern(checkRegex);

Matcher endM = endP.matcher(text.substring(pos));

if (endM.find()) {

int endGroup = endM.groupCount();

endTokenPos = endM.start(endGroup);

endTokenLength = endM.end(endGroup) - endTokenPos;

if (endTokenPos == 0) {

ret.length = pos - ret.position + endTokenLength;

break;

}

}

}

int closestChildTokenPos = Integer.MAX_VALUE;

String closestChildTokenName = null;

for (String childTokenName : token.nestedTokens) {

Definition.TokenDef childDef = definition.tokens.get(childTokenName);

Integer childPos = findToken(text, pos, childDef, token.otherTextInside);

if (childPos != null && childPos < closestChildTokenPos) {

closestChildTokenPos = childPos;

closestChildTokenName = childTokenName;

if (closestChildTokenPos == 0) break;

}

}

if (token.searchParentEndTokenLast && checkRegex != null) {

Pattern endP = getCompiledPattern(checkRegex);

Matcher endM = endP.matcher(text.substring(pos));

if (endM.find()) {

int endGroup = endM.groupCount();

endTokenPos = endM.start(endGroup);

endTokenLength = endM.end(endGroup) - endTokenPos;

if (endTokenPos < closestChildTokenPos) {

ret.length = pos - ret.position + endTokenPos + endTokenLength;

break;

}

}

}

if (endTokenPos < closestChildTokenPos) {

ret.length = pos - ret.position + endTokenPos + endTokenLength;

break;

}

if (closestChildTokenPos == Integer.MAX_VALUE || closestChildTokenName == null) {

if (endRequired && checkRegex != null) {

Pattern endP = getCompiledPattern(checkRegex);

Matcher endM = endP.matcher(text.substring(pos));

if (endM.find()) {

int endGroup = endM.groupCount();

endTokenPos = endM.start(endGroup);

endTokenLength = endM.end(endGroup) - endTokenPos;

ret.length = pos - ret.position + endTokenPos + endTokenLength;

}

}

break;

}

if (closestChildTokenPos > 0 && !definition.tokens.get(tokenName).otherTextInside) {

throw new RuntimeException("Child token " + closestChildTokenName + " has illegal position!");

}

pos += closestChildTokenPos;

Definition.TokenDef childDef = definition.tokens.get(closestChildTokenName);

TokenItem child = parseToken(text, closestChildTokenName, childDef, myEndRegex, pos);

if (child.length == 0) {

throw new RuntimeException("Child token " + closestChildTokenName + " has no length!");

}

ret.length = child.position + child.length - ret.position;

ret.children.add(child);

pos = child.position + child.length;

}

return ret;

}

private TokenItem parseToken(String text, String tokenName, Definition.TokenDef token, String parentRegex, int pos) {

pos = skipWhitespace(text, pos);

return switch (token.type) {

case "Group" -> parseGroup(text, tokenName, token, parentRegex, pos);

case "GroupOneChildOnly" -> parseGroupOneChildOnly(text, tokenName, token, parentRegex, pos);

case "GroupAllChildrenInSameOrder" -> parseGroupAllChildrenInSameOrder(text, tokenName, token, parentRegex, pos);

case "SimpleToken" -> parseSimpleToken(text, tokenName, token, pos);

case "StartStop" -> parseStartStop(text, tokenName, token, parentRegex, pos, true);

case "StartOptStop" -> parseStartStop(text, tokenName, token, parentRegex, pos, false);

default -> throw new RuntimeException("Unknown token type: " + token.type);

};

}

private void maybeMergeSign(TokenItem tokenItem) {

if (definition.mergeSignIntoNumber == null) return;

if (tokenItem.children == null || tokenItem.children.isEmpty()) return;

List<String> signTokens = definition.mergeSignIntoNumber.signTokens;

List<String> numberTokens = definition.mergeSignIntoNumber.numberTokens;

List<String> operandTokens = definition.mergeSignIntoNumber.operandTokens;

int i = 0;

while (i < tokenItem.children.size()) {

TokenItem curr = tokenItem.children.get(i);

if (numberTokens.contains(curr.id) && i > 0) {

TokenItem prev = tokenItem.children.get(i - 1);

TokenItem sign = null;

TokenItem context = null;

int signKind = 0;

if (signTokens.contains(prev.id)) {

sign = prev;

context = (i >= 2) ? tokenItem.children.get(i - 2) : null;

signKind = 1;

} else if (prev.children != null && !prev.children.isEmpty() &&

signTokens.contains(prev.children.get(prev.children.size() - 1).id)) {

sign = prev.children.get(prev.children.size() - 1);

if (prev.children.size() >= 2) {

context = prev.children.get(prev.children.size() - 2);

} else if (i >= 2) {

context = tokenItem.children.get(i - 2);

} else {

context = null;

}

signKind = 2;

}

if (sign != null && (sign.position + sign.length == curr.position) && sign.length == 1) {

if (context == null || !operandTokens.contains(context.id)) {

curr.length += (curr.position - sign.position);

curr.position = sign.position;

if (signKind == 1) {

tokenItem.children.remove(i - 1);

i--;

} else {

prev.children.remove(prev.children.size() - 1);

if (prev.children.isEmpty()) {

tokenItem.children.remove(i - 1);

i--;

}

}

}

}

}

if (curr.children != null && !curr.children.isEmpty()) {

maybeMergeSign(curr);

}

i++;

}

}

public void postProcess(List<TokenItem> tokens) {

if (tokens == null) return;

int i = 0;

while (i < tokens.size()) {

TokenItem curr = tokens.get(i);

if (curr.children != null && !curr.children.isEmpty()) {

postProcess(curr.children);

}

Definition.TokenDef tokenDef = definition.tokens.get(curr.id);

if (tokenDef != null && tokenDef.deleteIfOnlyOneChild && curr.children != null && curr.children.size() == 1) {

TokenItem onlyChild = curr.children.get(0);

tokens.set(i, onlyChild);

curr = onlyChild;

}

i++;

}

}

public List<TokenItem> parse(String text) {

List<TokenItem> tokens = new ArrayList<>();

int pos = 0;

while (pos < text.length()) {

pos = skipWhitespace(text, pos);

int closestTokenPos = Integer.MAX_VALUE;

String closestTokenName = null;

for (String tokenName : definition.startTokens) {

Definition.TokenDef tokenDef = definition.tokens.get(tokenName);

Integer offset = findToken(text, pos, tokenDef, definition.otherTextInside);

if (offset != null && offset < closestTokenPos) {

closestTokenPos = offset;

closestTokenName = tokenName;

}

}

if (closestTokenName == null) {

if (definition.otherTextInside && pos < text.length()) {

tokens.add(new TokenItem("", pos, text.length() - pos));

}

break;

}

if (closestTokenPos > 0 && definition.otherTextInside) {

int errEnd = pos + closestTokenPos;

while (errEnd > pos && Character.isWhitespace(text.charAt(errEnd - 1))) {

errEnd--;

}

if (errEnd > pos) {

tokens.add(new TokenItem("", pos, errEnd - pos));

}

}

pos += closestTokenPos;

Definition.TokenDef tokenDef = definition.tokens.get(closestTokenName);

TokenItem child = parseToken(text, closestTokenName, tokenDef, null, pos);

if (child.length == 0) {

throw new RuntimeException("Child token " + closestTokenName + " has no length!");

}

tokens.add(child);

pos = child.position + child.length;

}

if (definition.mergeSignIntoNumber != null) {

TokenItem dummyRoot = new TokenItem("ROOT", 0, 0);

dummyRoot.children = tokens;

maybeMergeSign(dummyRoot);

tokens = dummyRoot.children;

}

postProcess(tokens);

return tokens;

}

private void recursiveFormat(byte[] array, TokenItem token, List<String> tokenKeys) {

int tokenId = tokenKeys.indexOf(token.id);

if (tokenId >= 0) {

byte charByte = (byte) tokenId;

int end = Math.min(array.length, token.position + token.length);

for (int k = token.position; k < end; k++) {

if (k >= 0) {

array[k] = charByte;

}

}

}

if (token.children != null) {

for (TokenItem child : token.children) {

recursiveFormat(array, child, tokenKeys);

}

}

}

public byte[] parseFormat(String text) {

byte[] ret = new byte[text.length()];

List<TokenItem> tokens = parse(text);

List<String> tokenKeys = new ArrayList<>(definition.tokens.keySet());

for (TokenItem token : tokens) {

recursiveFormat(ret, token, tokenKeys);

}

return ret;

}

}