#!/usr/bin/env python3
# Licensed under the Apache-2.0 license
# SPDX-License-Identifier: Apache-2.0

import argparse
import re
import subprocess
import logging
import sys


def get_roll_directives(module):
    """Parses MODULE.bazel content to find roll directives.

    Roll directives are comments in the format `# roll:dependency_name`
    following a commit hash in quotes.

    Args:
        module: The content of the MODULE.bazel file as a string.

    Returns:
        A dictionary mapping dependency names to their current commit hashes.
    """
    roll = {}
    for match in re.finditer(r'"([0-9A-Fa-f]+)",?\s+#\s+roll:(\w+)', module):
        roll[match.group(2)] = match.group(1)
    return roll


def git_ls_remote(url):
    """Retrieves the latest commit hash of a remote Git repository.

    Supports specifying a ref in the URL using the format 'url{ref}'.
    If no ref is specified, it defaults to 'HEAD'.

    Args:
        url: The URL of the remote Git repository, optionally followed by
          '{ref}'.

    Returns:
        The latest commit hash for the specified ref as a string.

    Raises:
        subprocess.CalledProcessError: If the git ls-remote command fails.
    """
    ref = "HEAD"
    if url.endswith("}"):
        url, ref = url.split("{")
        ref = ref[:-1]

    result = subprocess.run(
        [
            "git",
            "ls-remote",
            url,
            ref,
        ],
        capture_output=True,
        check=True,
    )
    data = result.stdout.decode("utf-8")
    hash, *_ = data.split()
    return hash


def roll(module, roll, replacements, dry_run=False):
    """Performs the rolling of dependencies in the module content.

    Iterates through the identified roll directives and replaces the old
    version (hash) with the new one from replacements.

    Args:
        module: The content of the MODULE.bazel file as a string.
        roll: A dictionary mapping dependency names to their current hashes.
        replacements: A dictionary mapping dependency names to their new
          hashes. This dictionary is modified in-place.
        dry_run: If True, only log what would be updated without modifying the
          module content.

    Returns:
        A tuple containing:
        - module (str): The updated module content.
        - err (bool): True if there were errors (missing or unused
        replacements), False otherwise.
    """
    err = False
    for name, oldver in roll.items():
        if newver := replacements.pop(name, None):
            if dry_run:
                logging.info("DRY-RUN: updating %s from %s to %s", name, oldver, newver)
            else:
                logging.info("Updating %s from %s to %s", name, oldver, newver)
                module = module.replace(oldver, newver)
        else:
            logging.error("No replacement for %s", name)
            err = True

    for name in replacements:
        logging.error("No roll directive for %s", name)
        err = True
    return (module, err)


def main():
    """Main entry point for the dependency roller script.

    Parses command-line arguments, reads the module file, fetches remote
    hashes, performs the roll, and writes the updated content back to the
    file (unless dry-run is enabled).

    Returns:
        An integer: 0 if successful, 1 if there were errors during the roll.
    """
    parser = argparse.ArgumentParser(description="Visualize ELF memory layout.")
    parser.add_argument(
        "--logging",
        default="info",
        choices=["error", "warning", "info", "debug"],
        help="Logging level",
    )
    parser.add_argument(
        "--dry-run",
        action=argparse.BooleanOptionalAction,
        help="Dry-run: don't update dependencies",
    )
    parser.add_argument(
        "--remote",
        action="append",
        default=[],
        help="Remote repositorie URLs to check as name=url or name=url{ref}",
    )
    parser.add_argument("module", help="Path to MODULE.bazel")

    args = parser.parse_args()
    logging.basicConfig(level=args.logging.upper())

    replacements = {}
    for r in args.remote:
        name, url = r.split("=", 1)
        replacements[name] = git_ls_remote(url)
        logging.info("Remote %s = %s", name, replacements[name])

    with open(args.module, "rt") as f:
        module = f.read()

    rolls = get_roll_directives(module)
    module, err = roll(module, rolls, replacements, args.dry_run)

    if args.dry_run:
        logging.info("DRY-RUN: would rewrite %s", args.module)
    else:
        with open(args.module, "wt") as f:
            f.write(module)

    return int(err)


if __name__ == "__main__":
    sys.exit(main())