##############################################################################
#
# Copyright (c) 2002 Zope Foundation and Contributors.
# All Rights Reserved.
#
# This software is subject to the provisions of the Zope Public License,
# Version 2.1 (ZPL).  A copy of the ZPL should accompany this distribution.
# THIS SOFTWARE IS PROVIDED "AS IS" AND ANY AND ALL EXPRESS OR IMPLIED
# WARRANTIES ARE DISCLAIMED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
# WARRANTIES OF TITLE, MERCHANTABILITY, AGAINST INFRINGEMENT, AND FITNESS
# FOR A PARTICULAR PURPOSE.
#
##############################################################################
"""Bootstrap schema interfaces and exceptions
"""
from functools import total_ordering

import zope.interface
from zope.interface import Attribute
from zope.interface.interfaces import IInterface

from zope.schema._messageid import _


# pylint:disable=inherit-non-class,keyword-arg-before-vararg,
# pylint:disable=no-self-argument


class StopValidation(Exception):
    """Raised if the validation is completed early.

    Note that this exception should be always caught, since it is just
    a way for the validator to save time.
    """


@total_ordering
class ValidationError(zope.interface.Invalid):
    """Raised if the Validation process fails."""

    #: The field that raised the error, if known.
    field = None

    #: The value that failed validation.
    value = None

    def with_field_and_value(self, field, value):
        self.field = field
        self.value = value
        return self

    def doc(self):
        return self.__class__.__doc__

    def __lt__(self, other):
        # There's no particular reason we choose to sort this way,
        # it's just the way we used to do it with __cmp__.
        if not hasattr(other, 'args'):
            return True
        return self.args < other.args

    def __eq__(self, other):
        if not hasattr(other, 'args'):
            return False
        return self.args == other.args

    # XXX : This is probably inconsistent with __eq__, which is
    # a violation of the language spec.
    __hash__ = zope.interface.Invalid.__hash__  # python3

    def __repr__(self):  # pragma: no cover
        return '%s(%s)' % (
            self.__class__.__name__,
            ', '.join(repr(arg) for arg in self.args))


class RequiredMissing(ValidationError):
    __doc__ = _("""Required input is missing.""")


class WrongType(ValidationError):
    __doc__ = _("""Object is of wrong type.""")

    #: The type or tuple of types that was expected.
    #:
    #: .. versionadded:: 4.7.0
    expected_type = None

    def __init__(self, value=None, expected_type=None, name=None, *args):
        """
        WrongType(value, expected_type, name)

        .. versionchanged:: 4.7.0
           Added named arguments to the constructor and the `expected_type`
           field.
        """
        ValidationError.__init__(self, value, expected_type, name, *args)
        self.expected_type = expected_type
        self.value = value


class OutOfBounds(ValidationError):
    """
    A value was out of the allowed bounds.

    This is the common superclass for `OrderableOutOfBounds` and
    `LenOutOfBounds`, which in turn are the superclasses for `TooBig`
    and `TooSmall`, and `TooLong` and `TooShort`, respectively.

    .. versionadded:: 4.7.0
    """

    #: The value that was exceeded
    bound = None

    #: A constant for `violation_direction`.
    TOO_LARGE = type('TOO_LARGE', (), {'__slots__': ()})()

    #: A constant for `violation_direction`.
    TOO_SMALL = type('TOO_SMALL', (), {'__slots__': ()})()

    #: Whether the value was too large or
    #: not large enough. One of the values
    #: defined by the constants `TOO_LARGE`
    #: or `TOO_SMALL`
    violation_direction = None

    def __init__(self, value=None, bound=None, *args):
        """
        OutOfBounds(value, bound)
        """
        super(OutOfBounds, self).__init__(value, bound, *args)
        self.value = value
        self.bound = bound


class OrderableOutOfBounds(OutOfBounds):
    """
    A value was too big or too small in comparison to another value.

    .. versionadded:: 4.7.0
    """


class TooBig(OrderableOutOfBounds):
    __doc__ = _("""Value is too big""")

    violation_direction = OutOfBounds.TOO_LARGE


class TooSmall(OrderableOutOfBounds):
    __doc__ = _("""Value is too small""")

    violation_direction = OutOfBounds.TOO_SMALL


class LenOutOfBounds(OutOfBounds):
    """
    The length of the value was out of bounds.

    .. versionadded:: 4.7.0
    """


class TooLong(LenOutOfBounds):
    __doc__ = _("""Value is too long""")

    violation_direction = OutOfBounds.TOO_LARGE


class TooShort(LenOutOfBounds):
    __doc__ = _("""Value is too short""")

    violation_direction = OutOfBounds.TOO_SMALL


class InvalidValue(ValidationError):
    __doc__ = _("""Invalid value""")


class ConstraintNotSatisfied(ValidationError):
    __doc__ = _("""Constraint not satisfied""")


class NotAContainer(ValidationError):
    __doc__ = _("""Not a container""")


class NotAnIterator(ValidationError):
    __doc__ = _("""Not an iterator""")


class WrongContainedType(ValidationError):
    __doc__ = _("""Wrong contained type""")

    #: A collection of exceptions raised when validating
    #: the *value*.
    #:
    #: .. versionadded:: 4.7.0
    errors = ()

    def __init__(self, errors=None, name=None, *args):
        """
        WrongContainedType(errors, name)

        .. versionchanged:: 4.7.0
           Added named arguments to the constructor, and the `errors` property.
        """
        super(WrongContainedType, self).__init__(errors, name, *args)
        self.errors = errors


class SchemaNotCorrectlyImplemented(WrongContainedType):
    __doc__ = _("""An object failed schema or invariant validation.""")

    #: A dictionary mapping failed attribute names of the
    #: *value* to the underlying exception
    schema_errors = None

    #: A list of exceptions from validating the invariants
    #: of the schema.
    invariant_errors = ()

    def __init__(self, errors=None, name=None, schema_errors=None,
                 invariant_errors=(), *args):
        """
        SchemaNotCorrectlyImplemented(errors, name, schema_errors,
                                      invariant_errors)

        .. versionchanged:: 4.7.0
           Added named arguments to the constructor.
        """
        super(SchemaNotCorrectlyImplemented, self).__init__(
            errors, name, *args)
        self.schema_errors = schema_errors
        self.invariant_errors = invariant_errors


class SchemaNotFullyImplemented(ValidationError):
    __doc__ = _("""Schema not fully implemented""")


class SchemaNotProvided(ValidationError):
    __doc__ = _("""Schema not provided""")

    #: The interface that the *value* was supposed to provide,
    #: but does not.
    schema = None

    def __init__(self, schema=None, value=None, *args):
        """
        SchemaNotProvided(schema, value)

        .. versionchanged:: 4.7.0
           Added named arguments to the constructor and the `schema` property.
        """
        super(SchemaNotProvided, self).__init__(schema, value, *args)
        self.schema = schema
        self.value = value


class NotAnInterface(WrongType, SchemaNotProvided):
    """
    Object is not an interface.

    This is a `WrongType` exception for backwards compatibility with
    existing ``except`` clauses, but it is raised when
    ``IInterface.providedBy`` is not true, so it's also a
    `SchemaNotProvided`. The ``expected_type`` field is filled in as
    ``IInterface``; this is not actually a `type`, and
    ``isinstance(thing, IInterface)`` is always false.

    .. versionadded:: 4.7.0
    """

    expected_type = IInterface

    def __init__(self, value, name):
        super(NotAnInterface, self).__init__(value, IInterface, name)


class IFromUnicode(zope.interface.Interface):
    """Parse a unicode string to a value

    We will often adapt fields to this interface to support views and
    other applications that need to convert raw data as unicode
    values.
    """

    def fromUnicode(value):
        """Convert a unicode string to a value.
        """


class IFromBytes(zope.interface.Interface):
    """
    Parse a byte string to a value.

    If the string needs to be decoded, decoding is done using UTF-8.

    .. versionadded:: 4.8.0
    """

    def fromBytes(value):
        """Convert a byte string to a value.
        """


class IContextAwareDefaultFactory(zope.interface.Interface):
    """A default factory that requires a context.

    The context is the field context. If the field is not bound, context may
    be ``None``.
    """

    def __call__(context):
        """Returns a default value for the field."""


class IBeforeObjectAssignedEvent(zope.interface.Interface):
    """An object is going to be assigned to an attribute on another object.

    Subscribers to this event can change the object on this event to change
    what object is going to be assigned. This is useful, e.g. for wrapping
    or replacing objects before they get assigned to conform to application
    policy.
    """

    object = Attribute("The object that is going to be assigned.")

    name = Attribute("The name of the attribute under which the object "
                     "will be assigned.")

    context = Attribute("The context object where the object will be "
                        "assigned to.")


class IValidatable(zope.interface.Interface):
    # Internal interface, the base for IField, but used to prevent
    # import recursion. This should *not* be implemented by anything
    # other than IField.
    def validate(value):
        """Validate that the given value is a valid field value.

        Returns nothing but raises an error if the value is invalid.
        It checks everything specific to a Field and also checks
        with the additional constraint.
        """


class NO_VALUE(object):
    def __repr__(self):  # pragma: no cover
        return '<NO_VALUE>'


NO_VALUE = NO_VALUE()
