FPSMS-backend/python/Bag4.py

#!/usr/bin/env python3
"""
Bag4 v4.0 – FPSMS job orders by plan date, with DataFlex expiry under Lot.

Uses the public API GET /py/job-orders and POST /py/job-order-print-submit (no login required).
Same as Bag3, plus expiry (today + defaultShelfLifeDays) on DataFlex ZPL and as the 4th laser TCP param.

Bag3 remains the line without expiry on DataFlex; do not share settings files.

Run: python Bag4.py
"""

import errno
import json
import os
import select
import socket
import sys
import tempfile
import threading
import time
import tkinter as tk
from dataclasses import dataclass
from datetime import date, datetime, timedelta
from tkinter import messagebox, ttk
from typing import Callable, Optional, Tuple

import requests

# UI "列印機" check uses short TCP probes; DataFlex may refuse connections briefly during E1005 recovery.
_DATAFLEX_RECOVERY_GRACE_UNTIL: float = 0.0


def touch_dataflex_recovery_grace(seconds: float = 22.0) -> None:
    """While host reset runs, avoid flashing printer status to red."""
    global _DATAFLEX_RECOVERY_GRACE_UNTIL
    u = time.time() + max(0.0, seconds)
    if u > _DATAFLEX_RECOVERY_GRACE_UNTIL:
        _DATAFLEX_RECOVERY_GRACE_UNTIL = u


try:
    import serial
except ImportError:
    serial = None  # type: ignore

try:
    import win32print  # type: ignore[import]
    import win32ui  # type: ignore[import]
    import win32con  # type: ignore[import]
    import win32gui  # type: ignore[import]
except ImportError:
    win32print = None  # type: ignore[assignment]
    win32ui = None  # type: ignore[assignment]
    win32con = None  # type: ignore[assignment]
    win32gui = None  # type: ignore[assignment]

try:
    from PIL import Image, ImageDraw, ImageFont, ImageOps
    try:
        from PIL import ImageWin  # type: ignore
    except Exception:
        ImageWin = None  # type: ignore[assignment]
    import qrcode
    _HAS_PIL_QR = True
except ImportError:
    Image = None  # type: ignore[assignment]
    ImageDraw = None  # type: ignore[assignment]
    ImageFont = None  # type: ignore[assignment]
    ImageOps = None  # type: ignore[assignment]
    ImageWin = None  # type: ignore[assignment]
    qrcode = None  # type: ignore[assignment]
    _HAS_PIL_QR = False

APP_VERSION = "4.0"

DEFAULT_BASE_URL = os.environ.get("FPSMS_BASE_URL", "http://localhost:8090/api")
# When run as PyInstaller exe, save settings next to the exe; otherwise next to script
if getattr(sys, "frozen", False):
    _SETTINGS_DIR = os.path.dirname(sys.executable)
else:
    _SETTINGS_DIR = os.path.dirname(os.path.abspath(__file__))
# Bag4 has its own settings file so it doesn't share with Bag1/Bag2/Bag3.
SETTINGS_FILE = os.path.join(_SETTINGS_DIR, "bag4_settings.json")
LASER_COUNTER_FILE = os.path.join(_SETTINGS_DIR, "bag4_last_batch_count.txt")

DEFAULT_SETTINGS = {
    "api_ip": "localhost",
    "api_port": "8090",
    "dabag_ip": "",
    "dabag_port": "3008",
    "laser_ip": "192.168.17.10",
    "laser_port": "45678",
    # For 標簽機 on Windows, this is the Windows printer name, e.g. "TSC TTP-246M Pro"
    "label_com": "TSC TTP-246M Pro",
}


def load_settings() -> dict:
    """Load settings from JSON file; return defaults if missing or invalid."""
    try:
        if os.path.isfile(SETTINGS_FILE):
            with open(SETTINGS_FILE, "r", encoding="utf-8") as f:
                data = json.load(f)
                return {**DEFAULT_SETTINGS, **data}
    except Exception:
        pass
    return dict(DEFAULT_SETTINGS)


def save_settings(settings: dict) -> None:
    """Save settings to JSON file."""
    with open(SETTINGS_FILE, "w", encoding="utf-8") as f:
        json.dump(settings, f, indent=2, ensure_ascii=False)


def build_base_url(api_ip: str, api_port: str) -> str:
    ip = (api_ip or "localhost").strip()
    port = (api_port or "8090").strip()
    return f"http://{ip}:{port}/api"


def try_printer_connection(printer_name: str, sett: dict) -> bool:
    """Try to connect to the selected printer (TCP IP:port or COM). Returns True if OK."""
    if printer_name == "打袋機 DataFlex":
        ip = (sett.get("dabag_ip") or "").strip()
        port_str = (sett.get("dabag_port") or "3008").strip()
        if not ip:
            return False
        try:
            port = int(port_str)
        except ValueError:
            return False
        # Retry once: firmware often busy for ~1s after E1005 / blank label.
        timeout = max(PRINTER_SOCKET_TIMEOUT, 6.0)
        for attempt in range(2):
            try:
                s = socket.create_connection((ip, port), timeout=timeout)
                s.close()
                return True
            except (socket.error, OSError):
                if attempt == 0:
                    time.sleep(0.35)
                continue
        return False
    if printer_name == "激光機":
        ip = (sett.get("laser_ip") or "").strip()
        port_str = (sett.get("laser_port") or "45678").strip()
        if not ip:
            return False
        try:
            port = int(port_str)
            s = socket.create_connection((ip, port), timeout=PRINTER_SOCKET_TIMEOUT)
            s.close()
            return True
        except (socket.error, ValueError, OSError):
            return False
    if printer_name == "標簽機":
        target = (sett.get("label_com") or "").strip()
        if not target:
            return False
        # On Windows, allow using a Windows printer name (e.g. "TSC TTP-246M Pro")
        # as an alternative to a COM port. If it doesn't look like a COM port,
        # try opening it via the Windows print spooler.
        if os.name == "nt" and not target.upper().startswith("COM"):
            if win32print is None:
                return False
            try:
                handle = win32print.OpenPrinter(target)
                win32print.ClosePrinter(handle)
                return True
            except Exception:
                return False
        # Fallback: treat as serial COM port (original behaviour)
        if serial is None:
            return False
        try:
            ser = serial.Serial(target, timeout=1)
            ser.close()
            return True
        except (serial.SerialException, OSError):
            return False
    return False

# Larger font for aged users (point size)
FONT_SIZE = 16
FONT_SIZE_BUTTONS = 15
# Printer selector: field + dropdown (use tk.OptionMenu so menu font is respected on Windows)
FONT_SIZE_COMBO = 18
FONT_SIZE_QTY = 12  # smaller for 需求數量 under batch no.
FONT_SIZE_META = 11  # single-line 需求／已印 (compact list)
# Less vertical padding so ~30 rows fit more comfortably
LIST_ROW_PADY = 2
LIST_ROW_IPADY = 5
FONT_SIZE_ITEM = 20  # item code and item name (larger for readability)
FONT_FAMILY = "Microsoft JhengHei UI"  # Traditional Chinese; fallback to TkDefaultFont
FONT_SIZE_ITEM_CODE = 20  # item code (larger for readability)
FONT_SIZE_ITEM_NAME = 26  # item name (bigger than item code)
# Column widths: fixed frame widths so 品號/品名 columns line up across rows
LEFT_COL_WIDTH_PX = 300   # 工單 + 需求／已印 block
ITEM_CODE_WRAP = 140      # Label wraplength (px)
# Narrower than wrap+padding so short codes sit closer to 品名 (still aligned across rows)
CODE_COL_WIDTH_PX = ITEM_CODE_WRAP + 6
ITEM_NAME_WRAP = 640      # item name wraps in remaining space

# Light blue theme (softer than pure grey)
BG_TOP = "#E8F4FC"
BG_LIST = "#D4E8F7"
BG_ROOT = "#E1F0FF"
BG_ROW = "#C5E1F5"
BG_ROW_SELECTED = "#6BB5FF"  # highlighted when selected (for printing)
# Connection status bar
BG_STATUS_ERROR = "#FFCCCB"   # red background when disconnected
FG_STATUS_ERROR = "#B22222"   # red text
BG_STATUS_OK = "#90EE90"     # light green when connected
FG_STATUS_OK = "#006400"      # green text
RETRY_MS = 30 * 1000          # 30 seconds reconnect
# POST /py/job-order-print-submit: retries when server is briefly unavailable
PRINT_SUBMIT_MAX_ATTEMPTS = 5
PRINT_SUBMIT_RETRY_DELAY_SEC = 1.5
PRINTER_CHECK_MS = 60 * 1000  # 1 minute when printer OK
PRINTER_RETRY_MS = 30 * 1000  # 30 seconds when printer failed
PRINTER_SOCKET_TIMEOUT = 3
DATAFLEX_SEND_TIMEOUT = 10  # seconds when sending ZPL to DataFlex


def _dataflex_float_env(name: str, default: float) -> float:
    raw = (os.environ.get(name) or "").strip()
    if not raw:
        return default
    try:
        return float(raw)
    except ValueError:
        return default


def _dataflex_bool_env(name: str, default: bool) -> bool:
    raw = (os.environ.get(name) or "").strip().lower()
    if not raw:
        return default
    return raw in ("1", "true", "yes", "on")


def _dataflex_int_env(name: str, default: int) -> int:
    raw = (os.environ.get(name) or "").strip()
    if not raw:
        return default
    try:
        return int(raw)
    except ValueError:
        return default


# Job list auto-refresh interval (ms). 0 = off (list rebuild can hide DataFlex「停止列印」).
# Re-enable: FPSMS_JOB_LIST_REFRESH_MS=60000
JOB_LIST_AUTO_REFRESH_MS = max(0, _dataflex_int_env("FPSMS_JOB_LIST_REFRESH_MS", 0))
# Defer full list rebuild while printing; retry after this interval until idle. FPSMS_JOB_LIST_DEFER_WHILE_PRINTING_MS
JOB_LIST_DEFER_WHILE_PRINTING_MS = max(
    500,
    _dataflex_int_env("FPSMS_JOB_LIST_DEFER_WHILE_PRINTING_MS", 1500),
)


# Gap between bag labels (after each job has fully left the client). Tune if bags are blank/skipped.
# Override: FPSMS_DATAFLEX_INTER_LABEL_DELAY_SEC (e.g. 3.5 if ~3–5% blanks per 100).
DATAFLEX_INTER_LABEL_DELAY_SEC = _dataflex_float_env(
    "FPSMS_DATAFLEX_INTER_LABEL_DELAY_SEC", 0.3
)
# Brief pause after each ZPL send so firmware can commit before we FIN the socket (reduces dropped/blank jobs).
# Override: FPSMS_DATAFLEX_POST_LABEL_SETTLE_SEC
DATAFLEX_POST_LABEL_SETTLE_SEC = _dataflex_float_env(
    "FPSMS_DATAFLEX_POST_LABEL_SETTLE_SEC", 0.08
)
# Before each print job: light reset only (~JA + ~RO). Must finish before first ^XA or first label can be lost.
# Override: FPSMS_DATAFLEX_POST_PREPRINT_DELAY_SEC
DATAFLEX_PREPRINT_BYTES = b"~JA\r\n~RO1\r\n~RO2\r\n"
DATAFLEX_POST_PREPRINT_DELAY_SEC = _dataflex_float_env(
    "FPSMS_DATAFLEX_POST_PREPRINT_DELAY_SEC", 0.55
)
# Whether each new print job starts with full reset (~JR) so DataFlex batch counter returns to 0.
# Set FPSMS_DATAFLEX_FULL_RESET_EACH_JOB=0 to keep only light preprint reset.
DATAFLEX_FULL_RESET_EACH_JOB = _dataflex_bool_env(
    "FPSMS_DATAFLEX_FULL_RESET_EACH_JOB", False
)
# Extra-safe mode: run light preprint reset (~JA/~RO) before EVERY bag.
# Slower, but reduces E1005 on unstable firmware.
DATAFLEX_PREPRINT_EACH_LABEL = _dataflex_bool_env(
    "FPSMS_DATAFLEX_PREPRINT_EACH_LABEL", False
)
DATAFLEX_VERIFY_STATUS_AFTER_SEND = _dataflex_bool_env(
    "FPSMS_DATAFLEX_VERIFY_STATUS_AFTER_SEND", False
)
# Hard-disable automatic reset/counter commands during printing.
# When False, normal print path sends ZPL only (no ~JA/~RO/~JR).
DATAFLEX_AUTO_RESET_ENABLED = _dataflex_bool_env(
    "FPSMS_DATAFLEX_AUTO_RESET_ENABLED", False
)
# After a failed TCP send, always run host recovery + retry (recommended when E1005 stops the run).
DATAFLEX_RECOVER_ON_SEND_ERROR = _dataflex_bool_env(
    "FPSMS_DATAFLEX_RECOVER_ON_SEND_ERROR", True
)
DATAFLEX_STATUS_QUERY_TIMEOUT_SEC = _dataflex_float_env(
    "FPSMS_DATAFLEX_STATUS_QUERY_TIMEOUT_SEC", 0.8
)
DATAFLEX_RECOVERY_MAX_ATTEMPTS = max(
    1,
    _dataflex_int_env("FPSMS_DATAFLEX_RECOVERY_MAX_ATTEMPTS", 2),
)
DATAFLEX_RECOVERY_WAIT_SEC = _dataflex_float_env(
    "FPSMS_DATAFLEX_RECOVERY_WAIT_SEC", 0.8
)
# Prevent cumulative thermal/mechanical fault in long runs (E1000 after ~40 bags on some units):
# pause briefly every N bags.
DATAFLEX_COOLDOWN_EVERY_LABELS = max(
    0,
    _dataflex_int_env("FPSMS_DATAFLEX_COOLDOWN_EVERY_LABELS", 8),
)
DATAFLEX_COOLDOWN_SEC = _dataflex_float_env(
    "FPSMS_DATAFLEX_COOLDOWN_SEC", 3.5
)
# Extra long pause every M bags (head cool-down). 0 = off. FPSMS_DATAFLEX_THERMAL_REST_EVERY_LABELS
DATAFLEX_THERMAL_REST_EVERY_LABELS = max(
    0,
    _dataflex_int_env("FPSMS_DATAFLEX_THERMAL_REST_EVERY_LABELS", 20),
)
DATAFLEX_THERMAL_REST_SEC = _dataflex_float_env(
    "FPSMS_DATAFLEX_THERMAL_REST_SEC", 5.0
)
# Light ~HS check every N bags. Default off — periodic checks + recovery caused long stalls with E1005 on some units.
DATAFLEX_VERIFY_EVERY_LABELS = max(
    0,
    _dataflex_int_env("FPSMS_DATAFLEX_VERIFY_EVERY_LABELS", 0),
)
# Status bar progress while printing (main thread). 0 = off.
DATAFLEX_UI_PROGRESS_EVERY = max(
    0,
    _dataflex_int_env("FPSMS_DATAFLEX_UI_PROGRESS_EVERY", 5),
)
# One TCP send: single ZPL with ^PQn (n identical bags). Some DataFlex units may fault (E1005); default off.
DATAFLEX_SINGLE_TCP_JOB = _dataflex_bool_env(
    "FPSMS_DATAFLEX_SINGLE_TCP_JOB", False
)
# Link-OS SGD: raw-ZPL job shows this host id instead of a generic name (e.g. "ZPL. EMULATION").
# Same id when the same job order is printed again. Disable: FPSMS_DATAFLEX_HOST_IDENTIFICATION_SGD=0
DATAFLEX_HOST_IDENTIFICATION_SGD = _dataflex_bool_env(
    "FPSMS_DATAFLEX_HOST_IDENTIFICATION_SGD", True
)
# Bag ZPL size (dots). ^PW700 matched little content (mostly vertical ^A@R), so previews showed a wide strip with empty right margin.
DATAFLEX_LABEL_PW = max(
    280,
    _dataflex_int_env("FPSMS_DATAFLEX_LABEL_PW", 400),
)
DATAFLEX_LABEL_LL = max(
    200,
    _dataflex_int_env("FPSMS_DATAFLEX_LABEL_LL", 500),
)
# Some Zebra/DataFlex units RST the socket on host half-close; Windows surfaces WinError 10054.
# Set FPSMS_DATAFLEX_SKIP_SHUTDOWN_WR=1 to omit shutdown(SHUT_WR) and only close() (often avoids RST).
DATAFLEX_SKIP_SHUTDOWN_WR = _dataflex_bool_env(
    "FPSMS_DATAFLEX_SKIP_SHUTDOWN_WR", False
)
# Full recovery (~JR soft reset) — used by「打袋重設」only; longer delay for firmware
DATAFLEX_POST_FULL_RECOVERY_DELAY_SEC = 1.2
# Zebra ~RO only (used when FPSMS_DATAFLEX_NO_JR is set for full recovery)
DATAFLEX_RESET_BYTES = b"~RO1\r\n~RO2\r\n"
# Full host recovery: ~JA clear buffers, ~RO counters, ~JR soft reset (clears latched errors without power cycle)
DATAFLEX_FULL_RECOVERY_BYTES = b"~JA\r\n~RO1\r\n~RO2\r\n~JR\r\n"


def _dataflex_full_recovery_payload() -> bytes:
    """~JA+~RO+~JR for manual「打袋重設」; set env FPSMS_DATAFLEX_NO_JR=1 to skip ~JR."""
    if os.environ.get("FPSMS_DATAFLEX_NO_JR", "").strip().lower() in ("1", "true", "yes"):
        return b"~JA\r\n" + DATAFLEX_RESET_BYTES
    return DATAFLEX_FULL_RECOVERY_BYTES


def _zpl_escape(s: str) -> str:
    """Escape text for ZPL ^FD...^FS (backslash and caret)."""
    return s.replace("\\", "\\\\").replace("^", "\\^")


def _dataflex_host_identification_sgd_prefix(job_order_id: Optional[int]) -> str:
    """
    Optional ASCII prefix before ^XA: set zpl.host_identification so the printer lists the job
    under the job order id instead of a generic raw-ZPL label.
    """
    if not DATAFLEX_HOST_IDENTIFICATION_SGD or job_order_id is None:
        return ""
    try:
        jid = str(int(job_order_id))
    except (TypeError, ValueError):
        return ""
    if not jid.isdigit():
        return ""
    return f'! U1 setvar "zpl.host_identification" "{jid}"\r\n'


def _dataflex_zpl_bytes(zpl: str) -> bytes:
    """UTF-8 ZPL with one trailing CRLF so the printer sees a clear job boundary."""
    s = (zpl or "").rstrip("\r\n")
    return (s + "\r\n").encode("utf-8")


def _dataflex_is_benign_tcp_reset(err: BaseException) -> bool:
    """True when peer closed with RST/FIN in a way that is normal for raw printer TCP (Windows 10054)."""
    if isinstance(err, (BrokenPipeError, ConnectionResetError, ConnectionAbortedError)):
        return True
    if isinstance(err, OSError):
        if getattr(err, "winerror", None) == 10054:  # WSAECONNRESET
            return True
        if err.errno in (
            errno.ECONNRESET,
            errno.EPIPE,
            errno.ECONNABORTED,
        ):
            return True
    return False


def _dataflex_shutdown_write_maybe(sock: socket.socket) -> None:
    """Half-close write side; ignore printer RST (common after ZPL on port 9100-style links)."""
    if DATAFLEX_SKIP_SHUTDOWN_WR:
        return
    try:
        sock.shutdown(socket.SHUT_WR)
    except OSError as e:
        if _dataflex_is_benign_tcp_reset(e):
            return
        raise


def format_expiry_print_label(d: date) -> str:
    """Printed bag wording, e.g. Expiry Date 20260821."""
    return f"Expiry Date {d.strftime('%Y%m%d')}"


def job_expiry_zpl_text(jo: dict) -> Optional[str]:
    """Expiry yyyyMMdd from print-time shelf life days, else API expiryDate."""
    days = jo.get("defaultShelfLifeDays")
    if isinstance(days, bool):
        days = None
    if isinstance(days, float) and days.is_integer():
        days = int(days)
    if isinstance(days, int) and days > 0:
        return format_expiry_print_label(date.today() + timedelta(days=days))
    iso = jo.get("expiryDate")
    if iso:
        s = str(iso).strip()[:10]
        try:
            y, m, day = (int(p) for p in s.split("-"))
            return format_expiry_print_label(date(y, m, day))
        except ValueError:
            return None
    return None


def job_expiry_laser_param(jo: dict) -> str:
    """Same expiry as DataFlex ZPL, sanitized for `;`-separated laser TCP."""
    return (job_expiry_zpl_text(jo) or "").replace(";", ",")


def generate_zpl_dataflex(
    batch_no: str,
    item_code: str,
    item_name: str,
    item_id: Optional[int] = None,
    stock_in_line_id: Optional[int] = None,
    lot_no: Optional[str] = None,
    job_order_id: Optional[int] = None,
    expiry_text: Optional[str] = None,
    font_regular: str = "E:STXihei.ttf",
    font_bold: str = "E:STXihei.ttf",
) -> str:
    """
    Row 1 (from zero): QR code, then item name (rotated 90°).
    Row 2: smaller Lot, then expiry at the next X, then item code.
    Text is ^A@R (90° CW); the next line under Lot is +X, not +Y.
    Label and QR use lotNo from API when present, else batch_no (Bxxxxx).
    Light preprint (~JA/~RO) is sent before labels; full ~JR recovery is only for「打袋重設」.
    """
    desc = _zpl_escape((item_name or "—").strip())
    code = _zpl_escape((item_code or "—").strip())
    label_line = (lot_no or batch_no or "").strip()
    label_esc = _zpl_escape(label_line)
    exp_raw = (expiry_text or "").strip()
    exp_esc = _zpl_escape(exp_raw) if exp_raw else ""
    # QR payload: prefer JSON {"itemId":..., "stockInLineId":...} when both present; else fall back to lot/batch text
    if item_id is not None and stock_in_line_id is not None:
        qr_payload = json.dumps({"itemId": item_id, "stockInLineId": stock_in_line_id})
    else:
        qr_payload = label_line if label_line else batch_no.strip()
    qr_value = _zpl_escape(qr_payload)
    # Explicit ^PQ1: each ^XA…^XZ is exactly one bag. Avoids E1005 "over quantity" on some Zebra/DataFlex
    # firmware when many labels are sent on one TCP session without a per-job quantity.
    host_id = _dataflex_host_identification_sgd_prefix(job_order_id)
    if exp_esc:
        row2 = f"""^FO0,200
^A@R,40,40,{font_regular}^FD{label_esc}^FS
^FO42,200
^A@R,40,40,{font_regular}^FD{exp_esc}^FS
^FO88,200
^A@R,88,88,{font_bold}^FD{code}^FS"""
    else:
        row2 = f"""^FO0,200
^A@R,72,72,{font_regular}^FD{label_esc}^FS
^FO55,200
^A@R,88,88,{font_bold}^FD{code}^FS"""
    return host_id + f"""^XA
^PQ1,0,1,N
^CI28
^PW{DATAFLEX_LABEL_PW}
^LL{DATAFLEX_LABEL_LL}
^PO N
^FO10,20
^BQN,2,4^FDQA,{qr_value}^FS
^FO170,20
^A@R,72,72,{font_regular}^FD{desc}^FS
{row2}
^XZ"""


def dataflex_zpl_set_print_quantity(zpl: str, copies: int) -> str:
    """
    Replace the fixed ^PQ1 line from generate_zpl_dataflex() with ^PQn so one ZPL job prints
    n identical bags over one TCP connection.
    """
    if copies < 1:
        copies = 1
    old = "^PQ1,0,1,N"
    if old not in zpl:
        raise RuntimeError(
            "DataFlex ZPL 缺少預期的 ^PQ1 列（無法改為單次連線多張）。"
        )
    return zpl.replace(old, f"^PQ{copies},0,1,N", 1)


def send_dataflex_preprint_reset(ip: str, port: int, *, force: bool = False) -> None:
    """
    Fast prep before printing: ~JA + ~RO (no ~JR). Clears buffer and zeros batch counters so the first
    bag starts quickly. Use before fixed-qty batch and continuous mode.
    """
    if not force and not DATAFLEX_AUTO_RESET_ENABLED:
        return
    sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    try:
        sock.setsockopt(socket.IPPROTO_TCP, socket.TCP_NODELAY, 1)
    except OSError:
        pass
    sock.settimeout(DATAFLEX_SEND_TIMEOUT)
    try:
        sock.connect((ip, port))
        sock.sendall(DATAFLEX_PREPRINT_BYTES)
        time.sleep(DATAFLEX_POST_PREPRINT_DELAY_SEC)
        _dataflex_shutdown_write_maybe(sock)
    finally:
        sock.close()


def send_dataflex_job_counter_reset(ip: str, port: int, *, force: bool = False) -> None:
    """
    Full host recovery for「打袋重設」: ~JA, ~RO, and ~JR (soft reset) to clear latched E1005.
    Slower than [send_dataflex_preprint_reset]; do not use on every row click.
    """
    if not force and not DATAFLEX_AUTO_RESET_ENABLED:
        return
    sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    try:
        sock.setsockopt(socket.IPPROTO_TCP, socket.TCP_NODELAY, 1)
    except OSError:
        pass
    sock.settimeout(DATAFLEX_SEND_TIMEOUT)
    try:
        sock.connect((ip, port))
        sock.sendall(_dataflex_full_recovery_payload())
        time.sleep(DATAFLEX_POST_FULL_RECOVERY_DELAY_SEC)
        _dataflex_shutdown_write_maybe(sock)
    finally:
        sock.close()


def send_dataflex_start_job_reset(ip: str, port: int, *, force: bool = False) -> None:
    """
    Start-of-job reset sequence.

    Full reset first (default) ensures printer-side batch quantity returns to 0 for each job;
    then light preprint reset prepares the first bag send.

    Use force=True for the start of each print job and when selecting a job row so batch
    counter resets even if FPSMS_DATAFLEX_AUTO_RESET_ENABLED=0 (that flag mainly gates
    extra per-label / recovery traffic).
    """
    if not force and not DATAFLEX_AUTO_RESET_ENABLED:
        return
    if DATAFLEX_FULL_RESET_EACH_JOB:
        send_dataflex_job_counter_reset(ip, port, force=force)
    send_dataflex_preprint_reset(ip, port, force=force)


def send_dataflex_reset_and_labels(
    ip: str,
    port: int,
    zpl: str,
    copies: int,
    delay_sec: float,
) -> None:
    """
    One TCP connection: light preprint (~JA + ~RO), short pause, then `copies` identical ZPL labels
    with delay_sec between copies (not after the last). Avoids rapid connect/disconnect per bag.
    """
    if copies < 1:
        return
    raw_zpl = _dataflex_zpl_bytes(zpl)
    sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    try:
        sock.setsockopt(socket.IPPROTO_TCP, socket.TCP_NODELAY, 1)
    except OSError:
        pass
    sock.settimeout(DATAFLEX_SEND_TIMEOUT)
    try:
        sock.connect((ip, port))
        sock.sendall(DATAFLEX_PREPRINT_BYTES)
        time.sleep(DATAFLEX_POST_PREPRINT_DELAY_SEC)
        for i in range(copies):
            sock.sendall(raw_zpl)
            time.sleep(DATAFLEX_POST_LABEL_SETTLE_SEC)
            if i < copies - 1:
                time.sleep(delay_sec)
        _dataflex_shutdown_write_maybe(sock)
    finally:
        sock.close()


def generate_zpl_label_small(
    batch_no: str,
    item_code: str,
    item_name: str,
    item_id: Optional[int] = None,
    stock_in_line_id: Optional[int] = None,
    lot_no: Optional[str] = None,
    font: str = "MingLiUHKSCS",
) -> str:
    """
    ZPL for 標簽機. Row 1: item name. Row 2: QR left | item code + lot no (or batch) right.
    QR contains {"itemId": xxx, "stockInLineId": xxx} when both present; else batch_no.
    Unicode (^CI28); font set for Big-5 (e.g. MingLiUHKSCS).
    """
    desc = _zpl_escape((item_name or "—").strip())
    code = _zpl_escape((item_code or "—").strip())
    label_line2 = (lot_no or batch_no or "—").strip()
    label_line2_esc = _zpl_escape(label_line2)
    if item_id is not None and stock_in_line_id is not None:
        qr_data = _zpl_escape(json.dumps({"itemId": item_id, "stockInLineId": stock_in_line_id}))
    else:
        qr_data = f"QA,{batch_no}"
    return f"""^XA
^CI28
^PW500
^LL500
^FO10,15
^FB480,3,0,L,0
^A@N,38,38,{font}^FD{desc}^FS
^FO10,110
^BQN,2,6^FD{qr_data}^FS
^FO150,110
^A@N,48,48,{font}^FD{code}^FS
^FO150,175
^A@N,40,40,{font}^FD{label_line2_esc}^FS
^XZ"""


# Label image size (pixels) for 標簽機 image printing.
# Enlarged for readability (approx +90% scale).
LABEL_IMAGE_W = 720
LABEL_IMAGE_H = 530
LABEL_PADDING = 23
LABEL_FONT_NAME_SIZE = 42
LABEL_FONT_CODE_SIZE = 49
LABEL_FONT_BATCH_SIZE = 34
LABEL_QR_SIZE = 210


def _get_chinese_font(size: int) -> Optional["ImageFont.FreeTypeFont"]:
    """Return a Chinese-capable font for PIL, or None to use default."""
    if ImageFont is None:
        return None
    # Prefer real font files on Windows (font *names* may fail and silently fallback).
    if os.name == "nt":
        fonts_dir = os.path.join(os.environ.get("WINDIR", r"C:\Windows"), "Fonts")
        for rel in (
            "msjh.ttc",   # Microsoft JhengHei
            "msjhl.ttc",  # Microsoft JhengHei Light
            "msjhbd.ttc", # Microsoft JhengHei Bold
            "mingliu.ttc",
            "mingliub.ttc",
            "kaiu.ttf",
            "msyh.ttc",   # Microsoft YaHei
            "msyhbd.ttc",
            "simhei.ttf",
            "simsun.ttc",
        ):
            p = os.path.join(fonts_dir, rel)
            try:
                if os.path.exists(p):
                    return ImageFont.truetype(p, size)
            except (OSError, IOError):
                continue
    # Fallback: try common font names (may still work depending on Pillow build)
    for name in (
        "Microsoft JhengHei UI",
        "Microsoft JhengHei",
        "MingLiU",
        "MingLiU_HKSCS",
        "Microsoft YaHei",
        "SimHei",
        "SimSun",
    ):
        try:
            return ImageFont.truetype(name, size)
        except (OSError, IOError):
            continue
    try:
        return ImageFont.load_default()
    except Exception:
        return None


def render_label_to_image(
    batch_no: str,
    item_code: str,
    item_name: str,
    item_id: Optional[int] = None,
    stock_in_line_id: Optional[int] = None,
    lot_no: Optional[str] = None,
) -> "Image.Image":
    """
    Render 標簽機 label as a PIL Image (white bg, black text + QR).
    Use this image for printing so Chinese displays correctly; words are drawn bigger.
    Requires Pillow and qrcode. Raises RuntimeError if not available.
    """
    if not _HAS_PIL_QR or Image is None or qrcode is None:
        raise RuntimeError("Pillow and qrcode are required for image labels. Run: pip install Pillow qrcode[pil]")
    img = Image.new("RGB", (LABEL_IMAGE_W, LABEL_IMAGE_H), "white")
    draw = ImageDraw.Draw(img)
    # QR payload (same as ZPL)
    if item_id is not None and stock_in_line_id is not None:
        qr_data = json.dumps({"itemId": item_id, "stockInLineId": stock_in_line_id})
    else:
        qr_data = f"QA,{batch_no}"
    # Draw QR top-left area
    qr = qrcode.QRCode(box_size=4, border=2)
    qr.add_data(qr_data)
    qr.make(fit=True)
    qr_img = qr.make_image(fill_color="black", back_color="white")
    _resample = getattr(Image, "Resampling", Image).NEAREST
    qr_img = qr_img.resize((LABEL_QR_SIZE, LABEL_QR_SIZE), _resample)
    img.paste(qr_img, (LABEL_PADDING, LABEL_PADDING))
    # Fonts (bigger for readability)
    font_name = _get_chinese_font(LABEL_FONT_NAME_SIZE)
    font_code = _get_chinese_font(LABEL_FONT_CODE_SIZE)
    font_batch = _get_chinese_font(LABEL_FONT_BATCH_SIZE)
    x_right = LABEL_PADDING + LABEL_QR_SIZE + LABEL_PADDING
    y_line = LABEL_PADDING
    # Line 1: item name (wrap within remaining width)
    name_str = (item_name or "—").strip()
    max_name_w = LABEL_IMAGE_W - x_right - LABEL_PADDING
    if font_name:
        # Wrap rule: after 7 "words" (excl. parentheses). ()（） not counted; +=*/. and A–Z/a–z count as 0.5.
        def _wrap_text(text: str, font, max_width: int) -> list:
            ignore = set("()（）")
            half = set("+=*/.abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ")
            max_count = 6.5
            lines: list[str] = []
            current: list[str] = []
            count = 0.0

            for ch in text:
                if ch == "\n":
                    lines.append("".join(current).strip())
                    current = []
                    count = 0.0
                    continue

                ch_count = 0.0 if ch in ignore else (0.5 if ch in half else 1.0)
                if count + ch_count > max_count and current:
                    lines.append("".join(current).strip())
                    current = []
                    count = 0.0

                current.append(ch)
                count += ch_count

            if current:
                lines.append("".join(current).strip())

            # Max 2 rows for item name. If still long, keep everything in row 2.
            if len(lines) > 2:
                lines = [lines[0], "".join(lines[1:]).strip()]

            # Safety: if any line still exceeds pixel width, wrap by width as well.
            if hasattr(draw, "textbbox"):
                out: list[str] = []
                for ln in lines:
                    buf: list[str] = []
                    for ch in ln:
                        buf.append(ch)
                        bbox = draw.textbbox((0, 0), "".join(buf), font=font)
                        if bbox[2] - bbox[0] > max_width and len(buf) > 1:
                            out.append("".join(buf[:-1]).strip())
                            buf = [buf[-1]]
                    if buf:
                        out.append("".join(buf).strip())
                out = [x for x in out if x]
                if len(out) > 2:
                    out = [out[0], "".join(out[1:]).strip()]
                return out

            lines = [x for x in lines if x]
            if len(lines) > 2:
                lines = [lines[0], "".join(lines[1:]).strip()]
            return lines
        lines = _wrap_text(name_str, font_name, max_name_w)
        for i, ln in enumerate(lines):
            draw.text((x_right, y_line + i * (LABEL_FONT_NAME_SIZE + 4)), ln, font=font_name, fill="black")
        y_line += len(lines) * (LABEL_FONT_NAME_SIZE + 4) + 8
    else:
        draw.text((x_right, y_line), name_str[:30], fill="black")
        y_line += LABEL_FONT_NAME_SIZE + 12
    # Item code (bigger)
    code_str = (item_code or "—").strip()
    if font_code:
        draw.text((x_right, y_line), code_str, font=font_code, fill="black")
    else:
        draw.text((x_right, y_line), code_str, fill="black")
    y_line += LABEL_FONT_CODE_SIZE + 6
    # Batch/lot line
    batch_str = (lot_no or batch_no or "—").strip()
    if font_batch:
        draw.text((x_right, y_line), batch_str, font=font_batch, fill="black")
    else:
        draw.text((x_right, y_line), batch_str, fill="black")
    return img


def _image_to_zpl_gfa(pil_image: "Image.Image") -> str:
    """
    Convert a PIL image into ZPL ^GFA (ASCII hex) so we can print Chinese reliably
    on ZPL printers (USB/Windows printer or COM) without relying on GDI drivers.
    """
    if Image is None or ImageOps is None:
        raise RuntimeError("Pillow is required for image-to-ZPL conversion.")
    # Convert to 1-bit monochrome bitmap. Invert so '1' bits represent black in ZPL.
    img_bw = ImageOps.invert(pil_image.convert("L")).convert("1")
    w, h = img_bw.size
    bytes_per_row = (w + 7) // 8
    raw = img_bw.tobytes()
    total = bytes_per_row * h
    # Ensure length matches expected (Pillow should already pack per row).
    if len(raw) != total:
        raw = raw[:total].ljust(total, b"\x00")
    hex_data = raw.hex().upper()
    return f"""^XA
^PW{w}
^LL{h}
^FO0,0
^GFA,{total},{total},{bytes_per_row},{hex_data}
^FS
^XZ"""


def zpl_apply_print_quantity(zpl: str, copies: int) -> str:
    """
    Ask the printer to output `copies` identical labels from one ZPL format by inserting ^PQ after ^XA.
    Results in a **single** spool job / one write — no N separate Windows jobs, no chained ^XA blocks
    (which broke some TSC drivers with white-on-white ^GFA output).
    """
    if copies <= 1:
        return zpl
    first_fmt = zpl.split("^XZ", 1)[0] if "^XZ" in zpl else zpl
    if "^PQ" in first_fmt.upper():
        return zpl
    lines = zpl.splitlines()
    new_lines: list[str] = []
    inserted = False
    for line in lines:
        new_lines.append(line)
        if not inserted and line.strip() == "^XA":
            # ZPL II: q labels, 0 pause between, 1 replicate (non-serial), N = default options.
            # Same graphic (^GFA) is repeated q times — e.g. 需求數量 150 → 150 identical labels, one spool job.
            new_lines.append(f"^PQ{copies},0,1,N")
            inserted = True
    if not inserted:
        raise RuntimeError(
            "標籤 ZPL 無法插入 ^PQ（格式非預期）。請聯絡程式維護。"
        )
    ending = "\n" if zpl.endswith("\n") else ""
    return "\n".join(new_lines) + ending


def send_image_to_label_printer(printer_name: str, pil_image: "Image.Image") -> None:
    """
    Send a PIL Image to 標簽機 via Windows GDI (so Chinese and graphics print correctly).
    Only supported when target is a Windows printer name (not COM port). Requires pywin32.
    """
    dest = (printer_name or "").strip()
    if not dest:
        raise ValueError("Label printer destination is empty.")
    if os.name != "nt" or dest.upper().startswith("COM"):
        raise RuntimeError("Image printing is only supported for a Windows printer name (e.g. TSC TTP-246M Pro).")
    if win32print is None or win32ui is None or win32con is None or win32gui is None:
        raise RuntimeError("pywin32 is required. Run: pip install pywin32")
    dc = win32ui.CreateDC()
    dc.CreatePrinterDC(dest)
    dc.StartDoc("FPSMS Label")
    dc.StartPage()
    try:
        bmp_w = pil_image.width
        bmp_h = pil_image.height
        # Scale-to-fit printable area (important for smaller physical labels).
        try:
            page_w = int(dc.GetDeviceCaps(win32con.HORZRES))
            page_h = int(dc.GetDeviceCaps(win32con.VERTRES))
        except Exception:
            page_w, page_h = bmp_w, bmp_h
        if page_w <= 0 or page_h <= 0:
            page_w, page_h = bmp_w, bmp_h
        scale = min(page_w / max(1, bmp_w), page_h / max(1, bmp_h))
        out_w = max(1, int(bmp_w * scale))
        out_h = max(1, int(bmp_h * scale))
        x0 = max(0, (page_w - out_w) // 2)
        y0 = max(0, (page_h - out_h) // 2)

        # Most reliable: render via Pillow ImageWin directly to printer DC.
        if ImageWin is not None:
            dib = ImageWin.Dib(pil_image.convert("RGB"))
            dib.draw(dc.GetHandleOutput(), (x0, y0, x0 + out_w, y0 + out_h))
        else:
            # Fallback: Draw image to printer DC via temp BMP (GDI uses BMP)
            with tempfile.NamedTemporaryFile(suffix=".bmp", delete=False) as f:
                tmp_bmp = f.name
            try:
                pil_image.save(tmp_bmp, "BMP")
                hbm = win32gui.LoadImage(
                    0, tmp_bmp, win32con.IMAGE_BITMAP, 0, 0,
                    win32con.LR_LOADFROMFILE | win32con.LR_CREATEDIBSECTION,
                )
                if hbm == 0:
                    raise RuntimeError("Failed to load label image as bitmap.")
                try:
                    mem_dc = win32ui.CreateDCFromHandle(win32gui.CreateCompatibleDC(dc.GetSafeHdc()))
                    bmp = getattr(win32ui, "CreateBitmapFromHandle", lambda h: win32ui.PyCBitmap.FromHandle(h))(hbm)
                    mem_dc.SelectObject(bmp)
                    dc.StretchBlt((x0, y0), (out_w, out_h), mem_dc, (0, 0), (bmp_w, bmp_h), win32con.SRCCOPY)
                finally:
                    win32gui.DeleteObject(hbm)
            finally:
                try:
                    os.unlink(tmp_bmp)
                except OSError:
                    pass
    finally:
        dc.EndPage()
        dc.EndDoc()


def send_zpl_to_dataflex(ip: str, port: int, zpl: str) -> None:
    """Send ZPL label (^XA…^XZ) to DataFlex printer via TCP. Raises on connection/send error."""
    sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    try:
        sock.setsockopt(socket.IPPROTO_TCP, socket.TCP_NODELAY, 1)
    except OSError:
        pass
    sock.settimeout(DATAFLEX_SEND_TIMEOUT)
    try:
        sock.connect((ip, port))
        sock.sendall(_dataflex_zpl_bytes(zpl))
        time.sleep(DATAFLEX_POST_LABEL_SETTLE_SEC)
        _dataflex_shutdown_write_maybe(sock)
    finally:
        sock.close()


def query_dataflex_host_status(ip: str, port: int) -> str:
    """
    Query DataFlex/Zebra host status (~HS). Returns decoded status text, or empty string
    when device does not return host status.
    """
    sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    try:
        sock.setsockopt(socket.IPPROTO_TCP, socket.TCP_NODELAY, 1)
    except OSError:
        pass
    sock.settimeout(max(0.2, DATAFLEX_STATUS_QUERY_TIMEOUT_SEC))
    try:
        sock.connect((ip, port))
        sock.sendall(b"~HS\r\n")
        chunks: list[bytes] = []
        while True:
            try:
                data = sock.recv(4096)
            except socket.timeout:
                break
            except OSError as ex:
                if _dataflex_is_benign_tcp_reset(ex):
                    break
                raise
            if not data:
                break
            chunks.append(data)
            if sum(len(c) for c in chunks) >= 16384:
                break
        return b"".join(chunks).decode("utf-8", errors="ignore")
    finally:
        sock.close()


def _dataflex_status_has_e1005(status_text: str) -> bool:
    s = (status_text or "").lower()
    return "e1005" in s or "1005" in s


def _dataflex_status_problem_code(status_text: str) -> Optional[str]:
    """If host status (~HS) suggests a fault, return a short code like E1000; else None."""
    s = (status_text or "").lower()
    for code in ("e1000", "e1005", "e1004", "e1003", "e1002", "e1001"):
        if code in s:
            return code.upper()
    return None


def assert_dataflex_host_ok(ip: str, port: int) -> None:
    """
    Query ~HS once. If printer reports a known fault token, stop the job early.
    Empty/short replies are ignored (some firmware is quiet).
    """
    st = query_dataflex_host_status(ip, port)
    if not (st or "").strip():
        return
    prob = _dataflex_status_problem_code(st)
    if prob is not None:
        raise RuntimeError(
            f"打袋機狀態異常 {prob}（~HS）。請看機台畫面處理後再印。"
        )


def recover_dataflex_if_host_fault(ip: str, port: int) -> None:
    """
    If ~HS reports E1000/E1005/etc., clear host state once and continue — do not abort the whole run.
    Keeps work short so the print thread does not look "frozen".
    """
    st = query_dataflex_host_status(ip, port)
    if not (st or "").strip():
        return
    if _dataflex_status_problem_code(st) is None:
        return
    touch_dataflex_recovery_grace(14.0)
    send_dataflex_job_counter_reset(ip, port, force=True)
    send_dataflex_preprint_reset(ip, port, force=True)
    time.sleep(max(0.35, DATAFLEX_RECOVERY_WAIT_SEC))


def send_dataflex_label_with_recovery(ip: str, port: int, zpl: str) -> None:
    """
    Send one bag label with one automatic recovery attempt.

    If first send fails (including firmware-latched states such as E1005),
    perform full recovery (~JA/~RO/~JR), then light preprint reset (~JA/~RO),
    and retry once.
    """
    last_err: Optional[Exception] = None
    for attempt in range(DATAFLEX_RECOVERY_MAX_ATTEMPTS):
        try:
            if DATAFLEX_AUTO_RESET_ENABLED and DATAFLEX_PREPRINT_EACH_LABEL:
                send_dataflex_preprint_reset(ip, port)
            send_zpl_to_dataflex(ip, port, zpl)
            if DATAFLEX_VERIFY_STATUS_AFTER_SEND:
                status_text = query_dataflex_host_status(ip, port)
                if _dataflex_status_has_e1005(status_text):
                    raise RuntimeError("DataFlex E1005 detected from host status.")
            return
        except (ConnectionRefusedError, socket.timeout, OSError, RuntimeError) as ex:
            last_err = ex
            if attempt >= DATAFLEX_RECOVERY_MAX_ATTEMPTS - 1:
                break
            if DATAFLEX_AUTO_RESET_ENABLED or DATAFLEX_RECOVER_ON_SEND_ERROR:
                touch_dataflex_recovery_grace(14.0)
                send_dataflex_job_counter_reset(ip, port, force=True)
                send_dataflex_preprint_reset(ip, port, force=True)
            time.sleep(max(0.35, DATAFLEX_RECOVERY_WAIT_SEC))

    if last_err is not None:
        raise last_err
    raise RuntimeError("DataFlex label send failed.")


def send_zpl_to_label_printer(target: str, zpl: str) -> None:
    """
    Send ZPL to 標簽機.

    On Windows, if target is not a COM port (e.g. "TSC TTP-246M Pro"),
    send raw ZPL to the named Windows printer via the spooler.
    Otherwise, treat target as a serial COM port (original behaviour).
    """
    dest = (target or "").strip()
    if not dest:
        raise ValueError("Label printer destination is empty.")

    # Unicode (^CI28); send UTF-8 to 標簽機
    raw_bytes = zpl.encode("utf-8")

    # Windows printer name path (USB printer installed as normal printer)
    if os.name == "nt" and not dest.upper().startswith("COM"):
        if win32print is None:
            raise RuntimeError("pywin32 not installed. Run: pip install pywin32")
        handle = win32print.OpenPrinter(dest)
        try:
            job = win32print.StartDocPrinter(handle, 1, ("FPSMS Label", None, "RAW"))
            win32print.StartPagePrinter(handle)
            win32print.WritePrinter(handle, raw_bytes)
            win32print.EndPagePrinter(handle)
            win32print.EndDocPrinter(handle)
        finally:
            win32print.ClosePrinter(handle)
        return

    # Fallback: serial COM port
    if serial is None:
        raise RuntimeError("pyserial not installed. Run: pip install pyserial")
    ser = serial.Serial(dest, timeout=5)
    try:
        ser.write(raw_bytes)
    finally:
        ser.close()


def send_zpl_to_label_printer_batch(target: str, zpl: str, copies: int) -> None:
    """
    Print multiple identical ZPL labels in **exactly one** Windows spool job (or one COM write).

    Uses ZPL ^PQ so the printer firmware repeats the format N times — never one job per label.
    """
    if copies < 1:
        return
    zpl_out = zpl_apply_print_quantity(zpl, copies)
    send_zpl_to_label_printer(target, zpl_out)


def load_laser_last_count() -> tuple[int, Optional[str]]:
    """Load last batch count and date from laser counter file. Returns (count, date_str)."""
    if not os.path.exists(LASER_COUNTER_FILE):
        return 0, None
    try:
        with open(LASER_COUNTER_FILE, "r", encoding="utf-8") as f:
            lines = f.read().strip().splitlines()
            if len(lines) >= 2:
                return int(lines[1].strip()), lines[0].strip()
    except Exception:
        pass
    return 0, None


def save_laser_last_count(date_str: str, count: int) -> None:
    """Save laser batch count and date to file."""
    try:
        with open(LASER_COUNTER_FILE, "w", encoding="utf-8") as f:
            f.write(f"{date_str}\n{count}")
    except Exception:
        pass


LASER_PUSH_INTERVAL = 2  # seconds between pushes (like sample script)
# Click row with 激光機 selected: send this many times, delay between sends (not after last).
LASER_ROW_SEND_COUNT = 3
LASER_ROW_SEND_DELAY_SEC = 3


def laser_push_loop(
    ip: str,
    port: int,
    stop_event: threading.Event,
    root: tk.Tk,
    on_error: Callable[[str], None],
) -> None:
    """
    Run in a background thread: persistent connection to EZCAD, push B{yymmdd}{count:03d};;
    every LASER_PUSH_INTERVAL seconds. Resets count each new day. Uses counter file.
    """
    conn = None
    push_count, last_saved_date = load_laser_last_count()
    while not stop_event.is_set():
        try:
            if conn is None:
                conn = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
                conn.settimeout(0.4)
                conn.connect((ip, port))
            now = datetime.now()
            today_str = now.strftime("%y%m%d")
            if last_saved_date != today_str:
                push_count = 1
                last_saved_date = today_str
            batch = f"B{today_str}{push_count:03d}"
            reply = f"{batch};;"
            conn.sendall(reply.encode("utf-8"))
            save_laser_last_count(today_str, push_count)
            rlist, _, _ = select.select([conn], [], [], 0.4)
            if rlist:
                data = conn.recv(4096)
                if not data:
                    conn.close()
                    conn = None
            push_count += 1
            for _ in range(int(LASER_PUSH_INTERVAL * 2)):
                if stop_event.is_set():
                    break
                time.sleep(0.5)
        except socket.timeout:
            pass
        except Exception as e:
            if conn:
                try:
                    conn.close()
                except Exception:
                    pass
                conn = None
                try:
                    root.after(0, lambda msg=str(e): on_error(msg))
                except Exception:
                    pass
                for _ in range(6):
                    if stop_event.is_set():
                        break
                    time.sleep(0.5)
    if conn:
        try:
            conn.close()
        except Exception:
            pass


def send_job_to_laser(
    conn_ref: list,
    ip: str,
    port: int,
    item_id: Optional[int],
    stock_in_line_id: Optional[int],
    item_code: str,
    item_name: str,
    expiry_text: Optional[str] = None,
) -> tuple[bool, str]:
    """
    Send to laser using `;` separated params:
    {"itemId": itemId, "stockInLineId": stockInLineId} ; itemCode ; itemName ; [Expiry Date yyyyMMdd] ;;
    conn_ref: [socket or None] - reused across calls; closed only when switching printer.
    When both item_id and stock_in_line_id present, sends JSON first param; else fallback: 0;item_code;item_name;;
    Expiry is the 4th field when present (same wording as DataFlex).
    Returns (success, message).
    """
    code_str = (item_code or "").strip().replace(";", ",")
    name_str = (item_name or "").strip().replace(";", ",")
    exp_str = (expiry_text or "").strip().replace(";", ",")

    if item_id is not None and stock_in_line_id is not None:
        # Use compact JSON so device-side parser doesn't get spaces.
        json_part = json.dumps(
            {"itemId": item_id, "stockInLineId": stock_in_line_id},
            separators=(",", ":"),
        )
        head = json_part
    else:
        head = "0"
    if exp_str:
        reply = f"{head};{code_str};{name_str};{exp_str};;"
    else:
        reply = f"{head};{code_str};{name_str};;"
    conn = conn_ref[0]
    try:
        if conn is None:
            conn = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
            conn.settimeout(3.0)
            conn.connect((ip, port))
            conn_ref[0] = conn
        conn.settimeout(3.0)
        conn.sendall(reply.encode("utf-8"))
        conn.settimeout(0.5)
        try:
            data = conn.recv(4096)
            if data:
                ack = data.decode("utf-8", errors="ignore").strip().lower()
                if "receive" in ack and "invalid" not in ack:
                    return True, f"已送出激光機：{reply}（已確認）"
        except socket.timeout:
            pass
        return True, f"已送出激光機：{reply}"
    except (ConnectionRefusedError, socket.timeout, OSError) as e:
        if conn_ref[0] is not None:
            try:
                conn_ref[0].close()
            except Exception:
                pass
            conn_ref[0] = None
        if isinstance(e, ConnectionRefusedError):
            return False, f"無法連線至 {ip}:{port}，請確認激光機已開機且 IP 正確。"
        if isinstance(e, socket.timeout):
            return False, f"連線逾時 ({ip}:{port})，請檢查網路與連接埠。"
        return False, f"激光機送出失敗：{e}"


def send_job_to_laser_with_retry(
    conn_ref: list,
    ip: str,
    port: int,
    item_id: Optional[int],
    stock_in_line_id: Optional[int],
    item_code: str,
    item_name: str,
    expiry_text: Optional[str] = None,
) -> tuple[bool, str]:
    """Send job to laser; on failure, retry once. Returns (success, message)."""
    ok, msg = send_job_to_laser(
        conn_ref, ip, port, item_id, stock_in_line_id, item_code, item_name, expiry_text,
    )
    if ok:
        return True, msg
    ok2, msg2 = send_job_to_laser(
        conn_ref, ip, port, item_id, stock_in_line_id, item_code, item_name, expiry_text,
    )
    return ok2, msg2


def run_laser_row_send_thread(
    root: tk.Tk,
    laser_conn_ref: list,
    laser_busy_ref: list,
    ip: str,
    port: int,
    item_id: Optional[int],
    stock_in_line_id: Optional[int],
    item_code: str,
    item_name: str,
    set_status_message: Callable[[str, bool], None],
    base_url: Optional[str] = None,
    job_order_id: Optional[int] = None,
    on_recorded: Optional[Callable[[], None]] = None,
    expiry_text: Optional[str] = None,
) -> None:
    """
    On row click with 激光機: send LASER_ROW_SEND_COUNT times with LASER_ROW_SEND_DELAY_SEC between sends.
    UI updates on main thread; work runs in background so the window does not freeze.
    After success, POST LASER qty to API when job_order_id and base_url are set.
    """
    if laser_busy_ref[0]:
        messagebox.showwarning("激光機", "請等待目前激光發送完成。")
        return
    laser_busy_ref[0] = True

    def worker() -> None:
        try:
            n = LASER_ROW_SEND_COUNT
            for i in range(n):
                ok, msg = send_job_to_laser_with_retry(
                    laser_conn_ref,
                    ip,
                    port,
                    item_id,
                    stock_in_line_id,
                    item_code,
                    item_name,
                    expiry_text,
                )
                if not ok:
                    root.after(
                        0,
                        lambda m=msg: messagebox.showwarning("激光機", m),
                    )
                    return
                if i < n - 1:
                    time.sleep(LASER_ROW_SEND_DELAY_SEC)
            posted = False
            if base_url and job_order_id is not None:
                try:
                    submit_job_order_print_submit(base_url, int(job_order_id), n, "LASER")
                    posted = True
                except requests.RequestException as ex:
                    root.after(
                        0,
                        lambda err=str(ex): messagebox.showwarning(
                            "激光機",
                            f"已發送，但伺服器記錄失敗：{err}",
                        ),
                    )
            elif base_url:
                root.after(
                    0,
                    lambda: messagebox.showwarning(
                        "激光機",
                        "已發送，但無工單 id，無法寫入伺服器記錄。",
                    ),
                )
            root.after(
                0,
                lambda: set_status_message("已發送", is_error=False),
            )
            if on_recorded is not None and posted:
                root.after(0, on_recorded)
        except Exception as e:
            root.after(
                0,
                lambda err=str(e): messagebox.showwarning("激光機", f"送出失敗：{err}"),
            )
        finally:
            laser_busy_ref[0] = False

    threading.Thread(target=worker, daemon=True).start()


def run_dataflex_fixed_qty_thread(
    root: tk.Tk,
    dataflex_lock: threading.Lock,
    dataflex_busy_ref: list,
    ip: str,
    port: int,
    n: int,
    zpl: str,
    label_text: str,
    jo_id: Optional[int],
    base_url: str,
    set_status_message: Callable[[str, bool], None],
    on_recorded: Callable[[], None],
) -> None:
    """
    Send n DataFlex labels with delay between copies. Runs off the Tk main thread so the UI
    stays responsive (printer dropdown, other controls) during printing.
    """
    def worker() -> None:
        with dataflex_lock:
            if dataflex_busy_ref[0]:
                root.after(
                    0,
                    lambda: messagebox.showwarning(
                        "打袋機",
                        "請等待目前列印完成或先停止連續列印。",
                    ),
                )
                return
            dataflex_busy_ref[0] = True
        printed = 0
        used_single_tcp = False
        try:
            send_dataflex_start_job_reset(ip, port, force=True)
            if DATAFLEX_SINGLE_TCP_JOB and n >= 1:
                # One TCP connection, one ZPL, ^PQn — printer firmware prints n identical bags.
                used_single_tcp = True
                zpl_one = dataflex_zpl_set_print_quantity(zpl, n)
                root.after(
                    0,
                    lambda tn=n: set_status_message(
                        f"打袋單次發送中… {tn} 張（^PQ{tn}）",
                        is_error=False,
                    ),
                )
                send_dataflex_label_with_recovery(ip, port, zpl_one)
                if DATAFLEX_VERIFY_EVERY_LABELS > 0:
                    recover_dataflex_if_host_fault(ip, port)
                printed = n
            else:
                # One TCP job per bag. Slower but avoids E1005 on some units when ^PQ is large.
                for i in range(n):
                    send_dataflex_label_with_recovery(ip, port, zpl)
                    printed += 1
                    if DATAFLEX_UI_PROGRESS_EVERY > 0 and (
                        printed == 1 or printed % DATAFLEX_UI_PROGRESS_EVERY == 0
                    ):
                        p, t = printed, n
                        root.after(
                            0,
                            lambda p=p, t=t: set_status_message(
                                f"打袋列印中… {p}/{t}",
                                is_error=False,
                            ),
                        )
                    if (
                        DATAFLEX_VERIFY_EVERY_LABELS > 0
                        and printed % DATAFLEX_VERIFY_EVERY_LABELS == 0
                    ):
                        recover_dataflex_if_host_fault(ip, port)
                    if (
                        DATAFLEX_COOLDOWN_EVERY_LABELS > 0
                        and printed % DATAFLEX_COOLDOWN_EVERY_LABELS == 0
                        and i < n - 1
                    ):
                        time.sleep(max(0.0, DATAFLEX_COOLDOWN_SEC))
                    if (
                        DATAFLEX_THERMAL_REST_EVERY_LABELS > 0
                        and printed % DATAFLEX_THERMAL_REST_EVERY_LABELS == 0
                        and i < n - 1
                    ):
                        time.sleep(max(0.0, DATAFLEX_THERMAL_REST_SEC))
                    if i < n - 1:
                        time.sleep(DATAFLEX_INTER_LABEL_DELAY_SEC)
            root.after(
                0,
                lambda u=used_single_tcp: set_status_message(
                    (
                        f"已送出列印（單次 TCP）：批次 {label_text} x {n} 張"
                        if u
                        else f"已送出列印：批次 {label_text} x {n} 張"
                    ),
                    is_error=False,
                ),
            )
            if jo_id is not None:
                try:
                    submit_job_order_print_submit(base_url, int(jo_id), n, "DATAFLEX")
                    root.after(0, on_recorded)
                except requests.RequestException as ex:
                    root.after(
                        0,
                        lambda err=str(ex): messagebox.showwarning(
                            "打袋機",
                            f"列印可能已完成，但伺服器記錄失敗（可再試）：{err}",
                        ),
                    )
            else:
                root.after(
                    0,
                    lambda: messagebox.showwarning(
                        "打袋機",
                        f"已送出列印 {n} 張，但無工單 id，無法寫入伺服器記錄。",
                    ),
                )
        except ConnectionRefusedError:
            root.after(
                0,
                lambda: set_status_message(
                    f"無法連線至 {ip}:{port}，已送出 {printed}/{n} 張。",
                    is_error=True,
                ),
            )
        except socket.timeout:
            root.after(
                0,
                lambda: set_status_message(
                    f"連線逾時 ({ip}:{port})，已送出 {printed}/{n} 張。",
                    is_error=True,
                ),
            )
        except OSError as err:
            root.after(
                0,
                lambda e=err: set_status_message(
                    f"列印失敗：{e}（已送出 {printed}/{n} 張）",
                    is_error=True,
                ),
            )
        except RuntimeError as err:
            root.after(
                0,
                lambda e=err: set_status_message(
                    f"打袋機錯誤：{e}（已送出 {printed}/{n} 張）",
                    is_error=True,
                ),
            )
        except Exception as err:
            root.after(
                0,
                lambda e=err: set_status_message(
                    f"打袋機例外：{e}（已送出 {printed}/{n} 張）",
                    is_error=True,
                ),
            )
        finally:
            with dataflex_lock:
                dataflex_busy_ref[0] = False

    threading.Thread(target=worker, daemon=True).start()


def run_label_print_batch_thread(
    root: tk.Tk,
    label_lock: threading.Lock,
    label_busy_ref: list,
    com: str,
    zpl_img: str,
    n: int,
    jo_id: Optional[int],
    base_url: str,
    set_status_message: Callable[[str, bool], None],
    on_recorded: Callable[[], None],
) -> None:
    """
    Send n label copies off the main thread so DataFlex / laser / UI stay usable in parallel.
    """
    def worker() -> None:
        with label_lock:
            if label_busy_ref[0]:
                root.after(
                    0,
                    lambda: messagebox.showwarning(
                        "標籤機",
                        "請等待目前標籤列印完成。",
                    ),
                )
                return
            label_busy_ref[0] = True
        try:
            send_zpl_to_label_printer_batch(com, zpl_img, n)
            root.after(
                0,
                lambda: set_status_message(f"已送出列印：標籤 x {n} 張", is_error=False),
            )
            if jo_id is not None:
                try:
                    submit_job_order_print_submit(base_url, int(jo_id), n, "LABEL")
                    root.after(0, on_recorded)
                    root.after(
                        0,
                        lambda: messagebox.showinfo(
                            "標籤機",
                            f"已送出列印：{n} 張標籤（已記錄）",
                        ),
                    )
                except requests.RequestException as ex:
                    root.after(
                        0,
                        lambda err=str(ex): messagebox.showwarning(
                            "標籤機",
                            f"標籤已列印 {n} 張，但伺服器記錄失敗：{err}",
                        ),
                    )
            else:
                root.after(
                    0,
                    lambda: messagebox.showwarning(
                        "標籤機",
                        f"已送出列印：{n} 張標籤（無工單 id，無法寫入伺服器記錄）",
                    ),
                )
        except Exception as err:
            root.after(
                0,
                lambda e=str(err): messagebox.showerror("標籤機", f"列印失敗：{e}"),
            )
        finally:
            with label_lock:
                label_busy_ref[0] = False

    threading.Thread(target=worker, daemon=True).start()


def _printed_qty_int(raw) -> int:
    """Parse API printed qty field (may be float JSON) to int."""
    try:
        return int(float(raw)) if raw is not None else 0
    except (TypeError, ValueError):
        return 0


def _filter_job_orders_by_search(data: list, needle: str) -> list:
    """Substring match on item code, job order code, item name, lot (case-insensitive)."""
    n = needle.strip().lower()
    if not n:
        return data
    out: list = []
    for jo in data:
        parts = [
            str(jo.get("itemCode") or ""),
            str(jo.get("code") or ""),
            str(jo.get("itemName") or ""),
            str(jo.get("lotNo") or ""),
        ]
        if any(n in p.lower() for p in parts):
            out.append(jo)
    return out


def format_qty(val) -> str:
    """Format quantity: integer without .0, with thousand separator."""
    if val is None:
        return "—"
    try:
        n = float(val)
        if n == int(n):
            return f"{int(n):,}"
        return f"{n:,.2f}".rstrip("0").rstrip(".")
    except (TypeError, ValueError):
        return str(val)


def batch_no(year: int, job_order_id: int) -> str:
    """Batch no.: B + 4-digit year + jobOrderId zero-padded to 6 digits."""
    return f"B{year}{job_order_id:06d}"


def get_font(size: int = FONT_SIZE, bold: bool = False) -> tuple:
    try:
        return (FONT_FAMILY, size, "bold" if bold else "normal")
    except Exception:
        return ("TkDefaultFont", size, "bold" if bold else "normal")


def fetch_job_orders(base_url: str, plan_start: date) -> list:
    """Call GET /py/job-orders and return the JSON list."""
    url = f"{base_url.rstrip('/')}/py/job-orders"
    params = {"planStart": plan_start.isoformat()}
    resp = requests.get(url, params=params, timeout=30)
    resp.raise_for_status()
    return resp.json()


def submit_job_order_print_submit(
    base_url: str,
    job_order_id: int,
    qty: int,
    print_channel: str = "LABEL",
) -> None:
    """
    Record printed quantity in the FPSMS database via PyController.

    POST ``/api/py/job-order-print-submit`` (path under base_url) — **public endpoint, no login**
    or API key required. Each successful call appends one row to ``py_job_order_print_submit``;
    totals per job order and channel are aggregated server-side.

    Raises ``requests.RequestException`` if all retry attempts fail.
    """
    url = f"{base_url.rstrip('/')}/py/job-order-print-submit"
    payload = {
        "jobOrderId": int(job_order_id),
        "qty": int(qty),
        "printChannel": print_channel,
    }
    last_err: Optional[Exception] = None
    for attempt in range(PRINT_SUBMIT_MAX_ATTEMPTS):
        try:
            resp = requests.post(url, json=payload, timeout=30)
            resp.raise_for_status()
            return
        except requests.RequestException as ex:
            last_err = ex
            if attempt < PRINT_SUBMIT_MAX_ATTEMPTS - 1:
                time.sleep(PRINT_SUBMIT_RETRY_DELAY_SEC)
    if last_err is not None:
        raise last_err
    raise RuntimeError("submit_job_order_print_submit: unexpected empty error")


def set_row_highlight(row_frame: tk.Frame, selected: bool) -> None:
    """Set row and all nested Frame/Label children to selected or normal background."""
    bg = BG_ROW_SELECTED if selected else BG_ROW

    def _paint(w: tk.Misc) -> None:
        if isinstance(w, (tk.Frame, tk.Label)):
            w.configure(bg=bg)
            for c in w.winfo_children():
                _paint(c)

    _paint(row_frame)


def on_job_order_click(jo: dict, batch: str) -> None:
    """Show message and highlight row (keeps printing to selected printer)."""
    item_code = jo.get("itemCode") or "—"
    item_name = jo.get("itemName") or "—"
    messagebox.showinfo(
        "工單",
        f'已點選：批次 {batch}\n品號 {item_code}　{item_name}',
    )


def ask_label_count(parent: tk.Tk) -> Optional[int]:
    """
    When printer is 標簽機, ask how many labels to print:
    optional direct qty in text field (e.g. 150), +50/+10/+5/+1, 重置, then 確認送出.
    That count becomes ZPL ^PQ in one job — 150 → 150 identical labels.
    Returns count (>= 1), or None if cancelled.
    """
    result: list[Optional[int]] = [None]
    qty_var = tk.StringVar(value="0")

    win = tk.Toplevel(parent)
    win.title("標簽印數")
    win.geometry("580x280")
    win.transient(parent)
    win.grab_set()
    win.configure(bg=BG_TOP)
    ttk.Label(win, text="印多少個？", font=get_font(FONT_SIZE)).pack(pady=(12, 4))

    entry_row = tk.Frame(win, bg=BG_TOP)
    entry_row.pack(pady=8)
    tk.Label(entry_row, text="需求數量：", font=get_font(FONT_SIZE), bg=BG_TOP).pack(side=tk.LEFT, padx=(0, 6))
    qty_entry = tk.Entry(
        entry_row,
        textvariable=qty_var,
        width=12,
        font=get_font(FONT_SIZE),
        bg="white",
        justify=tk.RIGHT,
    )
    qty_entry.pack(side=tk.LEFT, padx=4)

    def current_qty() -> int:
        s = (qty_var.get() or "").strip().replace(",", "")
        if not s:
            return 0
        try:
            return max(0, int(s))
        except ValueError:
            return 0

    def reset_qty() -> None:
        qty_var.set("0")

    ttk.Button(entry_row, text="重置", command=reset_qty, width=8).pack(side=tk.LEFT, padx=8)

    def add(n: int) -> None:
        qty_var.set(str(current_qty() + n))

    def confirm() -> None:
        q = current_qty()
        if q < 1:
            messagebox.showwarning("標簽機", "請輸入需求數量或按 +50、+10、+5、+1。", parent=win)
            return
        result[0] = q
        win.destroy()

    btn_row1 = tk.Frame(win, bg=BG_TOP)
    btn_row1.pack(pady=8)
    for label, value in [("+50", 50), ("+10", 10), ("+5", 5), ("+1", 1)]:
        def make_add(v: int):
            return lambda: add(v)
        ttk.Button(btn_row1, text=label, command=make_add(value), width=8).pack(side=tk.LEFT, padx=4)

    ttk.Button(win, text="確認送出", command=confirm, width=14).pack(pady=12)
    qty_entry.bind("<Return>", lambda e: confirm())
    win.protocol("WM_DELETE_WINDOW", win.destroy)
    win.wait_window()
    return result[0]
    
def ask_bag_count(parent: tk.Tk) -> Optional[Tuple[int, bool]]:
    """
    When printer is 打袋機 DataFlex: qty with +按鈕 then 確認送出, or big bottom「C」for continuous.
    Returns (count, continuous_print). If continuous_print is True, count is ignored (use 0).
    None if cancelled.
    """
    result: list[Optional[Tuple[int, bool]]] = [None]
    qty_var = tk.StringVar(value="0")

    win = tk.Toplevel(parent)
    win.title("打袋列印數量")
    win.geometry("580x420")
    win.transient(parent)
    win.grab_set()
    win.configure(bg=BG_TOP)
    ttk.Label(win, text="列印多少個袋？", font=get_font(FONT_SIZE)).pack(pady=(12, 4))

    entry_row = tk.Frame(win, bg=BG_TOP)
    entry_row.pack(pady=8)
    tk.Label(entry_row, text="需求數量：", font=get_font(FONT_SIZE), bg=BG_TOP).pack(side=tk.LEFT, padx=(0, 6))
    qty_entry = tk.Entry(
        entry_row,
        textvariable=qty_var,
        width=12,
        font=get_font(FONT_SIZE),
        bg="white",
        justify=tk.RIGHT,
    )
    qty_entry.pack(side=tk.LEFT, padx=4)

    def current_qty() -> int:
        s = (qty_var.get() or "").strip().replace(",", "")
        if not s:
            return 0
        try:
            return max(0, int(s))
        except ValueError:
            return 0

    def reset_qty() -> None:
        qty_var.set("0")

    ttk.Button(entry_row, text="重置", command=reset_qty, width=8).pack(side=tk.LEFT, padx=8)

    def add(n: int) -> None:
        qty_var.set(str(current_qty() + n))

    def confirm() -> None:
        q = current_qty()
        if q < 1:
            messagebox.showwarning("打袋機", "請輸入需求數量或按 +50、+10、+5、+1。", parent=win)
            return
        result[0] = (q, False)
        win.destroy()

    def start_continuous() -> None:
        """Big C: continuous print until 停止; counter reset at job start."""
        result[0] = (0, True)
        win.destroy()

    btn_row1 = tk.Frame(win, bg=BG_TOP)
    btn_row1.pack(pady=8)
    for label, value in [("+50", 50), ("+10", 10), ("+5", 5), ("+1", 1)]:
        def make_add(v: int):
            return lambda: add(v)
        ttk.Button(btn_row1, text=label, command=make_add(value), width=8).pack(side=tk.LEFT, padx=4)

    ttk.Button(win, text="確認送出", command=confirm, width=14).pack(pady=12)
    qty_entry.bind("<Return>", lambda e: confirm())

    sep = ttk.Separator(win, orient=tk.HORIZONTAL)
    sep.pack(fill=tk.X, padx=16, pady=(4, 8))

    bottom = tk.Frame(win, bg=BG_TOP)
    bottom.pack(fill=tk.X, padx=12, pady=(0, 12))
    tk.Label(
        bottom,
        text="連續出袋 · 每單開始重設計數 · 另開視窗按「停止列印」結束",
        font=get_font(FONT_SIZE_META),
        bg=BG_TOP,
        fg="#333333",
        wraplength=540,
        justify=tk.CENTER,
    ).pack(fill=tk.X, pady=(0, 6))

    tk.Button(
        bottom,
        text="C(連續印)",
        command=start_continuous,
        font=(FONT_FAMILY, 38, "bold"),
        bg="#2E7D32",
        fg="white",
        activebackground="#1B5E20",
        activeforeground="white",
        relief=tk.RAISED,
        bd=4,
        cursor="hand2",
        padx=24,
        pady=18,
    ).pack(fill=tk.X)
    win.protocol("WM_DELETE_WINDOW", win.destroy)
    win.wait_window()
    return result[0]


@dataclass(frozen=True)
class DataflexPrintSession:
    """
    Snapshot taken when the user starts DataFlex print (especially C 連續印).
    The worker must use only this object — not grid row index, scroll position, or selection.
    """

    job_order_id: Optional[int]
    job_code: str
    item_code: str
    item_name: str
    label_text: str
    zpl: str
    printer_ip: str
    printer_port: int
    batch_display: str


def build_dataflex_print_session(
    jo: dict,
    batch: str,
    zpl: str,
    label_text: str,
    printer_ip: str,
    printer_port: int,
) -> DataflexPrintSession:
    jo_id = jo.get("id")
    jo_code = (jo.get("code") or "").strip()
    if not jo_code and jo_id is not None:
        jo_code = f"#{jo_id}"
    elif not jo_code:
        jo_code = "—"
    return DataflexPrintSession(
        job_order_id=int(jo_id) if jo_id is not None else None,
        job_code=jo_code,
        item_code=(jo.get("itemCode") or "—").strip(),
        item_name=(jo.get("itemName") or "—").strip(),
        label_text=label_text,
        zpl=zpl,
        printer_ip=printer_ip,
        printer_port=printer_port,
        batch_display=(batch or "—").strip(),
    )


def run_dataflex_continuous_thread(
    root: tk.Tk,
    session: DataflexPrintSession,
    stop_event: threading.Event,
    stop_win: tk.Toplevel,
    dataflex_lock: threading.Lock,
    dataflex_busy_ref: list,
    dataflex_stop_win_ref: list,
    active_session_ref: list,
    base_url: str,
    set_status_message: Callable[[str, bool], None],
    on_recorded: Callable[[], None],
) -> None:
    """Send bags in a loop until stop_event; all payload comes from session (in-memory snapshot)."""

    def worker() -> None:
        with dataflex_lock:
            if dataflex_busy_ref[0]:
                active_session_ref[0] = None

                def _abort_start() -> None:
                    messagebox.showwarning(
                        "打袋機",
                        "請等待目前列印完成或先停止連續列印。",
                    )
                    dataflex_stop_win_ref[0] = None
                    try:
                        stop_win.destroy()
                    except tk.TclError:
                        pass

                root.after(0, _abort_start)
                return
            dataflex_busy_ref[0] = True

        ip = session.printer_ip
        port = session.printer_port
        zpl = session.zpl
        label_text = session.label_text
        printed = 0
        error_shown = False
        try:
            send_dataflex_start_job_reset(ip, port, force=True)
            while not stop_event.is_set():
                send_dataflex_label_with_recovery(ip, port, zpl)
                printed += 1
                if DATAFLEX_UI_PROGRESS_EVERY > 0 and (
                    printed == 1 or printed % DATAFLEX_UI_PROGRESS_EVERY == 0
                ):
                    p = printed
                    root.after(
                        0,
                        lambda p=p, jc=session.job_code: set_status_message(
                            f"連續打袋 · 工單 {jc}… 已印 {p} 張",
                            is_error=False,
                        ),
                    )
                if (
                    DATAFLEX_VERIFY_EVERY_LABELS > 0
                    and printed % DATAFLEX_VERIFY_EVERY_LABELS == 0
                ):
                    recover_dataflex_if_host_fault(ip, port)
                if (
                    DATAFLEX_COOLDOWN_EVERY_LABELS > 0
                    and printed % DATAFLEX_COOLDOWN_EVERY_LABELS == 0
                ):
                    _sleep_interruptible(stop_event, max(0.0, DATAFLEX_COOLDOWN_SEC))
                if (
                    DATAFLEX_THERMAL_REST_EVERY_LABELS > 0
                    and printed % DATAFLEX_THERMAL_REST_EVERY_LABELS == 0
                ):
                    _sleep_interruptible(stop_event, max(0.0, DATAFLEX_THERMAL_REST_SEC))
                _sleep_interruptible(stop_event, DATAFLEX_INTER_LABEL_DELAY_SEC)
        except ConnectionRefusedError:
            error_shown = True
            root.after(
                0,
                lambda: set_status_message(
                    f"無法連線至 {ip}:{port}，請確認印表機已開機且 IP 正確。",
                    is_error=True,
                ),
            )
        except socket.timeout:
            error_shown = True
            root.after(
                0,
                lambda: set_status_message(
                    f"連線逾時 ({ip}:{port})，請檢查網路與連接埠。",
                    is_error=True,
                ),
            )
        except OSError as err:
            error_shown = True
            root.after(
                0,
                lambda e=err: set_status_message(f"列印失敗：{e}", is_error=True),
            )
        except RuntimeError as err:
            error_shown = True
            root.after(
                0,
                lambda e=err: set_status_message(f"打袋機錯誤：{e}", is_error=True),
            )
        except Exception as err:
            error_shown = True
            root.after(
                0,
                lambda e=err: set_status_message(f"打袋機例外：{e}", is_error=True),
            )
        finally:
            with dataflex_lock:
                dataflex_busy_ref[0] = False
            active_session_ref[0] = None

            def _done() -> None:
                dataflex_stop_win_ref[0] = None
                try:
                    if os.name == "nt":
                        stop_win.attributes("-topmost", False)
                except tk.TclError:
                    pass
                try:
                    stop_win.destroy()
                except tk.TclError:
                    pass
                jc = session.job_code
                if printed > 0:
                    set_status_message(
                        f"連續列印結束：工單 {jc} · {label_text}，已印 {printed} 張",
                        is_error=False,
                    )
                    if session.job_order_id is not None:
                        try:
                            submit_job_order_print_submit(
                                base_url,
                                session.job_order_id,
                                printed,
                                "DATAFLEX",
                            )
                            on_recorded()
                        except requests.RequestException as ex:
                            messagebox.showwarning(
                                "打袋機",
                                f"列印可能已完成，但伺服器記錄失敗（可再試）：{ex}",
                            )
                elif not error_shown:
                    set_status_message("連續列印未印出或已取消", is_error=True)

            root.after(0, _done)

    threading.Thread(target=worker, daemon=True).start()


def _sleep_interruptible(stop_event: threading.Event, total_sec: float) -> None:
    """Sleep up to total_sec but return early if stop_event is set."""
    end = time.perf_counter() + total_sec
    while time.perf_counter() < end:
        if stop_event.is_set():
            return
        remaining = end - time.perf_counter()
        if remaining <= 0:
            break
        time.sleep(min(0.05, remaining))


def open_dataflex_stop_window(
    parent: tk.Tk,
    stop_event: threading.Event,
    stop_win_ref: list,
    session: DataflexPrintSession,
) -> tk.Toplevel:
    """
    Small window with 停止列印 for DataFlex continuous mode (non-modal so stop stays usable).

    Stays above other dialogs (e.g. 標籤機 quantity) via periodic lift + optional topmost on Windows,
    so switching printer and printing labels does not hide the stop control. Ref is cleared on destroy.
    Job details come from the in-memory session snapshot, not the grid selection.
    """
    win = tk.Toplevel(parent)
    win.title("打袋機連續列印")
    win.geometry("480x240")
    # On Windows, transient(root) can hide this Toplevel when the menubutton / printer row
    # updates (e.g. switching to 激光機); keep transient only on non-Windows.
    if os.name != "nt":
        win.transient(parent)
    win.configure(bg=BG_TOP)
    stop_win_ref[0] = win
    if os.name == "nt":
        try:
            win.attributes("-topmost", True)
        except tk.TclError:
            pass

    tk.Label(
        win,
        text="連續列印進行中（內容以按下 C 時的工單為準，與列表捲動／日期無關）",
        font=get_font(FONT_SIZE_META),
        bg=BG_TOP,
        wraplength=440,
        justify=tk.CENTER,
    ).pack(pady=(12, 6))
    detail = (
        f"工單：{session.job_code}\n"
        f"品號：{session.item_code}\n"
        f"品名：{session.item_name}\n"
        f"批次／批號：{session.label_text}"
    )
    tk.Label(
        win,
        text=detail,
        font=get_font(FONT_SIZE),
        bg=BG_TOP,
        fg="#111111",
        wraplength=440,
        justify=tk.LEFT,
        anchor=tk.W,
    ).pack(padx=16, pady=(0, 8), fill=tk.X)

    def clear_topmost() -> None:
        if os.name == "nt":
            try:
                win.attributes("-topmost", False)
            except tk.TclError:
                pass

    def stop() -> None:
        stop_event.set()
        stop_win_ref[0] = None
        clear_topmost()
        try:
            win.destroy()
        except tk.TclError:
            pass

    def periodic_lift() -> None:
        if stop_win_ref[0] is not win:
            return
        try:
            if not win.winfo_exists():
                return
            win.lift()
            if os.name == "nt":
                win.attributes("-topmost", True)
        except tk.TclError:
            return
        parent.after(4000, periodic_lift)

    tk.Button(
        win,
        text="停止列印",
        command=stop,
        font=get_font(FONT_SIZE_BUTTONS),
        bg=BG_STATUS_ERROR,
        fg=FG_STATUS_ERROR,
        padx=20,
        pady=10,
    ).pack(pady=12)
    win.protocol("WM_DELETE_WINDOW", stop)
    parent.after(500, periodic_lift)
    return win


def main() -> None:
    settings = load_settings()
    base_url_ref = [build_base_url(settings["api_ip"], settings["api_port"])]

    root = tk.Tk()
    root.title(f"FP-MTMS Bag4 v{APP_VERSION} 打袋機")
    root.geometry("1120x960")
    root.minsize(480, 360)
    root.configure(bg=BG_ROOT)

    # Style: larger font for aged users; light blue theme
    style = ttk.Style()
    try:
        style.configure(".", font=get_font(FONT_SIZE), background=BG_TOP)
        style.configure("TButton", font=get_font(FONT_SIZE_BUTTONS), background=BG_TOP)
        style.configure("TLabel", font=get_font(FONT_SIZE), background=BG_TOP)
        style.configure("TEntry", font=get_font(FONT_SIZE))
        style.configure("TFrame", background=BG_TOP)
        # TCombobox field (if other combos use ttk later)
        style.configure("TCombobox", font=get_font(FONT_SIZE_COMBO))
    except tk.TclError:
        pass

    # Status bar at top: connection state (no popup on error)
    status_frame = tk.Frame(root, bg=BG_STATUS_ERROR, padx=12, pady=6)
    status_frame.pack(fill=tk.X)
    status_lbl = tk.Label(
        status_frame,
        text="連接不到服務器",
        font=get_font(FONT_SIZE_BUTTONS),
        bg=BG_STATUS_ERROR,
        fg=FG_STATUS_ERROR,
        anchor=tk.CENTER,
    )
    status_lbl.pack(fill=tk.X)

    def set_status_ok():
        status_frame.configure(bg=BG_STATUS_OK)
        status_lbl.configure(text="連接正常", bg=BG_STATUS_OK, fg=FG_STATUS_OK)

    def set_status_error():
        status_frame.configure(bg=BG_STATUS_ERROR)
        status_lbl.configure(text="連接不到服務器", bg=BG_STATUS_ERROR, fg=FG_STATUS_ERROR)

    def set_status_message(msg: str, is_error: bool = False) -> None:
        """Show a message on the status bar."""
        if is_error:
            status_frame.configure(bg=BG_STATUS_ERROR)
            status_lbl.configure(text=msg, bg=BG_STATUS_ERROR, fg=FG_STATUS_ERROR)
        else:
            status_frame.configure(bg=BG_STATUS_OK)
            status_lbl.configure(text=msg, bg=BG_STATUS_OK, fg=FG_STATUS_OK)

    # Laser: keep connection open for repeated sends; close when switching away
    laser_conn_ref: list = [None]
    laser_send_busy_ref: list = [False]
    # DataFlex: shared lock so fixed-qty and continuous jobs do not overlap (independent of laser/label)
    dataflex_lock = threading.Lock()
    dataflex_busy_ref: list = [False]
    # Suppress transient DataFlex "disconnected" UI while we intentionally reset/print.
    dataflex_status_grace_until_ref: list[float] = [0.0]
    # 標籤機: own lock so label jobs do not overlap; does not block DataFlex or laser
    label_lock = threading.Lock()
    label_busy_ref: list = [False]
    # DataFlex continuous: stop Toplevel ref so we can lift it after other dialogs
    dataflex_stop_win_ref: list = [None]
    # In-memory job snapshot for C 連續印 (not tied to grid row position after start)
    active_dataflex_session_ref: list[Optional[DataflexPrintSession]] = [None]

    def lift_dataflex_stop_if_running() -> None:
        """After closing another dialog (e.g. 標籤印數), bring the stop panel forward again."""
        w = dataflex_stop_win_ref[0]
        if w is None:
            return
        try:
            if w.winfo_exists():
                w.lift()
                if os.name == "nt":
                    w.attributes("-topmost", True)
        except tk.TclError:
            pass

    def hold_dataflex_status_ok(seconds: float) -> None:
        until = time.time() + max(0.0, seconds)
        if until > dataflex_status_grace_until_ref[0]:
            dataflex_status_grace_until_ref[0] = until

    # Top: left [前一天] [date] [後一天]  |  right [printer dropdown]
    top = tk.Frame(root, padx=12, pady=12, bg=BG_TOP)
    top.pack(fill=tk.X)

    date_var = tk.StringVar(value=date.today().isoformat())
    printer_options = ["打袋機 DataFlex", "標簽機", "激光機"]
    printer_var = tk.StringVar(value=printer_options[0])

    def go_prev_day() -> None:
        try:
            d = date.fromisoformat(date_var.get().strip())
            date_var.set((d - timedelta(days=1)).isoformat())
            load_job_orders(from_user_date_change=True)
        except ValueError:
            date_var.set(date.today().isoformat())
            load_job_orders(from_user_date_change=True)

    def go_next_day() -> None:
        try:
            d = date.fromisoformat(date_var.get().strip())
            date_var.set((d + timedelta(days=1)).isoformat())
            load_job_orders(from_user_date_change=True)
        except ValueError:
            date_var.set(date.today().isoformat())
            load_job_orders(from_user_date_change=True)

    # 前一天 (previous day) with left arrow icon
    btn_prev = ttk.Button(top, text="◀  前一天", command=go_prev_day)
    btn_prev.pack(side=tk.LEFT, padx=(0, 8))

    # Date field (no "日期:" label); shorter width
    date_entry = tk.Entry(
        top,
        textvariable=date_var,
        font=get_font(FONT_SIZE),
        width=10,
        bg="white",
    )
    date_entry.pack(side=tk.LEFT, padx=(0, 8), ipady=4)

    # 後一天 (next day) with right arrow icon
    btn_next = ttk.Button(top, text="後一天  ▶", command=go_next_day)
    btn_next.pack(side=tk.LEFT, padx=(0, 8))

    # Top right: Setup button + printer selection
    right_frame = tk.Frame(top, bg=BG_TOP)
    right_frame.pack(side=tk.RIGHT)
    ttk.Button(right_frame, text="設定", command=lambda: open_setup_window(root, settings, base_url_ref)).pack(
        side=tk.LEFT, padx=(0, 12)
    )

    def on_dataflex_host_reset() -> None:
        """Send ~JA/~RO/~JR to clear E1005 latch without turning the printer off."""
        ip = (settings.get("dabag_ip") or "").strip()
        port_str = (settings.get("dabag_port") or "3008").strip()
        if not ip:
            messagebox.showwarning("打袋機", "請先在「設定」填寫打袋機 IP。")
            return
        try:
            port = int(port_str)
        except ValueError:
            port = 3008
        hold_dataflex_status_ok(12.0)

        def worker() -> None:
            try:
                send_dataflex_job_counter_reset(ip, port, force=True)
                root.after(
                    0,
                    lambda: messagebox.showinfo(
                        "打袋機",
                        "已送出主機重設（緩衝清除／計數／軟重設）。\n"
                        "若畫面仍顯示 E1005，請再按一次或關機重開。",
                    ),
                )
            except OSError as ex:
                root.after(
                    0,
                    lambda e=str(ex): messagebox.showerror(
                        "打袋機",
                        f"連線失敗，無法重設：{e}",
                    ),
                )

        threading.Thread(target=worker, daemon=True).start()

    ttk.Button(right_frame, text="打袋重設", command=on_dataflex_host_reset).pack(
        side=tk.LEFT, padx=(0, 8)
    )
    # 列印機 label: green when printer connected, red when not (checked periodically)
    printer_status_lbl = tk.Label(
        right_frame,
        text="列印機：",
        font=get_font(FONT_SIZE),
        bg=BG_STATUS_ERROR,
        fg="black",
        padx=6,
        pady=2,
    )
    printer_status_lbl.pack(side=tk.LEFT, padx=(0, 4))
    # tk.OptionMenu (not ttk.Combobox): on Windows the ttk dropdown uses OS font and stays tiny;
    # OptionMenu's menu supports font= for the open list.
    printer_combo = tk.OptionMenu(right_frame, printer_var, *printer_options)
    _combo_font = get_font(FONT_SIZE_COMBO)
    printer_combo.configure(
        font=_combo_font,
        bg=BG_TOP,
        fg="black",
        activebackground=BG_TOP,
        activeforeground="black",
        width=14,
        anchor="w",
        highlightthickness=0,
        bd=1,
        relief=tk.GROOVE,
    )
    printer_combo["menu"].configure(font=_combo_font, tearoff=0)
    printer_combo.pack(side=tk.LEFT)

    printer_after_ref = [None]

    def set_printer_status_ok():
        printer_status_lbl.configure(bg=BG_STATUS_OK, fg=FG_STATUS_OK)

    def set_printer_status_error():
        printer_status_lbl.configure(bg=BG_STATUS_ERROR, fg=FG_STATUS_ERROR)

    def check_printer() -> None:
        if printer_after_ref[0] is not None:
            root.after_cancel(printer_after_ref[0])
            printer_after_ref[0] = None
        if printer_var.get() == "打袋機 DataFlex":
            if (
                dataflex_busy_ref[0]
                or time.time() < dataflex_status_grace_until_ref[0]
                or time.time() < _DATAFLEX_RECOVERY_GRACE_UNTIL
            ):
                set_printer_status_ok()
                printer_after_ref[0] = root.after(5000, check_printer)
                return
        ok = try_printer_connection(printer_var.get(), settings)
        if ok:
            set_printer_status_ok()
            printer_after_ref[0] = root.after(PRINTER_CHECK_MS, check_printer)
        else:
            set_printer_status_error()
            printer_after_ref[0] = root.after(PRINTER_RETRY_MS, check_printer)

    def on_printer_selection_changed(*args) -> None:
        check_printer()
        if printer_var.get() != "激光機":
            if laser_conn_ref[0] is not None:
                try:
                    laser_conn_ref[0].close()
                except Exception:
                    pass
                laser_conn_ref[0] = None
        # DataFlex continuous stop panel can drop behind after OptionMenu closes; re-lift for any choice.
        root.after(100, lift_dataflex_stop_if_running)

    printer_var.trace_add("write", on_printer_selection_changed)

    def open_setup_window(parent_win: tk.Tk, sett: dict, base_url_ref_list: list) -> None:
        """Modal setup: API IP/port, 打袋機/激光機 IP+port, 標簽機 COM port."""
        d = tk.Toplevel(parent_win)
        d.title("設定")
        d.geometry("440x520")
        d.transient(parent_win)
        d.grab_set()
        d.configure(bg=BG_TOP)
        f = tk.Frame(d, padx=16, pady=16, bg=BG_TOP)
        f.pack(fill=tk.BOTH, expand=True)
        grid_row = [0]  # use list so inner function can update

        def _ensure_dot_in_entry(entry: tk.Entry) -> None:
            """Allow typing dot (.) in Entry when IME or layout blocks it (e.g. 192.168.17.27)."""
            def on_key(event):
                if event.keysym in ("period", "decimal"):
                    pos = entry.index(tk.INSERT)
                    entry.insert(tk.INSERT, ".")
                    return "break"
            entry.bind("<KeyPress>", on_key)

        def add_section(label_text: str, key_ip: str | None, key_port: str | None, key_single: str | None):
            out = []
            ttk.Label(f, text=label_text, font=get_font(FONT_SIZE_BUTTONS)).grid(
                row=grid_row[0], column=0, columnspan=2, sticky=tk.W, pady=(8, 2)
            )
            grid_row[0] += 1
            if key_single:
                ttk.Label(
                    f,
                    text="列印機名稱 (Windows)：",
                ).grid(
                    row=grid_row[0],
                    column=0,
                    sticky=tk.W,
                    pady=2,
                )
                var = tk.StringVar(value=sett.get(key_single, ""))
                e = tk.Entry(f, textvariable=var, width=22, font=get_font(FONT_SIZE), bg="white")
                e.grid(row=grid_row[0], column=1, sticky=tk.W, pady=2)
                _ensure_dot_in_entry(e)
                grid_row[0] += 1
                return [(key_single, var)]
            if key_ip:
                ttk.Label(f, text="IP：").grid(row=grid_row[0], column=0, sticky=tk.W, pady=2)
                var_ip = tk.StringVar(value=sett.get(key_ip, ""))
                e_ip = tk.Entry(f, textvariable=var_ip, width=22, font=get_font(FONT_SIZE), bg="white")
                e_ip.grid(row=grid_row[0], column=1, sticky=tk.W, pady=2)
                _ensure_dot_in_entry(e_ip)
                grid_row[0] += 1
                out.append((key_ip, var_ip))
            if key_port:
                ttk.Label(f, text="Port：").grid(row=grid_row[0], column=0, sticky=tk.W, pady=2)
                var_port = tk.StringVar(value=sett.get(key_port, ""))
                e_port = tk.Entry(f, textvariable=var_port, width=12, font=get_font(FONT_SIZE), bg="white")
                e_port.grid(row=grid_row[0], column=1, sticky=tk.W, pady=2)
                _ensure_dot_in_entry(e_port)
                grid_row[0] += 1
                out.append((key_port, var_port))
            return out

        all_vars = []
        all_vars.extend(add_section("API 伺服器", "api_ip", "api_port", None))
        all_vars.extend(add_section("打袋機 DataFlex", "dabag_ip", "dabag_port", None))
        all_vars.extend(add_section("激光機", "laser_ip", "laser_port", None))
        all_vars.extend(add_section("標簽機 (USB)", None, None, "label_com"))

        def on_save():
            for key, var in all_vars:
                sett[key] = var.get().strip()
            save_settings(sett)
            base_url_ref_list[0] = build_base_url(sett["api_ip"], sett["api_port"])
            d.destroy()

        btn_f = tk.Frame(d, bg=BG_TOP)
        btn_f.pack(pady=12)
        ttk.Button(btn_f, text="儲存", command=on_save).pack(side=tk.LEFT, padx=4)
        ttk.Button(btn_f, text="取消", command=d.destroy).pack(side=tk.LEFT, padx=4)
        d.wait_window()

    job_orders_frame = tk.Frame(root, bg=BG_LIST)
    job_orders_frame.pack(fill=tk.BOTH, expand=True, padx=12, pady=12)

    search_var = tk.StringVar()
    search_frame = tk.Frame(job_orders_frame, bg=BG_LIST)
    search_frame.pack(fill=tk.X, pady=(0, 6))
    tk.Label(
        search_frame,
        text="搜尋品號／工單／批號：",
        font=get_font(FONT_SIZE_QTY),
        bg=BG_LIST,
        fg="black",
    ).pack(side=tk.LEFT, padx=(0, 6))
    search_entry = tk.Entry(
        search_frame,
        textvariable=search_var,
        width=32,
        font=get_font(FONT_SIZE_QTY),
        bg="white",
    )
    search_entry.pack(side=tk.LEFT, fill=tk.X, expand=True, padx=(0, 8))

    # Scrollable area for buttons
    canvas = tk.Canvas(job_orders_frame, highlightthickness=0, bg=BG_LIST)
    scrollbar = ttk.Scrollbar(job_orders_frame, orient=tk.VERTICAL, command=canvas.yview)
    inner = tk.Frame(canvas, bg=BG_LIST)

    win_id = canvas.create_window((0, 0), window=inner, anchor=tk.NW)
    canvas.configure(yscrollcommand=scrollbar.set)

    def _on_inner_configure(event):
        canvas.configure(scrollregion=canvas.bbox("all"))

    def _on_canvas_configure(event):
        canvas.itemconfig(win_id, width=event.width)

    inner.bind("<Configure>", _on_inner_configure)
    canvas.bind("<Configure>", _on_canvas_configure)

    # Mouse wheel: default Tk scroll speed (one unit per notch)
    def _on_mousewheel(event):
        if getattr(event, "delta", None) is not None:
            canvas.yview_scroll(int(-1 * (event.delta / 120)), "units")
        elif event.num == 5:
            canvas.yview_scroll(1, "units")
        elif event.num == 4:
            canvas.yview_scroll(-1, "units")

    canvas.bind("<MouseWheel>", _on_mousewheel)
    inner.bind("<MouseWheel>", _on_mousewheel)
    canvas.bind("<Button-4>", _on_mousewheel)
    canvas.bind("<Button-5>", _on_mousewheel)
    inner.bind("<Button-4>", _on_mousewheel)
    inner.bind("<Button-5>", _on_mousewheel)

    scrollbar.pack(side=tk.RIGHT, fill=tk.Y)
    canvas.pack(side=tk.LEFT, fill=tk.BOTH, expand=True)

    # Track which row is highlighted (selected for printing) and which job id
    selected_row_holder = [None]  # [tk.Frame | None]
    selected_jo_id_ref = [None]   # [int | None] job order id for selection preservation
    last_data_ref = [None]        # [list | None] last successful fetch for current date
    last_plan_start_ref = [date.today()]  # plan date for the current list (search filter uses same)
    after_id_ref = [None]         # [str | None] root.after id to cancel retry/refresh

    def _data_equal(a: Optional[list], b: Optional[list]) -> bool:
        if a is None or b is None:
            return a is b
        if len(a) != len(b):
            return False
        for x, y in zip(a, b):
            if x.get("id") != y.get("id"):
                return False
            for k in ("bagPrintedQty", "labelPrintedQty", "laserPrintedQty"):
                if x.get(k) != y.get(k):
                    return False
        return True

    def _build_list_from_data(data: list, plan_start: date, preserve_selection: bool) -> None:
        selected_row_holder[0] = None
        year = plan_start.year
        selected_id = selected_jo_id_ref[0] if preserve_selection else None
        found_row = None
        for jo in data:
            jo_id = jo.get("id")
            raw_batch = batch_no(year, jo_id) if jo_id is not None else "—"
            lot_no_val = jo.get("lotNo")
            batch = (lot_no_val or "—").strip() if lot_no_val else "—"
            jo_no_display = (jo.get("code") or "").strip()
            if not jo_no_display and jo_id is not None:
                jo_no_display = raw_batch
            elif not jo_no_display:
                jo_no_display = "—"
            # Line 1: job order no.; line 2: 需求 + 已印（袋／標／激）on one row for compact scrolling
            head_line = f"工單：{jo_no_display}"
            item_code = jo.get("itemCode") or "—"
            item_name = jo.get("itemName") or "—"
            req_qty = jo.get("reqQty")
            qty_str = format_qty(req_qty)
            bag_pq = _printed_qty_int(jo.get("bagPrintedQty"))
            label_pq = _printed_qty_int(jo.get("labelPrintedQty"))
            laser_pq = _printed_qty_int(jo.get("laserPrintedQty"))
            meta_line = (
                f"需求：{qty_str}　"
                f"已印　袋{bag_pq:,}　標{label_pq:,}　激{laser_pq:,}"
            )
            # Columns: fixed-width left | fixed-width 品號 | 品名 (expand)
            row = tk.Frame(
                inner,
                bg=BG_ROW,
                relief=tk.RAISED,
                bd=2,
                cursor="hand2",
                padx=10,
                pady=LIST_ROW_IPADY,
            )
            row.pack(fill=tk.X, pady=LIST_ROW_PADY)

            left = tk.Frame(row, bg=BG_ROW, width=LEFT_COL_WIDTH_PX)
            left.pack_propagate(False)
            left.pack(side=tk.LEFT, anchor=tk.NW, fill=tk.Y)
            batch_lbl = tk.Label(
                left,
                text=head_line,
                font=get_font(FONT_SIZE_BUTTONS),
                bg=BG_ROW,
                fg="black",
            )
            batch_lbl.pack(anchor=tk.W)
            meta_lbl = tk.Label(
                left,
                text=meta_line,
                font=get_font(FONT_SIZE_META),
                bg=BG_ROW,
                fg="#222222",
                anchor=tk.W,
                justify=tk.LEFT,
                wraplength=LEFT_COL_WIDTH_PX - 8,
            )
            meta_lbl.pack(anchor=tk.W)

            code_col = tk.Frame(row, bg=BG_ROW, width=CODE_COL_WIDTH_PX)
            code_col.pack_propagate(False)
            code_col.pack(side=tk.LEFT, anchor=tk.NW, fill=tk.Y, padx=(6, 2))
            code_lbl = tk.Label(
                code_col,
                text=item_code,
                font=get_font(FONT_SIZE_ITEM_CODE),
                bg=BG_ROW,
                fg="black",
                wraplength=ITEM_CODE_WRAP,
                justify=tk.LEFT,
                anchor=tk.NW,
            )
            code_lbl.pack(anchor=tk.NW)

            name_col = tk.Frame(row, bg=BG_ROW)
            name_col.pack(side=tk.LEFT, fill=tk.BOTH, expand=True, anchor=tk.NW)
            name_lbl = tk.Label(
                name_col,
                text=item_name or "—",
                font=get_font(FONT_SIZE_ITEM_NAME),
                bg=BG_ROW,
                fg="black",
                wraplength=ITEM_NAME_WRAP,
                justify=tk.LEFT,
                anchor=tk.NW,
            )
            name_lbl.pack(anchor=tk.NW)

            def _on_click(e, j=jo, b=batch, r=row):
                if (
                    printer_var.get() == "打袋機 DataFlex"
                    and dataflex_busy_ref[0]
                    and active_dataflex_session_ref[0] is not None
                ):
                    s = active_dataflex_session_ref[0]
                    messagebox.showwarning(
                        "打袋機",
                        f"連續列印進行中，請先按「停止列印」。\n\n"
                        f"工單：{s.job_code}\n"
                        f"品號：{s.item_code}\n"
                        f"品名：{s.item_name}",
                    )
                    return
                if selected_row_holder[0] is not None:
                    set_row_highlight(selected_row_holder[0], False)
                set_row_highlight(r, True)
                selected_row_holder[0] = r
                selected_jo_id_ref[0] = j.get("id")
                if printer_var.get() == "打袋機 DataFlex":
                    ip = (settings.get("dabag_ip") or "").strip()
                    port_str = (settings.get("dabag_port") or "3008").strip()
                    try:
                        port = int(port_str)
                    except ValueError:
                        port = 3008
                    if not ip:
                        messagebox.showerror("打袋機", "請在設定中填寫打袋機 DataFlex 的 IP。")
                    else:
                        hold_dataflex_status_ok(12.0)

                        def _after_row_select_reset() -> None:
                            bag_ans = ask_bag_count(root)
                            if bag_ans is not None:
                                n, continuous = bag_ans
                                hold_dataflex_status_ok(12.0)
                                item_code = j.get("itemCode") or "—"
                                item_name = j.get("itemName") or "—"
                                item_id = j.get("itemId")
                                stock_in_line_id = j.get("stockInLineId")
                                lot_no = j.get("lotNo")
                                zpl = generate_zpl_dataflex(
                                    b,
                                    item_code,
                                    item_name,
                                    item_id=item_id,
                                    stock_in_line_id=stock_in_line_id,
                                    lot_no=lot_no,
                                    job_order_id=j.get("id"),
                                    expiry_text=job_expiry_zpl_text(j),
                                )
                                label_text = (lot_no or b).strip()
                                if continuous:
                                    if dataflex_busy_ref[0]:
                                        messagebox.showwarning(
                                            "打袋機",
                                            "請等待目前列印完成或先停止連續列印。",
                                        )
                                        return
                                    session = build_dataflex_print_session(
                                        j,
                                        b,
                                        zpl,
                                        label_text,
                                        ip,
                                        port,
                                    )
                                    active_dataflex_session_ref[0] = session
                                    stop_ev = threading.Event()
                                    stop_win = open_dataflex_stop_window(
                                        root,
                                        stop_ev,
                                        dataflex_stop_win_ref,
                                        session,
                                    )
                                    run_dataflex_continuous_thread(
                                        root=root,
                                        session=session,
                                        stop_event=stop_ev,
                                        stop_win=stop_win,
                                        dataflex_lock=dataflex_lock,
                                        dataflex_busy_ref=dataflex_busy_ref,
                                        dataflex_stop_win_ref=dataflex_stop_win_ref,
                                        active_session_ref=active_dataflex_session_ref,
                                        base_url=base_url_ref[0],
                                        set_status_message=set_status_message,
                                        on_recorded=lambda: load_job_orders(
                                            from_user_date_change=False
                                        ),
                                    )
                                else:
                                    run_dataflex_fixed_qty_thread(
                                        root=root,
                                        dataflex_lock=dataflex_lock,
                                        dataflex_busy_ref=dataflex_busy_ref,
                                        ip=ip,
                                        port=port,
                                        n=n,
                                        zpl=zpl,
                                        label_text=label_text,
                                        jo_id=j.get("id"),
                                        base_url=base_url_ref[0],
                                        set_status_message=set_status_message,
                                        on_recorded=lambda: load_job_orders(
                                            from_user_date_change=False
                                        ),
                                    )

                        def _row_select_reset_worker() -> None:
                            try:
                                send_dataflex_start_job_reset(ip, port, force=True)
                            except OSError as ex:
                                root.after(
                                    0,
                                    lambda e=str(ex): messagebox.showwarning(
                                        "打袋機",
                                        f"點選工單時重設批次計數失敗（仍可比對數量）：{e}",
                                    ),
                                )
                            root.after(0, _after_row_select_reset)

                        threading.Thread(target=_row_select_reset_worker, daemon=True).start()
                elif printer_var.get() == "標簽機":
                    com = (settings.get("label_com") or "").strip()
                    if not com:
                        messagebox.showerror("標簽機", "請在設定中填寫標簽機名稱 (例如：TSC TTP-246M Pro)。")
                    else:
                        count = ask_label_count(root)
                        lift_dataflex_stop_if_running()
                        if count is not None:
                            item_code = j.get("itemCode") or "—"
                            item_name = j.get("itemName") or "—"
                            item_id = j.get("itemId")
                            stock_in_line_id = j.get("stockInLineId")
                            lot_no = j.get("lotNo")
                            n = count
                            try:
                                # Always render to image (Chinese OK), then send as ZPL graphic (^GFA).
                                # This is more reliable than Windows GDI and works for both Windows printer name and COM.
                                if not _HAS_PIL_QR:
                                    raise RuntimeError("請先安裝 Pillow + qrcode（pip install Pillow qrcode[pil]）。")
                                label_img = render_label_to_image(
                                    b, item_code, item_name,
                                    item_id=item_id, stock_in_line_id=stock_in_line_id,
                                    lot_no=lot_no,
                                )
                                zpl_img = _image_to_zpl_gfa(label_img)
                                run_label_print_batch_thread(
                                    root=root,
                                    label_lock=label_lock,
                                    label_busy_ref=label_busy_ref,
                                    com=com,
                                    zpl_img=zpl_img,
                                    n=n,
                                    jo_id=j.get("id"),
                                    base_url=base_url_ref[0],
                                    set_status_message=set_status_message,
                                    on_recorded=lambda: load_job_orders(
                                        from_user_date_change=False
                                    ),
                                )
                            except Exception as err:
                                messagebox.showerror("標簽機", f"列印失敗：{err}")
                elif printer_var.get() == "激光機":
                    ip = (settings.get("laser_ip") or "").strip()
                    port_str = (settings.get("laser_port") or "45678").strip()
                    try:
                        port = int(port_str)
                    except ValueError:
                        port = 45678
                    if not ip:
                        set_status_message("請在設定中填寫激光機的 IP。", is_error=True)
                    else:
                        item_id = j.get("itemId")
                        stock_in_line_id = j.get("stockInLineId")
                        item_code_val = j.get("itemCode") or ""
                        item_name_val = j.get("itemName") or ""
                        run_laser_row_send_thread(
                            root=root,
                            laser_conn_ref=laser_conn_ref,
                            laser_busy_ref=laser_send_busy_ref,
                            ip=ip,
                            port=port,
                            item_id=item_id,
                            stock_in_line_id=stock_in_line_id,
                            item_code=item_code_val,
                            item_name=item_name_val,
                            set_status_message=set_status_message,
                            base_url=base_url_ref[0],
                            job_order_id=j.get("id"),
                            on_recorded=lambda: load_job_orders(from_user_date_change=False),
                            expiry_text=job_expiry_laser_param(j),
                        )

            for w in (
                row,
                left,
                batch_lbl,
                meta_lbl,
                code_col,
                code_lbl,
                name_col,
                name_lbl,
            ):
                w.bind("<Button-1>", _on_click)
                w.bind("<MouseWheel>", _on_mousewheel)
                w.bind("<Button-4>", _on_mousewheel)
                w.bind("<Button-5>", _on_mousewheel)
            if preserve_selection and selected_id is not None and jo.get("id") == selected_id:
                found_row = row
        if found_row is not None:
            set_row_highlight(found_row, True)
            selected_row_holder[0] = found_row

    def refresh_visible_list() -> None:
        """Re-apply search filter to last fetched rows without hitting the API."""
        raw = last_data_ref[0]
        if raw is None:
            return
        ps = last_plan_start_ref[0]
        needle = search_var.get().strip()
        shown = _filter_job_orders_by_search(raw, needle) if needle else raw
        for w in inner.winfo_children():
            w.destroy()
        _build_list_from_data(shown, ps, preserve_selection=True)

    search_entry.bind("<KeyRelease>", lambda e: refresh_visible_list())

    def load_job_orders(from_user_date_change: bool = False) -> None:
        if after_id_ref[0] is not None:
            root.after_cancel(after_id_ref[0])
            after_id_ref[0] = None
        date_str = date_var.get().strip()
        try:
            plan_start = date.fromisoformat(date_str)
        except ValueError:
            messagebox.showerror("日期錯誤", f"請使用 yyyy-MM-dd 格式。目前：{date_str}")
            return
        if from_user_date_change:
            selected_row_holder[0] = None
            selected_jo_id_ref[0] = None
        try:
            data = fetch_job_orders(base_url_ref[0], plan_start)
        except requests.RequestException:
            set_status_error()
            after_id_ref[0] = root.after(RETRY_MS, lambda: load_job_orders(from_user_date_change=False))
            return
        set_status_ok()
        old_data = last_data_ref[0]
        last_data_ref[0] = data
        last_plan_start_ref[0] = plan_start
        data_changed = not _data_equal(old_data, data)
        if data_changed or from_user_date_change:
            printing_busy = (
                dataflex_busy_ref[0]
                or label_busy_ref[0]
                or laser_send_busy_ref[0]
            )
            # Do not destroy/rebuild all rows while printing — that removes click bindings and
            # can hide DataFlex「停止列印」. Retry until idle (one deferred pass at a time).
            if printing_busy and not from_user_date_change:
                after_id_ref[0] = root.after(
                    JOB_LIST_DEFER_WHILE_PRINTING_MS,
                    lambda: load_job_orders(from_user_date_change=False),
                )
            else:
                # Rebuild list: clear and rebuild from current data (last_data_ref already updated)
                for w in inner.winfo_children():
                    w.destroy()
                preserve = not from_user_date_change
                needle = search_var.get().strip()
                shown = _filter_job_orders_by_search(data, needle) if needle else data
                _build_list_from_data(shown, plan_start, preserve_selection=preserve)
        if from_user_date_change:
            canvas.yview_moveto(0)
        if JOB_LIST_AUTO_REFRESH_MS > 0:
            after_id_ref[0] = root.after(
                JOB_LIST_AUTO_REFRESH_MS,
                lambda: load_job_orders(from_user_date_change=False),
            )

    # Load default (today) on start; then start printer connection check
    root.after(100, lambda: load_job_orders(from_user_date_change=True))
    root.after(300, check_printer)

    root.mainloop()


def _startup_error_log_path() -> str:
    if getattr(sys, "frozen", False):
        base = os.path.dirname(sys.executable)
    else:
        base = os.path.dirname(os.path.abspath(__file__))
    return os.path.join(base, "bag4_startup_error.log")


if __name__ == "__main__":
    try:
        main()
    except SystemExit:
        raise
    except Exception:
        import traceback

        log_path = _startup_error_log_path()
        try:
            with open(log_path, "w", encoding="utf-8") as f:
                traceback.print_exc(file=f)
        except OSError:
            log_path = "(could not write log file)"
        msg = f"Bag4 啟動失敗，詳情已寫入：\n{log_path}"
        print(msg, file=sys.stderr)
        traceback.print_exc()
        try:
            _err_root = tk.Tk()
            _err_root.withdraw()
            messagebox.showerror("Bag4", msg)
            _err_root.destroy()
        except Exception:
            pass
        if getattr(sys, "frozen", False):
            try:
                input("按 Enter 關閉…")
            except (EOFError, KeyboardInterrupt):
                pass
        sys.exit(1)