import copy

from django.db.models.query import QuerySet, EmptyQuerySet, insert_query

from django.db.models import signals

from django.db.models.fields import FieldDoesNotExist

def ensure_default_manager(sender, **kwargs):

    """

    Ensures that a Model subclass contains a default manager  and sets the

    _default_manager attribute on the class. Also sets up the _base_manager

    points to a plain Manager instance (which could be the same as

    _default_manager if it's not a subclass of Manager).

    """

    cls = sender

    if cls._meta.abstract:

        return

    if not getattr(cls, '_default_manager', None):

        # Create the default manager, if needed.

        try:

            cls._meta.get_field('objects')

            raise ValueError, "Model %s must specify a custom Manager, because it has a field named 'objects'" % cls.__name__

        except FieldDoesNotExist:

            pass

        cls.add_to_class('objects', Manager())

        cls._base_manager = cls.objects

    elif not getattr(cls, '_base_manager', None):

        default_mgr = cls._default_manager.__class__

        if (default_mgr is Manager or

                getattr(default_mgr, "use_for_related_fields", False)):

            cls._base_manager = cls._default_manager

        else:

            # Default manager isn't a plain Manager class, or a suitable

            # replacement, so we walk up the base class hierarchy until we hit

            # something appropriate.

            for base_class in default_mgr.mro()[1:]:

                if (base_class is Manager or

                        getattr(base_class, "use_for_related_fields", False)):

                    cls.add_to_class('_base_manager', base_class())

                    return

            raise AssertionError("Should never get here. Please report a bug, including your model and model manager setup.")

signals.class_prepared.connect(ensure_default_manager)

class Manager(object):

    # Tracks each time a Manager instance is created. Used to retain order.

    creation_counter = 0

    def __init__(self):

        super(Manager, self).__init__()

        self._set_creation_counter()

        self.model = None

        self._inherited = False

    def contribute_to_class(self, model, name):

        # TODO: Use weakref because of possible memory leak / circular reference.

        self.model = model

        setattr(model, name, ManagerDescriptor(self))

        if not getattr(model, '_default_manager', None) or self.creation_counter < model._default_manager.creation_counter:

            model._default_manager = self

        if model._meta.abstract or (self._inherited and not self.model._meta.proxy):

            model._meta.abstract_managers.append((self.creation_counter, name,

                    self))

        else:

            model._meta.concrete_managers.append((self.creation_counter, name,

                self))

    def _set_creation_counter(self):

        """

        Sets the creation counter value for this instance and increments the

        class-level copy.

        """

        self.creation_counter = Manager.creation_counter

        Manager.creation_counter += 1

    def _copy_to_model(self, model):

        """

        Makes a copy of the manager and assigns it to 'model', which should be

        a child of the existing model (used when inheriting a manager from an

        abstract base class).

        """

        assert issubclass(model, self.model)

        mgr = copy.copy(self)

        mgr._set_creation_counter()

        mgr.model = model

        mgr._inherited = True

        return mgr

    #######################

    # PROXIES TO QUERYSET #

    #######################

    def get_empty_query_set(self):

        return EmptyQuerySet(self.model)

    def get_query_set(self):

        """Returns a new QuerySet object.  Subclasses can override this method

        to easily customize the behavior of the Manager.

        """

        return QuerySet(self.model)

    def none(self):

        return self.get_empty_query_set()

    def all(self):

        return self.get_query_set()

    def count(self):

        return self.get_query_set().count()

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

        return self.get_query_set().dates(*args, **kwargs)

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

        return self.get_query_set().distinct(*args, **kwargs)

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

        return self.get_query_set().extra(*args, **kwargs)

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

        return self.get_query_set().get(*args, **kwargs)

    def get_or_create(self, **kwargs):

        return self.get_query_set().get_or_create(**kwargs)

    def create(self, **kwargs):

        return self.get_query_set().create(**kwargs)

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

        return self.get_query_set().filter(*args, **kwargs)

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

        return self.get_query_set().aggregate(*args, **kwargs)

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

        return self.get_query_set().annotate(*args, **kwargs)

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

        return self.get_query_set().complex_filter(*args, **kwargs)

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

        return self.get_query_set().exclude(*args, **kwargs)

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

        return self.get_query_set().in_bulk(*args, **kwargs)

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

        return self.get_query_set().iterator(*args, **kwargs)

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

        return self.get_query_set().latest(*args, **kwargs)

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

        return self.get_query_set().order_by(*args, **kwargs)

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

        return self.get_query_set().select_related(*args, **kwargs)

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

        return self.get_query_set().values(*args, **kwargs)

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

        return self.get_query_set().values_list(*args, **kwargs)

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

        return self.get_query_set().update(*args, **kwargs)

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

        return self.get_query_set().reverse(*args, **kwargs)

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

        return self.get_query_set().defer(*args, **kwargs)

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

        return self.get_query_set().only(*args, **kwargs)

    def _insert(self, values, **kwargs):

        return insert_query(self.model, values, **kwargs)

    def _update(self, values, **kwargs):

        return self.get_query_set()._update(values, **kwargs)

class ManagerDescriptor(object):

    # This class ensures managers aren't accessible via model instances.

    # For example, Poll.objects works, but poll_obj.objects raises AttributeError.

    def __init__(self, manager):

        self.manager = manager

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

        if instance != None:

            raise AttributeError, "Manager isn't accessible via %s instances" % type.__name__

        return self.manager

class EmptyManager(Manager):

    def get_query_set(self):

        return self.get_empty_query_set()