"""Gixsql CBL Runner — gixpp + cobc pipeline for DB COBOL programs."""

from __future__ import annotations
import logging
import os
import re
import sqlite3
import subprocess
from dataclasses import dataclass, field
from pathlib import Path
from typing import Optional

logger = logging.getLogger(__name__)


def _strip_schema_qualifiers(text: str) -> str:
    """DB2 schema-qualified table refs (SCHEMA.TABLE) → TABLE.

    SQLite has no schema objects, so gixsql-generated SQL such as
    `FROM SALARYDB.EMP_MASTER` fails at OPEN time ('no such table:
    SALARYDB.EMP_MASTER', SQLCODE != 0) and the program ABENDs before its
    main loop. Strip the qualifier from table positions only
    (after FROM/INTO/UPDATE/JOIN). Column aliases (E.EMP-ID, B.DEPT-CODE)
    and host-var INTO (:DBV-X) are untouched. Program-agnostic: handles
    ANY <schema>.<table>, incl. multi-part (DB2INST1.PAYROLL.TIMESHEET).
    """
    def _fix(m: re.Match) -> str:
        kw = m.group(1)
        table = m.group(2).rsplit('.', 1)[-1]
        return f"{kw} {table}"
    return re.sub(
        r'\b(FROM|INTO|UPDATE|JOIN)\s+([\w-]+(?:\.[\w-]+)+)',
        _fix, text, flags=re.IGNORECASE,
    )


def _normalize_schema_qualifiers(text: str) -> str:
    """Strip schema qualifiers inside EXEC SQL blocks (before gixpp).

    Applied to the source BEFORE gixpp so the generated SQL string literals
    reference plain table names. Only EXEC SQL blocks are touched; other
    text (data literals, comments) is left unchanged. Mirrors
    `_normalize_current_timestamp`.
    """
    def _fix_block(m: re.Match) -> str:
        return _strip_schema_qualifiers(m.group(0))
    return re.sub(r'(?is)EXEC SQL\b.*?\bEND-EXEC', _fix_block, text)


def _normalize_current_timestamp(text: str) -> str:
    """SQLite backend: DB2 `CURRENT TIMESTAMP` → `CURRENT_TIMESTAMP` inside EXEC SQL.

    Applied to the source BEFORE gixpp. gixpp wraps long SQL across continuation
    lines and can split the token (`CURRENT TIMES` / `TAMP`), which defeats a
    post-gixpp same-line regex; normalizing the source first makes the generated
    SQL string literals concatenate to the SQLite-valid `CURRENT_TIMESTAMP`.
    Only EXEC SQL blocks are touched; other text (data literals, comments) is
    left unchanged.
    """
    def _fix_sql(m: re.Match) -> str:
        block = m.group(0)
        return re.sub(r'\bCURRENT\s+TIMESTAMP\b', 'CURRENT_TIMESTAMP',
                      block, flags=re.IGNORECASE)
    return re.sub(r'(?is)EXEC SQL\b.*?\bEND-EXEC', _fix_sql, text)


@dataclass
class GixsqlBuildResult:
    success: bool
    exe_path: str = ""
    log: str = ""


@dataclass
class GixsqlRunResult:
    success: bool
    returncode: int = -1
    db_path: str = ""
    log: str = ""


@dataclass
class GixsqlTableData:
    table_name: str = ""
    rows: list[dict] = field(default_factory=list)


class GixsqlCobolRunner:
    """gixpp + cobc 管线：预处理 → 编译 → 运行 → DB读取"""

    def __init__(self, gixpp_path: str | Path, lib_path: str | Path,
                 cobc_cmd: str = "cobc",
                 compile_flags: str = ""):
        self.gixpp_path = Path(gixpp_path)
        self.lib_path = Path(lib_path)
        self.cobc_cmd = cobc_cmd
        self.compile_flags = compile_flags

    def _build_env(self) -> dict:
        env = os.environ.copy()
        env["LD_LIBRARY_PATH"] = str(self.lib_path)
        if "PATH" in env:
            env["PATH"] = str(self.lib_path) + ";" + env["PATH"]
        else:
            env["PATH"] = str(self.lib_path)
        return env

    def _expand_copy_replacing(self, text: str, search_dirs: list[Path]) -> str:
        """Expand COPY ... REPLACING statements inline (Python-side).
        gixpp's ESQL parser chokes on COPY with REPLACING pseudo-text (==...==).
        """
        def _resolve_copy(m: re.Match) -> str:
            name = m.group(1)
            for d in search_dirs:
                for ext in (".cpy", ".CPY", ".cbl", ".CBL", ""):
                    cp = d / f"{name}{ext}"
                    if cp.exists():
                        cpy_text = cp.read_text(encoding="utf-8-sig")
                        replaces_text = m.group(2)
                        if replaces_text:
                            pairs = re.findall(r'==(.*?)==\s+BY\s+==(.*?)==', replaces_text)
                            for old_txt, new_txt in pairs:
                                cpy_text = cpy_text.replace(old_txt, new_txt)
                        return cpy_text
            logger.warning(f"  COPY {name} not found in {search_dirs}")
            return f"      * COPY {name} NOT FOUND"

        text = re.sub(
            r'^ {6,}COPY\s+(\w+)\s+REPLACING\s+(.+?)\.$',
            _resolve_copy,
            text,
            flags=re.MULTILINE | re.IGNORECASE,
        )
        return text

    def _expand_all_copies(self, text: str, search_dirs: list[Path]) -> str:
        """Expand ALL COPY statements (including COPY SQLCA) — replaces cobc -E."""
        def _resolve_copy_cb(m: re.Match) -> str:
            name = m.group(1).strip().upper()
            replacing_text = m.group(2)
            # Try each search dir
            for d in search_dirs:
                for ext in (".cpy", ".CPY", ".cbl", ".CBL", ""):
                    cp = d / f"{name}{ext}"
                    if cp.exists():
                        cpy_text = cp.read_text(encoding="utf-8-sig")
                        if replacing_text:
                            pairs = re.findall(r'==(.*?)==\s+BY\s+==(.*?)==', replacing_text)
                            for old_txt, new_txt in pairs:
                                cpy_text = cpy_text.replace(old_txt, new_txt)
                        return cpy_text
            # If SQLCA not found in copybook dirs, provide inline definition
            if name == "SQLCA":
                return (
                    "       01 SQLCA.\n"
                    "           05 SQLCAID PIC X(8).\n"
                    "           05 SQLCABC PIC S9(9) COMP-5.\n"
                    "           05 SQLCODE PIC S9(9) COMP-5.\n"
                    "           05 SQLERRM.\n"
                    "               49 SQLERRML PIC S9(4) COMP-5.\n"
                    "               49 SQLERRMC PIC X(256).\n"
                    "           05 SQLERRP PIC X(8).\n"
                    "           05 SQLERRD PIC S9(9) COMP-5 OCCURS 6.\n"
                    "           05 SQLWARN.\n"
                    "               10 SQLWARN0 PIC X(1).\n"
                    "               10 SQLWARN1 PIC X(1).\n"
                    "               10 SQLWARN2 PIC X(1).\n"
                    "               10 SQLWARN3 PIC X(1).\n"
                    "               10 SQLWARN4 PIC X(1).\n"
                    "               10 SQLWARN5 PIC X(1).\n"
                    "               10 SQLWARN6 PIC X(1).\n"
                    "               10 SQLWARN7 PIC X(1).\n"
                    "           05 SQLEXT PIC X(8).\n"
                )
            logger.warning(f"  COPY {name} not found in {search_dirs}")
            return f"      * COPY {name} NOT FOUND\n"

        # Expand COPY name. and COPY name REPLACING ... .
        text = re.sub(
            r'^ {6,}COPY\s+(\w+(?:-\w+)*)\s*(REPLACING\s+.+?)?\.$',
            _resolve_copy_cb,
            text,
            flags=re.MULTILINE | re.IGNORECASE,
        )
        return text

    def _normalize_source(self, src_path: Path) -> tuple[Path, Path]:
        """Pre-process COBOL source for gixpp: expand COPY, strip comments, fix indentation.

        Returns (pre_path, norm_path) where both point to the same gixpp-ready source.
        """
        text = src_path.read_text(encoding="utf-8-sig")

        # 0. Strip ALL comment lines BEFORE any EXEC SQL transforms (regex may match
        #    'EXEC SQL' inside Japanese comments, pulling comment text into SQL strings)
        text = re.sub(r'^[ \t]{0,10}\*.*\n?', '', text, flags=re.MULTILINE)

        # 1. Replace EXEC SQL INCLUDE SQLCA → COPY SQLCA
        text = re.sub(r'EXEC SQL INCLUDE SQLCA END-EXEC\.', '      COPY SQLCA.', text, flags=re.IGNORECASE)
        # Transform EXEC SQL CONNECT TO 'literal' → use WS variables (gixpp requires :variable not literal)
        def _transform_connect(m):
            inner = m.group(1)
            m_lit = re.search(r"CONNECT\s+TO\s+'([^']*)'", inner, re.IGNORECASE)
            if not m_lit:
                return m.group(0)
            conn_var = "WS-GIX-CONN"
            usr_var = "WS-GIX-USR"
            new_inner = re.sub(
                r"CONNECT\s+TO\s+'[^']*'",
                f"CONNECT TO :{conn_var} USER :{usr_var}",
                inner,
            flags=re.IGNORECASE | re.DOTALL
            )
            # Orchestrator copies DB to CWD/kin.
            return (f"MOVE 'sqlite://kin' TO {conn_var}\n"
                    f"           MOVE 'gix' TO {usr_var}\n"
                    f"           EXEC SQL\n"
                    f"           {new_inner.strip()}\n"
                    f"           END-EXEC.")
        text = re.sub(r'(?is)EXEC SQL(.*?CONNECT\s+TO.*?)END-EXEC\.', _transform_connect, text)
        # Add WS-GIX-* after COPY SQLCA
        text = re.sub(
            r"^(\s*COPY SQLCA\.)",
            r"\1\n"
            r"       01 WS-GIX-VARS.\n"
            r"           03 WS-GIX-CONN PIC X(256).\n"
            r"           03 WS-GIX-USR  PIC X(16).",
            text,
            flags=re.MULTILINE | re.IGNORECASE
        )

        # 2. Expand ALL COPY statements in Python (replaces cobc -E)
        if hasattr(self, '_copybook_dirs') and self._copybook_dirs:
            text = self._expand_all_copies(text, self._copybook_dirs)

        # 4. Collapse multiple spaces between keywords
        lines = []
        for line in text.splitlines(keepends=True):
            line = re.sub(r'(\b\w+)\s{2,}(\b\w+\b)', lambda m: f'{m.group(1)} {m.group(2)}', line)
            lines.append(line)
        text = ''.join(lines)

        # 5. Normalize DIVISION/SECTION headers to start at column 8 (7-space indent)
        #    gixpp fixed-format scanner requires headers in Area A (columns 8-11).
        def _fix_header(m):
            return '       ' + m.group(1).lstrip()
        text = re.sub(
            r'^ {6,12}((?:IDENTIFICATION|ENVIRONMENT|DATA|PROCEDURE)\s+DIVISION\.'
            r'|(?:FILE|WORKING-STORAGE|LINKAGE|CONFIGURATION|INPUT-OUTPUT)\s+SECTION\.'
            r'|(?:FILE-CONTROL|I-O-CONTROL)\.'
            r'|SOURCE-COMPUTER\.|OBJECT-COMPUTER\.|SPECIAL-NAMES\.'
            r')',
            _fix_header,
            text,
            flags=re.MULTILINE | re.IGNORECASE
        )

        pre_path = src_path.parent / f"{src_path.stem}_pre.cbl"
        pre_path.write_text(text, encoding="utf-8")

        # 6. No cobc -E — all COPY expansions done in Python above.
        # Use the pre_path directly as the norm_path (gixpp input).
        # 6. Fix SQL clause ordering in EXEC SQL blocks:
        #    gixpp expects SELECT ... INTO ... FROM ... (INTO before FROM),
        #    but some programs have SELECT ... FROM ... INTO ...
        def _fix_sql_from_into(m):
            block = m.group(0)
            # Only touch SELECT ... FROM ... INTO (not INSERT/DELETE)
            if re.match(r'\s*EXEC SQL\s+SELECT\b', block, re.MULTILINE | re.IGNORECASE):
                # Swap FROM line and INTO line within SELECT blocks
                block = re.sub(
                    r'^(\s+)(FROM\b.*)\n(\s+)(INTO\b.*)$',
                    r'\1\4\n\1\2',
                    block,
                    flags=re.MULTILINE | re.IGNORECASE
                )
            return block
        text = re.sub(r'(\s*EXEC SQL\n.*?\n\s*END-EXEC\.)', _fix_sql_from_into, text,
                      flags=re.DOTALL | re.IGNORECASE)

        # 7. Add missing 01-level variables used in PROCEDURE DIVISION but
        #    not defined in DATA DIVISION (source program defects).
        missing_vars = {
            'KIN06CLD': '       01  WS-COL-IDX             PIC 9(002).\n',
        }
        pid = src_path.stem.upper()
        if pid in missing_vars and not re.search(r'\b01\s+WS-COL-IDX\b', text):
            text = re.sub(
                r'^(\s*)(PROCEDURE\s+DIVISION)',
                lambda m: m.group(1) + missing_vars[pid] + '\n' + m.group(1) + m.group(2),
                text, count=1, flags=re.MULTILINE | re.IGNORECASE
            )

        # 8. SQLite backend: DB2 `CURRENT TIMESTAMP` → `CURRENT_TIMESTAMP` inside
        #    EXEC SQL. Must run before gixpp (gixpp can split the token across
        #    continuation lines, defeating the post-gixpp same-line patch).
        text = _normalize_current_timestamp(text)

        # 9. SQLite backend: DB2 schema-qualified table refs (SCHEMA.TABLE) →
        #    TABLE inside EXEC SQL. gixsql would otherwise emit
        #    `FROM SALARYDB.EMP_MASTER`, which SQLite cannot resolve.
        text = _normalize_schema_qualifiers(text)

        norm_path = src_path.parent / f"{src_path.stem}_norm.cbl"
        norm_path.write_text(text, encoding="utf-8")
        # Save a copy in runtime for diagnosis
        try:
            debug_dir = Path(__file__).parent.parent / "runtime" / src_path.stem / "pre_src"
            debug_dir.mkdir(parents=True, exist_ok=True)
            (debug_dir / f"{src_path.stem}_norm.cbl").write_text(text, encoding="utf-8")
            (debug_dir / f"{src_path.stem}_pre.cbl").write_text(
                (src_path.parent / f"{src_path.stem}_pre.cbl").read_text(encoding="utf-8"),
                encoding="utf-8"
            )
        except Exception:
            pass
        return pre_path, norm_path

    def preprocess(self, src_path: str | Path, out_dir: str | Path,
                   copybook_dirs: list[str | Path] | None = None) -> str:
        """Step 1a: gixpp プリプロセス"""
        out_dir = Path(out_dir)
        out_dir.mkdir(parents=True, exist_ok=True)
        src_path = Path(src_path)

        self._copybook_dirs = [Path(d) for d in copybook_dirs] if copybook_dirs else None

        _, norm_path = self._normalize_source(src_path)
        out_path = out_dir / f"{src_path.stem}_pp.cbl"

        cmd = [str(self.gixpp_path), "-i", str(norm_path), "-o", str(out_path), "-e"]
        if self._copybook_dirs:
            for d in self._copybook_dirs:
                cmd += ["-I", str(d)]
        logger.info(f"  gixpp: {' '.join(cmd)}")
        r = subprocess.run(cmd, capture_output=True, timeout=30, env=self._build_env())
        if r.returncode != 0:
            err = r.stderr.decode("utf-8", "replace")[:500]
            raise RuntimeError(f"gixpp failed (rc={r.returncode}): {err}")
        return str(out_path)

    def _patch_sql_identifiers(self, pp_path: Path) -> None:
        """Translate DB2 hyphenated identifiers to underscores inside GIXSQL SQL strings.

        gixsql emits the SQL text verbatim from the COBOL source (e.g.
        "INSERT INTO EMP-MASTER (EMP-ID, ...)"), but SQLite cannot parse bare
        hyphenated identifiers. Convert '-' -> '_' only inside the SQL string
        literals (VALUE "..." lines and & "..." continuation lines), leaving
        COBOL-level identifiers (cursor names, host variables, work items) untouched.
        """
        text = pp_path.read_text(encoding="utf-8")

        def _fix_line(m: re.Match) -> str:
            return m.group(1) + m.group(2).replace('-', '_') + m.group(3)

        # SQL start lines:  GIXSQL ... VALUE "SQL TEXT"
        text = re.sub(
            r'^(GIXSQL.*?VALUE\s+")([^"]*)(")',
            _fix_line, text, flags=re.MULTILINE
        )
        # SQL continuation lines:  GIXSQL  &  "SQL TEXT"
        text = re.sub(
            r'^(GIXSQL\s*&\s*")([^"]*)(")',
            _fix_line, text, flags=re.MULTILINE
        )
        # SQLite accepts CURRENT_TIMESTAMP (no space); gixsql emits CURRENT TIMESTAMP
        text = re.sub(r'\bCURRENT\s+TIMESTAMP\b', 'CURRENT_TIMESTAMP', text, flags=re.IGNORECASE)
        pp_path.write_text(text, encoding="utf-8")

    def _patch_sqlcode_normalize(self, pp_path: Path) -> None:
        """Inject SQLITE-constraint → -803 mapping after each SQL execution.

        gixsql+SQLite reports duplicate-key (PRIMARY KEY / UNIQUE) violations as
        SQLCODE=-1555 / -2067 / -19, whereas the COBOL programs follow DB2
        semantics (SQLCODE = -803). Without this mapping, `IF SQLCODE = -803`
        branches are unreachable under gixsql+SQLite. The injected code is
        program-agnostic: it only rewrites the constraint-violation codes.
        """
        text = pp_path.read_text(encoding="utf-8")
        mapping = (
            '           IF SQLCODE = -1555\n'
            '               MOVE -803 TO SQLCODE\n'
            '           END-IF\n'
            '           IF SQLCODE = -2067\n'
            '               MOVE -803 TO SQLCODE\n'
            '           END-IF\n'
            '           IF SQLCODE = -19\n'
            '               MOVE -803 TO SQLCODE\n'
            '           END-IF\n'
        )
        text = re.sub(
            r'(GIXSQLEndSQL\s*\n?.*?END-CALL\.?)\s*\n(\s*)(IF SQLCODE\s+)',
            lambda m: m.group(1) + '\n' + m.group(2) + mapping + m.group(2) + m.group(3),
            text,
            flags=re.IGNORECASE | re.DOTALL
        )
        pp_path.write_text(text, encoding="utf-8")

    def _patch_sqlcode_override(self, pp_path: Path) -> None:
        """Inject MOVE 0 TO SQLCODE after each GIXSQLEndSQL call.

        Workaround for gixsql DLL bug: GIXSQLExecParams/GIXSQLExec fail with
        'Can't find a connection' even though the connection is valid.
        Setting SQLCODE=0 lets the program flow through success paths for
        coverage measurement. The DB state is not validated in coverage runs.
        """
        text = pp_path.read_text(encoding="utf-8")
        text = re.sub(
            r'(GIXSQLEndSQL\s*\n?.*?END-CALL\.?)\s*\n(\s*)(IF SQLCODE\s+(?:NOT\s+)?=\s+0)',
            r'\1\n\2           MOVE 0 TO SQLCODE\n\2\3',
            text,
            flags=re.IGNORECASE | re.DOTALL
        )
        pp_path.write_text(text, encoding="utf-8")

    def compile(self, pp_path: str | Path, exe_path: str | Path,
                copybook_dirs: list[str | Path] | None = None,
                extra_srcs: list[str | Path] | None = None) -> GixsqlBuildResult:
        """Step 1b: cobc 编译（gixsql 链接）"""
        pp_path = Path(pp_path)
        exe_path = Path(exe_path)
        exe_dir = exe_path.parent
        exe_dir.mkdir(parents=True, exist_ok=True)

        # SQL is now executed correctly (hyphen->underscore identifiers), so the
        # SQLCODE=0 override workaround is no longer needed. It masked real SQL
        # errors and caused infinite FETCH loops (SQLCODE forced to 0 prevents
        # "PERFORM UNTIL SQLCODE NOT = 0" from terminating at EOF=100).
        # self._patch_sqlcode_override(pp_path)

        # Translate DB2 hyphenated identifiers -> underscores in SQL strings
        self._patch_sql_identifiers(pp_path)

        # Map gixsql SQLite constraint codes (-1555/-2067/-19) -> DB2 -803 so
        # `IF SQLCODE = -803` branches are reachable under gixsql+SQLite.
        self._patch_sqlcode_normalize(pp_path)

        # Functions that the preprocessed COBOL actually CALLs
        gixsql_k = [
            "-K", "GIXSQLStartSQL",
            "-K", "GIXSQLSetSQLParams", "-K", "GIXSQLSetResultParams",
            "-K", "GIXSQLExecParams", "-K", "GIXSQLExec",
            "-K", "GIXSQLExecSelectIntoOne",
            "-K", "GIXSQLEndSQL",
            "-K", "GIXSQLConnect",
            "-K", "GIXSQLCursorDeclare",
            "-K", "GIXSQLCursorDeclareParams",
            "-K", "GIXSQLCursorFetchOne",
            "-K", "GIXSQLCursorOpen",
            "-K", "GIXSQLCursorClose",
        ]
        cmd = [
            self.cobc_cmd, "-x",
            "-L", str(self.lib_path.resolve()),
            *gixsql_k,
            "-l", "gixsql",
        ]
        if copybook_dirs:
            for d in copybook_dirs:
                cmd += ["-I", str(d)]
        if self.compile_flags:
            cmd += self.compile_flags.split()
        cmd += ["-o", str(exe_path)]
        cmd.append(str(pp_path))
        if extra_srcs:
            for s in extra_srcs:
                cmd.append(str(s))

        logger.info(f"  cobc: {' '.join(cmd)}")
        try:
            r = subprocess.run(cmd, capture_output=True, timeout=60, env=self._build_env(),
                               cwd=str(exe_dir))
            log = (r.stdout.decode("utf-8", "replace") + "\n" +
                   r.stderr.decode("utf-8", "replace"))
            if r.returncode != 0:
                return GixsqlBuildResult(False, log=log[:1000])
            # .gcno files are generated in exe_dir (compile CWD). No need to copy.
            return GixsqlBuildResult(True, exe_path=str(exe_path), log=log[:500])
        except subprocess.TimeoutExpired:
            return GixsqlBuildResult(False, log="Compile timeout (60s)")

    def run(self, exe_path: str | Path, work_dir: str | Path,
            db_path: str | Path,
            input_dir: str | Path | None = None,
            timeout: int = 30,
            cobol_lib_path: str | Path | None = None,
            env_overrides: dict[str, str] | None = None,
            command_args: list[str] | None = None) -> GixsqlRunResult:
        """Step 3: COBOL DB プログラム実行"""
        exe_path = Path(exe_path)
        work_dir = Path(work_dir)
        db_path = Path(db_path)
        work_dir.mkdir(parents=True, exist_ok=True)
        exe_dir = exe_path.parent
        exe_dir.mkdir(parents=True, exist_ok=True)

        lib_path = Path(self.lib_path)

        # Deploy correct DLLs to exe_dir so loader finds them first
        # Search lib_path first, then fall back to gixpp bin dir for runtime DLLs
        gixpp_dir = self.gixpp_path.parent
        dll_names = [
            "libgixsql.dll", "libgixsql-sqlite.dll",
            "libgcc_s_dw2-1.dll", "libstdc++-6.dll",
            "libwinpthread-1.dll", "libiconv-2.dll",
            "libintl-8.dll", "zlib1.dll",
        ]
        for name in dll_names:
            src = lib_path / name
            if not src.exists():
                src = gixpp_dir / name
            if src.exists():
                dst = exe_dir / name
                if not dst.exists() or dst.stat().st_size != src.stat().st_size:
                    dst.write_bytes(src.read_bytes())

        # libfmt.dll search: TEMP fallback → lib_path → gixpp bin → x86/gcc subdirectory
        fmt_src = Path(os.environ.get("TEMP", "")) / "zan_dll" / "libfmt.dll"
        if not fmt_src.exists():
            fmt_src = lib_path / "libfmt.dll"
        if not fmt_src.exists():
            fmt_src = gixpp_dir / "libfmt.dll"
        if not fmt_src.exists():
            # gixsql binary package variant: <gixpp-parent>/lib/x86/gcc/libfmt.dll
            fmt_src = gixpp_dir.parent / "lib" / "x86" / "gcc" / "libfmt.dll"
        if fmt_src.exists():
            (exe_dir / "libfmt.dll").write_bytes(fmt_src.read_bytes())

        env = self._build_env()
        env["GIXSQL_DB_PATH"] = str(db_path)
        if cobol_lib_path:
            env["COB_LIBRARY_PATH"] = str(cobol_lib_path)
        if env_overrides:
            env.update(env_overrides)

        if input_dir:
            idir = Path(input_dir)
            if idir.exists():
                for f in idir.iterdir():
                    if f.is_file():
                        dst = work_dir / f.name
                        dst.write_bytes(f.read_bytes())

        cmd = [str(exe_path)]
        if command_args:
            cmd.extend(command_args)
        logger.info(f"  run: {' '.join(cmd)} (cwd={work_dir}, db={db_path})")
        try:
            r = subprocess.run(cmd, capture_output=True, timeout=timeout,
                               cwd=str(work_dir), env=env)
            log = (r.stdout.decode("utf-8", "replace") + "\n" +
                   r.stderr.decode("utf-8", "replace"))
            ok = r.returncode == 0 or r.returncode == 1
            return GixsqlRunResult(ok, returncode=r.returncode,
                                   db_path=str(db_path), log=log[:1000])
        except subprocess.TimeoutExpired:
            return GixsqlRunResult(False, log="Run timeout")

    def read_db_tables(self, db_path: str | Path,
                       table_names: list[str]) -> list[GixsqlTableData]:
        """Step 4: SQLite DB から全テーブル読み取り"""
        db_path = Path(db_path)
        if not db_path.exists():
            logger.warning(f"  DB not found: {db_path}")
            return []
        conn = sqlite3.connect(str(db_path))
        conn.row_factory = sqlite3.Row
        results = []
        for tname in table_names:
            try:
                rows = conn.execute(f"SELECT * FROM [{tname}]").fetchall()
                results.append(GixsqlTableData(
                    table_name=tname,
                    rows=[dict(r) for r in rows],
                ))
            except sqlite3.OperationalError as e:
                logger.warning(f"  Table {tname} not found: {e}")
        conn.close()
        return results