#

# Copyright (C) 2015  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

from dnfpluginscore import _, logger

import dnf

import dnf.cli

import dnf.exceptions

import fnmatch

import hawkey

import os

import tempfile

import time

NOT_READABLE = _('Unable to read version lock configuration: %s')

NO_LOCKLIST = _('Locklist not set')

ADDING_SPEC = _('Adding versionlock on:')

EXCLUDING_SPEC = _('Adding exclude on:')

EXISTING_SPEC = _('Package already locked in equivalent form:')

ALREADY_LOCKED = _('Package {} is already locked')

ALREADY_EXCLUDED = _('Package {} is already excluded')

DELETING_SPEC = _('Deleting versionlock for:')

NOTFOUND_SPEC = _('No package found for:')

NO_VERSIONLOCK = _('Excludes from versionlock plugin were not applied')

APPLY_LOCK = _('Versionlock plugin: number of lock rules from file "{}" applied: {}')

APPLY_EXCLUDE = _('Versionlock plugin: number of exclude rules from file "{}" applied: {}')

NEVRA_ERROR = _('Versionlock plugin: could not parse pattern:')

locklist_fn = None

class VersionLock(dnf.Plugin):

    name = 'versionlock'

    def __init__(self, base, cli):

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

        self.base = base

        self.cli = cli

        if self.cli is not None:

            self.cli.register_command(VersionLockCommand)

    def config(self):

        global locklist_fn

        cp = self.read_config(self.base.conf)

        locklist_fn = (cp.has_section('main') and cp.has_option('main', 'locklist')

                       and cp.get('main', 'locklist'))

    def locking_enabled(self):

        if self.cli is None:

            enabled = True  # loaded via the api, not called by cli

        else:

            enabled = self.cli.demands.plugin_filtering_enabled

            if enabled is None:

                enabled = self.cli.demands.resolving

        return enabled

    def sack(self):

        if not self.locking_enabled():

            logger.debug(NO_VERSIONLOCK)

            return

        excludes_query = self.base.sack.query().filter(empty=True)

        locked_query = self.base.sack.query().filter(empty=True)

        locked_names = set()

        # counter of applied rules [locked_count, excluded_count]

        count = [0, 0]

        for pat in _read_locklist():

            excl = 0

            if pat and pat[0] == '!':

                pat = pat[1:]

                excl = 1

            possible_nevras = dnf.subject.Subject(pat).get_nevra_possibilities()

            if possible_nevras:

                count[excl] += 1

            else:

                logger.error("%s %s", NEVRA_ERROR, pat)

                continue

            for nevra in possible_nevras:

                pat_query = nevra.to_query(self.base.sack)

                if excl:

                    excludes_query = excludes_query.union(pat_query)

                else:

                    locked_names.add(nevra.name)

                    locked_query = locked_query.union(pat_query)

        if count[1]:

            logger.debug(APPLY_EXCLUDE.format(locklist_fn, count[1]))

        if count[0]:

            logger.debug(APPLY_LOCK.format(locklist_fn, count[0]))

        if locked_names:

            all_versions = self.base.sack.query().filter(name__glob=list(locked_names))

            other_versions = all_versions.difference(locked_query)

            excludes_query = excludes_query.union(other_versions)

            # exclude also anything that obsoletes the locked versions of packages

            excludes_query = excludes_query.union(

                self.base.sack.query().filterm(obsoletes=locked_query))

        excludes_query.filterm(reponame__neq=hawkey.SYSTEM_REPO_NAME)

        if excludes_query:

            self.base.sack.add_excludes(excludes_query)

EXC_CMDS = ['exclude', 'add-!', 'add!', 'blacklist']

DEL_CMDS = ['delete', 'del']

ALL_CMDS = ['add', 'clear', 'list'] + EXC_CMDS + DEL_CMDS

class VersionLockCommand(dnf.cli.Command):

    aliases = ("versionlock",)

    summary = _("control package version locks")

    usage = "[add|exclude|list|delete|clear] [<package-nevr-spec>]"

    @staticmethod

    def set_argparser(parser):

        parser.add_argument("--raw", default=False, action='store_true',

                            help=_("Use package specifications as they are, do not "

                                   "try to parse them"))

        parser.add_argument("subcommand", nargs='?',

                            metavar="[add|exclude|list|delete|clear]")

        parser.add_argument("package", nargs='*',

                            metavar="[<package-nevr-spec>]")

    def configure(self):

        self.cli.demands.sack_activation = True

        self.cli.demands.available_repos = True

    def run(self):

        cmd = 'list'

        if self.opts.subcommand:

            if self.opts.subcommand not in ALL_CMDS:

                cmd = 'add'

                self.opts.package.insert(0, self.opts.subcommand)

            elif self.opts.subcommand in EXC_CMDS:

                cmd = 'exclude'

            elif self.opts.subcommand in DEL_CMDS:

                cmd = 'delete'

            else:

                cmd = self.opts.subcommand

        if cmd == 'add':

            (entry, entry_cmd) = _search_locklist(self.opts.package)

            if entry == '':

                _write_locklist(self.base, self.opts.package, self.opts.raw, True,

                                "\n# Added lock on %s\n" % time.ctime(),

                                ADDING_SPEC, '')

            elif cmd != entry_cmd:

                raise dnf.exceptions.Error(ALREADY_EXCLUDED.format(entry))

            else:

                logger.info("%s %s", EXISTING_SPEC, entry)

        elif cmd == 'exclude':

            (entry, entry_cmd) = _search_locklist(self.opts.package)

            if entry == '':

                _write_locklist(self.base, self.opts.package, self.opts.raw, False,

                                "\n# Added exclude on %s\n" % time.ctime(),

                                EXCLUDING_SPEC, '!')

            elif cmd != entry_cmd:

                raise dnf.exceptions.Error(ALREADY_LOCKED.format(entry))

            else:

                logger.info("%s %s", EXISTING_SPEC, entry)

        elif cmd == 'list':

            for pat in _read_locklist():

                print(pat)

        elif cmd == 'clear':

            if not locklist_fn:

                raise dnf.exceptions.Error(NO_LOCKLIST)

            with open(locklist_fn, 'w') as f:

                # open in write mode truncates file

                pass

        elif cmd == 'delete':

            if not locklist_fn:

                raise dnf.exceptions.Error(NO_LOCKLIST)

            dirname = os.path.dirname(locklist_fn)

            (out, tmpfilename) = tempfile.mkstemp(dir=dirname, suffix='.tmp')

            locked_specs = _read_locklist()

            count = 0

            with os.fdopen(out, 'w', -1) as out:

                for ent in locked_specs:

                    if _match(ent, self.opts.package):

                        print("%s %s" % (DELETING_SPEC, ent))

                        count += 1

                        continue

                    out.write(ent)

                    out.write('\n')

            if not count:

                os.unlink(tmpfilename)

            else:

                os.chmod(tmpfilename, 0o644)

                os.rename(tmpfilename, locklist_fn)

def _read_locklist():

    locklist = []

    try:

        if not locklist_fn:

            raise dnf.exceptions.Error(NO_LOCKLIST)

        with open(locklist_fn) as llfile:

            for line in llfile.readlines():

                if line.startswith('#') or line.strip() == '':

                    continue

                locklist.append(line.strip())

    except IOError as e:

        raise dnf.exceptions.Error(NOT_READABLE % e)

    return locklist

def _search_locklist(package):

    found = action = ''

    locked_specs = _read_locklist()

    for ent in locked_specs:

        if _match(ent, package):

            found = ent

            action = 'exclude' if ent.startswith('!') else 'add'

            break

    return (found, action)

def _write_locklist(base, args, raw, try_installed, comment, info, prefix):

    specs = set()

    for pat in args:

        if raw:

            specs.add(pat)

            continue

        subj = dnf.subject.Subject(pat)

        pkgs = None

        if try_installed:

            pkgs = subj.get_best_query(dnf.sack._rpmdb_sack(base), with_nevra=True,

                                       with_provides=False, with_filenames=False)

        if not pkgs:

            pkgs = subj.get_best_query(base.sack, with_nevra=True, with_provides=False,

                                       with_filenames=False)

        if not pkgs:

            print("%s %s" % (NOTFOUND_SPEC, pat))

        for pkg in pkgs:

            specs.add(pkgtup2spec(*pkg.pkgtup))

    if specs:

        try:

            if not locklist_fn:

                raise dnf.exceptions.Error(NO_LOCKLIST)

            with open(locklist_fn, 'a') as f:

                f.write(comment)

                for spec in specs:

                    print("%s %s" % (info, spec))

                    f.write("%s%s\n" % (prefix, spec))

        except IOError as e:

            raise dnf.exceptions.Error(NOT_READABLE % e)

def _match(ent, patterns):

    ent = ent.lstrip('!')

    for pat in patterns:

        if ent == pat:

            return True

    try:

        n = hawkey.split_nevra(ent)

    except hawkey.ValueException:

        return False

    for name in (

        '%s' % n.name,

        '%s.%s' % (n.name, n.arch),

        '%s-%s' % (n.name, n.version),

        '%s-%s-%s' % (n.name, n.version, n.release),

        '%s-%s:%s' % (n.name, n.epoch, n.version),

        '%s-%s-%s.%s' % (n.name, n.version, n.release, n.arch),

        '%s-%s:%s-%s' % (n.name, n.epoch, n.version, n.release),

        '%s:%s-%s-%s.%s' % (n.epoch, n.name, n.version, n.release, n.arch),

        '%s-%s:%s-%s.%s' % (n.name, n.epoch, n.version, n.release, n.arch),

    ):

        for pat in patterns:

            if fnmatch.fnmatch(name, pat):

                return True

    return False

def pkgtup2spec(name, arch, epoch, version, release):

    # we ignore arch

    e = "" if epoch in (None, "") else "%s:" % epoch

    return "%s-%s%s-%s.*" % (name, e, version, release)