"""

Field classes.

"""

import datetime

import os

import re

import time

import urlparse

import warnings

from decimal import Decimal, DecimalException

try:

    from cStringIO import StringIO

except ImportError:

    from StringIO import StringIO

from django.core.exceptions import ValidationError

from django.core import validators

import django.utils.copycompat as copy

from django.utils import formats

from django.utils.translation import ugettext_lazy as _

from django.utils.encoding import smart_unicode, smart_str

from django.utils.functional import lazy

# Provide this import for backwards compatibility.

from django.core.validators import EMPTY_VALUES

from util import ErrorList

from widgets import TextInput, PasswordInput, HiddenInput, MultipleHiddenInput, \

        FileInput, CheckboxInput, Select, NullBooleanSelect, SelectMultiple, \

        DateInput, DateTimeInput, TimeInput, SplitDateTimeWidget, SplitHiddenDateTimeWidget

__all__ = (

    'Field', 'CharField', 'IntegerField',

    'DEFAULT_DATE_INPUT_FORMATS', 'DateField',

    'DEFAULT_TIME_INPUT_FORMATS', 'TimeField',

    'DEFAULT_DATETIME_INPUT_FORMATS', 'DateTimeField', 'TimeField',

    'RegexField', 'EmailField', 'FileField', 'ImageField', 'URLField',

    'BooleanField', 'NullBooleanField', 'ChoiceField', 'MultipleChoiceField',

    'ComboField', 'MultiValueField', 'FloatField', 'DecimalField',

    'SplitDateTimeField', 'IPAddressField', 'FilePathField', 'SlugField',

    'TypedChoiceField'

)

def en_format(name):

    """

    Helper function to stay backward compatible.

    """

    from django.conf.locale.en import formats

    warnings.warn(

        "`django.forms.fields.DEFAULT_%s` is deprecated; use `django.utils.formats.get_format('%s')` instead." % (name, name),

        PendingDeprecationWarning

    )

    return getattr(formats, name)

DEFAULT_DATE_INPUT_FORMATS = lazy(lambda: en_format('DATE_INPUT_FORMATS'), tuple, list)()

DEFAULT_TIME_INPUT_FORMATS = lazy(lambda: en_format('TIME_INPUT_FORMATS'), tuple, list)()

DEFAULT_DATETIME_INPUT_FORMATS = lazy(lambda: en_format('DATETIME_INPUT_FORMATS'), tuple, list)()

class Field(object):

    widget = TextInput # Default widget to use when rendering this type of Field.

    hidden_widget = HiddenInput # Default widget to use when rendering this as "hidden".

    default_validators = [] # Default set of validators

    default_error_messages = {

        'required': _(u'This field is required.'),

        'invalid': _(u'Enter a valid value.'),

    }

    # Tracks each time a Field instance is created. Used to retain order.

    creation_counter = 0

    def __init__(self, required=True, widget=None, label=None, initial=None,

                 help_text=None, error_messages=None, show_hidden_initial=False,

                 validators=[], localize=False):

        # required -- Boolean that specifies whether the field is required.

        #             True by default.

        # widget -- A Widget class, or instance of a Widget class, that should

        #           be used for this Field when displaying it. Each Field has a

        #           default Widget that it'll use if you don't specify this. In

        #           most cases, the default widget is TextInput.

        # label -- A verbose name for this field, for use in displaying this

        #          field in a form. By default, Django will use a "pretty"

        #          version of the form field name, if the Field is part of a

        #          Form.

        # initial -- A value to use in this Field's initial display. This value

        #            is *not* used as a fallback if data isn't given.

        # help_text -- An optional string to use as "help text" for this Field.

        # error_messages -- An optional dictionary to override the default

        #                   messages that the field will raise.

        # show_hidden_initial -- Boolean that specifies if it is needed to render a

        #                        hidden widget with initial value after widget.

        # validators -- List of addtional validators to use

        # localize -- Boolean that specifies if the field should be localized.

        if label is not None:

            label = smart_unicode(label)

        self.required, self.label, self.initial = required, label, initial

        self.show_hidden_initial = show_hidden_initial

        if help_text is None:

            self.help_text = u''

        else:

            self.help_text = smart_unicode(help_text)

        widget = widget or self.widget

        if isinstance(widget, type):

            widget = widget()

        # Trigger the localization machinery if needed.

        self.localize = localize

        if self.localize:

            widget.is_localized = True

        # Hook into self.widget_attrs() for any Field-specific HTML attributes.

        extra_attrs = self.widget_attrs(widget)

        if extra_attrs:

            widget.attrs.update(extra_attrs)

        self.widget = widget

        # Increase the creation counter, and save our local copy.

        self.creation_counter = Field.creation_counter

        Field.creation_counter += 1

        messages = {}

        for c in reversed(self.__class__.__mro__):

            messages.update(getattr(c, 'default_error_messages', {}))

        messages.update(error_messages or {})

        self.error_messages = messages

        self.validators = self.default_validators + validators

    def to_python(self, value):

        return value

    def validate(self, value):

        if value in validators.EMPTY_VALUES and self.required:

            raise ValidationError(self.error_messages['required'])

    def run_validators(self, value):

        if value in validators.EMPTY_VALUES:

            return

        errors = []

        for v in self.validators:

            try:

                v(value)

            except ValidationError, e:

                if hasattr(e, 'code') and e.code in self.error_messages:

                    message = self.error_messages[e.code]

                    if e.params:

                        message = message % e.params

                    errors.append(message)

                else:

                    errors.extend(e.messages)

        if errors:

            raise ValidationError(errors)

    def clean(self, value):

        """

        Validates the given value and returns its "cleaned" value as an

        appropriate Python object.

        Raises ValidationError for any errors.

        """

        value = self.to_python(value)

        self.validate(value)

        self.run_validators(value)

        return value

    def widget_attrs(self, widget):

        """

        Given a Widget instance (*not* a Widget class), returns a dictionary of

        any HTML attributes that should be added to the Widget, based on this

        Field.

        """

        return {}

    def __deepcopy__(self, memo):

        result = copy.copy(self)

        memo[id(self)] = result

        result.widget = copy.deepcopy(self.widget, memo)

        return result

class CharField(Field):

    def __init__(self, max_length=None, min_length=None, *args, **kwargs):

        self.max_length, self.min_length = max_length, min_length

        super(CharField, self).__init__(*args, **kwargs)

        if min_length is not None:

            self.validators.append(validators.MinLengthValidator(min_length))

        if max_length is not None:

            self.validators.append(validators.MaxLengthValidator(max_length))

    def to_python(self, value):

        "Returns a Unicode object."

        if value in validators.EMPTY_VALUES:

            return u''

        return smart_unicode(value)

    def widget_attrs(self, widget):

        if self.max_length is not None and isinstance(widget, (TextInput, PasswordInput)):

            # The HTML attribute is maxlength, not max_length.

            return {'maxlength': str(self.max_length)}

class IntegerField(Field):

    default_error_messages = {

        'invalid': _(u'Enter a whole number.'),

        'max_value': _(u'Ensure this value is less than or equal to %(limit_value)s.'),

        'min_value': _(u'Ensure this value is greater than or equal to %(limit_value)s.'),

    }

    def __init__(self, max_value=None, min_value=None, *args, **kwargs):

        super(IntegerField, self).__init__(*args, **kwargs)

        if max_value is not None:

            self.validators.append(validators.MaxValueValidator(max_value))

        if min_value is not None:

            self.validators.append(validators.MinValueValidator(min_value))

    def to_python(self, value):

        """

        Validates that int() can be called on the input. Returns the result

        of int(). Returns None for empty values.

        """

        value = super(IntegerField, self).to_python(value)

        if value in validators.EMPTY_VALUES:

            return None

        if self.localize:

            value = formats.sanitize_separators(value)

        try:

            value = int(str(value))

        except (ValueError, TypeError):

            raise ValidationError(self.error_messages['invalid'])

        return value

class FloatField(IntegerField):

    default_error_messages = {

        'invalid': _(u'Enter a number.'),

    }

    def to_python(self, value):

        """

        Validates that float() can be called on the input. Returns the result

        of float(). Returns None for empty values.

        """

        value = super(IntegerField, self).to_python(value)

        if value in validators.EMPTY_VALUES:

            return None

        if self.localize:

            value = formats.sanitize_separators(value)

        try:

            value = float(value)

        except (ValueError, TypeError):

            raise ValidationError(self.error_messages['invalid'])

        return value

class DecimalField(Field):

    default_error_messages = {

        'invalid': _(u'Enter a number.'),

        'max_value': _(u'Ensure this value is less than or equal to %(limit_value)s.'),

        'min_value': _(u'Ensure this value is greater than or equal to %(limit_value)s.'),

        'max_digits': _('Ensure that there are no more than %s digits in total.'),

        'max_decimal_places': _('Ensure that there are no more than %s decimal places.'),

        'max_whole_digits': _('Ensure that there are no more than %s digits before the decimal point.')

    }

    def __init__(self, max_value=None, min_value=None, max_digits=None, decimal_places=None, *args, **kwargs):

        self.max_digits, self.decimal_places = max_digits, decimal_places

        Field.__init__(self, *args, **kwargs)

        if max_value is not None:

            self.validators.append(validators.MaxValueValidator(max_value))

        if min_value is not None:

            self.validators.append(validators.MinValueValidator(min_value))

    def to_python(self, value):

        """

        Validates that the input is a decimal number. Returns a Decimal

        instance. Returns None for empty values. Ensures that there are no more

        than max_digits in the number, and no more than decimal_places digits

        after the decimal point.

        """

        if value in validators.EMPTY_VALUES:

            return None

        if self.localize:

            value = formats.sanitize_separators(value)

        value = smart_str(value).strip()

        try:

            value = Decimal(value)

        except DecimalException:

            raise ValidationError(self.error_messages['invalid'])

        return value

    def validate(self, value):

        super(DecimalField, self).validate(value)

        if value in validators.EMPTY_VALUES:

            return

        # Check for NaN, Inf and -Inf values. We can't compare directly for NaN,

        # since it is never equal to itself. However, NaN is the only value that

        # isn't equal to itself, so we can use this to identify NaN

        if value != value or value == Decimal("Inf") or value == Decimal("-Inf"):

            raise ValidationError(self.error_messages['invalid'])

        sign, digittuple, exponent = value.as_tuple()

        decimals = abs(exponent)

        # digittuple doesn't include any leading zeros.

        digits = len(digittuple)

        if decimals > digits:

            # We have leading zeros up to or past the decimal point.  Count

            # everything past the decimal point as a digit.  We do not count

            # 0 before the decimal point as a digit since that would mean

            # we would not allow max_digits = decimal_places.

            digits = decimals

        whole_digits = digits - decimals

        if self.max_digits is not None and digits > self.max_digits:

            raise ValidationError(self.error_messages['max_digits'] % self.max_digits)

        if self.decimal_places is not None and decimals > self.decimal_places:

            raise ValidationError(self.error_messages['max_decimal_places'] % self.decimal_places)

        if self.max_digits is not None and self.decimal_places is not None and whole_digits > (self.max_digits - self.decimal_places):

            raise ValidationError(self.error_messages['max_whole_digits'] % (self.max_digits - self.decimal_places))

        return value

class DateField(Field):

    widget = DateInput

    default_error_messages = {

        'invalid': _(u'Enter a valid date.'),

    }

    def __init__(self, input_formats=None, *args, **kwargs):

        super(DateField, self).__init__(*args, **kwargs)

        self.input_formats = input_formats

    def to_python(self, value):

        """

        Validates that the input can be converted to a date. Returns a Python

        datetime.date object.

        """

        if value in validators.EMPTY_VALUES:

            return None

        if isinstance(value, datetime.datetime):

            return value.date()

        if isinstance(value, datetime.date):

            return value

        for format in self.input_formats or formats.get_format('DATE_INPUT_FORMATS'):

            try:

                return datetime.date(*time.strptime(value, format)[:3])

            except ValueError:

                continue

        raise ValidationError(self.error_messages['invalid'])

class TimeField(Field):

    widget = TimeInput

    default_error_messages = {

        'invalid': _(u'Enter a valid time.')

    }

    def __init__(self, input_formats=None, *args, **kwargs):

        super(TimeField, self).__init__(*args, **kwargs)

        self.input_formats = input_formats

    def to_python(self, value):

        """

        Validates that the input can be converted to a time. Returns a Python

        datetime.time object.

        """

        if value in validators.EMPTY_VALUES:

            return None

        if isinstance(value, datetime.time):

            return value

        for format in self.input_formats or formats.get_format('TIME_INPUT_FORMATS'):

            try:

                return datetime.time(*time.strptime(value, format)[3:6])

            except ValueError:

                continue

        raise ValidationError(self.error_messages['invalid'])

class DateTimeField(Field):

    widget = DateTimeInput

    default_error_messages = {

        'invalid': _(u'Enter a valid date/time.'),

    }

    def __init__(self, input_formats=None, *args, **kwargs):

        super(DateTimeField, self).__init__(*args, **kwargs)

        self.input_formats = input_formats

    def to_python(self, value):

        """

        Validates that the input can be converted to a datetime. Returns a

        Python datetime.datetime object.

        """

        if value in validators.EMPTY_VALUES:

            return None

        if isinstance(value, datetime.datetime):

            return value

        if isinstance(value, datetime.date):

            return datetime.datetime(value.year, value.month, value.day)

        if isinstance(value, list):

            # Input comes from a SplitDateTimeWidget, for example. So, it's two

            # components: date and time.

            if len(value) != 2:

                raise ValidationError(self.error_messages['invalid'])