#!/usr/bin/python3
#
#   ubuntu-build - command line interface for Launchpad buildd operations.
#
#   Copyright (C) 2007 Canonical Ltd.
#   Authors:
#    - Martin Pitt <martin.pitt@canonical.com>
#    - Jonathan Davies <jpds@ubuntu.com>
#    - Michael Bienia <geser@ubuntu.com>
#
#   This program is free software: you can redistribute it and/or modify
#   it under the terms of the GNU General Public License as published by
#   the Free Software Foundation, either version 3 of the License, or
#   (at your option) any later version.
#
#   This program is distributed in the hope that it will be useful,
#   but WITHOUT ANY WARRANTY; without even the implied warranty of
#   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
#   GNU General Public License for more details.
#
#   You should have received a copy of the GNU General Public License
#   along with this program.  If not, see <http://www.gnu.org/licenses/>.
#

# Our modules to import.
import sys
from optparse import OptionGroup
from optparse import OptionParser
from ubuntutools.lp.udtexceptions import (SeriesNotFoundException,
                                          PackageNotFoundException,
                                          PocketDoesNotExistError,)
from ubuntutools.lp.lpapicache import Distribution, PersonTeam
from launchpadlib.credentials import TokenAuthorizationException
from ubuntutools.misc import split_release_pocket

from ubuntutools import getLogger
Logger = getLogger()


def main():
    # Usage.
    usage = "%prog <srcpackage> <release> <operation>\n\n"
    usage += "Where operation may be one of: rescore, retry, or status.\n"
    usage += "Only Launchpad Buildd Admins may rescore package builds."

    # Valid architectures.
    valid_archs = set([
        "armel", "armhf", "arm64", "amd64", "hppa", "i386", "ia64",
        "lpia", "powerpc", "ppc64el", "riscv64", "s390x", "sparc",
    ])

    # Prepare our option parser.
    opt_parser = OptionParser(usage)

    # Retry options
    retry_rescore_options = OptionGroup(opt_parser, "Retry and rescore options",
                                        "These options may only be used with "
                                        "the 'retry' and 'rescore' operations.")
    retry_rescore_options.add_option("-a", "--arch", type="string",
                                     action="append", dest="architecture",
                                     help="Rebuild or rescore a specific "
                                          "architecture. Valid architectures "
                                          "include: %s." %
                                          ", ".join(valid_archs))

    # Batch processing options
    batch_options = OptionGroup(opt_parser, "Batch processing",
                                "These options and parameter ordering is only "
                                "available in --batch mode.\nUsage: "
                                "ubuntu-build --batch [options] <package>...")
    batch_options.add_option('--batch',
                             action='store_true', dest='batch', default=False,
                             help='Enable batch mode')
    batch_options.add_option('--series',
                             action='store', dest='series', type='string',
                             help='Selects the Ubuntu series to operate on '
                                  '(default: current development series)')
    batch_options.add_option('--retry',
                             action='store_true', dest='retry', default=False,
                             help='Retry builds (give-back).')
    batch_options.add_option('--rescore',
                             action='store', dest='priority', type='int',
                             help='Rescore builds to <priority>.')
    batch_options.add_option('--arch2', action='append', dest='architecture',
                             type='string',
                             help="Affect only 'architecture' (can be used "
                                  "several times). Valid architectures are: %s."
                                  % ', '.join(valid_archs))

    # Add the retry options to the main group.
    opt_parser.add_option_group(retry_rescore_options)
    # Add the batch mode to the main group.
    opt_parser.add_option_group(batch_options)

    # Parse our options.
    (options, args) = opt_parser.parse_args()

    if not len(args):
        opt_parser.print_help()
        sys.exit(1)

    if not options.batch:
        # Check we have the correct number of arguments.
        if len(args) < 3:
            opt_parser.error("Incorrect number of arguments.")

        try:
            package = str(args[0]).lower()
            release = str(args[1]).lower()
            op = str(args[2]).lower()
        except IndexError:
            opt_parser.print_help()
            sys.exit(1)

        # Check our operation.
        if op not in ("rescore", "retry", "status"):
            Logger.error("Invalid operation: %s." % op)
            sys.exit(1)

        # If the user has specified an architecture to build, we only wish to
        # rebuild it and nothing else.
        if options.architecture:
            if options.architecture[0] not in valid_archs:
                Logger.error("Invalid architecture specified: %s."
                             % options.architecture[0])
                sys.exit(1)
            else:
                one_arch = True
        else:
            one_arch = False

        # split release and pocket
        try:
            (release, pocket) = split_release_pocket(release)
        except PocketDoesNotExistError as error:
            Logger.error(error)
            sys.exit(1)

        try:
            # Will fail here if we have no credentials, bail out
            Launchpad.login()
        except TokenAuthorizationException:
            sys.exit(1)

        # Get the ubuntu archive
        ubuntu_archive = Distribution('ubuntu').getArchive()
        # Get list of published sources for package in question.
        try:
            sources = ubuntu_archive.getSourcePackage(package, release, pocket)
            distroseries = Distribution('ubuntu').getSeries(release)
        except (SeriesNotFoundException, PackageNotFoundException) as error:
            Logger.error(error)
            sys.exit(1)
        # Get list of builds for that package.
        builds = sources.getBuilds()

        # Find out the version and component in given release.
        version = sources.getVersion()
        component = sources.getComponent()

        # Operations that are remaining may only be done by Ubuntu developers
        # (retry) or buildd admins (rescore). Check if the proper permissions
        # are in place.
        me = PersonTeam.me
        if op == "rescore":
            necessary_privs = me.isLpTeamMember('launchpad-buildd-admins')
        if op == "retry":
            necessary_privs = me.canUploadPackage(ubuntu_archive, distroseries,
                                                  sources.getPackageName(),
                                                  sources.getComponent(),
                                                  pocket=pocket)

        if op in ('rescore', 'retry') and not necessary_privs:
            Logger.error("You cannot perform the %s operation on a %s "
                         "package as you do not have the permissions "
                         "to do this action." % (op, component))
            sys.exit(1)

        # Output details.
        Logger.info("The source version for '%s' in %s (%s) is at %s." %
                    (package, release.capitalize(), component, version))

        Logger.info("Current build status for this package:")

        # Output list of arches for package and their status.
        done = False
        for build in builds:
            if one_arch and build.arch_tag != options.architecture[0]:
                # Skip this architecture.
                continue

            done = True
            Logger.info("%s: %s." % (build.arch_tag, build.buildstate))
            if op == 'rescore':
                if build.can_be_rescored:
                    # FIXME: make priority an option
                    priority = 5000
                    Logger.info('Rescoring build %s to %d...' % (build.arch_tag, priority))
                    build.rescore(score=priority)
                else:
                    Logger.info('Cannot rescore build on %s.' % build.arch_tag)
            if op == 'retry':
                if build.can_be_retried:
                    Logger.info('Retrying build on %s...' % build.arch_tag)
                    build.retry()
                else:
                    Logger.info('Cannot retry build on %s.' % build.arch_tag)

        # We are done
        if done:
            sys.exit(0)

        Logger.info("No builds for '%s' found in the %s release" % (package, release.capitalize()))
        Logger.info("It may have been built in a former release.")
        sys.exit(0)

    # Batch mode

    if not options.architecture:
        # no specific architectures specified, assume all valid ones
        archs = valid_archs
    else:
        archs = set(options.architecture)

    # filter out duplicate and invalid architectures
    archs.intersection_update(valid_archs)

    release = options.series
    if not release:
        release = (Distribution('ubuntu').getDevelopmentSeries().name
                   + '-proposed')
    try:
        (release, pocket) = split_release_pocket(release)
    except PocketDoesNotExistError as error:
        Logger.error(error)
        sys.exit(1)

    ubuntu_archive = Distribution('ubuntu').getArchive()
    try:
        distroseries = Distribution('ubuntu').getSeries(release)
    except SeriesNotFoundException as error:
        Logger.error(error)
        sys.exit(1)
    me = PersonTeam.me

    # Check permisions (part 1): Rescoring can only be done by buildd admins
    can_rescore = ((options.priority
                    and me.isLpTeamMember('launchpad-buildd-admins'))
                   or False)
    if options.priority and not can_rescore:
        Logger.error("You don't have the permissions to rescore "
                     "builds. Ignoring your rescore request.")

    for pkg in args:
        try:
            pkg = ubuntu_archive.getSourcePackage(pkg, release, pocket)
        except PackageNotFoundException as error:
            Logger.error(error)
            continue

        # Check permissions (part 2): check upload permissions for the source
        # package
        can_retry = options.retry and me.canUploadPackage(ubuntu_archive,
                                                          distroseries,
                                                          pkg.getPackageName(),
                                                          pkg.getComponent())
        if options.retry and not can_retry:
            Logger.error("You don't have the permissions to retry the "
                         "build of '%s'. Ignoring your request."
                         % pkg.getPackageName())

        Logger.info("The source version for '%s' in '%s' (%s) is: %s" %
                    (pkg.getPackageName(), release, pocket, pkg.getVersion()))

        Logger.info(pkg.getBuildStates(archs))
        if can_retry:
            Logger.info(pkg.retryBuilds(archs))
        if options.priority and can_rescore:
            Logger.info(pkg.rescoreBuilds(archs, options.priority))

        Logger.info('')


if __name__ == '__main__':
    main()