from django.contrib.auth.models import User

from django.db import models

class Animal(models.Model):

    name = models.CharField(max_length=150)

    latin_name = models.CharField(max_length=150)

    count = models.IntegerField()

    weight = models.FloatField()

    # use a non-default name for the default manager

    specimens = models.Manager()

    def __str__(self):

        return self.name

class Plant(models.Model):

    name = models.CharField(max_length=150)

    class Meta:

        # For testing when upper case letter in app name; regression for #4057

        db_table = "Fixtures_regress_plant"

class Stuff(models.Model):

    name = models.CharField(max_length=20, null=True)

    owner = models.ForeignKey(User, models.SET_NULL, null=True)

    def __str__(self):

        return self.name + " is owned by " + str(self.owner)

class Absolute(models.Model):

    name = models.CharField(max_length=40)

class Parent(models.Model):

    name = models.CharField(max_length=10)

    class Meta:

        ordering = ("id",)

class Child(Parent):

    data = models.CharField(max_length=10)

# Models to regression test #7572, #20820

class Channel(models.Model):

    name = models.CharField(max_length=255)

class Article(models.Model):

    title = models.CharField(max_length=255)

    channels = models.ManyToManyField(Channel)

    class Meta:

        ordering = ("id",)

# Subclass of a model with a ManyToManyField for test_ticket_20820

class SpecialArticle(Article):

    pass

# Models to regression test #22421

class CommonFeature(Article):

    class Meta:

        abstract = True

class Feature(CommonFeature):

    pass

# Models to regression test #11428

class Widget(models.Model):

    name = models.CharField(max_length=255)

    class Meta:

        ordering = ("name",)

    def __str__(self):

        return self.name

class WidgetProxy(Widget):

    class Meta:

        proxy = True

# Check for forward references in FKs and M2Ms with natural keys

class TestManager(models.Manager):

    def get_by_natural_key(self, key):

        return self.get(name=key)

class Store(models.Model):

    name = models.CharField(max_length=255, unique=True)

    main = models.ForeignKey("self", models.SET_NULL, null=True)

    objects = TestManager()

    class Meta:

        ordering = ("name",)

    def __str__(self):

        return self.name

    def natural_key(self):

        return (self.name,)

class Person(models.Model):

    name = models.CharField(max_length=255, unique=True)

    objects = TestManager()

    class Meta:

        ordering = ("name",)

    def __str__(self):

        return self.name

    # Person doesn't actually have a dependency on store, but we need to define

    # one to test the behavior of the dependency resolution algorithm.

    def natural_key(self):

        return (self.name,)

    natural_key.dependencies = ["fixtures_regress.store"]

class Book(models.Model):

    name = models.CharField(max_length=255)

    author = models.ForeignKey(Person, models.CASCADE)

    stores = models.ManyToManyField(Store)

    class Meta:

        ordering = ("name",)

    def __str__(self):

        return "%s by %s (available at %s)" % (

            self.name,

            self.author.name,

            ", ".join(s.name for s in self.stores.all()),

        )

class NaturalKeyWithFKDependencyManager(models.Manager):

    def get_by_natural_key(self, name, author):

        return self.get(name=name, author__name=author)

class NaturalKeyWithFKDependency(models.Model):

    name = models.CharField(max_length=255)

    author = models.ForeignKey(Person, models.CASCADE)

    objects = NaturalKeyWithFKDependencyManager()

    class Meta:

        unique_together = ["name", "author"]

    def natural_key(self):

        return (self.name,) + self.author.natural_key()

    natural_key.dependencies = ["fixtures_regress.Person"]

class NKManager(models.Manager):

    def get_by_natural_key(self, data):

        return self.get(data=data)

class NKChild(Parent):

    data = models.CharField(max_length=10, unique=True)

    objects = NKManager()

    def natural_key(self):

        return (self.data,)

    def __str__(self):

        return "NKChild %s:%s" % (self.name, self.data)

class RefToNKChild(models.Model):

    text = models.CharField(max_length=10)

    nk_fk = models.ForeignKey(NKChild, models.CASCADE, related_name="ref_fks")

    nk_m2m = models.ManyToManyField(NKChild, related_name="ref_m2ms")

    def __str__(self):

        return "%s: Reference to %s [%s]" % (

            self.text,

            self.nk_fk,

            ", ".join(str(o) for o in self.nk_m2m.all()),

        )

# ome models with pathological circular dependencies

class Circle1(models.Model):

    name = models.CharField(max_length=255, unique=True)

    def natural_key(self):

        return (self.name,)

    natural_key.dependencies = ["fixtures_regress.circle2"]

class Circle2(models.Model):

    name = models.CharField(max_length=255, unique=True)

    def natural_key(self):

        return (self.name,)

    natural_key.dependencies = ["fixtures_regress.circle1"]

class Circle3(models.Model):

    name = models.CharField(max_length=255, unique=True)

    def natural_key(self):

        return (self.name,)

    natural_key.dependencies = ["fixtures_regress.circle3"]

class Circle4(models.Model):

    name = models.CharField(max_length=255, unique=True)

    def natural_key(self):

        return (self.name,)

    natural_key.dependencies = ["fixtures_regress.circle5"]

class Circle5(models.Model):

    name = models.CharField(max_length=255, unique=True)

    def natural_key(self):

        return (self.name,)

    natural_key.dependencies = ["fixtures_regress.circle6"]

class Circle6(models.Model):

    name = models.CharField(max_length=255, unique=True)

    def natural_key(self):

        return (self.name,)

    natural_key.dependencies = ["fixtures_regress.circle4"]

class ExternalDependency(models.Model):

    name = models.CharField(max_length=255, unique=True)

    def natural_key(self):

        return (self.name,)

    natural_key.dependencies = ["fixtures_regress.book"]

# Model for regression test of #11101

class Thingy(models.Model):

    name = models.CharField(max_length=255)

class M2MToSelf(models.Model):

    parent = models.ManyToManyField("self", blank=True)

class BaseNKModel(models.Model):

    """

    Base model with a natural_key and a manager with `get_by_natural_key`

    """

    data = models.CharField(max_length=20, unique=True)

    objects = NKManager()

    class Meta:

        abstract = True

    def __str__(self):

        return self.data

    def natural_key(self):

        return (self.data,)

class M2MSimpleA(BaseNKModel):

    b_set = models.ManyToManyField("M2MSimpleB")

class M2MSimpleB(BaseNKModel):

    pass

class M2MSimpleCircularA(BaseNKModel):

    b_set = models.ManyToManyField("M2MSimpleCircularB")

class M2MSimpleCircularB(BaseNKModel):

    a_set = models.ManyToManyField("M2MSimpleCircularA")

class M2MComplexA(BaseNKModel):

    b_set = models.ManyToManyField("M2MComplexB", through="M2MThroughAB")

class M2MComplexB(BaseNKModel):

    pass

class M2MThroughAB(BaseNKModel):

    a = models.ForeignKey(M2MComplexA, models.CASCADE)

    b = models.ForeignKey(M2MComplexB, models.CASCADE)

class M2MComplexCircular1A(BaseNKModel):

    b_set = models.ManyToManyField(

        "M2MComplexCircular1B", through="M2MCircular1ThroughAB"

    )

class M2MComplexCircular1B(BaseNKModel):

    c_set = models.ManyToManyField(

        "M2MComplexCircular1C", through="M2MCircular1ThroughBC"

    )

class M2MComplexCircular1C(BaseNKModel):

    a_set = models.ManyToManyField(

        "M2MComplexCircular1A", through="M2MCircular1ThroughCA"

    )

class M2MCircular1ThroughAB(BaseNKModel):

    a = models.ForeignKey(M2MComplexCircular1A, models.CASCADE)

    b = models.ForeignKey(M2MComplexCircular1B, models.CASCADE)

class M2MCircular1ThroughBC(BaseNKModel):

    b = models.ForeignKey(M2MComplexCircular1B, models.CASCADE)

    c = models.ForeignKey(M2MComplexCircular1C, models.CASCADE)

class M2MCircular1ThroughCA(BaseNKModel):

    c = models.ForeignKey(M2MComplexCircular1C, models.CASCADE)

    a = models.ForeignKey(M2MComplexCircular1A, models.CASCADE)

class M2MComplexCircular2A(BaseNKModel):

    b_set = models.ManyToManyField(

        "M2MComplexCircular2B", through="M2MCircular2ThroughAB"

    )

class M2MComplexCircular2B(BaseNKModel):

    def natural_key(self):

        return (self.data,)

    # Fake the dependency for a circularity

    natural_key.dependencies = ["fixtures_regress.M2MComplexCircular2A"]

class M2MCircular2ThroughAB(BaseNKModel):

    a = models.ForeignKey(M2MComplexCircular2A, models.CASCADE)

    b = models.ForeignKey(M2MComplexCircular2B, models.CASCADE)