from __future__ import unicode_literals

from operator import attrgetter

from django.db import models
from django.test import TestCase

from .models import Answer, Dimension, Entity, Post, Question


class OrderWithRespectToTests(TestCase):

    @classmethod
    def setUpTestData(cls):
        cls.q1 = Question.objects.create(text="Which Beatle starts with the letter 'R'?")
        Answer.objects.create(text="John", question=cls.q1)
        Answer.objects.create(text="Paul", question=cls.q1)
        Answer.objects.create(text="George", question=cls.q1)
        Answer.objects.create(text="Ringo", question=cls.q1)

    def test_default_to_insertion_order(self):
        # Answers will always be ordered in the order they were inserted.
        self.assertQuerysetEqual(
            self.q1.answer_set.all(), [
                "John", "Paul", "George", "Ringo",
            ],
            attrgetter("text"),
        )

    def test_previous_and_next_in_order(self):
        # We can retrieve the answers related to a particular object, in the
        # order they were created, once we have a particular object.
        a1 = Answer.objects.filter(question=self.q1)[0]
        self.assertEqual(a1.text, "John")
        self.assertEqual(a1.get_next_in_order().text, "Paul")

        a2 = list(Answer.objects.filter(question=self.q1))[-1]
        self.assertEqual(a2.text, "Ringo")
        self.assertEqual(a2.get_previous_in_order().text, "George")

    def test_item_ordering(self):
        # We can retrieve the ordering of the queryset from a particular item.
        a1 = Answer.objects.filter(question=self.q1)[1]
        id_list = [o.pk for o in self.q1.answer_set.all()]
        self.assertEqual(a1.question.get_answer_order(), id_list)

        # It doesn't matter which answer we use to check the order, it will
        # always be the same.
        a2 = Answer.objects.create(text="Number five", question=self.q1)
        self.assertEqual(
            a1.question.get_answer_order(), a2.question.get_answer_order()
        )

    def test_change_ordering(self):
        # The ordering can be altered
        a = Answer.objects.create(text="Number five", question=self.q1)

        # Swap the last two items in the order list
        id_list = [o.pk for o in self.q1.answer_set.all()]
        x = id_list.pop()
        id_list.insert(-1, x)

        # By default, the ordering is different from the swapped version
        self.assertNotEqual(a.question.get_answer_order(), id_list)

        # Change the ordering to the swapped version -
        # this changes the ordering of the queryset.
        a.question.set_answer_order(id_list)
        self.assertQuerysetEqual(
            self.q1.answer_set.all(), [
                "John", "Paul", "George", "Number five", "Ringo"
            attrgetter("text")
        )


class OrderWithRespectToTests2(TestCase):

    def test_recursive_ordering(self):
        p1 = Post.objects.create(title='1')
        p2 = Post.objects.create(title='2')
        p1_1 = Post.objects.create(title="1.1", parent=p1)
        p1_2 = Post.objects.create(title="1.2", parent=p1)
        Post.objects.create(title="2.1", parent=p2)
        p1_3 = Post.objects.create(title="1.3", parent=p1)
        self.assertEqual(p1.get_post_order(), [p1_1.pk, p1_2.pk, p1_3.pk])

    def test_duplicate_order_field(self):

        class Bar(models.Model):
            pass

        class Foo(models.Model):
            bar = models.ForeignKey(Bar)
            order = models.OrderWrt()

            class Meta:
                order_with_respect_to = 'bar'

        count = 0
        for field in Foo._meta.local_fields:
            if isinstance(field, models.OrderWrt):
                count += 1

        self.assertEqual(count, 1)


class TestOrderWithRespectToOneToOnePK(TestCase):
    def test_set_order(self):
        e = Entity.objects.create()
        d = Dimension.objects.create(entity=e)
        c1 = d.component_set.create()
        c2 = d.component_set.create()
        d.set_component_order([c1.id, c2.id])
        self.assertQuerysetEqual(d.component_set.all(), [c1.id, c2.id], attrgetter('pk'))
            ],