"""

Field classes.

"""

import copy

import datetime

import os

import re

import time

import urlparse

try:

    from cStringIO import StringIO

except ImportError:

    from StringIO import StringIO

# Python 2.3 fallbacks

try:

    from decimal import Decimal, DecimalException

except ImportError:

    from django.utils._decimal import Decimal, DecimalException

try:

    set

except NameError:

    from sets import Set as set

import django.core.exceptions

from django.utils.translation import ugettext_lazy as _

from django.utils.encoding import smart_unicode, smart_str

from util import ErrorList, ValidationError

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'

)

# These values, if given to to_python(), will trigger the self.required check.

EMPTY_VALUES = (None, '')

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_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):

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

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

        #                        hidden widget with initial value after widget.

        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()

        # 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

        def set_class_error_messages(messages, klass):

            for base_class in klass.__bases__:

                set_class_error_messages(messages, base_class)

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

        messages = {}

        set_class_error_messages(messages, self.__class__)

        messages.update(error_messages or {})

        self.error_messages = messages

    def clean(self, value):

        """

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

        appropriate Python object.

        Raises ValidationError for any errors.

        """

        if self.required and value in EMPTY_VALUES:

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

        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):

    default_error_messages = {

        'max_length': _(u'Ensure this value has at most %(max)d characters (it has %(length)d).'),

        'min_length': _(u'Ensure this value has at least %(min)d characters (it has %(length)d).'),

    }

    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)

    def clean(self, value):

        "Validates max_length and min_length. Returns a Unicode object."

        super(CharField, self).clean(value)

        if value in EMPTY_VALUES:

            return u''

        value = smart_unicode(value)

        value_length = len(value)

        if self.max_length is not None and value_length > self.max_length:

            raise ValidationError(self.error_messages['max_length'] % {'max': self.max_length, 'length': value_length})

        if self.min_length is not None and value_length < self.min_length:

            raise ValidationError(self.error_messages['min_length'] % {'min': self.min_length, 'length': value_length})

        return 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 %s.'),

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

    }

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

        self.max_value, self.min_value = max_value, min_value

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

    def clean(self, value):

        """

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

        of int(). Returns None for empty values.

        """

        super(IntegerField, self).clean(value)

        if value in EMPTY_VALUES:

            return None

        try:

            value = int(str(value))

        except (ValueError, TypeError):

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

        if self.max_value is not None and value > self.max_value:

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

        if self.min_value is not None and value < self.min_value:

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

        return value

class FloatField(Field):

    default_error_messages = {

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

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

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

    }

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

        self.max_value, self.min_value = max_value, min_value

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

    def clean(self, value):

        """

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

        Returns None for empty values.

        """

        super(FloatField, self).clean(value)

        if not self.required and value in EMPTY_VALUES:

            return None

        try:

            value = float(value)

        except (ValueError, TypeError):

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

        if self.max_value is not None and value > self.max_value:

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

        if self.min_value is not None and value < self.min_value:

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

        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 %s.'),

        'min_value': _(u'Ensure this value is greater than or equal to %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_value, self.min_value = max_value, min_value

        self.max_digits, self.decimal_places = max_digits, decimal_places

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

    def clean(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.

        """

        super(DecimalField, self).clean(value)

        if not self.required and value in EMPTY_VALUES:

            return None

        value = smart_str(value).strip()

        try:

            value = Decimal(value)

        except DecimalException:

            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_value is not None and value > self.max_value:

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

        if self.min_value is not None and value < self.min_value:

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

        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

DEFAULT_DATE_INPUT_FORMATS = (

    '%Y-%m-%d', '%m/%d/%Y', '%m/%d/%y', # '2006-10-25', '10/25/2006', '10/25/06'

    '%b %d %Y', '%b %d, %Y',            # 'Oct 25 2006', 'Oct 25, 2006'

    '%d %b %Y', '%d %b, %Y',            # '25 Oct 2006', '25 Oct, 2006'

    '%B %d %Y', '%B %d, %Y',            # 'October 25 2006', 'October 25, 2006'

    '%d %B %Y', '%d %B, %Y',            # '25 October 2006', '25 October, 2006'

)

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 or DEFAULT_DATE_INPUT_FORMATS

    def clean(self, value):

        """

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

        datetime.date object.

        """

        super(DateField, self).clean(value)

        if value in 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:

            try:

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

            except ValueError:

                continue

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

DEFAULT_TIME_INPUT_FORMATS = (

    '%H:%M:%S',     # '14:30:59'

    '%H:%M',        # '14:30'

)

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 or DEFAULT_TIME_INPUT_FORMATS

    def clean(self, value):

        """

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

        datetime.time object.

        """

        super(TimeField, self).clean(value)

        if value in EMPTY_VALUES:

            return None

        if isinstance(value, datetime.time):

            return value

        for format in self.input_formats:

            try:

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

            except ValueError:

                continue

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

DEFAULT_DATETIME_INPUT_FORMATS = (

    '%Y-%m-%d %H:%M:%S',     # '2006-10-25 14:30:59'

    '%Y-%m-%d %H:%M',        # '2006-10-25 14:30'

    '%Y-%m-%d',              # '2006-10-25'

    '%m/%d/%Y %H:%M:%S',     # '10/25/2006 14:30:59'

    '%m/%d/%Y %H:%M',        # '10/25/2006 14:30'

    '%m/%d/%Y',              # '10/25/2006'

    '%m/%d/%y %H:%M:%S',     # '10/25/06 14:30:59'

    '%m/%d/%y %H:%M',        # '10/25/06 14:30'

    '%m/%d/%y',              # '10/25/06'

)

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 or DEFAULT_DATETIME_INPUT_FORMATS

    def clean(self, value):

        """

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

        Python datetime.datetime object.

        """

        super(DateTimeField, self).clean(value)

        if value in 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'])

            value = '%s %s' % tuple(value)

        for format in self.input_formats:

            try:

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

            except ValueError:

                continue

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