# Copyright (C) 2007 - 2010 by Intevation GmbH
# Authors:
# Bernhard Herzog <bh@intevation.de>
# Bjoern Ricks <bjoern.ricks@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 kde entperprise packagers"""

import re
import time
import logging

import treepkg.packager
import treepkg.subversion as subversion


class SourcePackager(treepkg.packager.SourcePackager):

    def __init__(self, *args, **kw):
        super(SourcePackager, self).__init__(*args, **kw)
        self.enterprise_version = (self.parent.pkg_date + "."
                                   + str(self.revision))

    def determine_package_version(self, directory):
        enterprise_version = self.enterprise_version
        revision = self.revision
        rules_revision = self.parent.rules_revision
        pkg_revision = self.parent.pkg_revision
        pkg_date = self.parent.pkg_date

        return super(SourcePackager, self).determine_package_version(
                directory, locals())

    def prepare_sources_for_tarball(self, pkgbasedir, pkgbaseversion):
        self.update_version_numbers(pkgbasedir)

    def get_change_msg(self):
        return self.changemsg_template % dict(revision=self.revision,
                                     pkg_date=self.parent.pkg_date,
                                     rules_revision=self.parent.rules_revision)

    def update_version_numbers(self, pkgbasedir):
        """Updates the version numbers in the code in pkgbasedir.
        The default implementation does nothing.  Derived classes should
        override this method if necessary.
        """


class RevisionPackager(treepkg.packager.RevisionPackager):

    source_packager_cls = SourcePackager

    def __init__(self, *args, **kw):
        self.pkg_date = kw.pop("pkg_date",
                               time.strftime("%Y%m%d", time.localtime()))
        super(RevisionPackager, self).__init__(*args, **kw)


class PackageTrack(treepkg.packager.PackageTrack):

    revision_packager_cls = RevisionPackager

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

    def __init__(self, *args, **kw):
        tags_url = kw.pop("tags_url")
        tags_pattern = kw.pop("tags_pattern")
        tags_subdir = kw.pop("tags_subdir")
        tags_rules_subdir = kw.pop("tags_rules_subdir")
        super(PackageTrack, self).__init__(*args, **kw)
        self.tag_detector = subversion.TagDetector(tags_url, tags_pattern,
                                                   tags_subdir)
        self.tag_rules_detector = subversion.TagDetector(tags_url, tags_pattern,
                                                   tags_rules_subdir)
        self.found_tag_rules = False
        if tags_rules_subdir:
            self.found_tag_rules = True

    def packager_for_new_revision(self):
        logging.info("Checking tags")
        self.tag_url = None
        self.use_tag_rules = self.found_tag_rules
        tag_url, tag_revision = self.tag_detector.newest_tag_revision()
        tag_rules_url, tag_rules_revision = self.tag_rules_detector.newest_tag_revision()
        logging.info("Found: %s: %s", tag_url, tag_revision)
        logging.info("Found rules: %s: %s", tag_rules_url, tag_rules_revision)
        if self.use_tag_rules and tag_rules_url is None:
            self.use_tag_rules = False # maybe it's better to raise an exception
        if tag_url is not None:
            if not self.use_tag_rules:
                tag_rules_revision = self.rules_working_copy.last_changed_revision()
            revision = (tag_revision, tag_rules_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
                self.tag_revision = tag_revision
                self.tag_rules_url = tag_rules_url
                self.tag_rules_revision = tag_rules_revision
                tag_date, tag_change_count = self.tag_pkg_parameters(tag_url)
                pkg_revision = (self.pkg_revision_template
                                % dict(pkg_revision=tag_change_count,
                                       rules_revision=revision[1]))
                return self.revision_packager_cls(self, tag=tag_url,
                                                  pkg_revision=pkg_revision,
                                                  pkg_date=tag_date,
                                                  *revision)
            else:
                logging.info("Revision %s has already been packaged.",
                             revision)
        
        else: # tag_url is not set -> build trunk
            # don't use rules from tags for trunk builds
            self.use_tag_rules = False
            return super(PackageTrack, self).packager_for_new_revision()

    def export_sources(self, to_dir):
        if self.tag_url is not None:
            logging.info("Exporting sources for tarball from %r to %r",
                         self.tag_url, to_dir)
            self.working_copy.export_tag(self.tag_url, to_dir,
                                         revision=self.tag_revision)
        else:
            super(PackageTrack, self).export_sources(to_dir)

    def copy_debian_directory(self, to_dir):
        if self.use_tag_rules:
            logging.info("Exporting debian package description from %s to %s",
                    self.tag_rules_url, to_dir)
            self.rules_working_copy.export_tag(self.tag_rules_url, to_dir)
        else:
            super(PackageTrack, self).copy_debian_directory(to_dir)

    def tag_pkg_parameters(self, tag_url):
        match = re.search(r"/enterprise[^.]*\.[^.]*\."
                          r"(?P<date>[0-9]{8})\.(?P<baserev>[0-9]+)/",
                          tag_url)
        if match:
            date = match.group("date")
            baserev = match.group("baserev")
            xml_log = subversion.log_xml(tag_url, baserev)
            revisions = subversion.extract_tag_revisions(xml_log)
            tag_change_count = len(revisions)
            return (date, tag_change_count)
        else:
            raise RuntimeError("Cannot determine tag parameters from %r"
                               % tag_url)