from django.db.backends import util

from django.db.models import signals, get_model

from django.db.models.related import RelatedObject

from django.db.models.query import QuerySet

from django.db.models.query_utils import QueryWrapper

from django.utils.encoding import smart_unicode

from django.utils.functional import curry

from django.core import exceptions

from django import forms

RECURSIVE_RELATIONSHIP_CONSTANT = 'self'

pending_lookups = {}

def add_lazy_relation(cls, field, relation, operation):

    """

    Adds a lookup on ``cls`` when a related field is defined using a string,

    i.e.::

        class MyModel(Model):

            fk = ForeignKey("AnotherModel")

    This string can be:

        * RECURSIVE_RELATIONSHIP_CONSTANT (i.e. "self") to indicate a recursive

          relation.

        * The name of a model (i.e "AnotherModel") to indicate another model in

          the same app.

        * An app-label and model name (i.e. "someapp.AnotherModel") to indicate

          another model in a different app.

    If the other model hasn't yet been loaded -- almost a given if you're using

    lazy relationships -- then the relation won't be set up until the

    class_prepared signal fires at the end of model initialization.

    operation is the work that must be performed once the relation can be resolved.

    """

    # Check for recursive relations

    if relation == RECURSIVE_RELATIONSHIP_CONSTANT:

        app_label = cls._meta.app_label

        model_name = cls.__name__

    else:

        # Look for an "app.Model" relation

        try:

            app_label, model_name = relation.split(".")

        except ValueError:

            # If we can't split, assume a model in current app

            app_label = cls._meta.app_label

            model_name = relation

    # Try to look up the related model, and if it's already loaded resolve the

    # string right away. If get_model returns None, it means that the related

    # model isn't loaded yet, so we need to pend the relation until the class

    # is prepared.

    model = get_model(app_label, model_name, False)

    if model:

        operation(field, model, cls)

    else:

        key = (app_label, model_name)

        value = (cls, field, operation)

        pending_lookups.setdefault(key, []).append(value)

def do_pending_lookups(sender, **kwargs):

    """

    Handle any pending relations to the sending model. Sent from class_prepared.

    """

    key = (sender._meta.app_label, sender.__name__)

    for cls, field, operation in pending_lookups.pop(key, []):

        operation(field, sender, cls)

signals.class_prepared.connect(do_pending_lookups)

#HACK

class RelatedField(object):

    def contribute_to_class(self, cls, name):

        sup = super(RelatedField, self)

        if hasattr(sup, 'contribute_to_class'):

            sup.contribute_to_class(cls, name)

        if not cls._meta.abstract and self.rel.related_name:

        other = self.rel.to

            def resolve_related_class(field, model, cls):

                field.rel.to = model

                field.do_related_class(model, cls)

            add_lazy_relation(cls, self, other, resolve_related_class)

        else:

            self.do_related_class(other, cls)

    def set_attributes_from_rel(self):

        self.name = self.name or (self.rel.to._meta.object_name.lower() + '_' + self.rel.to._meta.pk.name)

        if self.verbose_name is None:

            self.verbose_name = self.rel.to._meta.verbose_name

        self.rel.field_name = self.rel.field_name or self.rel.to._meta.pk.name

    def do_related_class(self, other, cls):

        self.set_attributes_from_rel()

        self.related = RelatedObject(other, cls, self)

        if not cls._meta.abstract:

            self.contribute_to_related_class(other, self.related)

        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)

        # get_(next/prev)_by_date work; other lookups are not allowed since that

        # gets messy pretty quick. This is a good candidate for some refactoring

        # in the future.

        if lookup_type in ['exact', 'gt', 'lt', 'gte', 'lte']:

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

        elif lookup_type == 'isnull':

            return []

        # This method defines the name that can be used to identify this

        # related object in a table-spanning query. It uses the lower-cased

        # object_name by default, but this can be overridden with the

        # "related_name" option.

class SingleRelatedObjectDescriptor(object):

    # This class provides the functionality that makes the related-object

    # managers available as attributes on a model class, for fields that have

    # a single "remote" value, on the class pointed to by a related field.

    # In the example "place.restaurant", the restaurant attribute is a

    # SingleRelatedObjectDescriptor instance.

    def __init__(self, related):

        self.related = related

    def __get__(self, instance, instance_type=None):

        if instance is None:

            return self

        try:

            return getattr(instance, self.cache_name)

        except AttributeError:

            params = {'%s__pk' % self.related.field.name: instance._get_pk_val()}

            setattr(instance, self.cache_name, rel_obj)

            return rel_obj

    def __set__(self, instance, value):

        if instance is None:

        # The similarity of the code below to the code in

        # ReverseSingleRelatedObjectDescriptor is annoying, but there's a bunch

        # of small differences that would make a common base class convoluted.

        # If null=True, we can assign null here, but otherwise the value needs

        # to be an instance of the related class.

        if value is None and self.related.field.null == False:

            raise ValueError('Cannot assign None: "%s.%s" does not allow null values.' %

                                (instance._meta.object_name, self.related.get_accessor_name()))

        elif value is not None and not isinstance(value, self.related.model):

            raise ValueError('Cannot assign "%r": "%s.%s" must be a "%s" instance.' %

                                (value, instance._meta.object_name,

                                 self.related.get_accessor_name(), self.related.opts.object_name))

        # Set the value of the related field to the value of the related object's related field

        setattr(value, self.related.field.attname, getattr(instance, self.related.field.rel.get_related_field().attname))

        # Since we already know what the related object is, seed the related

        # object caches now, too. This avoids another db hit if you get the

        # object you just set.

        setattr(instance, self.cache_name, value)

        setattr(value, self.related.field.get_cache_name(), instance)

class ReverseSingleRelatedObjectDescriptor(object):

    # This class provides the functionality that makes the related-object

    # managers available as attributes on a model class, for fields that have

    # a single "remote" value, on the class that defines the related field.

    # In the example "choice.poll", the poll attribute is a

    # ReverseSingleRelatedObjectDescriptor instance.

    def __init__(self, field_with_rel):

        self.field = field_with_rel

    def __get__(self, instance, instance_type=None):

        if instance is None:

            return self

        cache_name = self.field.get_cache_name()

        try:

            return getattr(instance, cache_name)

        except AttributeError:

            val = getattr(instance, self.field.attname)

            if val is None:

                # If NULL is an allowed value, return it.

                if self.field.null:

                    return None

                raise self.field.rel.to.DoesNotExist

            other_field = self.field.rel.get_related_field()

            if other_field.rel:

                params = {'%s__pk' % self.field.rel.field_name: val}

            else:

                params = {'%s__exact' % self.field.rel.field_name: val}

            # If the related manager indicates that it should be used for

            # related fields, respect that.

            rel_mgr = self.field.rel.to._default_manager

            if getattr(rel_mgr, 'use_for_related_fields', False):

            else:

            setattr(instance, cache_name, rel_obj)

            return rel_obj

    def __set__(self, instance, value):

        if instance is None:

        # If null=True, we can assign null here, but otherwise the value needs

        # to be an instance of the related class.

        if value is None and self.field.null == False:

            raise ValueError('Cannot assign None: "%s.%s" does not allow null values.' %

                                (instance._meta.object_name, self.field.name))

        elif value is not None and not isinstance(value, self.field.rel.to):

            raise ValueError('Cannot assign "%r": "%s.%s" must be a "%s" instance.' %

                                (value, instance._meta.object_name,

                                 self.field.name, self.field.rel.to._meta.object_name))

        # If we're setting the value of a OneToOneField to None, we need to clear

        # out the cache on any old related object. Otherwise, deleting the

        # previously-related object will also cause this object to be deleted,

        # which is wrong.

        if value is None:

            # Look up the previously-related object, which may still be available

            # since we've not yet cleared out the related field.

            # Use the cache directly, instead of the accessor; if we haven't

            # populated the cache, then we don't care - we're only accessing

            # the object to invalidate the accessor cache, so there's no

            # need to populate the cache just to expire it again.

            related = getattr(instance, self.field.get_cache_name(), None)

            # If we've got an old related object, we need to clear out its

            # cache. This cache also might not exist if the related object

            # hasn't been accessed yet.

            if related:

                try:

                    delattr(related, cache_name)

                except AttributeError:

                    pass

        # Set the value of the related field

        try:

            val = getattr(value, self.field.rel.get_related_field().attname)

        except AttributeError:

            val = None

        setattr(instance, self.field.attname, val)

        # Since we already know what the related object is, seed the related

        # object cache now, too. This avoids another db hit if you get the

        # object you just set.

        setattr(instance, self.field.get_cache_name(), value)

class ForeignRelatedObjectsDescriptor(object):

    # This class provides the functionality that makes the related-object

    # managers available as attributes on a model class, for fields that have

    # multiple "remote" values and have a ForeignKey pointed at them by

    # some other model. In the example "poll.choice_set", the choice_set

    # attribute is a ForeignRelatedObjectsDescriptor instance.

    def __init__(self, related):

        self.related = related   # RelatedObject instance

    def __get__(self, instance, instance_type=None):

        if instance is None:

            return self

        return self.create_manager(instance,

                self.related.model._default_manager.__class__)