# This program is free software; you can redistribute it and/or modify

# it under the terms of the GNU General Public License as published by

# the Free Software Foundation; either version 2 of the License, or

# (at your option) any later version.

#

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

# but WITHOUT ANY WARRANTY; without even the implied warranty of

# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

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

# Copyright 2004 Duke University

"""

Core DNF Errors.

"""

from __future__ import unicode_literals

from dnf.i18n import ucd, _, P_

import dnf.util

import libdnf

import warnings

class DeprecationWarning(DeprecationWarning):

    # :api

    pass

class Error(Exception):

    # :api

    """Base Error. All other Errors thrown by DNF should inherit from this.

    :api

    """

    def __init__(self, value=None):

        super(Error, self).__init__()

        self.value = None if value is None else ucd(value)

    def __str__(self):

        return "{}".format(self.value)

    def __unicode__(self):

        return ucd(self.__str__())

class CompsError(Error):

    # :api

    pass

class ConfigError(Error):

    def __init__(self, value=None, raw_error=None):

        super(ConfigError, self).__init__(value)

        self.raw_error = ucd(raw_error) if raw_error is not None else None

class DatabaseError(Error):

    pass

class DepsolveError(Error):

    # :api

    pass

class DownloadError(Error):

    # :api

    def __init__(self, errmap):

        super(DownloadError, self).__init__()

        self.errmap = errmap

    @staticmethod

    def errmap2str(errmap):

        errstrings = []

        for key in errmap:

            for error in errmap[key]:

                msg = '%s: %s' % (key, error) if key else '%s' % error

                errstrings.append(msg)

        return '\n'.join(errstrings)

    def __str__(self):

        return self.errmap2str(self.errmap)

class LockError(Error):

    pass

class MarkingError(Error):

    # :api

    def __init__(self, value=None, pkg_spec=None):

        """Initialize the marking error instance."""

        super(MarkingError, self).__init__(value)

        self.pkg_spec = None if pkg_spec is None else ucd(pkg_spec)

    def __str__(self):

        string = super(MarkingError, self).__str__()

        if self.pkg_spec:

            string += ': ' + self.pkg_spec

        return string

class MarkingErrors(Error):

    # :api

    def __init__(self, no_match_group_specs=(), error_group_specs=(), no_match_pkg_specs=(),

                 error_pkg_specs=(), module_depsolv_errors=()):

        """Initialize the marking error instance."""

        msg = _("Problems in request:")

        if (no_match_pkg_specs):

            msg += "\n" + _("missing packages: ") + ", ".join(no_match_pkg_specs)

        if (error_pkg_specs):

            msg += "\n" + _("broken packages: ") + ", ".join(error_pkg_specs)

        if (no_match_group_specs):

            msg += "\n" + _("missing groups or modules: ") + ", ".join(no_match_group_specs)

        if (error_group_specs):

            msg += "\n" + _("broken groups or modules: ") + ", ".join(error_group_specs)

        if (module_depsolv_errors):

            msg_mod = dnf.util._format_resolve_problems(module_depsolv_errors[0])

            if module_depsolv_errors[1] == \

                    libdnf.module.ModulePackageContainer.ModuleErrorType_ERROR_IN_DEFAULTS:

                msg += "\n" + "\n".join([P_('Modular dependency problem with Defaults:',

                                            'Modular dependency problems with Defaults:',

                                            len(module_depsolv_errors)),

                                        msg_mod])

            else:

                msg += "\n" + "\n".join([P_('Modular dependency problem:',

                                            'Modular dependency problems:',

                                            len(module_depsolv_errors)),

                                        msg_mod])

        super(MarkingErrors, self).__init__(msg)

        self.no_match_group_specs = no_match_group_specs

        self.error_group_specs = error_group_specs

        self.no_match_pkg_specs = no_match_pkg_specs

        self.error_pkg_specs = error_pkg_specs

        self.module_depsolv_errors = module_depsolv_errors

    @property

    def module_debsolv_errors(self):

        msg = "Attribute module_debsolv_errors is deprecated. Use module_depsolv_errors " \

              "attribute instead."

        warnings.warn(msg, DeprecationWarning, stacklevel=2)

        return self.module_depsolv_errors

class MetadataError(Error):

    pass

class MiscError(Error):

    pass

class PackagesNotAvailableError(MarkingError):

    def __init__(self, value=None, pkg_spec=None, packages=None):

        super(PackagesNotAvailableError, self).__init__(value, pkg_spec)

        self.packages = packages or []

class PackageNotFoundError(MarkingError):

    pass

class PackagesNotInstalledError(MarkingError):

    def __init__(self, value=None, pkg_spec=None, packages=None):

        super(PackagesNotInstalledError, self).__init__(value, pkg_spec)

        self.packages = packages or []

class ProcessLockError(LockError):

    def __init__(self, value, pid):

        super(ProcessLockError, self).__init__(value)

        self.pid = pid

    def __reduce__(self):

        """Pickling support."""

        return (ProcessLockError, (self.value, self.pid))

class RepoError(Error):

    # :api

    pass

class ThreadLockError(LockError):

    pass

class TransactionCheckError(Error):

    pass