"""

Field classes.

"""

import copy

import datetime

import os

import re

import time

# 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

from django.utils.translation import ugettext_lazy as _

from django.utils.encoding import StrAndUnicode, smart_unicode, smart_str

from util import ErrorList, ValidationError

from widgets import TextInput, PasswordInput, HiddenInput, MultipleHiddenInput, FileInput, CheckboxInput, Select, NullBooleanSelect, SelectMultiple, DateTimeInput

__all__ = (

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

    'DEFAULT_DATE_INPUT_FORMATS', 'DateField',

    'DEFAULT_TIME_INPUT_FORMATS', 'TimeField',

    'DEFAULT_DATETIME_INPUT_FORMATS', 'DateTimeField',

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

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

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

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

)

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

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

        if label is not None:

            label = smart_unicode(label)

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

        self.help_text = smart_unicode(help_text or '')

        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'])

        pieces = str(value).lstrip("-").split('.')

        decimals = (len(pieces) == 2) and len(pieces[1]) or 0

        digits = len(pieces[0])

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

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

    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'])

class RegexField(CharField):

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

        """

        regex can be either a string or a compiled regular expression object.

        error_message is an optional error message to use, if

        'Enter a valid value' is too generic for you.

        """

        # error_message is just kept for backwards compatibility:

        if error_message:

            error_messages = kwargs.get('error_messages') or {}

            error_messages['invalid'] = error_message

            kwargs['error_messages'] = error_messages

        super(RegexField, self).__init__(max_length, min_length, *args, **kwargs)

        if isinstance(regex, basestring):

            regex = re.compile(regex)

        self.regex = regex

    def clean(self, value):

        """

        Validates that the input matches the regular expression. Returns a

        Unicode object.

        """

        value = super(RegexField, self).clean(value)

        if value == u'':

            return value

        if not self.regex.search(value):

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

        return value

email_re = re.compile(

    r"(^[-!#$%&'*+/=?^_`{}|~0-9A-Z]+(\.[-!#$%&'*+/=?^_`{}|~0-9A-Z]+)*"  # dot-atom

    r'|^"([\001-\010\013\014\016-\037!#-\[\]-\177]|\\[\001-011\013\014\016-\177])*"' # quoted-string

    r')@(?:[A-Z0-9-]+\.)+[A-Z]{2,6}$', re.IGNORECASE)  # domain

class EmailField(RegexField):

    default_error_messages = {

        'invalid': _(u'Enter a valid e-mail address.'),

    }

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

        RegexField.__init__(self, email_re, max_length, min_length, *args,

                            **kwargs)

try:

    from django.conf import settings

    URL_VALIDATOR_USER_AGENT = settings.URL_VALIDATOR_USER_AGENT

except ImportError:

    # It's OK if Django settings aren't configured.

    URL_VALIDATOR_USER_AGENT = 'Django (http://www.djangoproject.com/)'

class UploadedFile(StrAndUnicode):

    "A wrapper for files uploaded in a FileField"

    def __init__(self, filename, content):

        self.filename = filename

        self.content = content

    def __unicode__(self):

        """

        The unicode representation is the filename, so that the pre-database-insertion

        logic can use UploadedFile objects

        """

        return self.filename

class FileField(Field):

    widget = FileInput

    default_error_messages = {

        'invalid': _(u"No file was submitted. Check the encoding type on the form."),

        'missing': _(u"No file was submitted."),

        'empty': _(u"The submitted file is empty."),

    }

    def __init__(self, *args, **kwargs):

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

    def clean(self, data, initial=None):

        super(FileField, self).clean(initial or data)

        if not self.required and data in EMPTY_VALUES:

            return None

        elif not data and initial:

            return initial

        try:

            f = UploadedFile(data['filename'], data['content'])

        except TypeError:

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

        except KeyError:

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

        if not f.content:

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

        return f

class ImageField(FileField):

    default_error_messages = {

        'invalid_image': _(u"Upload a valid image. The file you uploaded was either not an image or a corrupted image."),

    }

    def clean(self, data, initial=None):

        """

        Checks that the file-upload field data contains a valid image (GIF, JPG,

        PNG, possibly others -- whatever the Python Imaging Library supports).

        """

        f = super(ImageField, self).clean(data, initial)

        if f is None:

            return None

        elif not data and initial:

            return initial

        from PIL import Image

        from cStringIO import StringIO

        try:

            # load() is the only method that can spot a truncated JPEG,

            #  but it cannot be called sanely after verify()

            trial_image = Image.open(StringIO(f.content))

            trial_image.load()

            # verify() is the only method that can spot a corrupt PNG,

            #  but it must be called immediately after the constructor

            trial_image = Image.open(StringIO(f.content))

            trial_image.verify()

        except Exception: # Python Imaging Library doesn't recognize it as an image

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

        return f

url_re = re.compile(

    r'^https?://' # http:// or https://

    r'(?:(?:[A-Z0-9-]+\.)+[A-Z]{2,6}|' #domain...

    r'localhost|' #localhost...

    r'\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3})' # ...or ip

    r'(?::\d+)?' # optional port

    r'(?:/?|/\S+)$', re.IGNORECASE)

class URLField(RegexField):

    default_error_messages = {

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

        'invalid_link': _(u'This URL appears to be a broken link.'),

    }

    def __init__(self, max_length=None, min_length=None, verify_exists=False,

            validator_user_agent=URL_VALIDATOR_USER_AGENT, *args, **kwargs):

        super(URLField, self).__init__(url_re, max_length, min_length, *args,

                                       **kwargs)

        self.verify_exists = verify_exists

        self.user_agent = validator_user_agent

    def clean(self, value):

        # If no URL scheme given, assume http://

        if value and '://' not in value:

            value = u'http://%s' % value

        value = super(URLField, self).clean(value)

        if value == u'':

            return value

        if self.verify_exists:

            import urllib2

            from django.conf import settings

            headers = {

                "Accept": "text/xml,application/xml,application/xhtml+xml,text/html;q=0.9,text/plain;q=0.8,image/png,*/*;q=0.5",

                "Accept-Language": "en-us,en;q=0.5",

                "Accept-Charset": "ISO-8859-1,utf-8;q=0.7,*;q=0.7",

                "Connection": "close",

                "User-Agent": self.user_agent,

            }

            try:

                req = urllib2.Request(value, None, headers)

                u = urllib2.urlopen(req)

            except ValueError:

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