#!/usr/bin/env python3
"""Build wheel with bundled Claude Code CLI.

This script handles the complete wheel building process:
1. Optionally updates version
2. Downloads Claude Code CLI
3. Builds the wheel
4. Optionally cleans up the bundled CLI

Usage:
    python scripts/build_wheel.py                    # Build with current version
    python scripts/build_wheel.py --version 0.1.4    # Build with specific version
    python scripts/build_wheel.py --clean            # Clean bundled CLI after build
    python scripts/build_wheel.py --skip-download    # Skip CLI download (use existing)
"""

import argparse
import os
import platform
import re
import shutil
import subprocess
import sys
from pathlib import Path

try:
    import twine  # noqa: F401

    HAS_TWINE = True
except ImportError:
    HAS_TWINE = False


def run_command(cmd: list[str], description: str) -> None:
    """Run a command and handle errors."""
    print(f"\n{'=' * 60}")
    print(f"{description}")
    print(f"{'=' * 60}")
    print(f"$ {' '.join(cmd)}")
    print()

    try:
        result = subprocess.run(
            cmd,
            check=True,
            stdout=subprocess.PIPE,
            stderr=subprocess.STDOUT,
            text=True,
        )
        print(result.stdout)
    except subprocess.CalledProcessError as e:
        print(f"Error: {description} failed", file=sys.stderr)
        print(e.stdout, file=sys.stderr)
        sys.exit(1)


def update_version(version: str) -> None:
    """Update package version."""
    script_dir = Path(__file__).parent
    update_script = script_dir / "update_version.py"

    if not update_script.exists():
        print("Warning: update_version.py not found, skipping version update")
        return

    run_command(
        [sys.executable, str(update_script), version],
        f"Updating version to {version}",
    )


def get_bundled_cli_version() -> str:
    """Get the CLI version that should be bundled from _cli_version.py."""
    version_file = Path("src/claude_agent_sdk/_cli_version.py")
    if not version_file.exists():
        return "latest"

    content = version_file.read_text()
    match = re.search(r'__cli_version__ = "([^"]+)"', content)
    if match:
        return match.group(1)
    return "latest"


def download_cli(cli_version: str | None = None) -> None:
    """Download Claude Code CLI."""
    # Use provided version, or fall back to version from _cli_version.py
    if cli_version is None:
        cli_version = get_bundled_cli_version()

    script_dir = Path(__file__).parent
    download_script = script_dir / "download_cli.py"

    # Set environment variable for download script
    os.environ["CLAUDE_CLI_VERSION"] = cli_version

    run_command(
        [sys.executable, str(download_script)],
        f"Downloading Claude Code CLI ({cli_version})",
    )


def clean_dist() -> None:
    """Clean dist directory."""
    dist_dir = Path("dist")
    if dist_dir.exists():
        print(f"\n{'=' * 60}")
        print("Cleaning dist directory")
        print(f"{'=' * 60}")
        shutil.rmtree(dist_dir)
        print("Cleaned dist/")


def get_platform_tag() -> str:
    """Get the appropriate platform tag for the current platform.

    Uses minimum compatible versions for broad compatibility:
    - macOS: 11.0 (Big Sur) as minimum
    - Linux: manylinux_2_17 (widely compatible)
    - Windows: Standard tags
    """
    system = platform.system()
    machine = platform.machine().lower()

    if system == "Darwin":
        # macOS - use minimum version 11.0 (Big Sur) for broad compatibility
        if machine == "arm64":
            return "macosx_11_0_arm64"
        else:
            return "macosx_11_0_x86_64"
    elif system == "Linux":
        # Linux - use manylinux for broad compatibility
        if machine in ["x86_64", "amd64"]:
            return "manylinux_2_17_x86_64"
        elif machine in ["aarch64", "arm64"]:
            return "manylinux_2_17_aarch64"
        else:
            return f"linux_{machine}"
    elif system == "Windows":
        # Windows
        if machine in ["x86_64", "amd64"]:
            return "win_amd64"
        elif machine == "arm64":
            return "win_arm64"
        else:
            return "win32"
    else:
        # Unknown platform, use generic
        return f"{system.lower()}_{machine}"


def retag_wheel(wheel_path: Path, platform_tag: str) -> Path:
    """Retag a wheel with the correct platform tag using wheel package."""
    print(f"\n{'=' * 60}")
    print("Retagging wheel as platform-specific")
    print(f"{'=' * 60}")
    print(f"Old: {wheel_path.name}")

    # Use wheel package to properly retag (updates both filename and metadata)
    result = subprocess.run(
        [
            sys.executable,
            "-m",
            "wheel",
            "tags",
            "--platform-tag",
            platform_tag,
            "--remove",
            str(wheel_path),
        ],
        capture_output=True,
        text=True,
    )

    if result.returncode != 0:
        print(f"Warning: Failed to retag wheel: {result.stderr}")
        return wheel_path

    # Find the newly tagged wheel
    dist_dir = wheel_path.parent
    # The wheel package creates a new file with the platform tag
    new_wheels = list(dist_dir.glob(f"*{platform_tag}.whl"))

    if new_wheels:
        new_path = new_wheels[0]
        print(f"New: {new_path.name}")
        print("Wheel retagged successfully")

        # Remove the old wheel
        if wheel_path.exists() and wheel_path != new_path:
            wheel_path.unlink()

        return new_path
    else:
        print("Warning: Could not find retagged wheel")
        return wheel_path


def build_wheel() -> None:
    """Build the wheel."""
    run_command(
        [sys.executable, "-m", "build", "--wheel"],
        "Building wheel",
    )

    # Check if we have a bundled CLI - if so, retag the wheel as platform-specific
    bundled_cli = Path("src/claude_agent_sdk/_bundled/claude")
    bundled_cli_exe = Path("src/claude_agent_sdk/_bundled/claude.exe")

    if bundled_cli.exists() or bundled_cli_exe.exists():
        # Find the built wheel
        dist_dir = Path("dist")
        wheels = list(dist_dir.glob("*.whl"))

        if wheels:
            # Get platform tag
            platform_tag = get_platform_tag()

            # Retag each wheel (should only be one)
            for wheel in wheels:
                if "-any.whl" in wheel.name:
                    retag_wheel(wheel, platform_tag)
        else:
            print("Warning: No wheel found to retag")
    else:
        print("\nNo bundled CLI found - wheel will be platform-independent")


def build_sdist() -> None:
    """Build the source distribution."""
    run_command(
        [sys.executable, "-m", "build", "--sdist"],
        "Building source distribution",
    )


def check_package() -> None:
    """Check package with twine."""
    if not HAS_TWINE:
        print("\nWarning: twine not installed, skipping package check")
        print("Install with: pip install twine")
        return

    print(f"\n{'=' * 60}")
    print("Checking package with twine")
    print(f"{'=' * 60}")
    print(f"$ {sys.executable} -m twine check dist/*")
    print()

    try:
        result = subprocess.run(
            [sys.executable, "-m", "twine", "check", "dist/*"],
            check=False,
            stdout=subprocess.PIPE,
            stderr=subprocess.STDOUT,
            text=True,
        )
        print(result.stdout)

        if result.returncode != 0:
            print("\nWarning: twine check reported issues")
            print("Note: 'License-File' warnings are false positives from twine 6.x")
            print("PyPI will accept these packages without issues")
        else:
            print("Package check passed")
    except Exception as e:
        print(f"Warning: Failed to run twine check: {e}")


def clean_bundled_cli() -> None:
    """Clean bundled CLI."""
    bundled_dir = Path("src/claude_agent_sdk/_bundled")
    cli_files = list(bundled_dir.glob("claude*"))

    if cli_files:
        print(f"\n{'=' * 60}")
        print("Cleaning bundled CLI")
        print(f"{'=' * 60}")
        for cli_file in cli_files:
            if cli_file.name != ".gitignore":
                cli_file.unlink()
                print(f"Removed {cli_file}")
    else:
        print("\nNo bundled CLI to clean")


def list_artifacts() -> None:
    """List built artifacts."""
    dist_dir = Path("dist")
    if not dist_dir.exists():
        return

    print(f"\n{'=' * 60}")
    print("Built Artifacts")
    print(f"{'=' * 60}")

    artifacts = sorted(dist_dir.iterdir())
    if not artifacts:
        print("No artifacts found")
        return

    for artifact in artifacts:
        size_mb = artifact.stat().st_size / (1024 * 1024)
        print(f"  {artifact.name:<50} {size_mb:>8.2f} MB")

    total_size = sum(f.stat().st_size for f in artifacts) / (1024 * 1024)
    print(f"\n  {'Total:':<50} {total_size:>8.2f} MB")


def main() -> None:
    """Main entry point."""
    parser = argparse.ArgumentParser(
        description="Build wheel with bundled Claude Code CLI"
    )
    parser.add_argument(
        "--version",
        help="Version to set before building (e.g., 0.1.4)",
    )
    parser.add_argument(
        "--cli-version",
        default=None,
        help="Claude Code CLI version to download (default: read from _cli_version.py)",
    )
    parser.add_argument(
        "--skip-download",
        action="store_true",
        help="Skip downloading CLI (use existing bundled CLI)",
    )
    parser.add_argument(
        "--skip-sdist",
        action="store_true",
        help="Skip building source distribution",
    )
    parser.add_argument(
        "--clean",
        action="store_true",
        help="Clean bundled CLI after building",
    )
    parser.add_argument(
        "--clean-dist",
        action="store_true",
        help="Clean dist directory before building",
    )

    args = parser.parse_args()

    print("\n" + "=" * 60)
    print("Claude Agent SDK - Wheel Builder")
    print("=" * 60)

    # Clean dist if requested
    if args.clean_dist:
        clean_dist()

    # Update version if specified
    if args.version:
        update_version(args.version)

    # Download CLI unless skipped
    if not args.skip_download:
        download_cli(args.cli_version)
    else:
        print("\nSkipping CLI download (using existing)")

    # Build wheel
    build_wheel()

    # Build sdist unless skipped
    if not args.skip_sdist:
        build_sdist()

    # Check package
    check_package()

    # Clean bundled CLI if requested
    if args.clean:
        clean_bundled_cli()

    # List artifacts
    list_artifacts()

    print(f"\n{'=' * 60}")
    print("Build complete!")
    print(f"{'=' * 60}")
    print("\nNext steps:")
    print("  1. Test the wheel: pip install dist/*.whl")
    print("  2. Run tests: python -m pytest tests/")
    print("  3. Publish: twine upload dist/*")


if __name__ == "__main__":
    main()