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

import os
import logging
import shutil
import time

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

from base import BasePackageTrack


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, url=None):
        if url is not None:
            baseurl = url
        else:
            baseurl = self.localdir
        for desc in self.subdirectories:
            if len(desc) == 2:
                subdir, recurse = desc
            else:
                subdir = desc[0]
                recurse = True
            subversion.export(os.path.join(baseurl, subdir),
                              os.path.join(destdir, subdir),
                              recurse=recurse)

    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")
        # xutils-dev is needed for the revpath script used by
        # scripts/autogen.sh
        script = (self.createtarball_script
                  % dict(builddeps="xutils-dev",  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(BasePackageTrack):

    revision_packager_cls = RevisionPackager

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

    def export_tag(self, tag_url, to_dir):
        logging.info("Exporting sources from %s to %r",
                     tag_url, to_dir)
        self.working_copy.export(to_dir, url=tag_url)