"""resume: re-launch a bottle by its identity.

Reads ~/.bot-bottle/state/<identity>/metadata.json to recover the
(agent_name, cwd, copy_cwd) the bottle was originally started with,
then runs the same launch core as `start` — but pinned to the
recorded identity so the new bottle picks up any per-bottle Dockerfile
override and transcript snapshot under the same state dir.

Use case: an interrupted or preserved bottle needs to be relaunched;
the operator runs
    ./cli.py resume <identity>
to bring up the replacement from the recorded state.
"""

from __future__ import annotations

import argparse
import os

from ...backend import BottleSpec
from ...bottle_state import read_metadata
from ...log import die
from ...manifest import ManifestIndex
from ..constants import PROG
from .start import _launch_bottle


def cmd_resume(argv: list[str]) -> int:
    parser = argparse.ArgumentParser(prog=f"{PROG} resume", add_help=True)
    parser.add_argument("--dry-run", action="store_true")
    parser.add_argument(
        "identity",
        help="bottle identity from a prior `start` (see its session-end output)",
    )
    args = parser.parse_args(argv)

    metadata = read_metadata(args.identity)
    if metadata is None:
        die(
            f"no state recorded for identity {args.identity!r}; "
            f"check ~/.bot-bottle/state/ or run `cli.py start` to create a new bottle"
        )

    manifest = ManifestIndex.resolve(os.getcwd())
    manifest.require_agent(metadata.agent_name)

    spec = BottleSpec(
        manifest=manifest,
        agent_name=metadata.agent_name,
        copy_cwd=metadata.copy_cwd,
        user_cwd=metadata.cwd or os.getcwd(),
        identity=metadata.identity,
        bottle_names=tuple(metadata.bottle_names),
    )
    backend_name = metadata.backend or None
    return _launch_bottle(
        spec,
        dry_run=args.dry_run,
        backend_name=backend_name,
    )
