"""Push/pull experiment files through the skill's marimo scratchpad client.

This helper does not launch experiments or retry execution. Model downloads
remain remote. Transfers are ordinary notebook code, with no SSH or service.
"""

from __future__ import annotations

import argparse
import base64
import io
import json
import os
from pathlib import Path
import shutil
import subprocess
import sys
import zipfile


SKILL_REMOTE = (Path(os.environ.get("CODEX_HOME", str(Path.home() / ".codex")))
                / "skills/molab-marimo/scripts/molab_remote.py")


def execute(code, state_file, capture=False):
    command = [sys.executable, str(SKILL_REMOTE), "exec", "--state-file", state_file]
    return subprocess.run(command, input=code, text=True, capture_output=capture, check=True)


def pull_archive(paths, destination, args):
    code = f'''import base64, io, zipfile
from pathlib import Path
_root = Path({args.remote_root!r}).resolve()
_buffer = io.BytesIO()
with zipfile.ZipFile(_buffer, "w", compression=zipfile.ZIP_DEFLATED) as _archive:
    for _name in {paths!r}:
        _path = _root / _name
        if _path.is_dir():
            for _item in sorted(_path.rglob("*")):
                if _item.is_file():
                    _archive.write(_item, str(_item.relative_to(_root)))
        else:
            _archive.write(_path, _name)
print("MOLAB_FILES_BEGIN", flush=True)
_encoded = base64.b64encode(_buffer.getvalue()).decode("ascii")
for _offset in range(0, len(_encoded), 32768):
    print(_encoded[_offset:_offset + 32768], flush=True)
print("MOLAB_FILES_END", flush=True)
'''
    result = execute(code, args.state_file, capture=True)
    encoded = result.stdout.split("MOLAB_FILES_BEGIN\n", 1)[1].split("\nMOLAB_FILES_END", 1)[0]
    encoded = "".join(encoded.split())
    destination.mkdir(parents=True, exist_ok=True)
    with zipfile.ZipFile(io.BytesIO(base64.b64decode(encoded))) as archive:
        archive.extractall(destination)
        print("Retrieved", len(archive.namelist()), "files into", destination, flush=True)


def main():
    parser = argparse.ArgumentParser()
    parser.add_argument("--state-file", default="work/molab-state.json")
    parser.add_argument("--remote-root", default="molab_runs/resource_planning")
    commands = parser.add_subparsers(dest="command", required=True)
    push = commands.add_parser("push")
    push.add_argument("paths", nargs="+")
    pull = commands.add_parser("pull")
    pull.add_argument("paths", nargs="+")
    pull.add_argument("--destination", default="work/remote")
    pull_jsonl = commands.add_parser("pull-jsonl")
    pull_jsonl.add_argument("path")
    pull_jsonl.add_argument("--destination", default="work/remote")
    pull_jsonl.add_argument("--lines-per-part", type=int, default=64)
    args = parser.parse_args()

    if args.command == "push":
        buffer = io.BytesIO()
        with zipfile.ZipFile(buffer, "w", compression=zipfile.ZIP_DEFLATED) as archive:
            for raw_path in args.paths:
                path = Path(raw_path)
                if path.is_dir():
                    for item in sorted(path.rglob("*")):
                        if item.is_file() and "__pycache__" not in item.parts:
                            archive.write(item, str(item))
                else:
                    archive.write(path, str(path))
        encoded = base64.b64encode(buffer.getvalue()).decode("ascii")
        code = f'''import base64, io, zipfile
from pathlib import Path
_root = Path({args.remote_root!r}).resolve()
_root.mkdir(parents=True, exist_ok=True)
with zipfile.ZipFile(io.BytesIO(base64.b64decode({encoded!r}))) as _archive:
    _archive.extractall(_root)
    print("Transferred", len(_archive.namelist()), "files to", str(_root), flush=True)
'''
        execute(code, args.state_file)
    elif args.command == "pull":
        pull_archive(args.paths, Path(args.destination), args)
    else:
        if args.lines_per_part < 1:
            raise ValueError("lines-per-part must be positive")
        part_root = str(Path(".transfer_parts") / args.path)
        code = f'''import json
from pathlib import Path
_root = Path({args.remote_root!r}).resolve()
_parts = _root / {part_root!r}
_parts.mkdir(parents=True, exist_ok=True)
_paths = []
_part = None
try:
    with (_root / {args.path!r}).open("rb") as _source:
        for _index, _line in enumerate(_source):
            if _index % {args.lines_per_part} == 0:
                if _part is not None:
                    _part.close()
                _path = _parts / ("part%05d" % len(_paths))
                _paths.append(str(_path.relative_to(_root)))
                _part = _path.open("wb")
            _part.write(_line)
finally:
    if _part is not None:
        _part.close()
print("MOLAB_PARTS " + json.dumps(_paths), flush=True)
'''
        result = execute(code, args.state_file, capture=True)
        paths = json.loads(result.stdout.split("MOLAB_PARTS ", 1)[1].splitlines()[0])
        destination = Path(args.destination)
        for path in paths:
            pull_archive([path], destination, args)
        canonical = destination / args.path
        canonical.parent.mkdir(parents=True, exist_ok=True)
        with canonical.open("wb") as output:
            for path in paths:
                part = destination / path
                with part.open("rb") as source:
                    shutil.copyfileobj(source, output)
                part.unlink()
        print("Retrieved complete JSONL into", canonical, flush=True)


if __name__ == "__main__":
    main()