init.py

"""Implementation of the init command.

Scaffolds a new project by running cdk init, uv init, copying template files,
installing dependencies, and making the initial commit.
"""

import re
import shutil
import subprocess
import sys
from importlib.resources import files
from pathlib import Path

import click
import tomlkit

from gds_idea_app_kit import (
    GITHUB_ORG,
    REPO_PREFIX,
    __version__,
)
from gds_idea_app_kit.manifest import build_manifest, write_manifest
from gds_idea_app_kit.prerequisites import check_prerequisites


def _sanitize_app_name(name: str) -> str:
    """Sanitize and validate an app name for use as a DNS subdomain label.

    The name will become part of a domain: {name}.gds-idea.click

    Args:
        name: The raw app name from the user.

    Returns:
        The cleaned app name.

    Raises:
        click.BadParameter: If the name is invalid.
    """
    # Strip the repo prefix if the user accidentally included it
    prefix = f"{REPO_PREFIX}-"
    if name.startswith(prefix):
        name = name[len(prefix) :]

    # Lowercase
    name = name.lower()

    # Validate DNS label rules
    if not name:
        raise click.BadParameter("App name cannot be empty.")

    if len(name) > 63:
        raise click.BadParameter("App name must be 63 characters or fewer (DNS label limit).")

    if not re.match(r"^[a-z0-9]([a-z0-9-]*[a-z0-9])?$", name):
        raise click.BadParameter(
            "App name must contain only lowercase letters, numbers, and hyphens, "
            "and must start and end with a letter or number."
        )

    if "--" in name:
        raise click.BadParameter("App name must not contain consecutive hyphens (--).")

    if name.isdigit():
        raise click.BadParameter("App name must not be purely numeric.")

    return name


def _get_templates_dir() -> Path:
    """Get the path to the bundled templates directory."""
    return Path(str(files("gds_idea_app_kit") / "templates"))


def _apply_template_vars(content: str, variables: dict[str, str]) -> str:
    """Apply template variable substitution to content.

    Replaces {{key}} with value for each entry in variables.

    Args:
        content: The template content with {{placeholders}}.
        variables: Mapping of placeholder names to values.

    Returns:
        Content with all placeholders replaced.
    """
    for key, value in variables.items():
        content = content.replace(f"{{{{{key}}}}}", value)
    return content


def _copy_template(src: Path, dest: Path, variables: dict[str, str] | None = None) -> None:
    """Copy a template file to a destination, optionally applying variable substitution.

    Args:
        src: Path to the source template file.
        dest: Path to the destination file.
        variables: Optional mapping of placeholder names to values.
    """
    dest.parent.mkdir(parents=True, exist_ok=True)
    content = src.read_text()
    if variables:
        content = _apply_template_vars(content, variables)
    dest.write_text(content)


def _run_command(
    cmd: list[str],
    cwd: Path,
    project_dir: Path | None = None,
) -> subprocess.CompletedProcess:
    """Run a subprocess command with error handling.

    Args:
        cmd: The command and arguments to run.
        cwd: Working directory for the command.
        project_dir: The project directory (for cleanup message on failure).
            If not provided, uses cwd.

    Returns:
        The completed process result.
    """
    cleanup_dir = project_dir or cwd
    try:
        return subprocess.run(cmd, cwd=cwd, check=True, capture_output=True, text=True)
    except FileNotFoundError:
        if cmd[0] == "cdk":
            click.echo("Error: 'cdk' is not installed.", err=True)
            click.echo("", err=True)
            click.echo("Install it with one of:", err=True)
            click.echo("  npm install -g aws-cdk", err=True)
            click.echo("  brew install aws-cdk", err=True)
        else:
            click.echo(f"Error: '{cmd[0]}' is not installed.", err=True)
        sys.exit(1)
    except subprocess.CalledProcessError as e:
        click.echo(f"Error running: {' '.join(cmd)}", err=True)
        if e.stderr:
            click.echo(e.stderr, err=True)
        click.echo("", err=True)
        click.echo("To clean up the failed project:", err=True)
        click.echo(f"  rm -rf {cleanup_dir}", err=True)
        sys.exit(1)


def _delete_cdk_artifacts(project_dir: Path) -> None:
    """Delete files generated by cdk init that we don't need.

    Args:
        project_dir: The project root directory.
    """
    # Files to delete
    for name in ("requirements.txt", "requirements-dev.txt", "source.bat", "README.md"):
        path = project_dir / name
        if path.exists():
            path.unlink()

    # CDK generates a stack module directory named after the project dir.
    # e.g. gds-idea-app-foo → gds_idea_app_foo/gds_idea_app_foo_stack.py
    # We replace it with our own app.py, so delete the whole thing.
    dir_name = project_dir.name.replace("-", "_")
    stack_module = project_dir / dir_name
    if stack_module.is_dir():
        shutil.rmtree(stack_module)

    # CDK's generated app.py imports the stack module above -- delete it too.
    cdk_app = project_dir / "app.py"
    if cdk_app.exists():
        cdk_app.unlink()

    # CDK's generated tests/ directory
    tests_dir = project_dir / "tests"
    if tests_dir.is_dir():
        shutil.rmtree(tests_dir)


def _write_webapp_config(project_dir: Path, app_name: str, framework: str) -> None:
    """Write [tool.webapp] section to pyproject.toml for AppConfig.from_pyproject().

    Args:
        project_dir: The project root directory.
        app_name: The application name.
        framework: The web framework.
    """
    pyproject_path = project_dir / "pyproject.toml"
    with open(pyproject_path) as f:
        config = tomlkit.load(f)

    if "tool" not in config:
        config["tool"] = {}

    webapp = tomlkit.table()
    webapp.add("app_name", app_name)
    webapp.add("framework", framework)
    config["tool"]["webapp"] = webapp

    with open(pyproject_path, "w") as f:
        tomlkit.dump(config, f)


def run_init(framework: str, app_name: str, python_version: str) -> None:
    """Scaffold a new project.

    Creates a fully configured CDK + web app project with the given framework.
    The project directory will be named gds-idea-app-{app_name}.

    Args:
        framework: The web framework (streamlit, dash, fastapi).
        app_name: Name for the application.
        python_version: Python version for the project.
    """
    # -- Validate inputs --
    app_name = _sanitize_app_name(app_name)
    repo_name = f"{REPO_PREFIX}-{app_name}"
    project_dir = Path.cwd() / repo_name

    if project_dir.exists():
        click.echo(f"Error: Directory already exists: {project_dir}", err=True)
        sys.exit(1)

    # -- Check prerequisites before creating anything --
    check_prerequisites()

    click.echo(f"Scaffolding {framework} app: {app_name}")
    click.echo(f"  Directory: {repo_name}/")
    click.echo(f"  Python: {python_version}")
    click.echo()

    # -- Create directory and run cdk init (must be first, needs empty dir) --
    project_dir.mkdir()
    click.echo("Running cdk init...")
    _run_command(
        ["cdk", "init", "app", "--language", "python", "--generate-only"],
        cwd=project_dir,
        project_dir=project_dir,
    )

    # -- Run uv init on top of cdk output --
    click.echo("Running uv init...")
    _run_command(["uv", "init", "--no-workspace"], cwd=project_dir, project_dir=project_dir)

    # -- Clean up CDK artifacts we don't need --
    click.echo("Cleaning up CDK artifacts...")
    _delete_cdk_artifacts(project_dir)

    # -- Prepare template variables --
    python_version_nodot = python_version.replace(".", "")
    template_vars = {
        "app_name": app_name,
        "python_version": python_version,
        "python_version_nodot": python_version_nodot,
    }
    templates = _get_templates_dir()

    # -- Copy app.py (CDK entry point) --
    click.echo("Copying template files...")
    _copy_template(templates / "common" / "app.py", project_dir / "app.py")

    # -- Copy framework files into app_src/ --
    app_src = project_dir / "app_src"
    app_src.mkdir(exist_ok=True)

    # Framework app file (e.g. streamlit_app.py)
    framework_app = f"{framework}_app.py"
    _copy_template(templates / framework / framework_app, app_src / framework_app)

    # Dockerfile (has template vars for python version)
    _copy_template(
        templates / framework / "Dockerfile",
        app_src / "Dockerfile",
        variables=template_vars,
    )

    # App pyproject.toml (from .toml.template with substitution)
    _copy_template(
        templates / framework / "pyproject.toml.template",
        app_src / "pyproject.toml",
        variables=template_vars,
    )

    # -- Copy CI/CD workflow --
    _copy_template(
        templates / "common" / "ci_cd_cdk_app.yml",
        project_dir / ".github" / "workflows" / "ci_cd_cdk_app.yml",
    )

    # -- Copy .devcontainer/ files --
    _copy_template(
        templates / "common" / "devcontainer.json",
        project_dir / ".devcontainer" / "devcontainer.json",
    )
    _copy_template(
        templates / "common" / "docker-compose.yml",
        project_dir / ".devcontainer" / "docker-compose.yml",
    )

    # -- Copy dev_mocks/ --
    dev_mocks_src = templates / "dev_mocks"
    for mock_file in dev_mocks_src.iterdir():
        if mock_file.is_file():
            _copy_template(mock_file, project_dir / "dev_mocks" / mock_file.name)

    # -- Append to .gitignore --
    gitignore = project_dir / ".gitignore"
    extra = (templates / "common" / "gitignore-extra").read_text()
    with open(gitignore, "a") as f:
        f.write("\n")
        f.write(extra)

    # -- Install CDK dependencies --
    click.echo("Installing CDK dependencies...")
    _run_command(
        [
            "uv",
            "add",
            "aws-cdk-lib",
            "constructs",
            "gds-idea-cdk-constructs @ git+ssh://git@github.com/co-cddo/gds-idea-cdk-constructs.git",
        ],
        cwd=project_dir,
        project_dir=project_dir,
    )

    # -- Write [tool.webapp] config for AppConfig.from_pyproject() --
    click.echo("Writing project configuration...")
    _write_webapp_config(project_dir, app_name, framework)

    # -- Build and write manifest --
    manifest = build_manifest(
        framework=framework,
        app_name=app_name,
        tool_version=__version__,
        project_dir=project_dir,
    )
    write_manifest(project_dir, manifest)

    # -- Sync dependencies --
    click.echo("Syncing dependencies...")
    _run_command(["uv", "sync"], cwd=project_dir, project_dir=project_dir)

    # -- Initial git commit --
    click.echo("Creating initial commit...")
    _run_command(["git", "add", "."], cwd=project_dir, project_dir=project_dir)
    _run_command(
        ["git", "commit", "-m", f"Initial scaffold ({framework}, Python {python_version})"],
        cwd=project_dir,
        project_dir=project_dir,
    )

    # -- Print next steps --
    click.echo()
    click.echo(f"Project created: {repo_name}/")
    click.echo()
    click.echo("Next steps:")
    click.echo(f"  cd {repo_name}")
    click.echo()
    click.echo("  # Create the GitHub repo (requires gh CLI):")
    click.echo(f"  gh repo create {GITHUB_ORG}/{repo_name} --private --source . --push")
    click.echo()
    click.echo("  # Or add a remote manually:")
    click.echo(f"  git remote add origin git@github.com:{GITHUB_ORG}/{repo_name}.git")
    click.echo("  git push -u origin main")