# Copyright (C) 2007, 2008 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.

"""Base classes for all gnupg packagers"""

import os
import re
import inspect
import new

import treepkg.util
import treepkg.packager
import treepkg.run as run
from treepkg.cmdexpand import cmdexpand


class BaseSourcePackager(treepkg.packager.SourcePackager):

    def orig_source_version(self, directory):
        """Determines the version from the configure.ac file in directory"""
        filename = os.path.join(directory, "configure.ac")
        for line in open(filename):

            # Matches lines like
            # m4_define(my_version, [1.1.7])
            # used by most of the gnupg packages
            match = re.match(r"m4_define\(\[?my_version\]?, \[([0-9.]+)\]\)",
                             line)
            if match:
                return match.group(1)

            # Matches lines like.
            # AC_INIT(pinentry, 0.7.6-cvs, [gnupg-devel@gnupg.org])
            # pinentry is the GnuPG package that actually needs this
            match = re.match(r"AC_INIT\([a-zA-Z_]+, ([0-9.]+)", line)
            if match:
                return match.group(1)

        raise RuntimeError("Could not determine the version number from %s"
                           % filename)

    def determine_package_version(self, directory):
        return "%s+svn%d" % (self.orig_source_version(directory), self.revision)

    def do_package(self):
        pkgbaseversion, pkgbasedir = self.export_sources()

        run.call(cmdexpand("/bin/sh autogen.sh"), cwd=pkgbasedir,
                 suppress_output=True)
        orig_version = self.orig_source_version(pkgbasedir)

        # patch the version number in the newly generated configure
        # file.  autogen.sh normally determines it from svn, but here it
        # ran on a copy that did not include the .svn subdirectories and
        # thus could not find the svn revision.
        treepkg.util.replace_in_file(os.path.join(pkgbasedir, "configure"),
                                     re.escape(orig_version) + "-svn0",
                                     orig_version + "-svn%d" % self.revision)

        pkgbasename = self.pkg_basename + "_" + pkgbaseversion
        origtargz = os.path.join(self.work_dir,
                                 pkgbasename + ".orig.tar.gz")
        self.create_tarball(origtargz, self.work_dir,
                            os.path.basename(pkgbasedir))

        changemsg = ("Update to SVN rev. %d" % (self.revision,))
        self.copy_debian_directory(pkgbasedir, pkgbaseversion,
                                   changemsg)

        self.create_source_package(pkgbasedir, origtargz)
        self.move_source_package(pkgbasename)


class SmartSourcePackager(BaseSourcePackager):

    """SourcePackager that uses pbuilder to create the source tarball.

    We try to create source tarballs that are as close to the tarballs
    created by the upstream maintainers.  For the gnupg software this
    means need to run 'make dist' in a configured SVN working copy with
    some additional software installed like autoconf and texinfo.  We
    want to avoid running code from a working copy outside of the
    pbuilder environment and to have to install recipe specific
    additional software packages in the treepkg host system.  Therefore
    we create the source tarball using 'pbuilder execute' with a script.
    """

    createtarball_script = """\
#! /bin/bash
set -e

apt-get --assume-yes --force-yes install %(builddeps)s

# copy the source tree to a directory that's under pbuilder control so
# that it gets removed along with the build environment.  Otherwise we
# end up with a directory containing files that cannot be removed by
# treepkg
workdir=/tmp/work
cp -a %(basedir)s $workdir
cd $workdir

# tweak autoconf settings so that make dist produces a tar.gz, not a
# tar.bz2. Removing all options whose names contain 'dist' should
# achieve that.
cp Makefile.am Makefile.am.orig
sed -e '/AUTOMAKE_OPTIONS/ s/[a-zA-Z0-9-]*dist[a-zA-Z0-9-]*//g' \
    Makefile.am.orig > Makefile.am

./autogen.sh
./configure --enable-maintainer-mode

# revert autoconf changes, so that the original Makefile.am ends up in
# the tarball
mv Makefile.am.orig Makefile.am

%(make_dist_command)s

mv *.tar.gz %(origtargz)s
"""

    make_dist_command = "make dist"

    def __init__(self, *args):
        super(SmartSourcePackager, self).__init__(*args)
        self.pkgbasename = None
        self.pkgbaseversion = None
        self.origtargz = None

    def copy_workingcopy(self, dest):
        treepkg.util.copytree(self.track.checkout_dir, dest)

    def create_original_tarball(self):
        copied_working_copy = os.path.join(self.work_dir, "copied_working_copy")
        self.copy_workingcopy(copied_working_copy)

        self.pkgbaseversion = \
                            self.determine_package_version(copied_working_copy)
        self.pkgbasename = self.pkg_basename + "_" + self.pkgbaseversion
        self.origtargz = os.path.join(self.work_dir,
                                      self.pkgbasename + ".orig.tar.gz")

        script = (self.createtarball_script
                  % dict(builddeps=" ".join(self.track.dependencies_required()
                                            | self.tarball_dependencies),
                         basedir=copied_working_copy,
                         origtargz=self.origtargz,
                         make_dist_command=self.make_dist_command))
        script_name = os.path.join(self.work_dir, "createtarball")
        treepkg.util.writefile(script_name, script, 0755)

        treepkg.util.ensure_directory(self.src_dir)
        treepkg.util.ensure_directory(self.log_dir)
        self.track.builder.run_script(script_name,
                                      logfile=os.path.join(self.log_dir,
                                                           "tarball_log.txt"),
                                      bindmounts=[self.work_dir, self.src_dir])

    def create_orig_dir(self):
        """Unpacks the tarball created by create_original_tarball into work_dir
        """
        unpack_dir = os.path.join(self.work_dir, "unpack")
        treepkg.util.ensure_directory(unpack_dir)
        run.call(cmdexpand("tar xzf $origtargz -C $unpack_dir",
                           unpack_dir=unpack_dir, origtargz=self.origtargz))
        unpacked_files = treepkg.util.listdir_abs(unpack_dir)
        if len(unpacked_files) != 1:
            raise RuntimeError("%s should have extracted to a single directory",
                               origtargz)
        unpacked_dir = unpacked_files[0]

        orig_dir = os.path.join(self.work_dir, os.path.basename(unpacked_dir))
        os.rename(unpacked_dir, orig_dir)
        return orig_dir

    def do_package(self):
        self.create_original_tarball()
        orig_dir = self.create_orig_dir()

        changemsg = ("Update to SVN rev. %d" % (self.revision,))
        self.copy_debian_directory(orig_dir, self.pkgbaseversion, changemsg)

        self.create_source_package(orig_dir, self.origtargz)
        self.move_source_package(self.pkgbasename)


def define_gnupg_packager(pkg_basename,
                          tarball_dependencies=("autoconf", "automake",
                                                "texinfo", "subversion"),
                          make_dist_command=None):
    """Create a SourcePackager for a GnuPG package in the caller's globals().
    This is a helper function for the modules in the recipe.gnupg package.
    """
    base_class = BaseSourcePackager
    class_attributes = dict(pkg_basename=pkg_basename)
    if tarball_dependencies is not None:
        base_class = SmartSourcePackager
        class_attributes["tarball_dependencies"] = set(tarball_dependencies)
    if make_dist_command is not None:
        base_class = SmartSourcePackager
        class_attributes["make_dist_command"] = make_dist_command

    caller_globals = inspect.currentframe().f_back.f_globals
    caller_globals["SourcePackager"] = new.classobj("SourcePackager",
                                                    (base_class,),
                                                    class_attributes)