# repodiff.py

# DNF plugin adding a command to show differencies between two sets

# of repositories.

#

# Copyright (C) 2018 Red Hat, Inc.

#

# This copyrighted material is made available to anyone wishing to use,

# modify, copy, or redistribute it subject to the terms and conditions of

# the GNU General Public License v.2, or (at your option) any later version.

# This program is distributed in the hope that it will be useful, but WITHOUT

# ANY WARRANTY expressed or implied, including the implied warranties of

# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General

# Public License for more details.  You should have received a copy of the

# GNU General Public License along with this program; if not, write to the

# Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA

# 02110-1301, USA.  Any Red Hat trademarks that are incorporated in the

# source code or documentation are not subject to the GNU General Public

# License and may only be used or replicated with the express permission of

# Red Hat, Inc.

#

from __future__ import absolute_import

from __future__ import unicode_literals

import dnf.cli

from dnf.cli.option_parser import OptionParser

import hawkey

from dnfpluginscore import _

class RepoDiff(dnf.Plugin):

    name = "repodiff"

    def __init__(self, base, cli):

        super(RepoDiff, self).__init__(base, cli)

        if cli is None:

            return

        cli.register_command(RepoDiffCommand)

class RepoDiffCommand(dnf.cli.Command):

    aliases = ("repodiff",)

    summary = _("List differences between two sets of repositories")

    @staticmethod

    def set_argparser(parser):

        # I'd like to use --old and --new options like Yum did.

        # But ability to disable abbreviated long options is added

        # only in Python >= 3.5

        # So in command arguments we are not able to use arguments,

        # which are prefixes of main arguments (i.w. --new would be

        # treated as --newpackage). This is because we run .parse_args

        # two times - for main and then for command arguments.

        # https://stackoverflow.com/questions/33900846

        parser.add_argument("--repo-old", "-o", default=[], action="append", dest="old",

                            help=_("Specify old repository, can be used multiple times"))

        parser.add_argument("--repo-new", "-n", default=[], action="append", dest="new",

                            help=_("Specify new repository, can be used multiple times"))

        parser.add_argument("--arch", "--archlist", "-a", default=[],

                            action=OptionParser._SplitCallback, dest="arches",

                            help=_("Specify architectures to compare, can be used "

                                   "multiple times. By default, only source rpms are "

                                   "compared."))

        parser.add_argument("--size", "-s", action="store_true",

                            help=_("Output additional data about the size of the changes."))

        parser.add_argument("--compare-arch", action="store_true",

                            help=_("Compare packages also by arch. By default "

                                   "packages are compared just by name."))

        parser.add_argument("--simple", action="store_true",

                            help=_("Output a simple one line message for modified packages."))

        parser.add_argument("--downgrade", action="store_true",

                            help=_("Split the data for modified packages between "

                                   "upgraded and downgraded packages."))

    def configure(self):

        demands = self.cli.demands

        demands.sack_activation = True

        demands.available_repos = True

        demands.changelogs = True

        self.base.conf.disable_excludes = ["all"]

        # TODO yum was able to handle mirrorlist in --new/--old arguments

        # Can be resolved by improving --repofrompath option

        if not self.opts.new or not self.opts.old:

            msg = _("Both old and new repositories must be set.")

            raise dnf.exceptions.Error(msg)

        for repo in self.base.repos.all():

            if repo.id in self.opts.new + self.opts.old:

                repo.enable()

            else:

                repo.disable()

        if not self.opts.arches:

            self.opts.arches = ['src']

    def _pkgkey(self, pkg):

        if self.opts.compare_arch:

            return (pkg.name, pkg.arch)

        return pkg.name

    def _repodiff(self, old, new):

        '''compares packagesets old and new, returns dictionary with packages:

        added: only in new set

        removed: only in old set

        upgraded: in both old and new, new has bigger evr

        downgraded: in both old and new, new has lower evr

        obsoletes: dictionary of which old package is obsoleted by which new

        '''

        old_d = dict([(self._pkgkey(p), p) for p in old])

        old_keys = set(old_d.keys())

        new_d = dict([(self._pkgkey(p), p) for p in new])

        new_keys = set(new_d.keys())

        # mapping obsoleted_package_from_old: obsoleted_by_package_from_new

        obsoletes = dict()

        for obsoleter in new.filter(obsoletes=old):

            for obsoleted in old.filter(provides=obsoleter.obsoletes):

                obsoletes[self._pkgkey(obsoleted)] = obsoleter

        evr_cmp = self.base.sack.evr_cmp

        repodiff = dict(

            added=[new_d[k] for k in new_keys - old_keys],

            removed=[old_d[k] for k in old_keys - new_keys],

            obsoletes=obsoletes,

            upgraded=[],

            downgraded=[])

        for k in old_keys.intersection(new_keys):

            pkg_old = old_d[k]

            pkg_new = new_d[k]

            if pkg_old.evr == pkg_new.evr:

                continue

            if evr_cmp(pkg_old.evr, pkg_new.evr) > 0:

                repodiff['downgraded'].append((pkg_old, pkg_new))

            else:

                repodiff['upgraded'].append((pkg_old, pkg_new))

        return repodiff

    def _report(self, repodiff):

        def pkgstr(pkg):

            if self.opts.compare_arch:

                return str(pkg)

            return "%s-%s" % (pkg.name, pkg.evr)

        def sizestr(num):

            msg = str(num)

            if num > 0:

                msg += " ({})".format(dnf.cli.format.format_number(num).strip())

            elif num < 0:

                msg += " (-{})".format(dnf.cli.format.format_number(-num).strip())

            return msg

        def report_modified(pkg_old, pkg_new):

            msgs = []

            if self.opts.simple:

                msgs.append("%s -> %s" % (pkgstr(pkg_old), pkgstr(pkg_new)))

            else:

                msgs.append('')

                msgs.append("%s -> %s" % (pkgstr(pkg_old), pkgstr(pkg_new)))

                msgs.append('-' * len(msgs[-1]))

                if pkg_old.changelogs:

                    old_chlog = pkg_old.changelogs[0]

                else:

                    old_chlog = None

                for chlog in pkg_new.changelogs:

                    if old_chlog:

                        if chlog['timestamp'] < old_chlog['timestamp']:

                            break

                        elif (chlog['timestamp'] == old_chlog['timestamp'] and

                              chlog['author'] == old_chlog['author'] and

                              chlog['text'] == old_chlog['text']):

                            break

                    msgs.append('* %s %s\n%s' % (

                        chlog['timestamp'].strftime("%a %b %d %Y"),

                        dnf.i18n.ucd(chlog['author']),

                        dnf.i18n.ucd(chlog['text'])))

                if self.opts.size:

                    msgs.append(_("Size change: {} bytes").format(

                        pkg_new.size - pkg_old.size))

            print('\n'.join(msgs))

        sizes = dict(added=0, removed=0, upgraded=0, downgraded=0)

        for pkg in sorted(repodiff['added']):

            print(_("Added package  : {}").format(pkgstr(pkg)))

            sizes['added'] += pkg.size

        for pkg in sorted(repodiff['removed']):

            print(_("Removed package: {}").format(pkgstr(pkg)))

            obsoletedby = repodiff['obsoletes'].get(self._pkgkey(pkg))

            if obsoletedby:

                print(_("Obsoleted by   : {}").format(pkgstr(obsoletedby)))

            sizes['removed'] += pkg.size

        if self.opts.downgrade:

            if repodiff['upgraded']:

                print(_("\nUpgraded packages"))

                for (pkg_old, pkg_new) in sorted(repodiff['upgraded']):

                    sizes['upgraded'] += (pkg_new.size - pkg_old.size)

                    report_modified(pkg_old, pkg_new)

            if repodiff['downgraded']:

                print(_("\nDowngraded packages"))

                for (pkg_old, pkg_new) in sorted(repodiff['downgraded']):

                    sizes['downgraded'] += (pkg_new.size - pkg_old.size)

                    report_modified(pkg_old, pkg_new)

        else:

            modified = repodiff['upgraded'] + repodiff['downgraded']

            if modified:

                print(_("\nModified packages"))

                for (pkg_old, pkg_new) in sorted(modified):

                    sizes['upgraded'] += (pkg_new.size - pkg_old.size)

                    report_modified(pkg_old, pkg_new)

        print(_("\nSummary"))

        print(_("Added packages: {}").format(len(repodiff['added'])))

        print(_("Removed packages: {}").format(len(repodiff['removed'])))

        if self.opts.downgrade:

            print(_("Upgraded packages: {}").format(len(repodiff['upgraded'])))

            print(_("Downgraded packages: {}").format(len(repodiff['downgraded'])))

        else:

            print(_("Modified packages: {}").format(

                len(repodiff['upgraded']) + len(repodiff['downgraded'])))

        if self.opts.size:

            print(_("Size of added packages: {}").format(sizestr(sizes['added'])))

            print(_("Size of removed packages: {}").format(sizestr(sizes['removed'])))

            if not self.opts.downgrade:

                print(_("Size of modified packages: {}").format(

                    sizestr(sizes['upgraded'] + sizes['downgraded'])))

            else:

                print(_("Size of upgraded packages: {}").format(

                    sizestr(sizes['upgraded'])))

                print(_("Size of downgraded packages: {}").format(

                    sizestr(sizes['downgraded'])))

            print(_("Size change: {}").format(

                sizestr(sizes['added'] + sizes['upgraded'] + sizes['downgraded'] -

                        sizes['removed'])))

    def run(self):

        # prepare old and new packagesets based by given arguments

        q_new = self.base.sack.query(hawkey.IGNORE_EXCLUDES).filter(

            reponame=self.opts.new)

        q_old = self.base.sack.query(hawkey.IGNORE_EXCLUDES).filter(

            reponame=self.opts.old)

        if self.opts.arches and '*' not in self.opts.arches:

            q_new.filterm(arch=self.opts.arches)

            q_old.filterm(arch=self.opts.arches)

        if self.opts.compare_arch:

            q_new.filterm(latest_per_arch=1)

            q_old.filterm(latest_per_arch=1)

        else:

            q_new.filterm(latest=1)

            q_old.filterm(latest=1)

        q_new.apply()

        q_old.apply()

        self._report(self._repodiff(q_old, q_new))