# 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.

import os
import logging
import shutil
import time

import treepkg.packager
import treepkg.util
import treepkg.subversion as subversion


class SubversionSubset(object):

    """Manage a subversion working copy that contains a subset of a repository

    The SVN repository for the enterprise 4 l10n sources contains all
    languages.  Only a small subset of those languages are actually
    maintained, though.  This class provides a way to manage a working
    copy that contains only the part that actually need to be packaged.
    """

    def __init__(self, baseurl, localdir, subdirectories):
        self.baseurl = baseurl
        self.localdir = localdir
        self.subdirectories = subdirectories

    def update_or_checkout(self, revision=None):
        for desc in self.subdirectories:
            if len(desc) == 2:
                subdir, recurse = desc
            else:
                subdir = desc[0]
                recurse = True
            self.update_or_checkout_subdir(subdir, revision, recurse=recurse)

    def update_or_checkout_subdir(self, subdir, revision, recurse):
        localdir = os.path.join(self.localdir, subdir)
        svn_url = self.baseurl + subdir
        if os.path.exists(localdir):
            logging.info("Updating the working copy in %r", localdir)
            subversion.update(localdir, revision=revision, recurse=recurse)
        else:
            logging.info("The working copy in %r doesn't exist yet."
                         "  Checking out from %r", localdir, svn_url)
            subversion.checkout(svn_url, localdir, revision=revision,
                                recurse=recurse)

    def export(self, destdir):
        for desc in self.subdirectories:
            subdir = desc[0]
            subversion.export(os.path.join(self.localdir, subdir),
                              os.path.join(destdir, subdir))

    def last_changed_revision(self):
        return max([subversion.last_changed_revision(os.path.join(self.localdir,
                                                                  desc[0]))
                    for desc in self.subdirectories])



class SourcePackager(treepkg.packager.SourcePackager):

    """Creates the debian source package for the l10n files

    This is a bit more complicated than for other packages.  The
    orig.tar.gz file of the debian source package contains one .tar.bz2
    file for every language.  Those .tar.bz files are the kde-18n-<lang>
    files released by the KDE project.  For now, we only have the German
    localization in the enterprise source package, so the orig.tar.gz
    file will have the following contents:

      kde-l10n-<version>/
      kde-l10n-<version>/kde-l10n-de-<version>.tar.bz2

    <version> is the same everywhere.
    """

    pkg_basename = "kde-l10n"

    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

# only handle the de subdirectory
echo de > subdirs

# create the CMakeFiles
./scripts/autogen.sh
mv de kde-l10n-de-%(version)s
 tar cjf %(tarball)s kde-l10n-de-%(version)s
"""


    def __init__(self, *args, **kw):
        super(SourcePackager, self).__init__(*args, **kw)
        self.enterprise_version = (time.strftime("%Y%m%d", time.localtime())
                                   + "." + str(self.revision))

    def determine_package_version(self, directory):
        enterprise_version = self.enterprise_version
        return self.track.version_template % locals()

    def create_l10n_de_tarball(self, pkgbaseversion, pkgbasedir):
        logging.info("Creating kde-l10n-de tarball")
        de_tarball = os.path.join(self.work_dir,
                                  "kde-l10n-de-" + pkgbaseversion + ".tar.bz2")
        # imake is needed for the revpath script
        script = (self.createtarball_script
                  % dict(builddeps="imake",  tarball=de_tarball,
                         basedir=pkgbasedir, version=pkgbaseversion))
        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])
        return de_tarball

    def do_package(self):
        pkgbaseversion, pkgbasedir = self.export_sources()
        de_tarball = self.create_l10n_de_tarball(pkgbaseversion, pkgbasedir)
        shutil.rmtree(pkgbasedir)

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

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

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


class RevisionPackager(treepkg.packager.RevisionPackager):

    source_packager_cls = SourcePackager


class PackageTrack(treepkg.packager.PackageTrack):

    extra_config_desc = ["version_template"]

    revision_packager_cls = RevisionPackager

    def __init__(self, *args, **kw):
        self.version_template = kw.pop("version_template")
        super(PackageTrack, self).__init__(*args, **kw)
        self.working_copy = SubversionSubset(self.svn_url, self.checkout_dir,
                                             subdirectories= [("", False),
                                                              ("de",),
                                                              ("scripts",)])

    def last_changed_revision(self):
        return self.working_copy.last_changed_revision()

    def update_checkout(self, revision=None):
        self.working_copy.update_or_checkout(revision=revision)

    def export_sources(self, to_dir):
        self.working_copy.export(to_dir)