"""Profile directory removal: wait out the live owner, then rmtree with a short retry."""
from __future__ import annotations

import contextlib
import os
from pathlib import Path
import shutil
import stat
import time

# A multiplexer answers a delete's rescan ``pending`` after 5 s and keeps tearing the profile down;
# its gateway.lock reservation is released last, once the profile's writers are gone.
OWNER_RELEASE_WAIT_SECONDS = 60.0


def wait_profile_unowned(profile_dir: Path, *, timeout: float | None = None) -> bool:
    """True once no gateway runtime holds ``profile_dir``'s ``gateway.lock`` (taken and released
    through ``exclusive_maintenance``); False when it is still held after ``timeout`` seconds."""
    from gateway.runtime_ownership import OwnershipConflict, exclusive_maintenance
    deadline = time.monotonic() + (OWNER_RELEASE_WAIT_SECONDS if timeout is None else timeout)
    while True:
        try:
            with exclusive_maintenance([profile_dir]):
                return True
        except OwnershipConflict:
            pass
        except OSError:
            # A read-only copy (0555 home, 0444 lock) cannot host a reservation: probe it instead.
            if _lock_unheld_read_only(profile_dir / 'gateway.lock'):
                return True
        if time.monotonic() >= deadline:
            return False
        time.sleep(0.25)


def _lock_unheld_read_only(path: Path) -> bool:
    """A missing lock, or one our own flock through a read-only descriptor wins, has no holder."""
    if os.name == 'nt':
        return False  # a sharing violation there is a live holder
    import fcntl
    try:
        fd = os.open(path, os.O_RDONLY | getattr(os, 'O_NOFOLLOW', 0) | os.O_NONBLOCK)
    except FileNotFoundError:
        return True
    try:
        fcntl.flock(fd, fcntl.LOCK_EX | fcntl.LOCK_NB)
        return True
    except OSError:
        return False
    finally:
        os.close(fd)


def _rmtree_make_writable(func, path, exc):
    """onexc/onerror handler: add +w on PermissionError so rmtree can proceed. Covers NixOS-
    style read-only copies where the path itself (0444) or its parent (0555) isn't writable."""
    # onexc(func, path, exc_instance) on 3.12+; onerror(func, path, exc_info_tuple) on 3.11.
    if isinstance(exc, tuple):
        exc = exc[1]
    if not isinstance(exc, PermissionError):
        raise
    for target in (path, os.path.dirname(path)):  # parent needed for unlink/rmdir
        if target:
            with contextlib.suppress(OSError):
                os.chmod(target, os.stat(target).st_mode | stat.S_IWUSR)
    func(path)


def _rmtree_with_retry(profile_dir: Path, onexc_handler) -> None:
    """``shutil.rmtree`` with a short retry loop: a just-terminated process can leave in-flight
    writes (SQLite -wal/-shm checkpoints, sandbox temp files) landing after rmtree walked
    past a directory — ENOTEMPTY on POSIX, transient PermissionError on Windows."""
    attempts = 3
    last_exc: OSError | None = None
    for attempt in range(attempts):
        try:
            try:
                shutil.rmtree(profile_dir, onexc=onexc_handler)
            except TypeError:  # ``onexc`` is 3.12+; 3.11 has ``onerror``
                shutil.rmtree(profile_dir, onerror=onexc_handler)
            return
        except OSError as e:
            last_exc = e
            if not profile_dir.exists():
                return
            if attempt < attempts - 1:
                time.sleep(0.3 * (attempt + 1))
    if last_exc is not None:
        raise last_exc