#!/usr/bin/env python3
import argparse, os, shutil, subprocess, sys
from pathlib import Path

ROOT = Path.home() / ".venvs"
ROOT.mkdir(exist_ok=True)

if __name__ == "__main__":
    ap = argparse.ArgumentParser()
    sub = ap.add_subparsers(dest="cmd", required=True)
    p_create = sub.add_parser("create"); p_create.add_argument("name")
    p_rm = sub.add_parser("remove"); p_rm.add_argument("name")
    sub.add_parser("list")
    args = ap.parse_args()

    if args.cmd == "create":
        target = ROOT / args.name
        if target.exists():
            print("Already exists", file=sys.stderr); sys.exit(1)
        subprocess.check_call([sys.executable, "-m", "venv", str(target)])
        print("Created:", target)
        print("Activate:")
        if os.name == "nt":
            print(fr"{target}\\Scripts\\activate")
        else:
            print(fr"source {target}/bin/activate")
    elif args.cmd == "list":
        for p in sorted(ROOT.iterdir()):
            if (p / ("Scripts" if os.name=="nt" else "bin") / "python").exists():
                print(p.name)
    elif args.cmd == "remove":
        target = ROOT / args.name
        shutil.rmtree(target, ignore_errors=True)
        print("Removed:", target)

#!/usr/bin/env python3
"""
venvman.py - Minimal virtual environment manager (cross-platform)

Commands:
  create  [--python /path/to/python]   Create a new venv under $VENV_HOME or ~/.venvs
  list                                       List all venvs
  remove                               Delete a venv
  info                                 Show interpreter/build/site-packages
  path                                 Print the venv path
  run   --                    Run a command inside the venv
  pip                     Run pip inside the venv (install/uninstall/show/…)
  freeze                               Show pip freeze for that venv
  export  -o requirements.txt          Save pip freeze to a file
  import  -r requirements.txt          Install from a requirements file

Environment:
  VENV_HOME     Root directory for environments (default: ~/.venvs)
"""

from __future__ import annotations

import argparse
import os
import shutil
import subprocess
import sys
from pathlib import Path
from typing import List

# ---------- Config & cross-platform constants ----------
ROOT = Path(os.environ.get("VENV_HOME", Path.home() / ".venvs"))
BIN_DIR = "Scripts" if os.name == "nt" else "bin"
PY_NAME = "python.exe" if os.name == "nt" else "python"
PIP_NAME = "pip.exe" if os.name == "nt" else "pip"


# ---------- Helpers ----------
def venv_path(name: str) -> Path:
    return ROOT / name


def venv_python(name: str) -> Path:
    return venv_path(name) / BIN_DIR / PY_NAME


def venv_pip(name: str) -> Path:
    return venv_path(name) / BIN_DIR / PIP_NAME


def ensure_exists(name: str) -> None:
    if not venv_python(name).exists():
        sys.exit(f"[!] Environment '{name}' not found at {venv_path(name)}")


def check_call(cmd: List[str], **kwargs) -> None:
    subprocess.check_call(cmd, **kwargs)


# ---------- Commands ----------
def cmd_create(args: argparse.Namespace) -> None:
    ROOT.mkdir(parents=True, exist_ok=True)
    target = venv_path(args.name)
    if target.exists():
        sys.exit(f"[!] Already exists: {target}")
    py = args.python or sys.executable
    print(f"[*] Creating venv '{args.name}' with {py} ...")
    check_call([py, "-m", "venv", str(target)])
    print(f"[+] Created: {target}")
    print("[i] Activate manually:")
    if os.name == "nt":
        print(fr"    {target}\Scripts\activate")
    else:
        print(f"    source {target}/bin/activate")


def cmd_list(_args: argparse.Namespace) -> None:
    if not ROOT.exists():
        print("(no environments)")
        return
    rows = []
    for p in sorted(ROOT.iterdir()):
        interp = p / BIN_DIR / PY_NAME
        if interp.exists():
            rows.append((p.name, interp))
    if not rows:
        print("(no environments)")
        return
    width = max(len(n) for n, _ in rows)
    for name, interp in rows:
        print(f"{name:<{width}}  ->  {interp}")


def cmd_remove(args: argparse.Namespace) -> None:
    path = venv_path(args.name)
    if not path.exists():
        print(f"[i] Not found: {path}")
        return
    print(f"[*] Removing {path} ...")
    shutil.rmtree(path)
    print("[+] Removed.")


def cmd_info(args: argparse.Namespace) -> None:
    ensure_exists(args.name)
    py = str(venv_python(args.name))
    # Ask the venv's python to describe itself in JSON (robust across platforms)
    out = subprocess.check_output(
        [
            py,
            "-c",
            (
                "import sys,sysconfig,platform,site,json;"
                "print(json.dumps({"
                "'version':sys.version.replace('\\n',' '),"
                "'implementation':platform.python_implementation(),"
                "'executable':sys.executable,"
                "'prefix':sys.prefix,"
                "'platform':sys.platform,"
                "'paths':sysconfig.get_paths(),"
                "'site':site.getsitepackages() if hasattr(site,'getsitepackages') else []"
                "}))"
            ),
        ],
        text=True,
    )
    import json

    info = json.loads(out)
    print(f"Name:        {args.name}")
    print(f"Path:        {venv_path(args.name)}")
    print(f"Executable:  {info['executable']}")
    print(f"Impl/Ver:    {info['implementation']} {info['version']}")
    print(f"Platform:    {info['platform']}")
    print("Paths:")
    for k, v in info["paths"].items():
        print(f"  {k:<12} {v}")
    if info["site"]:
        print("Site-packages:")
        for sp in info["site"]:
            print(f"  - {sp}")


def cmd_path(args: argparse.Namespace) -> None:
    ensure_exists(args.name)
    print(venv_path(args.name))


def cmd_run(args: argparse.Namespace) -> None:
    ensure_exists(args.name)
    if not args.cmd:
        sys.exit("[!] Provide a command after --, e.g. venvman run myenv -- python -V")
    env = os.environ.copy()
    env["PATH"] = str(venv_path(args.name) / BIN_DIR) + os.pathsep + env.get("PATH", "")
    env["VIRTUAL_ENV"] = str(venv_path(args.name))
    # On Windows, prefer the venv's Python if user asked to run "python"
    rc = subprocess.call(args.cmd, env=env)
    sys.exit(rc)


def cmd_pip(args: argparse.Namespace) -> None:
    ensure_exists(args.name)
    if not args.pip_args:
        sys.exit("[!] Provide pip arguments, e.g. venvman pip myenv install requests")
    check_call([str(venv_pip(args.name)), *args.pip_args])


def cmd_freeze(args: argparse.Namespace) -> None:
    ensure_exists(args.name)
    check_call([str(venv_pip(args.name)), "freeze"])


def cmd_export(args: argparse.Namespace) -> None:
    ensure_exists(args.name)
    out = subprocess.check_output([str(venv_pip(args.name)), "freeze"], text=True)
    Path(args.output).write_text(out, encoding="utf-8")
    print(f"[+] Wrote {args.output}")


def cmd_import(args: argparse.Namespace) -> None:
    ensure_exists(args.name)
    req = Path(args.requirements)
    if not req.exists():
        sys.exit(f"[!] Requirements not found: {req}")
    check_call([str(venv_pip(args.name)), "install", "-r", str(req)])


# ---------- CLI wiring ----------
def build_parser() -> argparse.ArgumentParser:
    ap = argparse.ArgumentParser(
        prog="venvman", description="Manage Python virtual environments using venv"
    )
    sub = ap.add_subparsers(dest="cmd", required=True)

    p = sub.add_parser("create", help="Create a new virtual environment")
    p.add_argument("name")
    p.add_argument("--python", help="Python interpreter to use (defaults to current)")
    p.set_defaults(func=cmd_create)

    p = sub.add_parser("list", help="List all environments")
    p.set_defaults(func=cmd_list)

    p = sub.add_parser("remove", help="Remove an environment")
    p.add_argument("name")
    p.set_defaults(func=cmd_remove)

    p = sub.add_parser("info", help="Show environment details")
    p.add_argument("name")
    p.set_defaults(func=cmd_info)

    p = sub.add_parser("path", help="Print the environment path")
    p.add_argument("name")
    p.set_defaults(func=cmd_path)

    p = sub.add_parser("run", help="Run a command inside the environment")
    p.add_argument("name")
    p.add_argument(
        "cmd",
        nargs=argparse.REMAINDER,
        help="Command to run (prefix with -- to separate)",
    )
    p.set_defaults(func=cmd_run)

    p = sub.add_parser("pip", help="Run pip inside the environment")
    p.add_argument("name")
    p.add_argument("pip_args", nargs=argparse.REMAINDER)
    p.set_defaults(func=cmd_pip)

    p = sub.add_parser("freeze", help="pip freeze inside the environment")
    p.add_argument("name")
    p.set_defaults(func=cmd_freeze)

    p = sub.add_parser("export", help="Export requirements to a file")
    p.add_argument("name")
    p.add_argument("-o", "--output", required=True)
    p.set_defaults(func=cmd_export)

    p = sub.add_parser("import", help="Install from a requirements file")
    p.add_argument("name")
    p.add_argument("-r", "--requirements", required=True)
    p.set_defaults(func=cmd_import)

    return ap


def main(argv: List[str] | None = None) -> None:
    parser = build_parser()
    args = parser.parse_args(argv)
    args.func(args)


if __name__ == "__main__":
    main()