#!/usr/bin/python3

import datetime

import dnf

import hashlib

import hawkey

import json

import sys

import tempfile

DNF_ERROR_EXIT_CODE = 10

def timestamp_to_rfc3339(timestamp):

    d = datetime.datetime.utcfromtimestamp(package.buildtime)

    return d.strftime('%Y-%m-%dT%H:%M:%SZ')

def dnfrepo(desc, parent_conf=None):

    """Makes a dnf.repo.Repo out of a JSON repository description"""

    repo = dnf.repo.Repo(desc["id"], parent_conf)

    if "baseurl" in desc:

        repo.baseurl = desc["baseurl"]

    elif "metalink" in desc:

        repo.metalink = desc["metalink"]

    elif "mirrorlist" in desc:

        repo.mirrorlist = desc["mirrorlist"]

    else:

        assert False

    if desc.get("ignoressl", False):

        repo.sslverify = False

    if "sslcacert" in desc:

        repo.sslcacert = desc["sslcacert"]

    if "sslclientkey" in desc:

        repo.sslclientkey = desc["sslclientkey"]

    if "sslclientcert" in desc:

        repo.sslclientcert = desc["sslclientcert"]

    # In dnf, the default metadata expiration time is 48 hours. However,

    # some repositories never expire the metadata, and others expire it much

    # sooner than that. Therefore we must make this configurable. If nothing

    # is provided, we default to never expiring the metadata, as hardcoding

    # some arbitrary does not seem very helpful.

    repo.metadata_expire = desc.get("metadata_expire", "-1")

    return repo

def create_base(repos, module_platform_id, persistdir, cachedir, arch):

    base = dnf.Base()

    # Enable fastestmirror to ensure we choose the fastest mirrors for

    # downloading metadata (when depsolving) and downloading packages.

    base.conf.fastestmirror = True

    # Try another mirror if it takes longer than 5 seconds to connect.

    base.conf.timeout = 5

    # Set the rest of the dnf configuration.

    base.conf.module_platform_id = module_platform_id

    base.conf.config_file_path = "/dev/null"

    base.conf.persistdir = persistdir

    base.conf.cachedir = cachedir

    base.conf.substitutions['arch'] = arch

    base.conf.substitutions['basearch'] = dnf.rpm.basearch(arch)

    for repo in repos:

        base.repos.add(dnfrepo(repo, base.conf))

    base.fill_sack(load_system_repo=False)

    return base

def exit_with_dnf_error(kind: str, reason: str):

    json.dump({"kind": kind, "reason": reason}, sys.stdout)

    sys.exit(DNF_ERROR_EXIT_CODE)

def repo_checksums(base):

    checksums = {}

    for repo in base.repos.iter_enabled():

        # Uses the same algorithm as libdnf to find cache dir:

        #   https://github.com/rpm-software-management/libdnf/blob/master/libdnf/repo/Repo.cpp#L1288

        if repo.metalink:

            url = repo.metalink

        elif repo.mirrorlist:

            url = repo.mirrorlist

        elif repo.baseurl:

            url = repo.baseurl[0]

        else:

            assert False

        digest = hashlib.sha256(url.encode()).hexdigest()[:16]

        repomd_file = f"{repo.id}-{digest}/repodata/repomd.xml"

        with open(f"{base.conf.cachedir}/{repomd_file}", "rb") as f:

            repomd = f.read()

        checksums[repo.id] = "sha256:" + hashlib.sha256(repomd).hexdigest()

    return checksums

call = json.load(sys.stdin)

command = call["command"]

arguments = call["arguments"]

repos = arguments.get("repos", {})

arch = arguments["arch"]

cachedir = arguments["cachedir"]

module_platform_id = arguments["module_platform_id"]

with tempfile.TemporaryDirectory() as persistdir:

    try:

        base = create_base(

            repos,

            module_platform_id,

            persistdir,

            cachedir,

            arch

        )

    except dnf.exceptions.Error as e:

        exit_with_dnf_error(

            type(e).__name__,

            f"Error occurred when setting up repo: {e}"

        )

    if command == "dump":

        packages = []

        for package in base.sack.query().available():

            packages.append({

                "name": package.name,

                "summary": package.summary,

                "description": package.description,

                "url": package.url,

                "epoch": package.epoch,

                "version": package.version,

                "release": package.release,

                "arch": package.arch,

                "buildtime": timestamp_to_rfc3339(package.buildtime),

                "license": package.license

            })

        json.dump({

            "checksums": repo_checksums(base),

            "packages": packages

        }, sys.stdout)

    elif command == "depsolve":

        errors = []

        try:

            base.install_specs(

                arguments["package-specs"],

                exclude=arguments.get("exclude-specs", [])

            )

        except dnf.exceptions.MarkingErrors as e:

            exit_with_dnf_error(

                "MarkingErrors",

                f"Error occurred when marking packages for installation: {e}"

            )

        try:

            base.resolve()

        except dnf.exceptions.DepsolveError as e:

            exit_with_dnf_error(

                "DepsolveError",

                (

                    "There was a problem depsolving "

                    f"{arguments['package-specs']}: {e}"

                )

            )

        dependencies = []

        for tsi in base.transaction:

            # Avoid using the install_set() helper, as it does not guarantee

            # a stable order

            if tsi.action not in dnf.transaction.FORWARD_ACTIONS:

                continue

            package = tsi.pkg

            dependencies.append({

                "name": package.name,

                "epoch": package.epoch,

                "version": package.version,

                "release": package.release,

                "arch": package.arch,

                "repo_id": package.reponame,

                "path": package.relativepath,

                "remote_location": package.remote_location(),

                "checksum": (

                    f"{hawkey.chksum_name(package.chksum[0])}:"

                    f"{package.chksum[1].hex()}"

                )

            })

        json.dump({

            "checksums": repo_checksums(base),

            "dependencies": dependencies

        }, sys.stdout)