# 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 ReadOnlyVariableError(Error):
    def __init__(self, value, variable_name):
        super(ReadOnlyVariableError, self).__init__(value)
        self.variable_name = variable_name


class RepoError(Error):
    # :api
    pass


class ThreadLockError(LockError):
    pass


class TransactionCheckError(Error):
    pass
