"""

Field classes.

"""

import datetime

import os

import re

import time

import urlparse

try:

    from cStringIO import StringIO

except ImportError:

    from StringIO import StringIO

from django.utils.translation import ugettext_lazy as _

from django.utils.encoding import smart_unicode, smart_str

__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'

)

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,

        # 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

        messages = {}

        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.

        """

        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)

            return u''

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

    }

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

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

        """

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

        of int(). Returns None for empty values.

        """

            return None

        try:

            value = int(str(value))

        except (ValueError, TypeError):

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

        return value

    default_error_messages = {

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

    }

        """

            return None

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

        """

        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.

        """

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

        """

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

        datetime.date object.

        """

            return None

        if isinstance(value, datetime.datetime):

            return value.date()

        if isinstance(value, datetime.date):

            return value

            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)

        """

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

        datetime.time object.

        """

            return None

        if isinstance(value, datetime.time):

            return value

            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)

        """

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

        Python datetime.datetime object.

        """