#!/usr/bin/env python3
"""
package_and_publish_testpypi.py
 
Create a sample package (pyproject.toml + module), build distributions, upload to TestPyPI,
and optionally verify installation from TestPyPI.
 
Usage examples:
    # Create project and build artifacts only (no upload)
    python package_and_publish_testpypi.py create MyPkg --version 0.1.0 --no-upload
 
    # Create, build and upload to TestPyPI (will prompt for credentials if none in env)
    python package_and_publish_testpypi.py create MyPkg --version 0.1.0
 
    # Create with unique timestamped version, upload, and verify install
    python package_and_publish_testpypi.py create MyPkg --unique --upload --verify
 
Notes:
 - Requires `build` and `twine` installed (pip install build twine).
 - For uploading via an API token set:
       TWINE_USERNAME="__token__"
       TWINE_PASSWORD="<pypi-AgENd...>"  (the API token value)
   Or the script will prompt you for username & password.
"""
 
from __future__ import annotations
 
import argparse
import getpass
import os
import subprocess
import sys
import tempfile
import time
from datetime import datetime
from pathlib import Path
from typing import Optional, Tuple
 
 
# ----------------------------
# Templates for the sample package
# ----------------------------
PYPROJECT_TPL = """[build-system]
requires = ["setuptools>=61", "wheel", "build"]
build-backend = "setuptools.build_meta"
 
[project]
name = "{name}"
version = "{version}"
description = "{description}"
readme = "README.md"
authors = [{{name = "{author}", email = "{email}"}}]
requires-python = ">=3.8"
license = {{text = "MIT"}}
keywords = ["sample", "test", "example"]
classifiers = [
  "Programming Language :: Python :: 3",
  "License :: OSI Approved :: MIT License",
]
"""
 
INIT_PY_TPL = '''"""
{pkg} — a tiny example package created by package_and_publish_testpypi.py
"""
 
__all__ = ["hello"]
__version__ = "{version}"
 
def hello(name: str) -> str:
    """Return a friendly greeting"""
    return f"Hello, {name}!"
'''
 
README_TPL = "# {name}\n\n{description}\n\nInstall from TestPyPI for verification."
 
GITIGNORE = """# Python caches
__pycache__/
*.py[cod]
 
# build artifacts
dist/
build/
*.egg-info/
 
# virtualenv
.venv/
"""
 
LICENSE_TPL = """MIT License
 
Copyright (c) {year} {author}
 
Permission is hereby granted, free of charge, to any person obtaining a copy...
"""
 
# ----------------------------
# Helpers
# ----------------------------
def run(cmd: list, cwd: Optional[Path] = None, capture: bool = False) -> Tuple[int, str]:
    """Run a command; return (rc, stdout+stderr)."""
    try:
        if capture:
            out = subprocess.check_output(cmd, cwd=str(cwd) if cwd else None, stderr=subprocess.STDOUT, text=True)
            return 0, out
        else:
            subprocess.check_call(cmd, cwd=str(cwd) if cwd else None)
            return 0, ""
    except subprocess.CalledProcessError as e:
        return e.returncode, (e.output or "")
    except FileNotFoundError as e:
        return 127, str(e)
 
 
def ensure_tool_available(module_name: str, human_cmd_description: str) -> None:
    """
    Ensure 'python -m module_name --version' succeeds. If not, prompt user to install it into current env.
    """
    rc, out = run([sys.executable, "-m", module_name, "--version"], capture=True)
    if rc != 0:
        print(f"[!] Tool '{module_name}' is required ({human_cmd_description}).")
        yn = input(f"Install '{module_name}' into the current interpreter now? [y/N]: ").strip().lower()
        if yn not in ("y", "yes"):
            print("[!] Aborting. Install the tool manually and re-run.")
            sys.exit(1)
        print(f"[*] Installing {module_name}...")
        rc2, out2 = run([sys.executable, "-m", "pip", "install", module_name], capture=True)
        if rc2 != 0:
            print("[!] Failed to install", module_name)
            print(out2)
            sys.exit(rc2)
        print(f"[+] Installed {module_name}.")
 
 
def write_sample_project(root: Path, name: str, version: str, description: str, author: str, email: str) -> None:
    """Create project skeleton and small module under root."""
    root.mkdir(parents=True, exist_ok=True)
    (root / "pyproject.toml").write_text(PYPROJECT_TPL.format(name=name, version=version, description=description, author=author, email=email), encoding="utf-8")
    (root / "README.md").write_text(README_TPL.format(name=name, description=description), encoding="utf-8")
    (root / ".gitignore").write_text(GITIGNORE, encoding="utf-8")
    (root / "LICENSE").write_text(LICENSE_TPL.format(year=datetime.utcnow().year, author=author), encoding="utf-8")
 
    pkg_dir = root / name
    pkg_dir.mkdir(exist_ok=True)
    (pkg_dir / "__init__.py").write_text(INIT_PY_TPL.format(pkg=name, version=version), encoding="utf-8")
 
    print(f"[+] Created project skeleton at {root.resolve()}")
    print("    files: pyproject.toml, README.md, LICENSE, .gitignore, package directory")
 
 
def build_distributions(project_dir: Path) -> None:
    """Run python -m build to create sdist & wheel in dist/"""
    print("[*] Building distributions with 'python -m build' ...")
    rc, out = run([sys.executable, "-m", "build", "--sdist", "--wheel"], cwd=project_dir, capture=True)
    if rc != 0:
        print("[!] Build failed:")
        print(out)
        sys.exit(rc)
    print(out)
    print("[+] Build completed. Check the 'dist/' directory.")
 
 
def upload_to_testpypi(project_dir: Path, username: Optional[str], password: Optional[str], repository_url: str = "https://test.pypi.org/legacy/") -> None:
    """
    Upload all files in dist/ to TestPyPI using twine. Credentials may be provided via args or environment.
    Environment variables TWINE_USERNAME/TWINE_PASSWORD take precedence if set.
    """
    env_user = os.environ.get("TWINE_USERNAME")
    env_pass = os.environ.get("TWINE_PASSWORD")
    if env_user:
        print("[i] Using TWINE_USERNAME from environment.")
        username = env_user
    if env_pass:
        password = env_pass
 
    if not username:
        username = input("TestPyPI username (or '__token__' if using API token): ").strip()
    if not password:
        password = getpass.getpass("TestPyPI password or API token: ")
 
    # Use python -m twine upload --repository-url <url> dist/*
    cmd = [sys.executable, "-m", "twine", "upload", "--repository-url", repository_url, "dist/*"]
    print("[*] Uploading to TestPyPI (this will prompt Twine for credentials unless provided via env)...")
    # Provide credentials as TWINE_USERNAME/TWINE_PASSWORD env for the subprocess
    env = os.environ.copy()
    env["TWINE_USERNAME"] = username
    env["TWINE_PASSWORD"] = password
    # Run twine as subprocess with env
    try:
        subprocess.check_call(cmd, cwd=str(project_dir), env=env)
    except subprocess.CalledProcessError as e:
        print("[!] Twine upload failed with exit code", e.returncode)
        sys.exit(e.returncode)
    print("[+] Upload to TestPyPI complete.")
 
 
def verify_install_from_testpypi(package_name: str, version: str) -> None:
    """
    Create a temporary venv, pip install the package from TestPyPI, and try to import it.
    This helps confirm your package is available and importable.
    """
    print("[*] Verifying installation from TestPyPI in a temporary venv...")
    tmpdir = Path(tempfile.mkdtemp(prefix="tpypi-verify-"))
    venv_dir = tmpdir / "venv"
    # create venv
    subprocess.check_call([sys.executable, "-m", "venv", str(venv_dir)])
    # determine python path
    if os.name == "nt":
        py = venv_dir / "Scripts" / "python.exe"
    else:
        py = venv_dir / "bin" / "python"
    py = str(py)
    # install from TestPyPI (no deps) to ensure we pull exactly the uploaded artifact:
    index_url = "https://test.pypi.org/simple/"
    pkg_spec = f"{package_name}=={version}"
    cmd_install = [py, "-m", "pip", "install", "--index-url", index_url, "--no-deps", pkg_spec]
    print(f"[*] Installing {pkg_spec} from TestPyPI into {venv_dir} ...")
    rc, out = run(cmd_install, capture=True)
    if rc != 0:
        print("[!] pip install from TestPyPI failed:")
        print(out)
        print("You may need to wait a minute for TestPyPI to index the package, or check that the upload succeeded.")
        sys.exit(rc)
    print(out)
    # try importing and calling hello()
    cmd_run = [py, "-c", f"import {package_name}; print('IMPORT_OK:', {package_name}.hello('Tester'))"]
    rc2, out2 = run(cmd_run, capture=True)
    if rc2 != 0:
        print("[!] Import test failed:")
        print(out2)
        sys.exit(rc2)
    print(out2.strip())
    print("[+] Verification SUCCEEDED. Temporary venv at:", venv_dir)
    print("[i] Remove it when done:", tmpdir)
 
 
# ----------------------------
# CLI
# ----------------------------
def build_parser() -> argparse.ArgumentParser:
    p = argparse.ArgumentParser(description="Create a sample package, build, and publish to TestPyPI")
    p.add_argument("action", choices=["create"], help="Action to perform (create builds and optionally uploads)")
    p.add_argument("name", help="Package name (must be a valid distribution name, e.g. mypkg)")
    p.add_argument("--version", default="0.1.0", help="Initial version (default: 0.1.0)")
    p.add_argument("--description", default="A sample test package", help="Short description")
    p.add_argument("--author", default=getpass.getuser() or "You", help="Author name")
    p.add_argument("--email", default="", help="Author email")
    p.add_argument("--unique", action="store_true", help="Append timestamp to version to ensure uniqueness (useful for repeated TestPyPI uploads)")
    p.add_argument("--no-upload", dest="upload", action="store_false", help="Do not upload to TestPyPI (just build)")
    p.add_argument("--upload", dest="upload", action="store_true", help="Upload to TestPyPI after building (default)")
    p.add_argument("--verify", action="store_true", help="After upload, attempt to pip install from TestPyPI and import")
    p.add_argument("--skip-tool-check", action="store_true", help="Skip checking for build/twine and skip auto-install prompt")
    return p
 
 
def main(argv: Optional[list] = None) -> None:
    args = build_parser().parse_args(argv)
    if args.action != "create":
        print("[!] Only 'create' action is supported in this script.")
        sys.exit(1)
 
    name = args.name.strip()
    version = args.version.strip()
    if args.unique:
        version = f"{version}.post{int(time.time())}"
 
    project_dir = Path(name)
    if project_dir.exists():
        print(f"[!] Directory '{project_dir}' already exists. Remove it or choose another name.")
        sys.exit(1)
 
    # 1) Create skeleton
    write_sample_project(project_dir, name, version, args.description, args.author, args.email)
 
    # 2) Ensure build & twine are available (unless skipped)
    if not args.skip_tool_check:
        ensure_tool_available("build", "create source & wheel distributions ('python -m build')")
        ensure_tool_available("twine", "upload distributions ('python -m twine upload')")
 
    # 3) Build distributions
    build_distributions(project_dir)
 
    # 4) Optionally upload to TestPyPI
    if args.upload:
        # Credentials may be provided via env; user will be prompted if not present
        upload_to_testpypi(project_dir, username=None, password=None)
 
    # 5) Optionally verify installation
    if args.upload and args.verify:
        # Wait a moment for TestPyPI to process the upload (small sleep helps typical cases)
        print("[i] Waiting a few seconds to allow TestPyPI to index the package...")
        time.sleep(3)
        verify_install_from_testpypi(name, version)
 
    print("[+] All done. Project dir:", project_dir.resolve())
 
 
if __name__ == "__main__":
    main()