#! /usr/bin/python
# Copyright (C) 2007, 2008, 2009 by Intevation GmbH
# Authors:
# Bernhard Herzog <bh@intevation.de>
#
# This program is free software under the GPL (>=v2)
# Read the file COPYING coming with the software for details.

"""Usage: treepkgbuilder COMMAND [options]

Manage the pbuilder environment for a tree packager installation.  The
pbuilder settings are taken from the configuration file, either the
default treepkg.cfg or the one given with the --config-file option.
Also, this script assumes that there is only one pbuilder setting for
all packagers.  Use treepkgbuilder COMMAND --help for more details about
the commands.
"""

import sys

import treepkgcmd
from treepkg.options import create_parser
from treepkg.packager import create_package_track, PackagerGroup
from treepkg.readconfig import read_config


class Command(object):

    names = ()

    def __init__(self, arguments):
        parser = self.create_parser()
        self.opts, self.rest = parser.parse_args(arguments)

    def create_parser(self):
        return create_parser()

    def read_config(self):
        self.treepkg_opts, self.packager_opts \
                           = read_config(self.opts.config_file)

    def get_builder(self):
        self.read_config()
        group = PackagerGroup([create_package_track(**opts)
                               for opts in self.packager_opts],
                              **self.treepkg_opts)
        track = group.get_package_tracks()[0]
        return track.builder



class InitCommand(Command):

    names = ("init",)

    def __init__(self, arguments):
        super(InitCommand, self).__init__(arguments)
        if self.opts.mirrorsite is None:
            print >>sys.stderr, "Missing required option --mirrorsite"
            sys.exit(1)

    def create_parser(self):
        parser = super(InitCommand, self).create_parser()
        parser.set_defaults(distribution="etch")
        parser.add_option("--mirrorsite",
                          help=("The debian mirror site"
                                " (pbuilder MIRRORSITE setting).  Required."))
        parser.add_option("--othermirror",
                          help=("Extra contents of the OTHERMIRROR setting."
                                " See the pbuilder documentation for the"
                                " format."))
        parser.add_option("--distribution",
                          help=("The debian distribution for the pbuilder"
                                " chroot. Default is etch."))
        return parser

    def run(self):
        builder = self.get_builder()
        builder.init_pbuilder(distribution=self.opts.distribution,
                              mirrorsite=self.opts.mirrorsite,
                              extramirrors=self.opts.othermirror)


class AddBinariesCommand(Command):

    names = ("add-binaries",)

    def create_parser(self):
        parser = super(AddBinariesCommand, self).create_parser()
        parser.set_defaults(subdir="manual")
        parser.add_option("--subdir",
                          help=("The subdirectory of extra-pkg into which"
                                " the packages are to be copied"
                                " (default 'manual')."))
        return parser


    def run(self):
        builder = self.get_builder()
        builder.add_binaries_to_extra_pkg(self.rest,
                                          subdirectory=self.opts.subdir)


class UpdateCommand(Command):

    names = ("update",)

    def run(self):
        builder = self.get_builder()
        builder.update(suppress_output=False, log_info=False)


class AddKeyCommand(Command):

    names = ("addkey", "add-key")

    def __init__(self, arguments):
        super(AddKeyCommand, self).__init__(arguments)
        if not self.opts.key_id:
            print >>sys.stderr, "No key id given"
            sys.exit(1)

    def create_parser(self):
        parser = super(AddKeyCommand, self).create_parser()
        parser.add_option("--key-id",
                          help=("The id of the key to add.  Required."))
        return parser

    def run(self):
        builder = self.get_builder()
        builder.add_apt_key(self.opts.key_id)


class LoginCommand(Command):

    names = ("login",)

    def create_parser(self):
        parser = super(LoginCommand, self).create_parser()
        parser.set_defaults(bind_mount=[])
        parser.add_option("--bind-mount", action="append",
                          help=("Directories to bind-mount in the chroot"
                                " environment."))
        parser.add_option("--save-after-login", action="store_true",
                          help="Copy changes back to the tarball.")
        return parser


    def run(self):
        self.get_builder().login(bindmounts=self.opts.bind_mount,
                                 save_after_login=self.opts.save_after_login)


class BuildCommand(Command):

    names = ("build",)

    def create_parser(self):
        parser = super(BuildCommand, self).create_parser()
        parser.add_option("--logfile", help=("The file for the build log."))
        parser.add_option("--binary-dir",
                          help=("Directory for the binary packages."))
        return parser

    def run(self):
        if len(self.rest) != 1:
            print >>sys.stderr, "Exactly one .dsc file must be specified"
            sys.exit(1)
        dsc_file = self.rest[0]
        self.get_builder().build(dsc_file, binary_dir=self.opts.binary_dir,
                                 logfile=self.opts.logfile)


class ExecuteCommand(Command):

    names = ("execute",)

    def create_parser(self):
        parser = super(ExecuteCommand, self).create_parser()
        parser.add_option("--logfile", help=("Log file."))
        parser.add_option("--bind-mount", action="append",
                          help=("Directories to bind-mount in the chroot"
                                " environment."))
        return parser

    def run(self):
        if not self.rest:
            print >>sys.stderr, "At least the script file must be specified"
            sys.exit(1)
        script = self.rest
        self.get_builder().run_script(script, bindmounts=self.opts.bind_mount,
                                      logfile=self.opts.logfile)


class HelpCommand(Command):

    names = ("help", "--help", "-h")

    def run(self):
        print __doc__.rstrip()
        print "Supported commands:"
        commands = sorted((cmd for cmd in iter_commands() if cmd.names),
                          key=lambda cmd: cmd.names[0])
        for cmd in commands:
            print "   ", " ".join(cmd.names)


def iter_commands():
    for key, obj in globals().items():
        if key.endswith("Command"):
            yield obj

def get_command_class(name):
    for obj in iter_commands():
        if name in obj.names:
            return obj
    return None


def main():
    arguments = sys.argv[1:]

    if len(arguments) < 1:
        print >>sys.stderr, "Missing command"
        sys.exit(1)

    command_name = arguments[0]
    arguments = arguments[1:]

    command_class = get_command_class(command_name)
    if command_class is None:
        print >>sys.stderr, "Unknown command %r" % command_name
        sys.exit(1)

    command = command_class(arguments)
    command.run()


main()