# 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
import treepkg.git as git


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
        return super(SourcePackager, self).determine_package_version(
                directory, locals())

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

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

    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)

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_scm_type", str, None),
                         ("tags_rules_url", str, None),
                         ("tags_rules_pattern", str, ""),
                         ("tags_rules_subdir", str, ""),
                         ("tags_rules_scm_type", str, None)]

    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_url = kw.pop("tags_rules_url")
        tags_rules_pattern = kw.pop("tags_rules_pattern")
        tags_rules_subdir = kw.pop("tags_rules_subdir")
        tags_scm_type = kw.pop("tags_scm_type")
        tags_rules_scm_type = kw.pop("tags_rules_scm_type")
        super(PackageTrack, self).__init__(*args, **kw)

        if not tags_rules_pattern:
            tags_rules_pattern = tags_pattern
        if not tags_scm_type:
            tags_scm_type = self.scm_type
        if not tags_rules_scm_type:
            tags_rules_scm_type = self.rules_scm_type 

        if tags_scm_type == "git":
            self.tag_detector = git.TagDetector(tags_url, tags_pattern,
                    self.checkout_dir)
        elif tags_scm_type == "svn":
            self.tag_detector = subversion.TagDetector(tags_url, tags_pattern,
                                                   tags_subdir)
        else:
            raise treepkg.packager.PackagerError("Unknown scm type \"%s\" for tag" \
                    " sources set" % tags_scm_type)

        if tags_rules_scm_type == "git":
            self.tag_rules_detector = git.TagDetector(tags_rules_url,
                    tags_rules_pattern, self.debian_dir)
        elif tags_rules_scm_type == "svn":
            self.tag_rules_detector = subversion.TagDetector(tags_rules_url,
                    tags_rules_pattern, tags_rules_subdir)
        else:
            raise treepkg.packager.PackagerError("Unknown scm type \"%s\" for tag" \
                    " rules set" % tags_rules_scm_type)
        self.found_tag_rules = False
        if tags_rules_url:
            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)

        # tag has been built -> build trunk
        # don't use rules from tags for trunk
        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)