"""Bring back a ``hermes --tui -w`` worktree a resume needs (N8).

Quitting a clean, idle ``--tui -w`` session removes its tree and branch, but the session's policy
froze that cwd, and the owner refuses every turn in a missing directory (``workspace_unavailable``).
So the launcher records each tree it creates in the profile's ``tui_worktrees.json``, and a resume
whose session cwd is such a missing tree recreates it at the same path before attaching: from its
branch when that still exists, else a new branch of the same name from the repo's current HEAD.

Only a path this profile's launcher recorded, directly under its repo's ``.worktrees/``, is ever
created; any other missing directory is left alone (the resume warns as before).
"""

from __future__ import annotations

import logging
import os
import subprocess
import threading
from pathlib import Path
from typing import Optional

logger = logging.getLogger(__name__)

_RECORD_NAME = "tui_worktrees.json"
_MAX_RECORDS = 500
_holder = threading.local()


def _record_path() -> Path:
    from hermes_constants import get_hermes_home
    return get_hermes_home() / _RECORD_NAME


def _key(path) -> str:
    return os.path.normcase(os.path.realpath(str(path)))


def _read() -> dict:
    from utils import read_json_or_empty
    trees = read_json_or_empty(_record_path()).get("trees")
    return trees if isinstance(trees, dict) else {}


def record_tui_worktree(wt_info: dict) -> None:
    """Remember a tree the ``-w`` / ``--tui -w`` launcher created, or a classic ``/worktree new``
    moved its gateway session into. Never raises."""
    try:
        from hermes_cli.auth import _file_lock
        from utils import atomic_json_write

        path = _record_path()
        with _file_lock(path.with_name(path.name + ".lock"), _holder, 5.0,
                        "Timed out waiting for the TUI worktree record lock"):
            trees = {k: v for k, v in _read().items()
                     if isinstance(v, dict) and (Path(str(v.get("repo_root") or "")) / ".git").exists()}
            trees[_key(wt_info["path"])] = {"path": str(wt_info["path"]), "branch": wt_info["branch"],
                                            "repo_root": str(wt_info["repo_root"])}
            atomic_json_write(path, {"version": 1, "trees": dict(list(trees.items())[-_MAX_RECORDS:])})
    except Exception:  # health: allow BLE001 -- a lost record only means no recreate on resume
        logger.debug("TUI worktree record failed for %s", wt_info.get("path"), exc_info=True)


def _recorded_tree_for(cwd: str) -> Optional[dict]:
    """The launcher's record of the missing tree *cwd* is (or is inside), or None."""
    try:
        trees = _read()
    except Exception:  # health: allow BLE001 -- unreadable record: create nothing
        return None
    probe = Path(cwd)
    for candidate in (probe, *probe.parents):
        entry = trees.get(_key(candidate))
        if not isinstance(entry, dict):
            continue
        repo = Path(str(entry.get("repo_root") or ""))
        tree = Path(str(entry.get("path") or ""))
        branch = str(entry.get("branch") or "")
        # Only a direct child of the repo's Hermes worktree dir, as _setup_worktree makes them.
        if (branch and (repo / ".git").exists()
                and _key(tree.parent) == _key(repo / ".worktrees") and _key(tree) == _key(candidate)):
            return {"path": str(tree), "branch": branch, "repo_root": str(repo)}
        return None
    return None


def _branch_exists(repo_root: str, branch: str) -> bool:
    from hermes_cli.worktree_ops import _git
    result = _git(["rev-parse", "--verify", "--quiet", f"refs/heads/{branch}"], repo_root)
    return result.returncode == 0


def recreate_tui_worktree(cwd: str, session_id: str) -> Optional[str]:
    """Recreate the launcher-made tree a resumed session's missing *cwd* names -> its path, or None.

    Reuses the branch when it survived (its commits come back), else makes it again from the repo's
    current HEAD. The tree is locked for the session so the stale-tree prune keeps it. Never raises.
    """
    if not cwd or os.path.isdir(cwd):
        return None
    entry = _recorded_tree_for(cwd)
    if entry is None:
        return None
    from hermes_cli._subprocess_compat import noninteractive_repo_git_env
    from hermes_cli.worktree_ops import (
        _copy_worktree_includes,
        _git,
        _git_quiet,
        _retain_worktree_for_session,
    )
    from hermes_constants import get_hermes_home

    repo_root, tree, branch = entry["repo_root"], Path(entry["path"]), entry["branch"]
    if tree.exists():  # a file, or a dir that appeared since: never overwrite it
        return None
    env = noninteractive_repo_git_env(repo_root)
    if env is None:
        return None
    try:
        # A tree deleted by hand leaves its admin entry; drop it so the path can be added again.
        _git_quiet(["worktree", "prune"], repo_root, timeout=15, stdin=subprocess.DEVNULL, env=env)
        tree.parent.mkdir(parents=True, exist_ok=True)
        args = ([str(tree), branch] if _branch_exists(repo_root, branch)
                else [str(tree), "-b", branch, "HEAD"])
        result = _git(["worktree", "add", *args], repo_root, timeout=120, stdin=subprocess.DEVNULL, env=env)
        if result.returncode != 0:
            logger.warning("could not recreate worktree %s: %s", tree, result.stderr.strip())
            return None
        _copy_worktree_includes(repo_root, tree)
        _retain_worktree_for_session(repo_root, str(tree), session_id, get_hermes_home() / "state.db")
    except (OSError, subprocess.SubprocessError) as exc:
        logger.warning("could not recreate worktree %s: %s", tree, exc)
        return None
    return str(tree)