王明 / Food-Labeling-Management-Platform

package com.foodlabel.nativeprinter;

import com.alibaba.fastjson.JSONObject;
import com.foodlabel.nativeprinter.debug.NativePrintDebugState;
import com.foodlabel.nativeprinter.support.PluginResult;
import com.foodlabel.nativeprinter.support.SafeJson;
import com.foodlabel.nativeprinter.support.ThrowableUtils;
import com.foodlabel.nativeprinter.template.NativeTemplateCommandBuilder;
import com.foodlabel.nativeprinter.transport.GprinterBluetoothTransport;
import com.foodlabel.nativeprinter.transport.UposBuiltinPrinterTransport;
import com.foodlabel.nativeprinter.transport.UposSerialPortTransport;
import com.taobao.weex.annotation.JSMethod;
import com.taobao.weex.bridge.JSCallback;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

import android.util.Base64;

import io.dcloud.feature.uniapp.common.UniModule;

public class NativeFastPrinterModule extends UniModule {
    private static final String BACKEND = "gprinter-sdk";
    private static final String PLUGIN_VERSION = "1.2.8";
    private static final String BUILD_TIME = String.valueOf(System.currentTimeMillis());
    private static final Object LOCK = new Object();
    private static final ExecutorService PRINT_EXECUTOR = Executors.newSingleThreadExecutor();
    private static final NativePrintDebugState DEBUG_STATE = new NativePrintDebugState(BACKEND, PLUGIN_VERSION);
    private static final GprinterBluetoothTransport BLUETOOTH_TRANSPORT = new GprinterBluetoothTransport();
    private static final UposBuiltinPrinterTransport UPOS_BUILTIN_TRANSPORT = new UposBuiltinPrinterTransport();
    private static final UposSerialPortTransport UPOS_SERIAL_TRANSPORT = new UposSerialPortTransport();
    /**
     * Some builds of NativePrintDebugState.attachTo() do not expose stage/lastError in JSON.
     * Keep an explicit copy here so JS can always read it for diagnosis.
     */
    private static volatile String LAST_STAGE = "";
    private static volatile String LAST_ERROR = "";
    private static volatile int LAST_COMMAND_BYTES = 0;
    private static volatile long LAST_WRITE_MS = 0L;

    private static void setStage(String stage) {
        LAST_STAGE = stage == null ? "" : stage;
        DEBUG_STATE.setStage(LAST_STAGE);
    }

    private static void setError(String error) {
        LAST_ERROR = error == null ? "" : error;
        DEBUG_STATE.setError(LAST_ERROR);
    }

    private static void clearError() {
        LAST_ERROR = "";
        DEBUG_STATE.clearError();
    }

    private static void setCommandBytes(int n) {
        LAST_COMMAND_BYTES = Math.max(0, n);
    }

    private static void setWriteMs(long ms) {
        LAST_WRITE_MS = Math.max(0L, ms);
    }

    private static final String[] SERIAL_PORT_CANDIDATES = new String[]{
            "/dev/ttyS1",
            "/dev/ttyS0",
            "/dev/ttyMSM0",
            "/dev/ttyMSM1",
            "/dev/ttyUSB0",
            "/dev/ttyACM0"
    };

    @JSMethod(uiThread = false)
    public void connect(JSONObject params, JSCallback callback) {
        String deviceId = SafeJson.getString(params, "deviceId", "");
        String deviceName = SafeJson.getString(params, "deviceName", "");
        PluginResult result = ensureConnected(deviceId, deviceName);
        if (callback != null) {
            callback.invoke(result.toJsonString());
        }
    }

    @JSMethod(uiThread = false)
    public void disconnect(JSCallback callback) {
        synchronized (LOCK) {
            BLUETOOTH_TRANSPORT.disconnect();
            DEBUG_STATE.clearCurrentDevice();
            setStage("disconnect:ok");
            clearError();
        }
        if (callback != null) {
            callback.invoke(debugResult(PluginResult.ok(false, "", "", "disconnect:ok")).toJsonString());
        }
    }

    @JSMethod(uiThread = false)
    public void isConnected(JSCallback callback) {
        boolean connected;
        synchronized (LOCK) {
            connected = BLUETOOTH_TRANSPORT.isConnected();
        }
        if (callback != null) {
            callback.invoke(debugResult(PluginResult.ok(connected, DEBUG_STATE.getCurrentDeviceId(), DEBUG_STATE.getCurrentDeviceName(), "isConnected:ok")).toJsonString());
        }
    }

    @JSMethod(uiThread = false)
    public void getDebugInfo(JSCallback callback) {
        boolean connected;
        synchronized (LOCK) {
            connected = BLUETOOTH_TRANSPORT.isConnected();
        }
        if (callback != null) {
            callback.invoke(debugResult(PluginResult.ok(connected, DEBUG_STATE.getCurrentDeviceId(), DEBUG_STATE.getCurrentDeviceName(), "debug:ok")).toJsonString());
        }
    }

    @JSMethod(uiThread = false)
    public void printTemplate(JSONObject params, JSCallback callback) {
        String deviceId = SafeJson.getString(params, "deviceId", "");
        String deviceName = SafeJson.getString(params, "deviceName", "");
        String templateJson = SafeJson.getString(params, "templateJson", "");
        String dataJson = SafeJson.getString(params, "dataJson", "{}");
        int dpi = SafeJson.getInt(params, "dpi", 203);
        int printQty = Math.max(1, SafeJson.getInt(params, "printQty", 1));
        String outputTransport = SafeJson.getString(params, "outputTransport", "bluetooth");
        final String uposPrefer = SafeJson.getString(params, "uposPrefer", "builtin");
        final String uposSerialPath = SafeJson.getString(params, "uposSerialPath", "");
        final int uposBaudrate = Math.max(1200, SafeJson.getInt(params, "uposBaudrate", 9600));
        final boolean useUpos = "upos".equalsIgnoreCase(outputTransport);

        if (templateJson == null || templateJson.trim().isEmpty()) {
            if (callback != null) {
                callback.invoke(errorResult(9011006, "Template json is empty.").toJsonString());
            }
            return;
        }

        if (!useUpos) {
            PluginResult connectResult = ensureConnected(deviceId, deviceName);
            if (!connectResult.success) {
                if (callback != null) callback.invoke(connectResult.toJsonString());
                return;
            }
        }

        setStage("printTemplate:queued");
        if (callback != null) {
            String did = useUpos ? "builtin-upos" : DEBUG_STATE.getCurrentDeviceId();
            String dname = useUpos ? "Built-in UPOS" : DEBUG_STATE.getCurrentDeviceName();
            callback.invoke(debugResult(PluginResult.ok(true, did, dname, "printTemplate:queued")).toJsonString());
        }

        PRINT_EXECUTOR.execute(new Runnable() {
            @Override
            public void run() {
                try {
                    DEBUG_STATE.resetBuildMetrics();
                    setStage("build-command");
                    long buildStarted = System.currentTimeMillis();
                    NativeTemplateCommandBuilder.BuildResult buildResult =
                            NativeTemplateCommandBuilder.buildWithStats(templateJson, dataJson, dpi, printQty);
                    DEBUG_STATE.setBuildMs(Math.max(0L, System.currentTimeMillis() - buildStarted));
                    DEBUG_STATE.setBuildResult(buildResult);

                    if (buildResult.bytes == null || buildResult.bytes.length == 0) {
                        setError("built command bytes empty");
                        setStage("printTemplate:error");
                        return;
                    }

                    if (useUpos) {
                        setCommandBytes(buildResult.bytes.length);
                        setStage("write-upos-command");
                        boolean ok = dispatchUposPrint(buildResult.bytes, uposPrefer, uposSerialPath, uposBaudrate);
                        if (!ok) {
                            setStage("printTemplate:error");
                            if (DEBUG_STATE.getLastError() == null || DEBUG_STATE.getLastError().isEmpty()) {
                                setError("upos write failed");
                            }
                            return;
                        }
                        DEBUG_STATE.markPrinted(System.currentTimeMillis());
                        setStage("printTemplate:ok");
                        clearError();
                        return;
                    }

                    long writeStarted = System.currentTimeMillis();
                    synchronized (LOCK) {
                        if (!BLUETOOTH_TRANSPORT.isConnected()) {
                            errorResult(9011005, "Bluetooth printer transport is not ready.");
                            return;
                        }
                        setStage("write-command");
                        boolean ok = BLUETOOTH_TRANSPORT.write(buildResult.bytes);
                        if (!ok) {
                            errorResult(9011011, "Printer writeDataImmediately returned false.");
                            return;
                        }
                    }
                    setCommandBytes(buildResult.bytes.length);
                    DEBUG_STATE.setWriteMs(Math.max(0L, System.currentTimeMillis() - writeStarted));
                    DEBUG_STATE.markPrinted(System.currentTimeMillis());
                    setStage("printTemplate:ok");
                    clearError();
                } catch (Throwable e) {
                    setError(ThrowableUtils.unwrap(e));
                    setStage("printTemplate:error");
                }
            }
        });
    }

    /**
     * 将 JS 侧已生成的 TSC/指令字节（Base64）经佳博 SDK 写出。
     * 用于整页光栅等路径，避免再走 JS 经典蓝牙 socket（慢、易超时）。
     */
    @JSMethod(uiThread = false)
    public void printCommandBytes(JSONObject params, JSCallback callback) {
        String deviceId = SafeJson.getString(params, "deviceId", "");
        String deviceName = SafeJson.getString(params, "deviceName", "");
        String base64 = SafeJson.getString(params, "base64", "");

        if (base64 == null || base64.trim().isEmpty()) {
            if (callback != null) {
                callback.invoke(errorResult(9011012, "base64 is empty.").toJsonString());
            }
            return;
        }

        PluginResult connectResult = ensureConnected(deviceId, deviceName);
        if (!connectResult.success) {
            if (callback != null) {
                callback.invoke(connectResult.toJsonString());
            }
            return;
        }

        setStage("printCommandBytes:queued");
        if (callback != null) {
            callback.invoke(debugResult(PluginResult.ok(true, DEBUG_STATE.getCurrentDeviceId(), DEBUG_STATE.getCurrentDeviceName(), "printCommandBytes:queued")).toJsonString());
        }

        PRINT_EXECUTOR.execute(new Runnable() {
            @Override
            public void run() {
                try {
                    byte[] bytes = Base64.decode(base64, Base64.DEFAULT);
                    if (bytes == null || bytes.length == 0) {
                        setError("decoded bytes empty");
                        setStage("printCommandBytes:error");
                        return;
                    }
                    long writeStarted = System.currentTimeMillis();
                    synchronized (LOCK) {
                        if (!BLUETOOTH_TRANSPORT.isConnected()) {
                            errorResult(9011005, "Bluetooth printer transport is not ready.");
                            return;
                        }
                        setStage("write-raw-command");
                        boolean ok = BLUETOOTH_TRANSPORT.write(bytes);
                        if (!ok) {
                            errorResult(9011011, "Printer writeDataImmediately returned false.");
                            return;
                        }
                    }
                    DEBUG_STATE.setWriteMs(Math.max(0L, System.currentTimeMillis() - writeStarted));
                    DEBUG_STATE.markPrinted(System.currentTimeMillis());
                    setStage("printCommandBytes:ok");
                    clearError();
                } catch (Throwable e) {
                    setError(ThrowableUtils.unwrap(e));
                    setStage("printCommandBytes:error");
                }
            }
        });
    }

    /**
     * UnifiedPOS SDK: built-in printer / serial port printing (no Bluetooth pairing).
     *
     * Params:
     * - base64: required, raw command bytes
     * - prefer: optional, "builtin" | "serial" (default builtin)
     * - serialPath: optional, e.g. "/dev/ttyS1"
     * - baudrate: optional, default 9600
     */
    @JSMethod(uiThread = false)
    public void printUposCommandBytes(JSONObject params, JSCallback callback) {
        String base64 = SafeJson.getString(params, "base64", "");
        String prefer = SafeJson.getString(params, "prefer", "builtin");
        String serialPath = SafeJson.getString(params, "serialPath", "");
        int baudrate = Math.max(1200, SafeJson.getInt(params, "baudrate", 9600));

        if (base64 == null || base64.trim().isEmpty()) {
            if (callback != null) {
                callback.invoke(errorResult(9011012, "base64 is empty.").toJsonString());
            }
            return;
        }

        setStage("printUposCommandBytes:queued");

        PRINT_EXECUTOR.execute(new Runnable() {
            @Override
            public void run() {
                try {
                    byte[] bytes = Base64.decode(base64, Base64.DEFAULT);
                    if (bytes == null || bytes.length == 0) {
                        setError("decoded bytes empty");
                        setStage("printUposCommandBytes:error");
                        return;
                    }
                    setCommandBytes(bytes.length);
                    boolean ok = dispatchUposPrint(bytes, prefer, serialPath, baudrate);
                    DEBUG_STATE.markPrinted(System.currentTimeMillis());
                    if (ok) {
                        setStage("printUposCommandBytes:ok");
                        clearError();
                        if (callback != null) {
                            callback.invoke(debugResult(PluginResult.ok(true, "", "", "printUposCommandBytes:ok")).toJsonString());
                        }
                    } else {
                        setStage("printUposCommandBytes:error");
                        if (DEBUG_STATE.getLastError() == null || DEBUG_STATE.getLastError().isEmpty()) {
                            setError("upos write failed");
                        }
                        if (callback != null) {
                            callback.invoke(errorResult(9011020, "UPOS print failed: " + DEBUG_STATE.getLastError()).toJsonString());
                        }
                    }
                } catch (Throwable e) {
                    setError(ThrowableUtils.unwrap(e));
                    setStage("printUposCommandBytes:error");
                    if (callback != null) {
                        callback.invoke(errorResult(9011021, "UPOS print exception: " + DEBUG_STATE.getLastError()).toJsonString());
                    }
                }
            }
        });
    }

    /**
     * 内置/串口 UPOS 写出（与 printUposCommandBytes 同源逻辑）。
     */
    private static boolean dispatchUposPrint(byte[] bytes, String prefer, String serialPath, int baudrate) {
        if (bytes == null || bytes.length == 0) {
            setError("bytes empty");
            return false;
        }
        long writeStarted = System.currentTimeMillis();
        boolean ok;
        if ("serial".equalsIgnoreCase(prefer)) {
            ok = writeBySerial(bytes, serialPath, baudrate);
        } else {
            ok = writeByBuiltinPrinter(bytes);
            if (!ok) {
                ok = writeBySerial(bytes, serialPath, baudrate);
            }
        }
        setWriteMs(Math.max(0L, System.currentTimeMillis() - writeStarted));
        return ok;
    }

    private static boolean writeByBuiltinPrinter(byte[] bytes) {
        try {
            setStage("upos:builtin:write");
            boolean ok = runUposWriteWithTimeout(new UposWriteOp() {
                @Override
                public boolean run() {
                    return UPOS_BUILTIN_TRANSPORT.write(bytes);
                }
            }, estimateUposWriteTimeoutMs(bytes == null ? 0 : bytes.length), "upos:builtin:write:timeout");
            if (!ok) {
                setError("upos builtin failed: " + UPOS_BUILTIN_TRANSPORT.getLastError());
            }
            return ok;
        } catch (Throwable e) {
            setError(ThrowableUtils.unwrap(e));
            return false;
        }
    }

    private static boolean writeBySerial(byte[] bytes, String path, int baudrate) {
        try {
            String usePath = (path != null && !path.trim().isEmpty()) ? path.trim() : null;
            if (usePath != null) {
                setStage("upos:serial:open:" + usePath);
                UPOS_SERIAL_TRANSPORT.close();
                if (!UPOS_SERIAL_TRANSPORT.open(usePath, baudrate)) {
                    setError("upos serial open failed: " + UPOS_SERIAL_TRANSPORT.getLastError());
                    return false;
                }
                setStage("upos:serial:write");
                boolean ok = runUposWriteWithTimeout(new UposWriteOp() {
                    @Override
                    public boolean run() {
                        return UPOS_SERIAL_TRANSPORT.write(bytes);
                    }
                }, estimateUposWriteTimeoutMs(bytes == null ? 0 : bytes.length), "upos:serial:write:timeout");
                if (!ok) setError("upos serial write failed: " + UPOS_SERIAL_TRANSPORT.getLastError());
                UPOS_SERIAL_TRANSPORT.close();
                return ok;
            }

            for (String candidate : SERIAL_PORT_CANDIDATES) {
                setStage("upos:serial:open:" + candidate);
                UPOS_SERIAL_TRANSPORT.close();
                if (!UPOS_SERIAL_TRANSPORT.open(candidate, baudrate)) {
                    continue;
                }
                setStage("upos:serial:write");
                boolean ok = runUposWriteWithTimeout(new UposWriteOp() {
                    @Override
                    public boolean run() {
                        return UPOS_SERIAL_TRANSPORT.write(bytes);
                    }
                }, estimateUposWriteTimeoutMs(bytes == null ? 0 : bytes.length), "upos:serial:write:timeout");
                if (!ok) {
                    UPOS_SERIAL_TRANSPORT.close();
                    continue;
                }
                UPOS_SERIAL_TRANSPORT.close();
                return true;
            }
            setError("upos serial open failed: no candidate ports worked");
            return false;
        } catch (Throwable e) {
            setError(ThrowableUtils.unwrap(e));
            return false;
        }
    }

    /**
     * UnifiedPOS/Serial 写入在部分机型/驱动上可能“卡死不返回且无异常”。
     * 为避免 JS Promise 长时间悬挂，增加超时保护：超时则尝试 close，并返回 false（上层会回调错误）。
     */
    private interface UposWriteOp {
        boolean run();
    }

    private static long estimateUposWriteTimeoutMs(int byteLen) {
        int n = Math.max(0, byteLen);
        // 基础 15s + 按体量加成（整页光栅可达数百 KB）；上限 3min，与 JS printUposCommandBytes 300s 对齐。
        long base = 15000L;
        long extra = (long) Math.min(150000L, (n / 1024L) * 900L);
        long ms = base + extra;
        if (ms < 15000L) ms = 15000L;
        if (ms > 180000L) ms = 180000L;
        return ms;
    }

    private static boolean runUposWriteWithTimeout(UposWriteOp op, long timeoutMs, String timeoutStage) {
        if (op == null) return false;
        final boolean[] done = new boolean[]{false};
        final boolean[] ok = new boolean[]{false};
        Thread t = new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    ok[0] = op.run();
                } catch (Throwable e) {
                    ok[0] = false;
                    setError(ThrowableUtils.unwrap(e));
                } finally {
                    done[0] = true;
                }
            }
        }, "upos-write");
        t.setDaemon(true);
        t.start();
        try {
            t.join(Math.max(1000L, timeoutMs));
        } catch (InterruptedException ignored) {
            // keep going
        }
        if (!done[0]) {
            setStage(timeoutStage);
            setError("upos write timeout");
            try {
                UPOS_SERIAL_TRANSPORT.close();
            } catch (Throwable ignored) {
            }
            try {
                UPOS_BUILTIN_TRANSPORT.close();
            } catch (Throwable ignored) {
            }
            return false;
        }
        return ok[0];
    }

    private PluginResult ensureConnected(String deviceId, String deviceName) {
        synchronized (LOCK) {
            PluginResult result = BLUETOOTH_TRANSPORT.ensureConnected(deviceId, deviceName, DEBUG_STATE);
            if (!result.success) {
                return debugResult(result);
            }
            return debugResult(PluginResult.ok(true, DEBUG_STATE.getCurrentDeviceId(), DEBUG_STATE.getCurrentDeviceName(), "connect:ok"));
        }
    }

    private static PluginResult errorResult(int code, String message) {
        setError(message == null ? "" : message);
        return debugResult(PluginResult.error(code, message));
    }

    private static PluginResult debugResult(PluginResult result) {
        PluginResult r = DEBUG_STATE.attachTo(result);
        // Always expose minimal diagnostics for JS (even if attachTo omits some fields).
        r.withMeta("backend", BACKEND)
                .withMeta("pluginVersion", PLUGIN_VERSION)
                .withMeta("buildTime", BUILD_TIME)
                .withMeta("stage", LAST_STAGE)
                .withMeta("lastError", LAST_ERROR)
                .withMeta("commandBytes", LAST_COMMAND_BYTES)
                .withMeta("writeMs", LAST_WRITE_MS);
        return r;
    }
}