"""
By specifying the 'proxy' Meta attribute, model subclasses can specify that
they will take data directly from the table of their base class table rather
than using a new table of their own. This allows them to act as simple proxies,
providing a modified interface to the data from the base class.
"""
from django.db import models

# A couple of managers for testing managing overriding in proxy model cases.


class PersonManager(models.Manager):
    def get_queryset(self):
        return super().get_queryset().exclude(name="fred")


class SubManager(models.Manager):
    def get_queryset(self):
        return super().get_queryset().exclude(name="wilma")


class Person(models.Model):
    """
    A simple concrete base class.
    """

    name = models.CharField(max_length=50)

    objects = PersonManager()

    def __str__(self):
        return self.name


class Abstract(models.Model):
    """
    A simple abstract base class, to be used for error checking.
    """

    data = models.CharField(max_length=10)

    class Meta:
        abstract = True


class MyPerson(Person):
    """
    A proxy subclass, this should not get a new table. Overrides the default
    manager.
    """

    class Meta:
        proxy = True
        ordering = ["name"]
        permissions = (("display_users", "May display users information"),)

    objects = SubManager()
    other = PersonManager()

    def has_special_name(self):
        return self.name.lower() == "special"


class ManagerMixin(models.Model):
    excluder = SubManager()

    class Meta:
        abstract = True


class OtherPerson(Person, ManagerMixin):
    """
    A class with the default manager from Person, plus a secondary manager.
    """

    class Meta:
        proxy = True
        ordering = ["name"]


class StatusPerson(MyPerson):
    """
    A non-proxy subclass of a proxy, it should get a new table.
    """

    status = models.CharField(max_length=80)

    objects = models.Manager()


# We can even have proxies of proxies (and subclass of those).


class MyPersonProxy(MyPerson):
    class Meta:
        proxy = True


class LowerStatusPerson(MyPersonProxy):
    status = models.CharField(max_length=80)

    objects = models.Manager()


class User(models.Model):
    name = models.CharField(max_length=100)

    def __str__(self):
        return self.name


class UserProxy(User):
    class Meta:
        proxy = True


class AnotherUserProxy(User):
    class Meta:
        proxy = True


class UserProxyProxy(UserProxy):
    class Meta:
        proxy = True


class MultiUserProxy(UserProxy, AnotherUserProxy):
    class Meta:
        proxy = True


# We can still use `select_related()` to include related models in our querysets.


class Country(models.Model):
    name = models.CharField(max_length=50)


class State(models.Model):
    name = models.CharField(max_length=50)
    country = models.ForeignKey(Country, models.CASCADE)

    def __str__(self):
        return self.name


class StateProxy(State):
    class Meta:
        proxy = True


# Proxy models still works with filters (on related fields)
# and select_related, even when mixed with model inheritance


class BaseUser(models.Model):
    name = models.CharField(max_length=255)

    def __str__(self):
        return ":".join(
            (
                self.__class__.__name__,
                self.name,
            )
        )


class TrackerUser(BaseUser):
    status = models.CharField(max_length=50)


class ProxyTrackerUser(TrackerUser):
    class Meta:
        proxy = True


class Issue(models.Model):
    summary = models.CharField(max_length=255)
    assignee = models.ForeignKey(
        ProxyTrackerUser, models.CASCADE, related_name="issues"
    )

    def __str__(self):
        return ":".join(
            (
                self.__class__.__name__,
                self.summary,
            )
        )


class Bug(Issue):
    version = models.CharField(max_length=50)
    reporter = models.ForeignKey(BaseUser, models.CASCADE)


class ProxyBug(Bug):
    """
    Proxy of an inherited class
    """

    class Meta:
        proxy = True


class ProxyProxyBug(ProxyBug):
    """
    A proxy of proxy model with related field
    """

    class Meta:
        proxy = True


class Improvement(Issue):
    """
    A model that has relation to a proxy model
    or to a proxy of proxy model
    """

    version = models.CharField(max_length=50)
    reporter = models.ForeignKey(ProxyTrackerUser, models.CASCADE)
    associated_bug = models.ForeignKey(ProxyProxyBug, models.CASCADE)


class ProxyImprovement(Improvement):
    class Meta:
        proxy = True
