王明 / Food-Labeling-Management-Platform

package com.foodlabel.nativeprinter.template;

import android.graphics.Bitmap;
import android.graphics.BitmapFactory;
import android.graphics.Canvas;
import android.graphics.Color;
import android.graphics.Paint;
import android.graphics.Paint.Align;
import android.graphics.Typeface;
import android.util.Base64;

import org.json.JSONArray;
import org.json.JSONObject;

import java.io.ByteArrayOutputStream;
import java.nio.charset.Charset;
import java.nio.charset.CharsetEncoder;
import java.nio.charset.StandardCharsets;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

public final class NativeTemplateCommandBuilder {
    private static final double DESIGN_DPI = 96.0;
    /**
     * 与 JS 光栅路径 clearTopRasterRows 等效：热敏头可印区相对模板顶边常有一小段空白，
     * 全部为 0 时顶部中文位图/TEXT 易被裁切；略下移与整页光栅观感一致。
     */
    private static final int LABEL_TOP_MARGIN_DOTS = 18;
    private static final int TEXT_PADDING_DOTS = 6;
    private static final int RIGHT_SAFE_MARGIN_DOTS = 8;
    /** 营养表数值列右对齐：比通用 TEXT 更贴右边框 */
    private static final int NUTRITION_VALUE_RIGHT_MARGIN_DOTS = 2;
    /** 条码条宽占模块比例（越小缝越宽） */
    private static final double BARCODE_MODULE_FILL_RATIO = 0.72;
    private static final int DEFAULT_THRESHOLD = 180;
    private static final Pattern PLACEHOLDER_PATTERN = Pattern.compile("\\{\\{\\s*([\\w.-]+)\\s*\\}\\}");
    private static final String[][] NUTRITION_FIXED_ITEMS = new String[][]{
            {"fat", "Total Fat"},
            {"saturatedFat", "Saturated Fat"},
            {"transFat", "Trans Fat"},
            {"cholesterol", "Cholesterol"},
            {"sodium", "Sodium"},
            {"carbs", "Total Carbohydrates"},
            {"dietaryFiber", "Dietary Fiber"},
            {"totalSugar", "Total Sugar"},
            {"protein", "Protein"},
            {"vitaminA", "Vitamin A"},
            {"vitaminC", "Vitamin C"},
            {"calcium", "Calcium"},
            {"iron", "Iron"}
    };

    private NativeTemplateCommandBuilder() {
    }

    public static byte[] build(String templateJson, String dataJson, int dpi, int printQty) throws Exception {
        JSONObject template = new JSONObject(templateJson);
        JSONObject data = (dataJson == null || dataJson.trim().isEmpty()) ? new JSONObject() : new JSONObject(dataJson);
        return buildWithStats(template, data, dpi, printQty).bytes;
    }

    public static byte[] build(JSONObject template, JSONObject data, int dpi, int printQty) throws Exception {
        return buildWithStats(template, data, dpi, printQty).bytes;
    }

    public static BuildResult buildWithStats(String templateJson, String dataJson, int dpi, int printQty) throws Exception {
        JSONObject template = new JSONObject(templateJson);
        JSONObject data = (dataJson == null || dataJson.trim().isEmpty()) ? new JSONObject() : new JSONObject(dataJson);
        return buildWithStats(template, data, dpi, printQty);
    }

    public static BuildResult buildWithStats(JSONObject template, JSONObject data, int dpi, int printQty) throws Exception {
        ByteArrayOutputStream out = new ByteArrayOutputStream();
        int nativeTextCount = 0;
        int rasterTextCount = 0;
        int qrCodeCount = 0;
        int barcodeCount = 0;
        int imagePatchCount = 0;
        int lineCount = 0;
        String unit = getString(template, "unit", "inch");
        double widthMm = round1(toMillimeter(getDouble(template, "width", 0), unit));
        double heightMm = round1(toMillimeter(getDouble(template, "height", 0), unit));
        double pageWidthPx = widthMm / 25.4 * DESIGN_DPI;
        /** 标签可印宽度（点）；BITMAP 超出时部分机型会把溢出列折到左侧，表现为「右边框印到最左边」 */
        int pageWidthDots = Math.max(8, pxToDots(pageWidthPx, dpi));

        addLine(out, "SIZE " + formatMm(widthMm) + " mm," + formatMm(heightMm) + " mm");
        addLine(out, "GAP 0 mm,0 mm");
        addLine(out, "CODEPAGE 1252");
        addLine(out, "DENSITY 14");
        addLine(out, "SPEED 5");
        addLine(out, "CLS");

        JSONArray elements = template.optJSONArray("elements");
        if (elements != null) {
            for (int i = 0; i < elements.length(); i++) {
                JSONObject element = elements.optJSONObject(i);
                if (element == null) continue;
                JSONObject config = element.optJSONObject("config");
                if (config == null) config = new JSONObject();
                String type = getString(element, "type", "").toUpperCase();

                if (type.startsWith("TEXT_")) {
                    String text = resolveElementText(type, config, data);
                    if (text.isEmpty()) continue;
                    String align = resolveElementAlign(element, config, pageWidthPx);
                    if (shouldRasterizeText(text, type, config)) {
                        rasterTextCount++;
                        BitmapPatch patch = createTextPatch(element, type, config, text, dpi, align);
                        writeBitmapPatch(out, patch, pageWidthDots);
                    } else {
                        nativeTextCount++;
                        int scale = resolveTextScale(getDouble(config, "fontSize", 14), dpi);
                        if ("TEXT_PRICE".equals(type)) {
                            // 价格行与普通文案保持接近视觉粗细，避免看起来偏“粗黑”。
                            scale = Math.max(1, scale - 1);
                        }
                        int x = resolveTextX(align, getDouble(element, "x", 0), getDouble(element, "width", 0), dpi, text, scale);
                        int y = yDots(getDouble(element, "y", 0), dpi);
                        int rotation = "vertical".equalsIgnoreCase(getString(element, "rotation", "horizontal")) ? 90 : 0;
                        String fontName = getString(config, "tscFont", "TSS24.BF2");
                        addLine(out, "TEXT " + x + "," + y + ",\"" + escapeTscString(fontName) + "\"," + rotation + "," + scale + "," + scale + ",\"" + escapeTscString(text) + "\"");
                    }
                    continue;
                }

                if ("QRCODE".equals(type)) {
                    String sourceLike = getString(
                            config,
                            "src",
                            getString(
                                    config,
                                    "Src",
                                    getString(
                                            config,
                                            "data",
                                            getString(config, "Data", getString(config, "url", getString(config, "Url", "")))
                                    )
                            )
                    );
                    if (isImageLikeSource(sourceLike)) {
                        BitmapPatch patch = createImagePatch(element, config, dpi, sourceLike);
                        if (patch != null) {
                            imagePatchCount++;
                            writeBitmapPatch(out, patch, pageWidthDots);
                        }
                        continue;
                    }
                    String value = resolveElementDataValue(type, config, data);
                    if (value.isEmpty()) continue;
                    if (isImageLikeSource(value)) {
                        BitmapPatch patch = createImagePatch(element, config, dpi, value);
                        if (patch != null) {
                            imagePatchCount++;
                            writeBitmapPatch(out, patch, pageWidthDots);
                        }
                        continue;
                    }
                    qrCodeCount++;
                    String level = normalizeQrLevel(getString(config, "errorLevel", "M"));
                    int x = pxToDots(getDouble(element, "x", 0), dpi);
                    int y = yDots(getDouble(element, "y", 0), dpi);
                    int size = resolveQrModuleSize(getDouble(element, "width", 0), getDouble(element, "height", 0), dpi, value, level);
                    addLine(out, "QRCODE " + x + "," + y + "," + level + "," + size + ",A,0,\"" + escapeTscString(value) + "\"");
                    continue;
                }

                if ("NUTRITION".equals(type)) {
                    nativeTextCount += emitNutritionNativeText(out, element, config, dpi);
                    continue;
                }

                if ("BARCODE".equals(type)) {
                    String symbology = normalizeBarcodeType(getString(config, "barcodeType", "CODE128"));
                    String value = formatBarcodeValueForTsc(symbology, resolveElementDataValue(type, config, data));
                    if (value.isEmpty()) continue;
                    barcodeCount++;
                    String orientation = getString(config, "orientation", getString(element, "rotation", "horizontal"));
                    boolean forceBitmap = getBoolean(config, "nativeBarcodeBitmap", false)
                            || getBoolean(config, "NativeBarcodeBitmap", false)
                            || "CODA".equals(symbology);
                    if ("vertical".equalsIgnoreCase(orientation)) {
                        BitmapPatch patch = createVerticalBarcodePatch(element, config, dpi, value);
                        if (patch != null) {
                            imagePatchCount++;
                            writeBitmapPatch(out, patch, pageWidthDots);
                        }
                        continue;
                    }
                    if (forceBitmap) {
                        BitmapPatch patch = createHorizontalBarcodePatch(element, config, dpi, value);
                        if (patch != null) {
                            imagePatchCount++;
                            writeBitmapPatch(out, patch, pageWidthDots);
                        }
                        continue;
                    }
                    int x = pxToDots(getDouble(element, "x", 0), dpi);
                    int y = yDots(getDouble(element, "y", 0), dpi);
                    int height = Math.max(20, pxToDots(getDouble(element, "height", 0), dpi));
                    int readable = getBoolean(config, "showText", true) ? 1 : 0;
                    int rotation = "vertical".equalsIgnoreCase(orientation) ? 90 : 0;
                    int barWidthDots = Math.max(48, pxToDots(getDouble(element, "width", 0), dpi));
                    int len = Math.max(1, value.length());
                    int narrow = clamp(barWidthDots / Math.max(48.0, len * 11.0), 2, 8);
                    int wide = clamp(barWidthDots / Math.max(28.0, len * 6.5), 3, 12);
                    if (wide <= narrow) wide = Math.min(12, narrow + 1);
                    addLine(out, "BARCODE " + x + "," + y + ",\"" + symbology + "\"," + height + "," + readable + "," + rotation + "," + narrow + "," + wide + ",\"" + escapeTscString(value) + "\"");
                    continue;
                }

                if ("IMAGE".equals(type)) {
                    BitmapPatch patch = createImagePatch(element, config, dpi);
                    if (patch != null) {
                        imagePatchCount++;
                        writeBitmapPatch(out, patch, pageWidthDots);
                    }
                    continue;
                }

                if ("BLANK".equals(type) && "line".equalsIgnoreCase(getString(element, "border", ""))) {
                    lineCount++;
                    int x = pxToDots(getDouble(element, "x", 0), dpi);
                    int y = yDots(getDouble(element, "y", 0), dpi);
                    int width = Math.max(1, pxToDots(getDouble(element, "width", 0), dpi));
                    int height = Math.max(1, pxToDots(getDouble(element, "height", 1), dpi));
                    addLine(out, "BAR " + x + "," + y + "," + width + "," + height);
                }
            }
        }

        addLine(out, "PRINT 1," + Math.max(1, printQty));
        return new BuildResult(
                out.toByteArray(),
                nativeTextCount,
                rasterTextCount,
                qrCodeCount,
                barcodeCount,
                imagePatchCount,
                lineCount,
                elements == null ? 0 : elements.length()
        );
    }

    private static String resolveElementText(String type, JSONObject config, JSONObject data) {
        String configText = getString(config, "text", "");
        boolean hasText = !configText.isEmpty();
        if ("TEXT_PRICE".equals(type)) {
            String bindingKey = resolveBindingKey(type, config);
            String boundValue = resolveTemplateValue(data, bindingKey);
            String raw = !boundValue.isEmpty() ? boundValue : (hasText ? applyTemplateData(configText, data) : "");
            if (raw.isEmpty()) return "";
            String prefix = getString(config, "prefix", "");
            String suffix = getString(config, "suffix", "");
            int decimal = (int) getDouble(config, "decimal", -1);
            if (decimal >= 0) {
                try {
                    double value = Double.parseDouble(raw);
                    raw = String.format(java.util.Locale.US, "%1$." + decimal + "f", value);
                } catch (Exception ignored) {
                }
            }
            raw = trimLeadingCurrencyIfPrefixed(raw, prefix);
            return normalizePriceCurrencySymbol(prefix + raw + suffix);
        }
        if (hasText && "TEXT_STATIC".equals(type)) {
            return applyTemplateData(configText, data);
        }
        if (hasText && configText.contains("{{")) {
            return applyTemplateData(configText, data);
        }
        String bindingKey = resolveBindingKey(type, config);
        String boundValue = resolveTemplateValue(data, bindingKey);
        if (!boundValue.isEmpty()) return boundValue;
        return hasText ? applyTemplateData(configText, data) : "";
    }

    private static String resolveElementDataValue(String type, JSONObject config, JSONObject data) {
        String raw = getString(
                config,
                "data",
                getString(
                        config,
                        "Data",
                        getString(
                                config,
                                "value",
                                getString(config, "Value", getString(config, "src", getString(config, "Src", getString(config, "url", getString(config, "Url", "")))))
                        )
                )
        );
        if (!raw.isEmpty()) return applyTemplateData(raw, data);
        return resolveTemplateValue(data, resolveBindingKey(type, config));
    }

    private static String resolveBindingKey(String type, JSONObject config) {
        String[] keys = new String[]{"dataKey", "field", "bindField", "key", "valueKey"};
        for (String key : keys) {
            String value = getString(config, key, "");
            if (!value.isEmpty()) return value;
        }
        switch (type) {
            case "TEXT_PRODUCT": return "productName";
            case "TEXT_LABEL_ID": return "labelId";
            case "TEXT_CATEGORY": return "category";
            case "TEXT_PRICE": return "price";
            case "TEXT_DATE": return "date";
            case "TEXT_TIME": return "time";
            case "QRCODE": return "qrCode";
            case "BARCODE": return "barcode";
            default:
                String pureType = type.replace("TEXT_", "").replace("FIELD_", "").replace("VALUE_", "");
                return pureType.isEmpty() ? "" : toCamelCase(pureType);
        }
    }

    private static String resolveTemplateValue(JSONObject data, String key) {
        if (key == null || key.isEmpty()) return "";
        String[] candidates;
        switch (key) {
            case "productName": candidates = new String[]{"productName", "product"}; break;
            case "product": candidates = new String[]{"product", "productName"}; break;
            case "qrCode": candidates = new String[]{"qrCode", "labelId", "barcode"}; break;
            case "barcode": candidates = new String[]{"barcode", "labelId", "qrCode"}; break;
            default: candidates = new String[]{key};
        }
        for (String candidate : candidates) {
            Object value = data.opt(candidate);
            if (value != null) return String.valueOf(value);
        }
        return "";
    }

    private static String applyTemplateData(String text, JSONObject data) {
        Matcher matcher = PLACEHOLDER_PATTERN.matcher(text == null ? "" : text);
        StringBuffer buffer = new StringBuffer();
        while (matcher.find()) {
            String key = matcher.group(1);
            Object value = data.opt(key);
            matcher.appendReplacement(buffer, Matcher.quoteReplacement(value == null ? "" : String.valueOf(value)));
        }
        matcher.appendTail(buffer);
        return buffer.toString();
    }

    private static String toCamelCase(String value) {
        String[] parts = value.toLowerCase().split("[_\\s-]+");
        StringBuilder builder = new StringBuilder();
        for (int i = 0; i < parts.length; i++) {
            if (parts[i].isEmpty()) continue;
            if (builder.length() == 0) {
                builder.append(parts[i]);
            } else {
                builder.append(Character.toUpperCase(parts[i].charAt(0))).append(parts[i].substring(1));
            }
        }
        return builder.toString();
    }

    private static String resolveElementAlign(JSONObject element, JSONObject config, double pageWidthPx) {
        String align = getString(config, "textAlign", "").toLowerCase();
        if ("left".equals(align) || "center".equals(align) || "right".equals(align)) return align;
        double centerX = getDouble(element, "x", 0) + getDouble(element, "width", 0) / 2.0;
        if (centerX <= pageWidthPx * 0.33) return "left";
        if (centerX >= pageWidthPx * 0.67) return "right";
        return "center";
    }

    private static boolean shouldRasterizeText(String text, String type, JSONObject config) {
        if (getBoolean(config, "invertColors", false) || getBoolean(config, "InvertColors", false)) {
            return true;
        }
        if (getBoolean(config, "forceRasterText", false)) {
            return true;
        }
        if (text == null || text.isEmpty()) return false;
        if ("TEXT_PRICE".equals(type) && isSimplePriceLikeText(text)) {
            // 价格行优先走原生 TEXT：避免位图二值化导致的糊边/左侧杂点。
            return false;
        }
        for (int i = 0; i < text.length(); i++) {
            char c = text.charAt(i);
            if (c < 32 || c > 126) {
                return true;
            }
        }
        CharsetEncoder encoder = getPrinterEncoder();
        if (encoder == null) return true;
        try {
            return !encoder.canEncode(text);
        } catch (Exception e) {
            return true;
        }
    }

    private static boolean isSimplePriceLikeText(String text) {
        String s = text == null ? "" : text.trim();
        if (s.isEmpty()) return false;
        // 允许货币符号 + 数字/小数点/逗号/空格，统一按原生字体输出。
        return s.matches("^[¥￥$€£]?\\s*[-+]?\\d+(?:[.,]\\d{1,2})?\\s*$");
    }

    private static String normalizePriceCurrencySymbol(String value) {
        if (value == null || value.isEmpty()) return "";
        return value.replace('￥', '¥');
    }

    private static String trimLeadingCurrencyIfPrefixed(String raw, String prefix) {
        if (raw == null || raw.isEmpty()) return "";
        String p = prefix == null ? "" : prefix.trim();
        if (p.isEmpty()) return raw;
        char c = p.charAt(0);
        if (c != '¥' && c != '￥' && c != '$' && c != '€' && c != '£') return raw;
        String s = raw.trim();
        while (!s.isEmpty()) {
            char ch = s.charAt(0);
            if (ch == '¥' || ch == '￥' || ch == '$' || ch == '€' || ch == '£') {
                s = s.substring(1).trim();
                continue;
            }
            break;
        }
        return s;
    }

    private static BitmapPatch createTextPatch(JSONObject element, String type, JSONObject config, String text, int dpi, String align) {
        String nativeSrc = text != null ? getString(config, "nativeSourceType", "") : "";
        boolean dateLikeTime =
                "DATE".equalsIgnoreCase(nativeSrc)
                        || "TIME".equalsIgnoreCase(nativeSrc)
                        || "DURATION".equalsIgnoreCase(nativeSrc);
        if (text != null && dateLikeTime) {
            /** 预览里日期与时间之间多空格，measure + 折行易把尾部数字挤到下一行；打印前压成单空格 */
            text = text.replaceAll("\\s{2,}", " ").trim();
        }
        int contentWidth = Math.max(8, pxToDots(getDouble(element, "width", 0), dpi));
        int elementHeightDots = Math.max(16, pxToDots(getDouble(element, "height", 0), dpi));
        boolean inverted = getBoolean(config, "invertColors", false) || getBoolean(config, "InvertColors", false);
        Paint paint = new Paint();
        paint.setAntiAlias(true);
        paint.setDither(true);
        paint.setSubpixelText(true);
        paint.setColor(inverted ? Color.WHITE : Color.BLACK);
        int fontSizeDots = Math.max(14, pxToDots(getDouble(config, "fontSize", 14), dpi));
        paint.setTextSize(fontSizeDots);
        /** 不再对 TEXT_PRICE 强制加粗：fakeBold + 粗体会糊边、measureText 偏窄，右对齐时左侧易出现杂点 */
        boolean bold = "bold".equalsIgnoreCase(getString(config, "fontWeight", ""));
        paint.setFakeBoldText(bold);
        paint.setTypeface(bold ? Typeface.create(Typeface.SANS_SERIF, Typeface.BOLD) : Typeface.SANS_SERIF);

        java.util.List<String> lines;
        if (dateLikeTime && text != null && text.indexOf('\n') < 0) {
            /** 与画布单行日期/时间一致：禁止按字符宽度硬切，避免出现「12: 00 5」类残缺行 */
            int wNeed = (int) Math.ceil(paint.measureText(text)) + 24;
            contentWidth = Math.max(contentWidth, wNeed);
            lines = new java.util.ArrayList<>();
            lines.add(text);
        } else {
            if (text != null && text.indexOf('\n') < 0) {
                int singleLineWidth = (int) Math.ceil(paint.measureText(text)) + 8;
                contentWidth = Math.max(contentWidth, singleLineWidth);
            }
            lines = splitTextLines(text == null ? "" : text, paint, Math.max(8, contentWidth));
        }
        Paint.FontMetrics metrics = paint.getFontMetrics();
        int lineHeight = Math.max(fontSizeDots + 2, (int) Math.ceil(Math.abs(metrics.top) + Math.abs(metrics.bottom) + 2));
        int totalHeight = lines.size() * lineHeight;
        float maxLineWidth = 0;
        for (String line : lines) {
            maxLineWidth = Math.max(maxLineWidth, paint.measureText(line));
        }
        int horizontalPadding = TEXT_PADDING_DOTS * 2;
        int verticalPadding = TEXT_PADDING_DOTS * 2;
        int width = ensureMultipleOf8(Math.max(contentWidth + horizontalPadding * 2, (int) Math.ceil(maxLineWidth) + horizontalPadding * 2 + 4));
        int height = Math.max(16, Math.max(elementHeightDots + verticalPadding * 2, totalHeight + verticalPadding * 2 + 4));
        Bitmap bitmap = Bitmap.createBitmap(width, height, Bitmap.Config.ARGB_8888);
        Canvas canvas = new Canvas(bitmap);
        canvas.drawColor(inverted ? Color.BLACK : Color.WHITE);
        if (inverted && elementHeightDots > 0 && contentWidth > 0) {
            Paint fill = new Paint();
            fill.setColor(Color.BLACK);
            canvas.drawRect(0, 0, width, height, fill);
        }

        int topOffset = "TEXT_PRICE".equals(type)
                ? Math.max(verticalPadding, (height - totalHeight) / 2)
                : verticalPadding;
        int drawableWidth = width - horizontalPadding * 2;

        for (int i = 0; i < lines.size(); i++) {
            String line = lines.get(i);
            float lineWidth = paint.measureText(line);
            float drawX = horizontalPadding;
            float baseline = topOffset + i * lineHeight - metrics.top;
            if ("center".equals(align)) {
                String eid = getString(element, "id", "");
                /** 条码下方人读数字：用 CENTER 对齐条区中心，避免 measure 偏差导致「差一截才居中」 */
                if (eid.contains("barcode") && eid.endsWith("_label")) {
                    Align saved = paint.getTextAlign();
                    paint.setTextAlign(Align.CENTER);
                    float cx = horizontalPadding + drawableWidth / 2f;
                    canvas.drawText(line, cx, baseline, paint);
                    paint.setTextAlign(saved);
                    continue;
                }
                drawX = horizontalPadding + Math.max(0, (drawableWidth - lineWidth) / 2f);
            } else if ("right".equals(align)) {
                /** ￥ 等字符 measureText 常偏窄；日期时间含空格时末字符也易被裁，统一略加余量并留右内边距 */
                float w = lineWidth;
                if ("TEXT_PRICE".equals(type)) {
                    w += Math.max(2f, paint.getTextSize() * 0.12f);
                } else {
                    w += Math.max(3f, paint.getTextSize() * 0.14f);
                }
                float rightPad = 4f;
                drawX = horizontalPadding + Math.max(0, drawableWidth - w - rightPad);
            }
            canvas.drawText(line, drawX, baseline, paint);
        }

        BitmapPatch patch = new BitmapPatch(Math.max(0, pxToDots(getDouble(element, "x", 0), dpi) - horizontalPadding),
                Math.max(0, yDots(getDouble(element, "y", 0), dpi) - verticalPadding),
                bitmapToMonochrome(bitmap, DEFAULT_THRESHOLD));
        bitmap.recycle();
        return patch;
    }

    private static BitmapPatch createImagePatch(JSONObject element, JSONObject config, int dpi) {
        return createImagePatch(element, config, dpi, null);
    }

    /**
     * 与 APP drawBarcodeLikePreview 同源：模块来自人读数字（1234），条宽比例见 BARCODE_MODULE_FILL_RATIO；
     * 在打印点阵坐标直接绘制，避免缩放后细缝被二值化糊死。人读数字由 JS 追加 TEXT_STATIC 输出。
     */
    private static BitmapPatch createHorizontalBarcodePatch(JSONObject element, JSONObject config, int dpi, String encodedValue) {
        int designW = Math.max(40, (int) Math.round(getDouble(element, "width", 140)));
        int designH = Math.max(28, (int) Math.round(getDouble(element, "height", 56)));
        String displayValue = barcodeDisplayText(config, encodedValue);
        String moduleSource = displayValue.isEmpty()
                ? stripCodabarDisplay(encodedValue)
                : displayValue;

        int printW = ensureMultipleOf8(Math.max(8, pxToDots(designW, dpi)));
        int printH = Math.max(8, pxToDots(designH, dpi));
        float scaleX = (float) printW / (float) Math.max(1, designW);
        float scaleY = (float) printH / (float) Math.max(1, designH);
        int padDots = Math.max(2, Math.round(2f * scaleX));
        int barTop = padDots;
        int barBottom = printH - padDots;
        int barHeightDots = Math.max(8, barBottom - barTop);
        int innerWDots = Math.max(8, printW - padDots * 2);

        Bitmap outputBitmap = Bitmap.createBitmap(printW, printH, Bitmap.Config.ARGB_8888);
        Canvas canvas = new Canvas(outputBitmap);
        canvas.drawColor(Color.WHITE);

        int[] modules = barcodeModulesFromValue(moduleSource);
        Paint barPaint = new Paint();
        barPaint.setAntiAlias(false);
        barPaint.setColor(Color.BLACK);
        if (modules.length > 0) {
            double moduleWDots = (double) innerWDots / (double) modules.length;
            for (int i = 0; i < modules.length; i++) {
                if (modules[i] != 1) continue;
                int left = padDots + (int) Math.round(i * moduleWDots);
                int barWDots = Math.max(1, (int) Math.round(moduleWDots * BARCODE_MODULE_FILL_RATIO));
                int right = Math.min(printW - padDots, left + barWDots);
                if (right > left) {
                    canvas.drawRect(left, barTop, right, barTop + barHeightDots, barPaint);
                }
            }
        }

        MonochromeImage mono = bitmapToMonochrome(outputBitmap, 192);
        outputBitmap.recycle();
        if (mono == null) return null;
        return new BitmapPatch(
                pxToDots(getDouble(element, "x", 0), dpi),
                yDots(getDouble(element, "y", 0), dpi),
                mono
        );
    }

    private static String stripCodabarDisplay(String value) {
        if (value == null) return "";
        String raw = value.trim();
        if (raw.length() >= 2) {
            char first = Character.toUpperCase(raw.charAt(0));
            char last = raw.charAt(raw.length() - 1);
            if ("ABCD".indexOf(first) >= 0 && "TNE*".indexOf(last) >= 0) {
                return raw.substring(1, raw.length() - 1);
            }
        }
        return raw;
    }

    private static String barcodeDisplayText(JSONObject config, String encodedValue) {
        String display = getString(
                config,
                "barcodeDisplayText",
                getString(config, "BarcodeDisplayText", "")
        ).trim();
        if (!display.isEmpty()) return stripCodabarDisplay(display);
        return stripCodabarDisplay(encodedValue);
    }

    private static BitmapPatch createVerticalBarcodePatch(JSONObject element, JSONObject config, int dpi, String value) {
        int width = ensureMultipleOf8(Math.max(8, pxToDots(getDouble(element, "width", 0), dpi)));
        int height = Math.max(12, pxToDots(getDouble(element, "height", 0), dpi));
        Bitmap outputBitmap = Bitmap.createBitmap(width, height, Bitmap.Config.ARGB_8888);
        Canvas canvas = new Canvas(outputBitmap);
        canvas.drawColor(Color.WHITE);

        int pad = 2;
        boolean showText = getBoolean(config, "showText", true);
        int textBandWidth = (showText && value != null && !value.isEmpty()) ? Math.max(10, (int) Math.round(width * 0.18)) : 0;
        int barAreaWidth = Math.max(8, width - textBandWidth - pad * 2);
        int innerHeight = Math.max(10, height - pad * 2);

        int[] modules = barcodeModulesFromValue(value);
        Paint barPaint = new Paint();
        barPaint.setAntiAlias(false);
        barPaint.setColor(Color.BLACK);
        if (modules.length > 0) {
            double moduleH = (double) innerHeight / (double) modules.length;
            double cursorY = pad;
            for (int i = 0; i < modules.length; i++) {
                if (modules[i] == 1) {
                    float top = (float) cursorY;
                    float bottom = (float) (cursorY + Math.max(0.7, moduleH * BARCODE_MODULE_FILL_RATIO));
                    canvas.drawRect(pad, top, pad + barAreaWidth, bottom, barPaint);
                }
                cursorY += moduleH;
            }
        }

        if (showText && value != null && !value.isEmpty() && textBandWidth > 0) {
            Paint txt = new Paint();
            txt.setAntiAlias(true);
            txt.setColor(Color.BLACK);
            int font = Math.max(9, Math.min(11, (int) Math.floor(textBandWidth * 0.75)));
            txt.setTextSize(font);
            txt.setTextAlign(Paint.Align.CENTER);
            float cx = width - textBandWidth / 2f;
            float cy = height / 2f;
            canvas.save();
            // 竖排文本按模板端习惯：从下到上
            canvas.rotate(-90f, cx, cy);
            Paint.FontMetrics fm = txt.getFontMetrics();
            float baseline = cy - (fm.ascent + fm.descent) / 2f;
            canvas.drawText(value, cx, baseline, txt);
            canvas.restore();
        }

        BitmapPatch patch = new BitmapPatch(
                pxToDots(getDouble(element, "x", 0), dpi),
                yDots(getDouble(element, "y", 0), dpi),
                bitmapToMonochrome(outputBitmap, (int) getDouble(config, "threshold", DEFAULT_THRESHOLD))
        );
        outputBitmap.recycle();
        return patch;
    }

    private static int[] barcodeModulesFromValue(String value) {
        String s = value == null ? "" : value.trim();
        if (s.isEmpty()) return new int[0];
        java.util.ArrayList<Integer> m = new java.util.ArrayList<>();
        // quiet + start
        int[] start = new int[]{1, 0, 1, 0, 1, 0, 1, 0};
        for (int v : start) m.add(v);
        for (int i = 0; i < s.length(); i++) {
            int code = s.charAt(i) & 0xFF;
            int key = (code ^ (i * 13) ^ (s.length() * 7)) & 0x1F;
            for (int b = 4; b >= 0; b--) {
                m.add((key >> b) & 1);
            }
            m.add(0);
        }
        int[] stop = new int[]{1, 0, 1, 1, 0, 1, 0, 1};
        for (int v : stop) m.add(v);
        int[] out = new int[m.size()];
        for (int i = 0; i < m.size(); i++) out[i] = m.get(i);
        return out;
    }

    /**
     * 营养表走 TSC TEXT + BOX，不走 BITMAP，避免机型把位图最右列折到 x=0（数值列出现在左侧）。
     * @return 发出的 TEXT 行数（供统计）
     */
    private static int emitNutritionNativeText(ByteArrayOutputStream out, JSONObject element, JSONObject config, int dpi) {
        int designW = Math.max(40, (int) Math.round(getDouble(element, "width", 0)));
        int designH = (int) Math.round(getDouble(config, "nativePrintHeight",
                getDouble(config, "NativePrintHeight", getDouble(element, "height", 72))));
        if (designH < 40) designH = 40;
        double elX = getDouble(element, "x", 0);
        double elY = getDouble(element, "y", 0);
        int padDesign = 3;
        int patchX = pxToDots(elX, dpi);
        int patchY = yDots(elY, dpi);
        int boxWDots = Math.max(8, pxToDots(designW, dpi));
        int boxHDots = Math.max(8, pxToDots(designH, dpi));
        int boxR = patchX + boxWDots - 1;
        int boxB = patchY + boxHDots - 1;
        addLine(out, "BOX " + patchX + "," + patchY + "," + boxR + "," + boxB + ",1");

        int titleSize = clamp((int) Math.round(getDouble(config, "nutritionTitleFontSize", 16)), 11, 22);
        int bodySize = clamp(Math.round(titleSize * 0.72f), 8, 14);
        int titleScale = resolveTextScale(titleSize, dpi);
        int bodyScale = resolveTextScale(bodySize, dpi);
        int titleLineHDots = titleScale * 24 + 4;
        int bodyLineHDots = bodyScale * 24 + 2;
        int padDots = Math.max(2, pxToDots(padDesign, dpi));
        int textCount = 0;

        int cursorY = patchY + padDots;
        textCount += addNativeTextLine(out, pxToDots(elX + padDesign, dpi), cursorY, titleScale, "Nutrition Facts");
        cursorY += titleLineHDots;

        int barX = patchX + padDots;
        int barW = Math.max(8, boxWDots - padDots * 2);
        addLine(out, "BAR " + barX + "," + cursorY + "," + barW + ",1");
        cursorY += 4;

        double innerX = elX + padDesign;
        double innerW = Math.max(8, designW - padDesign * 2.0);

        String calories = getString(config, "calories", getString(config, "Calories",
                getNutritionFixedField(config, "calories", "value")));
        if (!calories.trim().isEmpty()) {
            textCount += emitNutritionRow(out, innerX, innerW, cursorY, dpi, bodyScale,
                    "Calories", nutritionDisplayValue(calories, ""));
            cursorY += bodyLineHDots;
        }

        String servingsPerContainer = getString(config, "servingsPerContainer", getString(config, "ServingsPerContainer", ""));
        if (!servingsPerContainer.trim().isEmpty()) {
            textCount += emitNutritionRow(out, innerX, innerW, cursorY, dpi, bodyScale,
                    "Servings Per Container", servingsPerContainer);
            cursorY += bodyLineHDots;
        }

        String servingSize = getString(config, "servingSize", getString(config, "ServingSize", ""));
        if (!servingSize.trim().isEmpty()) {
            textCount += emitNutritionRow(out, innerX, innerW, cursorY, dpi, bodyScale,
                    "Serving Size", servingSize);
            cursorY += bodyLineHDots;
        }

        for (String[] row : NUTRITION_FIXED_ITEMS) {
            if (cursorY + bodyLineHDots > boxB - padDots) break;
            String value = getNutritionFixedField(config, row[0], "value");
            if (value.trim().isEmpty()) continue;
            String unit = getNutritionFixedField(config, row[0], "unit");
            textCount += emitNutritionRow(out, innerX, innerW, cursorY, dpi, bodyScale,
                    row[1], nutritionDisplayValue(value, unit));
            cursorY += bodyLineHDots;
        }

        JSONArray extra = config.optJSONArray("extraNutrients");
        if (extra != null) {
            for (int i = 0; i < extra.length(); i++) {
                if (cursorY + bodyLineHDots > boxB - padDots) break;
                JSONObject item = extra.optJSONObject(i);
                if (item == null) continue;
                String name = getString(item, "name", "").trim();
                String value = getString(item, "value", "").trim();
                String unit = getString(item, "unit", "").trim();
                if (value.isEmpty()) continue;
                if (name.isEmpty()) name = "Other";
                textCount += emitNutritionRow(out, innerX, innerW, cursorY, dpi, bodyScale,
                        name, nutritionDisplayValue(value, unit));
                cursorY += bodyLineHDots;
            }
        }
        return textCount;
    }

    private static int emitNutritionRow(
            ByteArrayOutputStream out,
            double innerX,
            double innerW,
            int textY,
            int dpi,
            int bodyScale,
            String label,
            String value
    ) {
        int count = 0;
        String safeLabel = label == null ? "" : label.trim();
        String safeValue = value == null ? "" : value.trim();
        if (!safeLabel.isEmpty()) {
            count += addNativeTextLine(out, resolveTextX("left", innerX, innerW, dpi, safeLabel, bodyScale),
                    textY, bodyScale, safeLabel);
        }
        if (!safeValue.isEmpty()) {
            count += addNativeTextLine(out, resolveNutritionValueX(innerX, innerW, dpi, safeValue, bodyScale),
                    textY, bodyScale, safeValue);
        }
        return count;
    }

    private static int addNativeTextLine(ByteArrayOutputStream out, int x, int y, int scale, String text) {
        if (text == null || text.trim().isEmpty()) return 0;
        addLine(out, "TEXT " + x + "," + y + ",\"TSS24.BF2\",0," + scale + "," + scale
                + ",\"" + escapeTscString(text.trim()) + "\"");
        return 1;
    }

    /** @deprecated 营养表已改 emitNutritionNativeText；保留供参考 */
    private static BitmapPatch createNutritionPatch(JSONObject element, JSONObject config, int dpi, int pageWidthDots) {
        /** 直接在打印点阵分辨率绘制，避免 160px→340dot 缩放导致文字糊、边框错位 */
        int designW = Math.max(40, (int) Math.round(getDouble(element, "width", 0)));
        int designH = (int) Math.round(getDouble(config, "nativePrintHeight",
                getDouble(config, "NativePrintHeight", getDouble(element, "height", 72))));
        if (designH < 40) designH = 40;
        int patchX = pxToDots(getDouble(element, "x", 0), dpi);
        int patchY = yDots(getDouble(element, "y", 0), dpi);
        int maxPrintW = pageWidthDots - patchX - RIGHT_SAFE_MARGIN_DOTS;
        int idealPrintW = ensureMultipleOf8(Math.max(8, pxToDots(designW, dpi)));
        int printW = idealPrintW;
        if (maxPrintW >= 8) {
            printW = Math.min(idealPrintW, ensureMultipleOf8(maxPrintW));
        }
        int printH = Math.max(8, pxToDots(designH, dpi));
        float sx = (float) printW / (float) Math.max(1, designW);

        Bitmap bitmap = Bitmap.createBitmap(printW, printH, Bitmap.Config.ARGB_8888);
        Canvas canvas = new Canvas(bitmap);
        canvas.drawColor(Color.WHITE);

        int pad = Math.max(2, Math.round(3f * sx));
        int contentLeft = pad;
        int innerRight = Math.max(pad + 24, printW - pad);
        int right = innerRight;
        int maxY = printH - pad - 1;

        int titleSize = clamp((int) Math.round(getDouble(config, "nutritionTitleFontSize", 16)), 11, 22);
        int bodySize = clamp(Math.round(titleSize * 0.72f), 8, 14);
        float titlePx = Math.max(9f, titleSize * sx);
        float bodyPx = Math.max(8f, bodySize * sx);
        float y = pad + titlePx;

        boolean titleBold = getBoolean(config, "nutritionTitleBold", false);
        boolean bodyBold = getBoolean(config, "nutritionBodyBold", false);

        Paint linePaint = new Paint();
        linePaint.setAntiAlias(false);
        linePaint.setColor(Color.BLACK);
        linePaint.setStrokeWidth(1f);

        Paint titlePaint = new Paint();
        titlePaint.setAntiAlias(false);
        titlePaint.setColor(Color.BLACK);
        titlePaint.setTextSize(titlePx);
        titlePaint.setTypeface(Typeface.create(Typeface.SANS_SERIF, titleBold ? Typeface.BOLD : Typeface.NORMAL));
        titlePaint.setSubpixelText(false);
        titlePaint.setTextAlign(Align.LEFT);
        canvas.drawText("Nutrition Facts", contentLeft, y, titlePaint);
        y += Math.max(1f, 1f * sx);
        canvas.drawLine(contentLeft, y, innerRight, y, linePaint);
        y += Math.max(2f, 2f * sx);

        Paint labelPaint = new Paint();
        labelPaint.setAntiAlias(false);
        labelPaint.setColor(Color.BLACK);
        labelPaint.setTextSize(bodyPx);
        labelPaint.setTypeface(Typeface.create(Typeface.SANS_SERIF, bodyBold ? Typeface.BOLD : Typeface.NORMAL));
        labelPaint.setSubpixelText(false);
        labelPaint.setTextAlign(Align.LEFT);

        Paint valuePaint = new Paint();
        valuePaint.setAntiAlias(false);
        valuePaint.setColor(Color.BLACK);
        valuePaint.setTextSize(bodyPx);
        valuePaint.setTypeface(Typeface.create(Typeface.SANS_SERIF, bodyBold ? Typeface.BOLD : Typeface.NORMAL));
        valuePaint.setSubpixelText(false);
        valuePaint.setTextAlign(Align.RIGHT);

        String calories = getString(config, "calories", getString(config, "Calories",
                getNutritionFixedField(config, "calories", "value")));
        if (!calories.trim().isEmpty()) {
            y = drawNutritionPair(canvas, "Calories", nutritionDisplayValue(calories, ""), contentLeft, right, y, maxY, labelPaint, valuePaint);
        }

        String servingsPerContainer = getString(config, "servingsPerContainer", getString(config, "ServingsPerContainer", ""));
        if (!servingsPerContainer.trim().isEmpty()) {
            y = drawNutritionPair(canvas, "Servings Per Container", servingsPerContainer, contentLeft, right, y, maxY, labelPaint, valuePaint);
        }

        String servingSize = getString(config, "servingSize", getString(config, "ServingSize", ""));
        if (!servingSize.trim().isEmpty()) {
            y = drawNutritionPair(canvas, "Serving Size", servingSize, contentLeft, right, y, maxY, labelPaint, valuePaint);
        }

        for (String[] row : NUTRITION_FIXED_ITEMS) {
            String key = row[0];
            String name = row[1];
            String value = getNutritionFixedField(config, key, "value");
            if (value.trim().isEmpty()) continue;
            String unit = getNutritionFixedField(config, key, "unit");
            y = drawNutritionPair(canvas, name, nutritionDisplayValue(value, unit), contentLeft, right, y, maxY, labelPaint, valuePaint);
            if (y >= maxY) break;
        }

        if (y < maxY) {
            JSONArray extra = config.optJSONArray("extraNutrients");
            if (extra != null) {
                for (int i = 0; i < extra.length(); i++) {
                    JSONObject item = extra.optJSONObject(i);
                    if (item == null) continue;
                    String name = getString(item, "name", "").trim();
                    String value = getString(item, "value", "").trim();
                    String unit = getString(item, "unit", "").trim();
                    if (value.isEmpty()) continue;
                    if (name.isEmpty()) name = "Other";
                    y = drawNutritionPair(canvas, name, nutritionDisplayValue(value, unit), contentLeft, right, y, maxY, labelPaint, valuePaint);
                    if (y >= maxY) break;
                }
            }
        }

        MonochromeImage mono = bitmapToMonochrome(bitmap, 200);
        bitmap.recycle();
        if (mono == null) return null;
        return new BitmapPatch(patchX, patchY, mono);
    }

    private static float drawNutritionPair(
            Canvas canvas,
            String label,
            String value,
            int left,
            int right,
            float baseline,
            int maxY,
            Paint labelPaint,
            Paint valuePaint
    ) {
        if (baseline + labelPaint.getTextSize() + 1 > maxY) return maxY;
        String safeLabel = (label == null ? "" : label).replace("\n", " ").replace("\r", " ").trim();
        String safeValue = (value == null ? "" : value).replace("\n", " ").replace("\r", " ").trim();

        /** 数值列不得超过 (right-left)；禁止再强制 minWidth=14，否则窄营养表（如 width=32dot）会挤爆列划分 */
        float totalWidth = (float) right - (float) left;
        if (totalWidth < 8f) {
            return maxY;
        }
        float minName = Math.min(40f, Math.max(14f, totalWidth * 0.5f));
        float valueColumnWidth = Math.min(totalWidth * 0.45f, Math.max(4f, totalWidth - minName));
        float valueColumnLeft = (float) right - valueColumnWidth;
        if (valueColumnLeft < left + 2f) {
            valueColumnLeft = left + 2f;
            valueColumnWidth = (float) right - valueColumnLeft;
        }
        float labelMaxRight = valueColumnLeft - 4f;
        float labelMaxWidth = Math.max(6f, labelMaxRight - left);

        if (!safeLabel.isEmpty() && labelPaint.measureText(safeLabel) > labelMaxWidth) {
            while (safeLabel.length() > 1 && labelPaint.measureText(safeLabel + "...") > labelMaxWidth) {
                safeLabel = safeLabel.substring(0, safeLabel.length() - 1);
            }
            safeLabel = safeLabel + "...";
        }
        labelPaint.setTextAlign(Align.LEFT);
        canvas.drawText(safeLabel, left, baseline + labelPaint.getTextSize(), labelPaint);
        if (!safeValue.isEmpty()) {
            valuePaint.setTextAlign(Align.RIGHT);
            float cellRight = (float) right - 2f;
            canvas.drawText(safeValue, cellRight, baseline + valuePaint.getTextSize(), valuePaint);
            valuePaint.setTextAlign(Align.LEFT);
        }
        return baseline + labelPaint.getTextSize() + 1;
    }

    private static String getNutritionFixedField(JSONObject config, String key, String field) {
        String directKey = "value".equals(field) ? key : key + "Unit";
        String direct = getString(config, directKey, "").trim();
        if (!direct.isEmpty()) return direct;
        JSONArray rows = config.optJSONArray("fixedNutrients");
        if (rows == null) return "";
        for (int i = 0; i < rows.length(); i++) {
            JSONObject item = rows.optJSONObject(i);
            if (item == null) continue;
            if (!key.equals(getString(item, "key", "").trim())) continue;
            return getString(item, field, "").trim();
        }
        return "";
    }

    private static String nutritionDisplayValue(String value, String unit) {
        String v = value == null ? "" : value.trim();
        String u = unit == null ? "" : unit.trim();
        if (v.isEmpty() && u.isEmpty()) return "";
        return "<" + v + (u.isEmpty() ? "" : (" " + u));
    }

    private static BitmapPatch createImagePatch(JSONObject element, JSONObject config, int dpi, String sourceOverride) {
        String source = sourceOverride;
        if (source == null || source.isEmpty()) {
            source = getString(config, "src", getString(config, "data", getString(config, "url", "")));
        }
        if (source.isEmpty()) return null;
        Bitmap sourceBitmap = decodeBitmap(source);
        if (sourceBitmap == null) return null;

        int width = ensureMultipleOf8(Math.max(8, pxToDots(getDouble(element, "width", 0), dpi)));
        int height = Math.max(8, pxToDots(getDouble(element, "height", 0), dpi));
        Bitmap outputBitmap = Bitmap.createBitmap(width, height, Bitmap.Config.ARGB_8888);
        Canvas canvas = new Canvas(outputBitmap);
        canvas.drawColor(Color.WHITE);

        int sourceWidth = sourceBitmap.getWidth();
        int sourceHeight = sourceBitmap.getHeight();
        String scaleMode = getString(config, "scaleMode", "contain").toLowerCase();
        int targetWidth = width;
        int targetHeight = height;
        int targetLeft = 0;
        int targetTop = 0;

        if (sourceWidth > 0 && sourceHeight > 0 && !"fill".equals(scaleMode)) {
            double ratio = "cover".equals(scaleMode)
                    ? Math.max((double) width / sourceWidth, (double) height / sourceHeight)
                    : Math.min((double) width / sourceWidth, (double) height / sourceHeight);
            targetWidth = Math.max(1, (int) Math.round(sourceWidth * ratio));
            targetHeight = Math.max(1, (int) Math.round(sourceHeight * ratio));
            targetLeft = (width - targetWidth) / 2;
            targetTop = (height - targetHeight) / 2;
        }

        Bitmap scaledBitmap = Bitmap.createScaledBitmap(sourceBitmap, targetWidth, targetHeight, true);
        Paint paint = new Paint();
        paint.setAntiAlias(true);
        paint.setFilterBitmap(true);
        canvas.drawBitmap(scaledBitmap, targetLeft, targetTop, paint);

        BitmapPatch patch = new BitmapPatch(pxToDots(getDouble(element, "x", 0), dpi),
                yDots(getDouble(element, "y", 0), dpi),
                bitmapToMonochrome(outputBitmap, (int) getDouble(config, "threshold", DEFAULT_THRESHOLD)));

        scaledBitmap.recycle();
        sourceBitmap.recycle();
        outputBitmap.recycle();
        return patch;
    }

    private static boolean isImageLikeSource(String source) {
        if (source == null) return false;
        String s = source.trim().toLowerCase();
        if (s.isEmpty()) return false;
        if (s.startsWith("data:image/")) return true;
        if (s.startsWith("file://")) return true;
        if (s.startsWith("/picture/") || s.startsWith("picture/")) return true;
        if (s.startsWith("/static/") || s.startsWith("static/")) return true;
        if (s.matches("^[a-z]:[\\\\/].*")) return true;
        return s.matches(".*\\.(png|jpe?g|gif|webp|bmp)(\\?.*)?$");
    }

    private static Bitmap decodeBitmap(String source) {
        try {
            if (source.startsWith("data:image/")) {
                int comma = source.indexOf(',');
                String payload = comma >= 0 ? source.substring(comma + 1) : "";
                if (payload.isEmpty()) return null;
                byte[] bytes = Base64.decode(payload, Base64.DEFAULT);
                return BitmapFactory.decodeByteArray(bytes, 0, bytes.length);
            }
            if (source.matches("^[A-Za-z0-9+/=\\r\\n]+$") && source.length() > 128) {
                byte[] bytes = Base64.decode(source, Base64.DEFAULT);
                return BitmapFactory.decodeByteArray(bytes, 0, bytes.length);
            }
            String path = source.startsWith("file://") ? source.substring(7) : source;
            return BitmapFactory.decodeFile(path);
        } catch (Exception e) {
            return null;
        }
    }

    private static java.util.List<String> splitTextLines(String text, Paint paint, int maxWidth) {
        java.util.List<String> lines = new java.util.ArrayList<>();
        String[] rawLines = (text == null ? "" : text.replace("\r", "")).split("\n");
        for (String segment : rawLines) {
            if (segment.isEmpty()) {
                lines.add("");
                continue;
            }
            StringBuilder current = new StringBuilder();
            for (int i = 0; i < segment.length(); i++) {
                char c = segment.charAt(i);
                String candidate = current.toString() + c;
                if (current.length() > 0 && paint.measureText(candidate) > maxWidth) {
                    lines.add(current.toString());
                    current.setLength(0);
                    current.append(c);
                } else {
                    current.append(c);
                }
            }
            if (current.length() > 0) lines.add(current.toString());
        }
        if (lines.isEmpty()) lines.add("");
        return lines;
    }

    /**
     * 限制位图宽度不超过标签右边界，避免 TSC 把溢出列折到 x=0（右边框出现在最左侧）。
     */
    private static BitmapPatch constrainPatchToPage(BitmapPatch patch, int pageWidthDots) {
        if (patch == null || patch.image == null || pageWidthDots <= 0) return patch;
        int x = Math.max(0, patch.x);
        int maxW = pageWidthDots - x - RIGHT_SAFE_MARGIN_DOTS;
        if (maxW < 8) return null;
        if (patch.image.width <= maxW) {
            if (x == patch.x) return patch;
            return new BitmapPatch(x, patch.y, patch.image);
        }
        int targetW = ensureMultipleOf8(maxW);
        MonochromeImage fitted = scaleMonochromeProportional(patch.image, targetW);
        if (fitted == null) return null;
        return new BitmapPatch(x, patch.y, fitted);
    }

    private static MonochromeImage scaleMonochromeProportional(MonochromeImage src, int targetWidth) {
        if (src == null || src.width <= 0 || src.height <= 0) return src;
        if (targetWidth >= src.width) return src;
        targetWidth = ensureMultipleOf8(Math.max(8, targetWidth));
        int targetHeight = Math.max(8, (int) Math.round((double) src.height * targetWidth / (double) src.width));
        Bitmap srcBitmap = Bitmap.createBitmap(src.width, src.height, Bitmap.Config.ARGB_8888);
        for (int y = 0; y < src.height; y++) {
            for (int x = 0; x < src.width; x++) {
                int v = src.pixels[y * src.width + x];
                srcBitmap.setPixel(x, y, v == 1 ? Color.BLACK : Color.WHITE);
            }
        }
        Bitmap scaled = Bitmap.createScaledBitmap(srcBitmap, targetWidth, targetHeight, false);
        srcBitmap.recycle();
        MonochromeImage mono = bitmapToMonochrome(scaled, DEFAULT_THRESHOLD);
        scaled.recycle();
        return mono;
    }

    /**
     * 与 JS pixelsToTscBitmapBytes 一致：mono 1=黑墨、0=白纸；TSC 位 0=黑点、位 1=不印。
     */
    private static void writeBitmapPatch(ByteArrayOutputStream out, BitmapPatch patch, int pageWidthDots) {
        writeBitmapPatchRaw(out, constrainPatchToPage(patch, pageWidthDots));
    }

    private static void writeBitmapPatchRaw(ByteArrayOutputStream out, BitmapPatch patch) {
        if (patch == null || patch.image == null) return;
        int bytesPerRow = patch.image.width / 8;
        addLine(out, "BITMAP " + patch.x + "," + patch.y + "," + bytesPerRow + "," + patch.image.height + ",0,");
        for (int y = 0; y < patch.image.height; y++) {
            for (int byteIndex = 0; byteIndex < bytesPerRow; byteIndex++) {
                int value = 0;
                for (int bit = 0; bit < 8; bit++) {
                    int x = byteIndex * 8 + bit;
                    int pixel = patch.image.pixels[y * patch.image.width + x];
                    if (pixel == 0) {
                        value |= (1 << (7 - bit));
                    }
                }
                out.write(value & 0xFF);
            }
        }
        out.write('\r');
        out.write('\n');
    }

    /** 设计 px 位图按 203dpi 缩放到打印点阵，与 APP 预览物理比例一致 */
    private static MonochromeImage monochromeScaledToPrintDots(Bitmap designBitmap, int dpi, int threshold) {
        if (designBitmap == null) return null;
        int designW = Math.max(1, designBitmap.getWidth());
        int designH = Math.max(1, designBitmap.getHeight());
        int printW = ensureMultipleOf8(Math.max(8, pxToDots(designW, dpi)));
        int printH = Math.max(8, pxToDots(designH, dpi));
        Bitmap scaled = Bitmap.createScaledBitmap(designBitmap, printW, printH, false);
        MonochromeImage mono = bitmapToMonochrome(scaled, threshold);
        if (scaled != designBitmap) {
            scaled.recycle();
        }
        return mono;
    }

    private static MonochromeImage bitmapToMonochrome(Bitmap bitmap, int threshold) {
        int bitmapWidth = bitmap.getWidth();
        int bitmapHeight = bitmap.getHeight();
        /** 位图宽已是 8 倍数时不再右补白列，减少 TSC 行宽错位导致左边出现「折过来的右边框」 */
        int width = bitmapWidth % 8 == 0 ? bitmapWidth : ensureMultipleOf8(bitmapWidth);
        int[] pixels = new int[width * bitmapHeight];
        for (int y = 0; y < bitmapHeight; y++) {
            for (int x = 0; x < width; x++) {
                if (x >= bitmapWidth) {
                    pixels[y * width + x] = 0;
                    continue;
                }
                int color = bitmap.getPixel(x, y);
                int alpha = (color >>> 24) & 0xFF;
                int red = (color >>> 16) & 0xFF;
                int green = (color >>> 8) & 0xFF;
                int blue = color & 0xFF;
                double gray = red * 0.299 + green * 0.587 + blue * 0.114;
                pixels[y * width + x] = alpha <= 10 || gray > threshold ? 0 : 1;
            }
        }
        return new MonochromeImage(width, bitmapHeight, pixels);
    }

    private static MonochromeImage invertMonochrome(MonochromeImage image) {
        if (image == null || image.pixels == null) return image;
        int[] pixels = new int[image.pixels.length];
        for (int i = 0; i < image.pixels.length; i++) {
            pixels[i] = image.pixels[i] == 1 ? 0 : 1;
        }
        return new MonochromeImage(image.width, image.height, pixels);
    }

    private static void addLine(ByteArrayOutputStream out, String line) {
        byte[] bytes = line.getBytes(getPrinterCharset());
        out.write(bytes, 0, bytes.length);
        out.write('\r');
        out.write('\n');
    }

    private static Charset getPrinterCharset() {
        try {
            return Charset.forName("windows-1252");
        } catch (Throwable first) {
            try {
                return Charset.forName("Cp1252");
            } catch (Throwable second) {
                return StandardCharsets.ISO_8859_1;
            }
        }
    }

    private static CharsetEncoder getPrinterEncoder() {
        try {
            return getPrinterCharset().newEncoder();
        } catch (Throwable first) {
            try {
                return StandardCharsets.ISO_8859_1.newEncoder();
            } catch (Throwable second) {
                return null;
            }
        }
    }

    private static String escapeTscString(String value) {
        return value == null ? "" : value.replace("\\", "\\\\").replace("\"", "\\\"");
    }

    private static String normalizeBarcodeType(String value) {
        String key = value == null ? "CODE128" : value.trim().toUpperCase();
        switch (key) {
            case "CODE39": return "39";
            case "EAN13": return "EAN13";
            case "EAN8": return "EAN8";
            case "UPCA": return "UPCA";
            case "UPCE": return "UPCE";
            case "CODABAR": return "CODA";
            case "ITF14": return "ITF14";
            case "ITF": return "ITF";
            default: return "128";
        }
    }

    /** TSC CODABAR 需起止符；纯数字在部分佳博/Virtual BT 上 BARCODE 指令会静默失败 */
    private static String formatBarcodeValueForTsc(String symbology, String value) {
        if (value == null || value.trim().isEmpty()) return "";
        String raw = value.trim();
        if (!"CODA".equalsIgnoreCase(symbology)) return raw;
        String upper = raw.toUpperCase();
        boolean hasStart = upper.length() > 0 && "ABCD".indexOf(upper.charAt(0)) >= 0;
        boolean hasStop = upper.length() > 0 && "TNE*".indexOf(upper.charAt(upper.length() - 1)) >= 0;
        if (hasStart && hasStop) return upper;
        String body = raw.replaceAll("[^0-9\\-$:/.+]", "");
        if (body.isEmpty()) return raw;
        return "A" + body + "B";
    }

    private static String normalizeQrLevel(String value) {
        String key = value == null ? "M" : value.trim().toUpperCase();
        if ("L".equals(key) || "M".equals(key) || "Q".equals(key) || "H".equals(key)) return key;
        return "M";
    }

    private static int resolveQrModuleSize(double widthPx, double heightPx, int dpi, String value, String level) {
        int targetDots = Math.max(24, Math.min(pxToDots(widthPx, dpi), pxToDots(heightPx, dpi)));
        int moduleCount = Math.max(21, estimateQrModuleCount(value, level));
        return clamp(Math.floorDiv(targetDots, moduleCount), 3, 12);
    }

    private static int estimateQrModuleCount(String value, String level) {
        int length = Math.max(1, value == null ? 0 : value.length());
        int[] capacities;
        switch (level) {
            case "L": capacities = new int[]{17, 32, 53, 78, 106, 134, 154, 192, 230, 271}; break;
            case "Q": capacities = new int[]{11, 20, 32, 46, 60, 74, 86, 108, 130, 151}; break;
            case "H": capacities = new int[]{7, 14, 24, 34, 44, 58, 64, 84, 98, 119}; break;
            default: capacities = new int[]{14, 26, 42, 62, 84, 106, 122, 152, 180, 213};
        }
        int version = capacities.length;
        for (int i = 0; i < capacities.length; i++) {
            if (length <= capacities[i]) {
                version = i + 1;
                break;
            }
        }
        return 21 + (version - 1) * 4;
    }

    private static int resolveTextScale(double fontSizePx, int dpi) {
        int targetDots = Math.max(12, (int) Math.round(fontSizePx * dpi / DESIGN_DPI));
        return clamp(targetDots / 24.0, 1, 7);
    }

    private static int resolveTextX(String align, double xPx, double widthPx, int dpi, String text, int scale) {
        int left = pxToDots(xPx, dpi);
        if ("left".equals(align)) return left;
        int boxWidth = pxToDots(widthPx, dpi);
        int fontDots = Math.max(24, scale * 24);
        int textWidth = estimateTextWidthDots(text, fontDots);
        if ("center".equals(align)) return Math.max(0, left + Math.max(0, boxWidth - textWidth) / 2);
        return Math.max(0, left + Math.max(0, boxWidth - textWidth - RIGHT_SAFE_MARGIN_DOTS));
    }

    private static int resolveNutritionValueX(double innerX, double innerW, int dpi, String text, int scale) {
        int left = pxToDots(innerX, dpi);
        int boxWidth = pxToDots(innerW, dpi);
        int fontDots = Math.max(24, scale * 24);
        int textWidth = estimateTextWidthDots(text, fontDots);
        return Math.max(left, left + Math.max(0, boxWidth - textWidth - NUTRITION_VALUE_RIGHT_MARGIN_DOTS));
    }

    private static int estimateTextWidthDots(String text, int fontDots) {
        double total = 0;
        for (int i = 0; i < text.length(); i++) {
            total += text.charAt(i) > 255 ? fontDots : fontDots * 0.6;
        }
        return (int) Math.round(total);
    }

    private static int clamp(double value, int min, int max) {
        return Math.max(min, Math.min(max, (int) Math.round(value)));
    }

    private static int ensureMultipleOf8(int value) {
        int safe = Math.max(8, value);
        return safe % 8 == 0 ? safe : safe + (8 - safe % 8);
    }

    private static int pxToDots(double value, int dpi) {
        return Math.max(0, (int) Math.round(value * dpi / DESIGN_DPI));
    }

    /** 模板 y（px）→ 点阵 y，并加上与光栅路径一致的上边距，减轻顶部裁切 */
    private static int yDots(double yPx, int dpi) {
        return Math.max(0, pxToDots(yPx, dpi) + LABEL_TOP_MARGIN_DOTS);
    }

    private static double toMillimeter(double value, String unit) {
        if ("mm".equalsIgnoreCase(unit)) return value;
        if ("cm".equalsIgnoreCase(unit)) return value * 10;
        if ("px".equalsIgnoreCase(unit)) return value / DESIGN_DPI * 25.4;
        return value * 25.4;
    }

    private static double round1(double value) {
        return Math.round(value * 10.0) / 10.0;
    }

    private static String formatMm(double value) {
        return String.format(java.util.Locale.US, "%.1f", value);
    }

    private static String getString(JSONObject json, String key, String fallback) {
        Object value = json.opt(key);
        return value == null ? fallback : String.valueOf(value);
    }

    private static double getDouble(JSONObject json, String key, double fallback) {
        try {
            Object value = json.opt(key);
            if (value == null) return fallback;
            if (value instanceof Number) return ((Number) value).doubleValue();
            return Double.parseDouble(String.valueOf(value));
        } catch (Exception e) {
            return fallback;
        }
    }

    private static boolean getBoolean(JSONObject json, String key, boolean fallback) {
        try {
            Object value = json.opt(key);
            if (value == null) return fallback;
            if (value instanceof Boolean) return (Boolean) value;
            return Boolean.parseBoolean(String.valueOf(value));
        } catch (Exception e) {
            return fallback;
        }
    }

    private static final class BitmapPatch {
        final int x;
        final int y;
        final MonochromeImage image;

        BitmapPatch(int x, int y, MonochromeImage image) {
            this.x = x;
            this.y = y;
            this.image = image;
        }
    }

    private static final class MonochromeImage {
        final int width;
        final int height;
        final int[] pixels;

        MonochromeImage(int width, int height, int[] pixels) {
            this.width = width;
            this.height = height;
            this.pixels = pixels;
        }
    }

    public static final class BuildResult {
        public final byte[] bytes;
        public final int nativeTextCount;
        public final int rasterTextCount;
        public final int qrCodeCount;
        public final int barcodeCount;
        public final int imagePatchCount;
        public final int lineCount;
        public final int elementCount;

        public BuildResult(byte[] bytes, int nativeTextCount, int rasterTextCount, int qrCodeCount, int barcodeCount,
                    int imagePatchCount, int lineCount, int elementCount) {
            this.bytes = bytes == null ? new byte[0] : bytes;
            this.nativeTextCount = nativeTextCount;
            this.rasterTextCount = rasterTextCount;
            this.qrCodeCount = qrCodeCount;
            this.barcodeCount = barcodeCount;
            this.imagePatchCount = imagePatchCount;
            this.lineCount = lineCount;
            this.elementCount = elementCount;
        }
    }
}