import datetime
import unittest

from django.apps.registry import Apps
from django.core.exceptions import ValidationError
from django.db import models
from django.test import TestCase

from .models import (
    CustomPKModel,
    FlexibleDatePost,
    ModelToValidate,
    Post,
    UniqueErrorsModel,
    UniqueFieldsModel,
    UniqueForDateModel,
    UniqueFuncConstraintModel,
    UniqueTogetherModel,
)


class GetUniqueCheckTests(unittest.TestCase):
    def test_unique_fields_get_collected(self):
        m = UniqueFieldsModel()
        self.assertEqual(
            (
                [
                    (UniqueFieldsModel, ("id",)),
                    (UniqueFieldsModel, ("unique_charfield",)),
                    (UniqueFieldsModel, ("unique_integerfield",)),
                ],
                [],
            ),
            m._get_unique_checks(),
        )

    def test_unique_together_gets_picked_up_and_converted_to_tuple(self):
        m = UniqueTogetherModel()
        self.assertEqual(
            (
                [
                    (UniqueTogetherModel, ("ifield", "cfield")),
                    (UniqueTogetherModel, ("ifield", "efield")),
                    (UniqueTogetherModel, ("id",)),
                ],
                [],
            ),
            m._get_unique_checks(),
        )

    def test_unique_together_normalization(self):
        """
        Test the Meta.unique_together normalization with different sorts of
        objects.
        """
        data = {
            "2-tuple": (("foo", "bar"), (("foo", "bar"),)),
            "list": (["foo", "bar"], (("foo", "bar"),)),
            "already normalized": (
                (("foo", "bar"), ("bar", "baz")),
                (("foo", "bar"), ("bar", "baz")),
            ),
            "set": (
                {("foo", "bar"), ("bar", "baz")},  # Ref #21469
                (("foo", "bar"), ("bar", "baz")),
            ),
        }

        for unique_together, normalized in data.values():

            class M(models.Model):
                foo = models.IntegerField()
                bar = models.IntegerField()
                baz = models.IntegerField()

                Meta = type(
                    "Meta", (), {"unique_together": unique_together, "apps": Apps()}
                )

            checks, _ = M()._get_unique_checks()
            for t in normalized:
                check = (M, t)
                self.assertIn(check, checks)

    def test_primary_key_is_considered_unique(self):
        m = CustomPKModel()
        self.assertEqual(
            ([(CustomPKModel, ("my_pk_field",))], []), m._get_unique_checks()
        )

    def test_unique_for_date_gets_picked_up(self):
        m = UniqueForDateModel()
        self.assertEqual(
            (
                [(UniqueForDateModel, ("id",))],
                [
                    (UniqueForDateModel, "date", "count", "start_date"),
                    (UniqueForDateModel, "year", "count", "end_date"),
                    (UniqueForDateModel, "month", "order", "end_date"),
                ],
            ),
            m._get_unique_checks(),
        )

    def test_unique_for_date_exclusion(self):
        m = UniqueForDateModel()
        self.assertEqual(
            (
                [(UniqueForDateModel, ("id",))],
                [
                    (UniqueForDateModel, "year", "count", "end_date"),
                    (UniqueForDateModel, "month", "order", "end_date"),
                ],
            ),
            m._get_unique_checks(exclude="start_date"),
        )

    def test_func_unique_constraint_ignored(self):
        m = UniqueFuncConstraintModel()
        self.assertEqual(
            m._get_unique_checks(),
            ([(UniqueFuncConstraintModel, ("id",))], []),
        )


class PerformUniqueChecksTest(TestCase):
    def test_primary_key_unique_check_not_performed_when_adding_and_pk_not_specified(
        self,
    ):
        # Regression test for #12560
        with self.assertNumQueries(0):
            mtv = ModelToValidate(number=10, name="Some Name")
            setattr(mtv, "_adding", True)
            mtv.full_clean()

    def test_primary_key_unique_check_performed_when_adding_and_pk_specified(self):
        # Regression test for #12560
        with self.assertNumQueries(1):
            mtv = ModelToValidate(number=10, name="Some Name", id=123)
            setattr(mtv, "_adding", True)
            mtv.full_clean()

    def test_primary_key_unique_check_not_performed_when_not_adding(self):
        # Regression test for #12132
        with self.assertNumQueries(0):
            mtv = ModelToValidate(number=10, name="Some Name")
            mtv.full_clean()

    def test_unique_db_default(self):
        UniqueFieldsModel.objects.create(unique_charfield="foo", non_unique_field=42)
        um = UniqueFieldsModel(unique_charfield="bar", non_unique_field=42)
        with self.assertRaises(ValidationError) as cm:
            um.full_clean()
        self.assertEqual(
            cm.exception.message_dict,
            {
                "unique_integerfield": [
                    "Unique fields model with this Unique integerfield already exists."
                ]
            },
        )

    def test_unique_for_date(self):
        Post.objects.create(
            title="Django 1.0 is released",
            slug="Django 1.0",
            subtitle="Finally",
            posted=datetime.date(2008, 9, 3),
        )
        p = Post(title="Django 1.0 is released", posted=datetime.date(2008, 9, 3))
        with self.assertRaises(ValidationError) as cm:
            p.full_clean()
        self.assertEqual(
            cm.exception.message_dict,
            {"title": ["Title must be unique for Posted date."]},
        )

        # Should work without errors
        p = Post(title="Work on Django 1.1 begins", posted=datetime.date(2008, 9, 3))
        p.full_clean()

        # Should work without errors
        p = Post(title="Django 1.0 is released", posted=datetime.datetime(2008, 9, 4))
        p.full_clean()

        p = Post(slug="Django 1.0", posted=datetime.datetime(2008, 1, 1))
        with self.assertRaises(ValidationError) as cm:
            p.full_clean()
        self.assertEqual(
            cm.exception.message_dict,
            {"slug": ["Slug must be unique for Posted year."]},
        )

        p = Post(subtitle="Finally", posted=datetime.datetime(2008, 9, 30))
        with self.assertRaises(ValidationError) as cm:
            p.full_clean()
        self.assertEqual(
            cm.exception.message_dict,
            {"subtitle": ["Subtitle must be unique for Posted month."]},
        )

        p = Post(title="Django 1.0 is released")
        with self.assertRaises(ValidationError) as cm:
            p.full_clean()
        self.assertEqual(
            cm.exception.message_dict, {"posted": ["This field cannot be null."]}
        )

    def test_unique_for_date_with_nullable_date(self):
        """
        unique_for_date/year/month checks shouldn't trigger when the
        associated DateField is None.
        """
        FlexibleDatePost.objects.create(
            title="Django 1.0 is released",
            slug="Django 1.0",
            subtitle="Finally",
            posted=datetime.date(2008, 9, 3),
        )
        p = FlexibleDatePost(title="Django 1.0 is released")
        p.full_clean()

        p = FlexibleDatePost(slug="Django 1.0")
        p.full_clean()

        p = FlexibleDatePost(subtitle="Finally")
        p.full_clean()

    def test_unique_errors(self):
        UniqueErrorsModel.objects.create(name="Some Name", no=10)
        m = UniqueErrorsModel(name="Some Name", no=11)
        with self.assertRaises(ValidationError) as cm:
            m.full_clean()
        self.assertEqual(
            cm.exception.message_dict, {"name": ["Custom unique name message."]}
        )

        m = UniqueErrorsModel(name="Some Other Name", no=10)
        with self.assertRaises(ValidationError) as cm:
            m.full_clean()
        self.assertEqual(
            cm.exception.message_dict, {"no": ["Custom unique number message."]}
        )
