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

"""Publishes selected packages created by treepkg"""

import os
import sys
import shlex

from optparse import OptionParser
from ConfigParser import SafeConfigParser

import treepkgcmd
from treepkg.readconfig import read_config_section, convert_bool
from treepkg.run import call, capture_output
from treepkg.cmdexpand import cmdexpand
from treepkg.publish import *
from treepkg.util import md5sum
from treepkg.info.status import TreepkgInfo

config_desc = ["distribution", "section", "num_newest",
               "build_user", "build_host", "build_listpackages",
               "publish_user", "publish_host",
               ("architectures", shlex.split, "i386, source"),
               ("after_upload_hook", shlex.split),
               ("publish_remove_old_packages", convert_bool),
               ("publish_dir", remove_trailing_slashes),
               ("cachedir",
                lambda s: expand_filename(remove_trailing_slashes(s)))]

def read_config(filename):
    if not os.path.exists(filename):
        print >>sys.stderr, "Config file %s does not exist" % filename
        sys.exit(1)
    parser = SafeConfigParser()
    parser.read([filename])
    return read_config_section(parser, "publishpackages", config_desc)

def parse_commandline():
    parser = OptionParser()
    parser.set_defaults(config_file=os.path.join(treepkgcmd.topdir,
                                                 "publishpackages.cfg"),
                        quiet=False)
    parser.add_option("--config-file",
                      help=("The configuration file."
                            " Default is publishpackages.cfg"))
    parser.add_option("--dist",
                      help=("The debian distribution name to use on"
                            " the publishing system"))
    parser.add_option("--section",
                      help=("The debian distribution section name to use on"
                            " the publishing system"))
    parser.add_option("--track",
                      help=("The package track whose files are to be"
                            " published. If not given, files of all tracks"
                            " will be published"))
    parser.add_option("--quiet", action="store_true",
                      help=("Do not print progress meters or other"
                            " informational output"))
    return parser.parse_args()

def get_treepkg_info(variables):
    runremote = prefix_for_remote_command(variables["build_user"],
                                          variables["build_host"])
    xml = capture_output(cmdexpand("@runremote $build_listpackages"
                                     " --newest=$num_newest",
                                     #runremote=runremote,
                                     runremote="",
                                     **variables)).splitlines()
    treepkginfo = TreepkgInfo.fromxml(xml)

def get_binary_arch(arch): 
    if not arch == "source":
        if not arch.startswith("binary"):
            arch = "binary-" + arch
    return arch

def check_package_is_new(packagename, destdir, packagemd5sum):
    destpackage = os.path.join(destdir, packagename)
    if not os.path.isfile(destpackage):
        return True
    destmd5sum = md5sum(destpackage)
    return destmd5sum == packagemd5sum

def copy_to_cache(variables, track, revision, quiet, architectures=None):
    scp_flags = []
    if quiet:
        scp_flags.append("-q")
    treepkginfo = get_treepkg_info(variables)
    treepkgroot = treepkginfo.root
    binaryarchs = []
    # change e.g. armel in binary-armel
    for arch in architectures:
        binaryarchs.append(get_binary_arch(arch))
    # add binary-all to requested packages
    if not binaryarchs is None:
        binaryarchs.append("binary-all")
    
    for track in treepkgroot.tracks:
        files = []
        for rev in track.revisions:
            for package in rev.packages:
                # only copy requested archs (+ all)
                if not binaryarchs is None and \
                   not package.arch in binaryarchs:
                    break
                destdir = os.path.join(variables["cachedir"],
                                       package.arch,
                                       track.name)
                print "package: %s, destdir: %s" % (package.name, destdir)
                md5sum = ""
                for checksum in package.checksums:
                    if checksum.type == "md5":
                        md5sum = checksum.checksum
                        break
                # update only if the packages differ
                if check_package_is_new(package.name, destdir, md5sum):
                    files.append(package.path)
         # scp the packages of a track to the cache dir 
         #call(cmdexpand("scp -p @scp_flags @files $cachedir/", files=files,
         #                scp_flags=scp_flagsd, cachedir=destdir))

def publish_packages_arch(variables, track, revision, dist, section, 
                          quiet, architectures):
    copy_to_cache(variables, track, revision, quiet, architectures)
#    copy_to_publishdir(variables, dist, section, arch, quiet)

def publish_packages(config_filename, track, revision, dist, section, quiet):
    config = read_config(config_filename)

    if dist is None:
        dist = config["distribution"]
    if section is None:
        section = config["section"]

    architectures = config["architectures"]
    publish_packages_arch(config, track, revision, dist, section,
                          quiet, architectures)

    # update apt archive
#    call(config["after_upload_hook"])

def main():
    options, args = parse_commandline()
    revision = None # for future use cases
    publish_packages(options.config_file, options.track, revision,
                     options.dist, options.section, options.quiet)

if __name__ == "__main__":
    main()