# Copyright (C) 2007, 2008, 2010 by Intevation GmbH
# Authors:
# Bernhard Herzog <bh@intevation.de>
# Modified for CE Andre Heinecke <aheinecke@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 for Windows CE 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\]?, \[([^]]+)\]\)",
                             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%s" % (self.orig_source_version(directory), self.revision)
    def sign_package(self):
        return None

    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%s" % 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. %s" % (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 as possible.  For the gnupg
    software this means we 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 having 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

export MINGWPATH=/opt/mingw32ce
export INCLUDE=$MINGWPATH/arm-mingw32ce/include:$MINGWPATH/include:\
/home/builder/wce-build/install/include:$INCLUDE
export LIB=$MINGWPATH/arm-mingw32ce/lib:$MINGWPATH/lib:\
/home/builder/wce-build/install/lib:$LIB
export PATH=:$PATH:$MINGWPATH/bin:$MINGWPATH/arm-mingw32ce/bin:\
$MINGWPATH/libexec/gcc/arm-mingw32ce/4.4.0:
export w32ce_root=/opt/mingw32ce

./autogen.sh --build-w32ce

# 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
"""
    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")

        # tweak automake settings so that make dist produces a tar.gz not
        # a tar.bz2
        run.call(cmdexpand("/bin/sh -c \"cp Makefile.am Makefile.am.orig\""), 
                           cwd=copied_working_copy,suppress_output=True)
        run.call(cmdexpand("/bin/sh -c \"sed -e '/AUTOMAKE_OPTIONS/ \
                            s/[a-zA-Z0-9-]*dist[a-zA-Z0-9-]*//g' \
                            Makefile.am.orig > Makefile.am\""), cwd=copied_working_copy,
                            suppress_output=True)
        
        run.call(cmdexpand("/bin/sh autogen.sh"), cwd=copied_working_copy,
                 suppress_output=True)
        orig_version = self.orig_source_version(copied_working_copy)
        treepkg.util.replace_in_file(os.path.join(copied_working_copy, 
                                                  "configure"), 
                                     re.escape(orig_version) + "-svn0",
                                     orig_version + "-svn%s" % self.revision)
      
        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. %s" % (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="make dist"):
    """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)