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

"""Base classes for all kdepim packagers"""

import os
import time
import inspect
import re
import logging

import treepkg.packager
import treepkg.subversion


class TagDetector(object):

    """Class to automatically find SVN tags and help package them

    The tags are found using three parameters:
      url -- The base url of the SVN tags directory to use
      pattern -- A regular expression matching the subdirectories to
                 consider in the tag directory specified by the url
      subdir -- A subdirectory of the directory matched by pattern to
                export and use to determine revision number
    """

    def __init__(self, url, pattern, subdir):
        self.url = url
        self.pattern = re.compile(pattern)
        self.subdir = subdir

    def list_tags(self):
        matches = []
        if self.url:
            for tag in treepkg.subversion.list_url(self.url):
                if self.pattern.match(tag.rstrip("/")):
                    matches.append(tag)
        return sorted(matches)

    def newest_tag_revision(self):
        """Determines the newest tag revision and returns (tagurl, revno)
        If no tag can be found, the method returns the tuple (None, None).
        """
        candidates = self.list_tags()
        if candidates:
            newest = candidates[-1]
            subdir = self.subdir
            if not subdir.endswith("/"):
                subdir += "/"
            tag_url = self.url + "/" + newest
            tag_subdirs = treepkg.subversion.list_url(tag_url)
            if subdir in tag_subdirs:
                subdir_url = tag_url + "/" + subdir
                revision = treepkg.subversion.last_changed_revision(subdir_url)
                return subdir_url, revision
        return None, None



class BaseSourcePackager(treepkg.packager.SourcePackager):

    def __init__(self, *args, **kw):
        super(BaseSourcePackager, 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 do_package(self):
        pkgbaseversion, pkgbasedir = self.export_sources()
        self.update_version_numbers(pkgbasedir)

        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 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 BasePackageTrack(treepkg.packager.PackageTrack):

    extra_config_desc = ["version_template",
                         ("tags_url", str, ""),
                         ("tags_pattern", str, ""),
                         ("tags_subdir", str, "")]

    def __init__(self, *args, **kw):
        self.version_template = kw.pop("version_template")
        tags_url = kw.pop("tags_url")
        tags_pattern = kw.pop("tags_pattern")
        tags_subdir = kw.pop("tags_subdir")
        super(BasePackageTrack, self).__init__(*args, **kw)
        self.tag_detector = TagDetector(tags_url, tags_pattern, tags_subdir)

    def packager_for_new_revision(self):
        logging.info("Checking tags")
        self.tag_url = None
        tag_url, tag_revision = self.tag_detector.newest_tag_revision()
        logging.info("Found: %s: %s", tag_url, tag_revision)
        if tag_url is not None:
            revision = (tag_revision,
                        self.rules_working_copy.last_changed_revision())
            logging.info("New revision is %s", revision)
            if revision not in self.get_revision_numbers():
                logging.info("Revision %s has not been packaged yet",
                             revision)
                self.tag_url = tag_url
                return self.revision_packager_cls(self, tag=tag_url, *revision)
            else:
                logging.info("Revision %s has already been packaged.",
                             revision)

        return super(BasePackageTrack, self).packager_for_new_revision()

    def export_sources(self, to_dir):
        if self.tag_url is not None:
            self.export_tag(self.tag_url, to_dir)
        else:
            super(BasePackageTrack, self).export_sources(to_dir)

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


def define_kdepim_packager(basename=None, external_subdirs=None):

    caller_globals = inspect.currentframe().f_back.f_globals

    SourcePackager = caller_globals.get("SourcePackager")
    if SourcePackager is None:
        class SourcePackager(BaseSourcePackager):
            pkg_basename = basename

    class RevisionPackager(treepkg.packager.RevisionPackager):
        source_packager_cls = SourcePackager

    class PackageTrack(BasePackageTrack):
        revision_packager_cls = RevisionPackager

        if external_subdirs is not None:
            svn_external_subdirs = external_subdirs

    caller_globals["PackageTrack"] = PackageTrack