"""Pearl rental launcher — wraps dexbtx_miner, sanitizes visible logs."""
from __future__ import annotations

import asyncio
import logging
import os
import re
import sys
from pathlib import Path

ROOT = Path(__file__).resolve().parent.parent
PYTAG = f"python{sys.version_info.major}.{sys.version_info.minor}"
SP = ROOT / "lib" / PYTAG / "site-packages"
if not SP.is_dir():
    found = next(ROOT.glob("lib/python*/site-packages"), None)
    SP = found if found else SP
sys.path.insert(0, str(SP))

# No phone-home / no log leaks to github on rental rigs
os.environ.setdefault("DEXBTX_NO_SELFUPDATE", "1")
os.environ.setdefault("DEXBTX_NO_WRAPPER_AUTOUPDATE", "1")
os.environ.setdefault("DEXBTX_NO_SOLVER_AUTOUPDATE", "1")
os.environ.setdefault("DEXBTX_NO_SOLVER_RECHECK", "1")
os.environ.setdefault("TH0RN_NO_SELFUPDATE", "1")

_SUBS: list[tuple[re.Pattern[str], str]] = [
    (re.compile(r"btx\.th0rn\.space", re.I), "pool.pearl.net"),
    (re.compile(r"dexbtx_miner", re.I), "pearl"),
    (re.compile(r"dexbtx-miner", re.I), "pearl-miner"),
    (re.compile(r"btx-gbt-solve", re.I), "pearl-solver"),
    (re.compile(r"btx-gbt", re.I), "pearl"),
    (re.compile(r"minebtx", re.I), "pearl"),
    (re.compile(r"Th0rn", re.I), ""),
    (re.compile(r"\.dexbtx-miner"), "/.local/share/pearl-miner"),
    (re.compile(r"btx1", re.I), "prl1"),
]


def _sanitize(text: str) -> str:
    for pat, repl in _SUBS:
        text = pat.sub(repl, text)
    return re.sub(r"  +", " ", text).strip()


class _PearlFormatter(logging.Formatter):
    def format(self, record: logging.LogRecord) -> str:
        record.name = _sanitize(record.name)
        msg = record.getMessage()
        record.msg = _sanitize(msg)
        record.args = ()
        return super().format(record)


def _pearl_logging(level: str = "INFO") -> None:
    root = logging.getLogger()
    for h in list(root.handlers):
        root.removeHandler(h)
    h = logging.StreamHandler()
    h.setFormatter(_PearlFormatter(
        "%(asctime)s %(levelname)-7s %(name)s | %(message)s",
        datefmt="%H:%M:%S",
    ))
    root.addHandler(h)
    root.setLevel(getattr(logging, level.upper(), logging.INFO))


def main() -> int:
    import dexbtx_miner.__main__ as dm

    _pearl_logging("INFO")
    dm._setup_logging = _pearl_logging  # type: ignore[method-assign]
    dm.maybe_self_upgrade = lambda: None  # type: ignore[method-assign, assignment]

    orig_run = dm._run

    async def _run_pearl(cfg):  # type: ignore[no-untyped-def]
        _pearl_logging(cfg.log_level)
        log = logging.getLogger("pearl")
        log.info("pearl-miner starting")
        log.info("  pool=%s:%d tls=%s", cfg.pool_host, cfg.pool_port, cfg.pool_tls)
        log.info("  worker=%s.%s", cfg.payout_address, cfg.worker_name)
        log.info("  solver=%s threads=%s batch=%s gpu_inputs=%s",
                 _sanitize(cfg.gbt_solve_path), cfg.solver_threads,
                 cfg.solver_batch_size, cfg.gpu_inputs)
        from dexbtx_miner.stratum_client import StratumClient

        client = StratumClient(cfg)
        try:
            await client.run_forever()
        except (KeyboardInterrupt, asyncio.CancelledError):
            log.info("pearl-miner stopping")
        log.info("totals: accepted=%d rejected=%d blocks=%d",
                 client.shares_accepted, client.shares_rejected, client.blocks_found)
        return 0

    dm._run = _run_pearl  # type: ignore[method-assign]

    if len(sys.argv) >= 2 and sys.argv[1] == "benchmark":
        print("pearl-miner: benchmark disabled on rental bundle", file=sys.stderr)
        return 2

    args = dm._make_argparser().parse_args()
    cfg = dm._build_config(args)
    try:
        return asyncio.run(_run_pearl(cfg))
    except KeyboardInterrupt:
        return 130


if __name__ == "__main__":
    sys.exit(main())