import datetime

import re

import time

from django.db import connection

from django.db.models.query_utils import QueryWrapper

from django.conf import settings

from django import forms

from django.utils.datastructures import DictWrapper

from django.utils.functional import curry

from django.utils.text import capfirst

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

from django.utils import datetime_safe

class NOT_PROVIDED:

    pass

# The values to use for "blank" in SelectFields. Will be appended to the start of most "choices" lists.

BLANK_CHOICE_DASH = [("", "---------")]

BLANK_CHOICE_NONE = [("", "None")]

class FieldDoesNotExist(Exception):

    pass

# A guide to Field parameters:

#

#   * name:      The name of the field specifed in the model.

#   * attname:   The attribute to use on the model object. This is the same as

#                "name", except in the case of ForeignKeys, where "_id" is

#                appended.

#   * db_column: The db_column specified in the model (or None).

#   * column:    The database column for this field. This is the same as

#                "attname", except if db_column is specified.

#

# Code that introspects values, or does other dynamic things, should use

# attname. For example, this gets the primary key value of object "obj":

#

#     getattr(obj, opts.pk.attname)

class Field(object):

    # Designates whether empty strings fundamentally are allowed at the

    # database level.

    empty_strings_allowed = True

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

    # The auto_creation_counter is used for fields that Django implicitly

    # creates, creation_counter is used for all user-specified fields.

    creation_counter = 0

    auto_creation_counter = -1

    def __init__(self, verbose_name=None, name=None, primary_key=False,

            max_length=None, unique=False, blank=False, null=False,

            db_index=False, rel=None, default=NOT_PROVIDED, editable=True,

            serialize=True, unique_for_date=None, unique_for_month=None,

            unique_for_year=None, choices=None, help_text='', db_column=None,

        self.name = name

        self.verbose_name = verbose_name

        self.primary_key = primary_key

        self.max_length, self._unique = max_length, unique

        self.blank, self.null = blank, null

        # Oracle treats the empty string ('') as null, so coerce the null

        # option whenever '' is a possible value.

        if self.empty_strings_allowed and connection.features.interprets_empty_strings_as_nulls:

            self.null = True

        self.rel = rel

        self.default = default

        self.editable = editable

        self.serialize = serialize

        self.unique_for_date, self.unique_for_month = unique_for_date, unique_for_month

        self.unique_for_year = unique_for_year

        self._choices = choices or []

        self.help_text = help_text

        self.db_column = db_column

        self.db_tablespace = db_tablespace or settings.DEFAULT_INDEX_TABLESPACE

        self.auto_created = auto_created

        # Set db_index to True if the field has a relationship and doesn't explicitly set db_index.

        self.db_index = db_index

        # Adjust the appropriate creation counter, and save our local copy.

        if auto_created:

            self.creation_counter = Field.auto_creation_counter

            Field.auto_creation_counter -= 1

        else:

            self.creation_counter = Field.creation_counter

            Field.creation_counter += 1

    def __cmp__(self, other):

        # This is needed because bisect does not take a comparison function.

        return cmp(self.creation_counter, other.creation_counter)

    def __deepcopy__(self, memodict):

        # We don't have to deepcopy very much here, since most things are not

        # intended to be altered after initial creation.

        obj = copy.copy(self)

        if self.rel:

            obj.rel = copy.copy(self.rel)

        memodict[id(self)] = obj

        return obj

    def to_python(self, value):

        """

        Converts the input value into the expected Python data type, raising

        django.core.exceptions.ValidationError if the data can't be converted.

        Returns the converted value. Subclasses should override this.

        """

        return value

        """

        """

        # The default implementation of this method looks at the

        # backend-specific DATA_TYPES dictionary, looking up the field by its

        # "internal type".

        #

        # A Field class can implement the get_internal_type() method to specify

        # which *preexisting* Django Field class it's most similar to -- i.e.,

        # an XMLField is represented by a TEXT column type, which is the same

        # as the TextField Django field type, which means XMLField's

        # get_internal_type() returns 'TextField'.

        #

        # But the limitation of the get_internal_type() / data_types approach

        # is that it cannot handle database column types that aren't already

        # mapped to one of the built-in Django field types. In this case, you

        # can implement db_type() instead of get_internal_type() to specify

        # exactly which wacky database column type you want to use.

        data = DictWrapper(self.__dict__, connection.ops.quote_name, "qn_")

        try:

            return connection.creation.data_types[self.get_internal_type()] % data

        except KeyError:

            return None

    def unique(self):

        return self._unique or self.primary_key

    unique = property(unique)

    def set_attributes_from_name(self, name):

        self.name = name

        self.attname, self.column = self.get_attname_column()

        if self.verbose_name is None and name:

            self.verbose_name = name.replace('_', ' ')

    def contribute_to_class(self, cls, name):

        self.set_attributes_from_name(name)

        cls._meta.add_field(self)

        if self.choices:

            setattr(cls, 'get_%s_display' % self.name, curry(cls._get_FIELD_display, field=self))

    def get_attname(self):

        return self.name

    def get_attname_column(self):

        attname = self.get_attname()

        column = self.db_column or attname

        return attname, column

    def get_cache_name(self):

        return '_%s_cache' % self.name

    def get_internal_type(self):

        return self.__class__.__name__

    def pre_save(self, model_instance, add):

        "Returns field's value just before saving."

        return getattr(model_instance, self.attname)

        """Returns field's value prepared for interacting with the database

        backend.

        Used by the default implementations of ``get_db_prep_save``and

        `get_db_prep_lookup```

        """

        return value

        "Returns field's value prepared for saving into a database."

        "Returns field's value prepared for database lookup."

        if hasattr(value, 'as_sql') or hasattr(value, '_as_sql'):

            # If the value has a relabel_aliases method, it will need to

            # be invoked before the final SQL is evaluated

            if hasattr(value, 'relabel_aliases'):

                return value

            if hasattr(value, 'as_sql'):

                sql, params = value.as_sql()

            else:

            return QueryWrapper(('(%s)' % sql), params)

        if lookup_type in ('regex', 'iregex', 'month', 'day', 'week_day', 'search'):

            return [value]

        elif lookup_type in ('exact', 'gt', 'gte', 'lt', 'lte'):

        elif lookup_type in ('range', 'in'):

        elif lookup_type in ('contains', 'icontains'):

            return ["%%%s%%" % connection.ops.prep_for_like_query(value)]

        elif lookup_type == 'iexact':

            return [connection.ops.prep_for_iexact_query(value)]

        elif lookup_type in ('startswith', 'istartswith'):

            return ["%s%%" % connection.ops.prep_for_like_query(value)]

        elif lookup_type in ('endswith', 'iendswith'):

            return ["%%%s" % connection.ops.prep_for_like_query(value)]

        elif lookup_type == 'isnull':

            return []

        elif lookup_type == 'year':

            if self.get_internal_type() == 'DateField':

                return connection.ops.year_lookup_bounds_for_date_field(value)

            else:

                return connection.ops.year_lookup_bounds(value)

    def has_default(self):

        "Returns a boolean of whether this field has a default value."

        return self.default is not NOT_PROVIDED

    def get_default(self):

        "Returns the default value for this field."

        if self.has_default():

            if callable(self.default):

                return self.default()

            return force_unicode(self.default, strings_only=True)

        if not self.empty_strings_allowed or (self.null and not connection.features.interprets_empty_strings_as_nulls):

            return None

        return ""

    def get_validator_unique_lookup_type(self):

        return '%s__exact' % self.name

    def get_choices(self, include_blank=True, blank_choice=BLANK_CHOICE_DASH):

        """Returns choices with a default blank choices included, for use

        as SelectField choices for this field."""

        first_choice = include_blank and blank_choice or []

        if self.choices:

            return first_choice + list(self.choices)

        rel_model = self.rel.to

        if hasattr(self.rel, 'get_related_field'):

            lst = [(getattr(x, self.rel.get_related_field().attname), smart_unicode(x)) for x in rel_model._default_manager.complex_filter(self.rel.limit_choices_to)]

        else:

            lst = [(x._get_pk_val(), smart_unicode(x)) for x in rel_model._default_manager.complex_filter(self.rel.limit_choices_to)]

        return first_choice + lst

    def get_choices_default(self):

        return self.get_choices()

    def get_flatchoices(self, include_blank=True, blank_choice=BLANK_CHOICE_DASH):

        "Returns flattened choices with a default blank choice included."

        first_choice = include_blank and blank_choice or []

        return first_choice + list(self.flatchoices)

    def _get_val_from_obj(self, obj):

            return getattr(obj, self.attname)

        else:

            return self.get_default()

    def value_to_string(self, obj):

        """

        Returns a string value of this field from the passed obj.

        This is used by the serialization framework.

        """