import threading
from typing import Any, Optional

_abort = threading.Event()
_sb_ref: Optional[Any] = None
_lock = threading.Lock()


class AbortedError(RuntimeError):
    pass


def clear() -> None:
    _abort.clear()


def set_flag() -> None:
    _abort.set()


def is_aborted() -> bool:
    return _abort.is_set()


def check() -> None:
    if _abort.is_set():
        raise AbortedError("aborted")


def register_sb(sb: Any) -> None:
    global _sb_ref
    with _lock:
        _sb_ref = sb


def clear_sb() -> None:
    global _sb_ref
    with _lock:
        _sb_ref = None


def nuke_driver() -> None:
    with _lock:
        sb = _sb_ref
    if sb is None:
        return
    try:
        driver = getattr(sb, "driver", None)
        if driver is not None:
            try:
                driver.quit()
            except Exception:
                pass
    except Exception:
        pass