package com.qianwen.core.tool.utils;

import java.util.Arrays;
import java.util.function.Function;
import org.apache.commons.beanutils.BeanUtilsBean;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

/* loaded from: blade-core-tool-9.3.0.0-SNAPSHOT.jar:org/springblade/core/tool/utils/TemplateParser.class */
public class TemplateParser {
    private static final Logger log = LoggerFactory.getLogger(TemplateParser.class);
    private static final char[] DEFAULT_PREPARE_START_SYMBOL = "${".toCharArray();
    private static final char[] DEFAULT_PREPARE_END_SYMBOL = "}".toCharArray();
    private String template;
    private Object parameter;
    private char[] templateArray;
    private int pos;
    private char symbol;
    private char[] newArr;
    private char[] prepareStartSymbol = DEFAULT_PREPARE_START_SYMBOL;
    private char[] prepareEndSymbol = DEFAULT_PREPARE_END_SYMBOL;
    private int len = 0;
    private byte prepareFlag = 0;

    public char[] getPrepareStartSymbol() {
        return this.prepareStartSymbol;
    }

    public void setPrepareStartSymbol(final char[] prepareStartSymbol) {
        this.prepareStartSymbol = prepareStartSymbol;
    }

    public char[] getPrepareEndSymbol() {
        return this.prepareEndSymbol;
    }

    public void setPrepareEndSymbol(final char[] prepareEndSymbol) {
        this.prepareEndSymbol = prepareEndSymbol;
    }

    public String getTemplate() {
        return this.template;
    }

    public void setTemplate(final String template) {
        this.template = template;
    }

    public Object getParameter() {
        return this.parameter;
    }

    public void setParameter(final Object parameter) {
        this.parameter = parameter;
    }

    public void setParsed(char[] chars, int end) {
        for (int i = 0; i < end; i++) {
            char aChar = chars[i];
            if (this.newArr.length <= this.len) {
                this.newArr = Arrays.copyOf(this.newArr, this.len + this.templateArray.length);
            }
            char[] cArr = this.newArr;
            int i2 = this.len;
            this.len = i2 + 1;
            cArr[i2] = aChar;
        }
    }

    public void setParsed(char... chars) {
        setParsed(chars, chars.length);
    }

    private void init() {
        this.templateArray = this.template.toCharArray();
        this.pos = 0;
        this.newArr = new char[this.templateArray.length * 2];
    }

    private boolean isPreparing() {
        return this.prepareFlag > 0;
    }

    private boolean isPrepare() {
        if (this.prepareStartSymbol[this.prepareFlag] == this.symbol) {
            this.prepareFlag = (byte) (this.prepareFlag + 1);
        }
        if (this.prepareFlag >= this.prepareStartSymbol.length) {
            this.prepareFlag = (byte) 0;
            return true;
        }
        return false;
    }

    private boolean isPrepareEnd() {
        char[] cArr;
        for (char c : this.prepareEndSymbol) {
            if (c == this.symbol) {
                return true;
            }
        }
        return false;
    }

    private boolean next() {
        char[] cArr = this.templateArray;
        int i = this.pos;
        this.pos = i + 1;
        this.symbol = cArr[i];
        return this.pos < this.templateArray.length;
    }

    public String parse(Function<String, String> propertyMapping) {
        init();
        boolean inPrepare = false;
        char[] expression = new char[128];
        int expressionPos = 0;
        while (next()) {
            if (isPrepare()) {
                inPrepare = true;
            } else if (inPrepare && isPrepareEnd()) {
                inPrepare = false;
                setParsed(propertyMapping.apply(new String(expression, 0, expressionPos)).toCharArray());
                expressionPos = 0;
            } else if (inPrepare) {
                int i = expressionPos;
                expressionPos++;
                expression[i] = this.symbol;
            } else if (!isPreparing()) {
                setParsed(this.symbol);
            }
        }
        if (isPrepareEnd() && expressionPos > 0) {
            setParsed(propertyMapping.apply(new String(expression, 0, expressionPos)).toCharArray());
        } else {
            setParsed(this.symbol);
        }
        return new String(this.newArr, 0, this.len);
    }

    public static String parse(String template, Object parameter) {
        return parse(template, (Function<String, String>) var -> {
            try {
                return BeanUtilsBean.getInstance().getProperty(parameter, var);
            } catch (Exception e) {
                log.warn(e.getMessage(), e);
                return StringPool.EMPTY;
            }
        });
    }

    public static String parse(String template, Function<String, String> parameterGetter) {
        TemplateParser parser = new TemplateParser();
        parser.template = template;
        return parser.parse(parameterGetter);
    }
}