from django.db import connection, transaction

from django.db.backends import util

from django.db.models import signals, get_model

from django.db.models.fields import AutoField, Field, IntegerField, PositiveIntegerField, PositiveSmallIntegerField, FieldDoesNotExist

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.translation import ugettext_lazy, string_concat, ungettext, ugettext as _

from django.utils.functional import curry

from django.core import exceptions

from django import forms

try:

    set

except NameError:

    from sets import Set as set   # Python 2.3 fallback

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)

        # Add an accessor to allow easy determination of the related query path for this field

        self.related_query_name = curry(self._get_related_query_name, cls._meta)

        if hasattr(sup, 'contribute_to_class'):

            sup.contribute_to_class(cls, name)

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

            self.rel.related_name = self.rel.related_name % {'class': cls.__name__.lower()}

        other = self.rel.to

        if isinstance(other, basestring):

            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)

    def get_db_prep_lookup(self, lookup_type, value):

        # If we are doing a lookup on a Related Field, we must be

        # comparing object instances. The value should be the PK of value,

        # not value itself.

        def pk_trace(value):

            # Value may be a primary key, or an object held in a relation.

            # If it is an object, then we need to get the primary key value for

            # that object. In certain conditions (especially one-to-one relations),

            # the primary key may itself be an object - so we need to keep drilling

            # down until we hit a value that can be used for a comparison.

            v, field = value, None

            try:

                while True:

                    v, field = getattr(v, v._meta.pk.name), v._meta.pk

            except AttributeError:

                pass

            if field:

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

                    v = [v]

                v = field.get_db_prep_lookup(lookup_type, v)

                if isinstance(v, list):

                    v = v[0]

            return v

        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:

                sql, params = value._as_sql()

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

        # FIXME: lt and gt are explicitally allowed to make

        # 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']:

            return [pk_trace(value)]

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

            return [pk_trace(v) for v in value]

        elif lookup_type == 'isnull':

            return []

        raise TypeError, "Related Field has invalid lookup: %s" % lookup_type

    def _get_related_query_name(self, opts):

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

        return self.rel.related_name or opts.object_name.lower()

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

        self.cache_name = '_%s_cache' % related.get_accessor_name()

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

            rel_obj = self.related.model._base_manager.get(**params)

            setattr(instance, self.cache_name, rel_obj)

            return rel_obj

    def __set__(self, instance, value):

        if instance is None:

            raise AttributeError, "%s must be accessed via instance" % self.related.opts.object_name

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

                rel_obj = rel_mgr.get(**params)

            else:

                rel_obj = QuerySet(self.field.rel.to).get(**params)

            setattr(instance, cache_name, rel_obj)

            return rel_obj

    def __set__(self, instance, value):

        if instance is None:

            raise AttributeError, "%s must be accessed via instance" % self._field.name

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

                cache_name = '_%s_cache' % self.field.related.get_accessor_name()

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

    def __set__(self, instance, value):

        if instance is None:

            raise AttributeError, "Manager must be accessed via instance"

        manager = self.__get__(instance)

        # If the foreign key can support nulls, then completely clear the related set.

        # Otherwise, just move the named objects into the set.

        if self.related.field.null:

            manager.clear()

        manager.add(*value)

    def delete_manager(self, instance):

        """

        Returns a queryset based on the related model's base manager (rather

        than the default manager, as returned by __get__). Used by

        Model.delete().

        """

        return self.create_manager(instance,

                self.related.model._base_manager.__class__)

    def create_manager(self, instance, superclass):

        """

        Creates the managers used by other methods (__get__() and delete()).

        """

        rel_field = self.related.field

        rel_model = self.related.model

        class RelatedManager(superclass):

            def get_query_set(self):

                return superclass.get_query_set(self).filter(**(self.core_filters))

            def add(self, *objs):

                for obj in objs:

                    if not isinstance(obj, self.model):

                        raise TypeError, "'%s' instance expected" % self.model._meta.object_name

                    setattr(obj, rel_field.name, instance)

                    obj.save()

            add.alters_data = True

            def create(self, **kwargs):

                kwargs.update({rel_field.name: instance})

                return super(RelatedManager, self).create(**kwargs)

            create.alters_data = True

            def get_or_create(self, **kwargs):

                # Update kwargs with the related object that this

                # ForeignRelatedObjectsDescriptor knows about.

                kwargs.update({rel_field.name: instance})

                return super(RelatedManager, self).get_or_create(**kwargs)

            get_or_create.alters_data = True

            # remove() and clear() are only provided if the ForeignKey can have a value of null.

            if rel_field.null:

                def remove(self, *objs):

                    val = getattr(instance, rel_field.rel.get_related_field().attname)

                    for obj in objs:

                        # Is obj actually part of this descriptor set?

                        if getattr(obj, rel_field.attname) == val:

                            setattr(obj, rel_field.name, None)

                            obj.save()

                        else:

                            raise rel_field.rel.to.DoesNotExist, "%r is not related to %r." % (obj, instance)

                remove.alters_data = True

                def clear(self):

                    for obj in self.all():

                        setattr(obj, rel_field.name, None)

                        obj.save()

                clear.alters_data = True

        manager = RelatedManager()

        attname = rel_field.rel.get_related_field().name