nodes/save_io.py

Part of Klondike Solitaire.

"""JSON save/load for the live GameState.

The engine's `simvx.core.save_manager.SaveManager` walks `Property(persist=True)`
descriptors. The Klondike state lives in mutable Python lists (deck order, move
history) -- not natural Property values -- so the payload is serialised by hand
to JSON, which also keeps the save file human-readable. The crash-safe write
itself is the engine's `simvx.core.io.atomic_write_text`.
"""

from __future__ import annotations

import json
from pathlib import Path

from simvx.core.io import atomic_write_text

from .game_state import GameState

DEFAULT_SLOT = "klondike"


def save_dir() -> Path:
    """Where save files live. Resolved per call so tests can redirect it via cwd.

    Nothing is created here: `atomic_write_text` makes the directory when the
    first save is written, so merely asking whether a save exists leaves no
    trace on disk.
    """
    return Path.cwd() / "saves"


def save_path(slot: str = DEFAULT_SLOT) -> Path:
    return save_dir() / f"{slot}.json"


def has_save(slot: str = DEFAULT_SLOT) -> bool:
    """Whether a save file exists, without paying to parse it."""
    return save_path(slot).exists()


def save_game(state: GameState, slot: str = DEFAULT_SLOT) -> Path:
    """Write the save, keeping one rotated `.bak` of the previous one.

    The rotation copies rather than moves, so the live save stays valid until
    `atomic_write_text` swaps the new payload in.
    """
    target = save_path(slot)
    if target.exists():
        target.with_suffix(".json.bak").write_bytes(target.read_bytes())
    return atomic_write_text(target, json.dumps(state.to_dict(), indent=2))


def load_game(slot: str = DEFAULT_SLOT) -> GameState | None:
    p = save_path(slot)
    if not p.exists():
        return None
    try:
        data = json.loads(p.read_text("utf-8"))
    except (json.JSONDecodeError, OSError):
        return None
    try:
        return GameState.from_dict(data)
    except (KeyError, ValueError, TypeError):
        return None


def delete_save(slot: str = DEFAULT_SLOT) -> bool:
    p = save_path(slot)
    if p.exists():
        p.unlink()
        return True
    return False