from datetime import datetime
from decimal import Decimal

from django import forms
from django.conf import settings
from django.contrib import admin
from django.contrib.admin import helpers
from django.contrib.admin.utils import (
    NestedObjects, display_for_field, display_for_value, flatten,
    flatten_fieldsets, help_text_for_field, label_for_field, lookup_field,
    quote,
)
from django.db import DEFAULT_DB_ALIAS, models
from django.test import SimpleTestCase, TestCase, override_settings
from django.utils.formats import localize
from django.utils.safestring import mark_safe

from .models import (
    Article, Car, Count, Event, EventGuide, Location, Site, Vehicle,
)


class NestedObjectsTests(TestCase):
    """
    Tests for ``NestedObject`` utility collection.
    """
    @classmethod
    def setUpTestData(cls):
        cls.n = NestedObjects(using=DEFAULT_DB_ALIAS)
        cls.objs = [Count.objects.create(num=i) for i in range(5)]

    def _check(self, target):
        self.assertEqual(self.n.nested(lambda obj: obj.num), target)

    def _connect(self, i, j):
        self.objs[i].parent = self.objs[j]
        self.objs[i].save()

    def _collect(self, *indices):
        self.n.collect([self.objs[i] for i in indices])

    def test_unrelated_roots(self):
        self._connect(2, 1)
        self._collect(0)
        self._collect(1)
        self._check([0, 1, [2]])

    def test_siblings(self):
        self._connect(1, 0)
        self._connect(2, 0)
        self._collect(0)
        self._check([0, [1, 2]])

    def test_non_added_parent(self):
        self._connect(0, 1)
        self._collect(0)
        self._check([0])

    def test_cyclic(self):
        self._connect(0, 2)
        self._connect(1, 0)
        self._connect(2, 1)
        self._collect(0)
        self._check([0, [1, [2]]])

    def test_queries(self):
        self._connect(1, 0)
        self._connect(2, 0)
        # 1 query to fetch all children of 0 (1 and 2)
        # 1 query to fetch all children of 1 and 2 (none)
        # Should not require additional queries to populate the nested graph.
        self.assertNumQueries(2, self._collect, 0)

    def test_on_delete_do_nothing(self):
        """
        The nested collector doesn't query for DO_NOTHING objects.
        """
        n = NestedObjects(using=DEFAULT_DB_ALIAS)
        objs = [Event.objects.create()]
        EventGuide.objects.create(event=objs[0])
        with self.assertNumQueries(2):
            # One for Location, one for Guest, and no query for EventGuide
            n.collect(objs)

    def test_relation_on_abstract(self):
        """
        NestedObjects.collect() doesn't trip (AttributeError) on the special
        notation for relations on abstract models (related_name that contains
        %(app_label)s and/or %(class)s) (#21846).
        """
        n = NestedObjects(using=DEFAULT_DB_ALIAS)
        Car.objects.create()
        n.collect([Vehicle.objects.first()])


class UtilsTests(SimpleTestCase):

    empty_value = '-empty-'

    def test_values_from_lookup_field(self):
        """
        Regression test for #12654: lookup_field
        """
        SITE_NAME = 'example.com'
        TITLE_TEXT = 'Some title'
        CREATED_DATE = datetime.min
        ADMIN_METHOD = 'admin method'
        SIMPLE_FUNCTION = 'function'
        INSTANCE_ATTRIBUTE = 'attr'

        class MockModelAdmin:
            def get_admin_value(self, obj):
                return ADMIN_METHOD

        def simple_function(obj):
            return SIMPLE_FUNCTION

        site_obj = Site(domain=SITE_NAME)
        article = Article(
            site=site_obj,
            title=TITLE_TEXT,
            created=CREATED_DATE,
        )
        article.non_field = INSTANCE_ATTRIBUTE

        verifications = (
            ('site', SITE_NAME),
            ('created', localize(CREATED_DATE)),
            ('title', TITLE_TEXT),
            ('get_admin_value', ADMIN_METHOD),
            (simple_function, SIMPLE_FUNCTION),
            ('test_from_model', article.test_from_model()),
            ('non_field', INSTANCE_ATTRIBUTE)
        )

        mock_admin = MockModelAdmin()
        for name, value in verifications:
            field, attr, resolved_value = lookup_field(name, article, mock_admin)

            if field is not None:
                resolved_value = display_for_field(resolved_value, field, self.empty_value)

            self.assertEqual(value, resolved_value)

    def test_null_display_for_field(self):
        """
        Regression test for #12550: display_for_field should handle None
        value.
        """
        display_value = display_for_field(None, models.CharField(), self.empty_value)
        self.assertEqual(display_value, self.empty_value)

        display_value = display_for_field(None, models.CharField(
            choices=(
                (None, "test_none"),
            )
        ), self.empty_value)
        self.assertEqual(display_value, "test_none")

        display_value = display_for_field(None, models.DateField(), self.empty_value)
        self.assertEqual(display_value, self.empty_value)

        display_value = display_for_field(None, models.TimeField(), self.empty_value)
        self.assertEqual(display_value, self.empty_value)

        # Regression test for #13071: NullBooleanField has special
        # handling.
        display_value = display_for_field(None, models.NullBooleanField(), self.empty_value)
        expected = '<img src="%sadmin/img/icon-unknown.svg" alt="None">' % settings.STATIC_URL
        self.assertHTMLEqual(display_value, expected)

        display_value = display_for_field(None, models.BooleanField(null=True), self.empty_value)
        expected = '<img src="%sadmin/img/icon-unknown.svg" alt="None" />' % settings.STATIC_URL
        self.assertHTMLEqual(display_value, expected)

        display_value = display_for_field(None, models.DecimalField(), self.empty_value)
        self.assertEqual(display_value, self.empty_value)

        display_value = display_for_field(None, models.FloatField(), self.empty_value)
        self.assertEqual(display_value, self.empty_value)

        display_value = display_for_field(None, models.JSONField(), self.empty_value)
        self.assertEqual(display_value, self.empty_value)

    def test_json_display_for_field(self):
        tests = [
            ({'a': {'b': 'c'}}, '{"a": {"b": "c"}}'),
            (['a', 'b'], '["a", "b"]'),
            ('a', '"a"'),
            ({'a': '你好 世界'}, '{"a": "你好 世界"}'),
            ({('a', 'b'): 'c'}, "{('a', 'b'): 'c'}"),  # Invalid JSON.
        ]
        for value, display_value in tests:
            with self.subTest(value=value):
                self.assertEqual(
                    display_for_field(value, models.JSONField(), self.empty_value),
                    display_value,
                )

    def test_number_formats_display_for_field(self):
        display_value = display_for_field(12345.6789, models.FloatField(), self.empty_value)
        self.assertEqual(display_value, '12345.6789')

        display_value = display_for_field(Decimal('12345.6789'), models.DecimalField(), self.empty_value)
        self.assertEqual(display_value, '12345.6789')

        display_value = display_for_field(12345, models.IntegerField(), self.empty_value)
        self.assertEqual(display_value, '12345')

    @override_settings(USE_L10N=True, USE_THOUSAND_SEPARATOR=True)
    def test_number_formats_with_thousand_separator_display_for_field(self):
        display_value = display_for_field(12345.6789, models.FloatField(), self.empty_value)
        self.assertEqual(display_value, '12,345.6789')

        display_value = display_for_field(Decimal('12345.6789'), models.DecimalField(), self.empty_value)
        self.assertEqual(display_value, '12,345.6789')

        display_value = display_for_field(12345, models.IntegerField(), self.empty_value)
        self.assertEqual(display_value, '12,345')

    def test_list_display_for_value(self):
        display_value = display_for_value([1, 2, 3], self.empty_value)
        self.assertEqual(display_value, '1, 2, 3')

        display_value = display_for_value([1, 2, 'buckle', 'my', 'shoe'], self.empty_value)
        self.assertEqual(display_value, '1, 2, buckle, my, shoe')

    @override_settings(USE_L10N=True, USE_THOUSAND_SEPARATOR=True)
    def test_list_display_for_value_boolean(self):
        self.assertEqual(
            display_for_value(True, '', boolean=True),
            '<img src="/static/admin/img/icon-yes.svg" alt="True">'
        )
        self.assertEqual(
            display_for_value(False, '', boolean=True),
            '<img src="/static/admin/img/icon-no.svg" alt="False">'
        )
        self.assertEqual(display_for_value(True, ''), 'True')
        self.assertEqual(display_for_value(False, ''), 'False')

    def test_label_for_field(self):
        """
        Tests for label_for_field
        """
        self.assertEqual(
            label_for_field("title", Article),
            "title"
        )
        self.assertEqual(
            label_for_field("hist", Article),
            "History"
        )
        self.assertEqual(
            label_for_field("hist", Article, return_attr=True),
            ("History", None)
        )

        self.assertEqual(
            label_for_field("__str__", Article),
            "article"
        )

        with self.assertRaisesMessage(AttributeError, "Unable to lookup 'unknown' on Article"):
            label_for_field("unknown", Article)

        def test_callable(obj):
            return "nothing"
        self.assertEqual(
            label_for_field(test_callable, Article),
            "Test callable"
        )
        self.assertEqual(
            label_for_field(test_callable, Article, return_attr=True),
            ("Test callable", test_callable)
        )

        self.assertEqual(
            label_for_field("test_from_model", Article),
            "Test from model"
        )
        self.assertEqual(
            label_for_field("test_from_model", Article, return_attr=True),
            ("Test from model", Article.test_from_model)
        )
        self.assertEqual(
            label_for_field("test_from_model_with_override", Article),
            "not What you Expect"
        )

        self.assertEqual(
            label_for_field(lambda x: "nothing", Article),
            "--"
        )
        self.assertEqual(label_for_field('site_id', Article), 'Site id')

        class MockModelAdmin:
            @admin.display(description='not Really the Model')
            def test_from_model(self, obj):
                return "nothing"

        self.assertEqual(
            label_for_field("test_from_model", Article, model_admin=MockModelAdmin),
            "not Really the Model"
        )
        self.assertEqual(
            label_for_field("test_from_model", Article, model_admin=MockModelAdmin, return_attr=True),
            ("not Really the Model", MockModelAdmin.test_from_model)
        )

    def test_label_for_field_form_argument(self):
        class ArticleForm(forms.ModelForm):
            extra_form_field = forms.BooleanField()

            class Meta:
                fields = '__all__'
                model = Article

        self.assertEqual(
            label_for_field('extra_form_field', Article, form=ArticleForm()),
            'Extra form field'
        )
        msg = "Unable to lookup 'nonexistent' on Article or ArticleForm"
        with self.assertRaisesMessage(AttributeError, msg):
            label_for_field('nonexistent', Article, form=ArticleForm()),

    def test_label_for_property(self):
        class MockModelAdmin:
            @property
            @admin.display(description='property short description')
            def test_from_property(self):
                return "this if from property"

        self.assertEqual(
            label_for_field("test_from_property", Article, model_admin=MockModelAdmin),
            'property short description'
        )

    def test_help_text_for_field(self):
        tests = [
            ('article', ''),
            ('unknown', ''),
            ('hist', 'History help text'),
        ]
        for name, help_text in tests:
            with self.subTest(name=name):
                self.assertEqual(help_text_for_field(name, Article), help_text)

    def test_related_name(self):
        """
        Regression test for #13963
        """
        self.assertEqual(
            label_for_field('location', Event, return_attr=True),
            ('location', None),
        )
        self.assertEqual(
            label_for_field('event', Location, return_attr=True),
            ('awesome event', None),
        )
        self.assertEqual(
            label_for_field('guest', Event, return_attr=True),
            ('awesome guest', None),
        )

    def test_safestring_in_field_label(self):
        # safestring should not be escaped
        class MyForm(forms.Form):
            text = forms.CharField(label=mark_safe('<i>text</i>'))
            cb = forms.BooleanField(label=mark_safe('<i>cb</i>'))

        form = MyForm()
        self.assertHTMLEqual(helpers.AdminField(form, 'text', is_first=False).label_tag(),
                             '<label for="id_text" class="required inline"><i>text</i>:</label>')
        self.assertHTMLEqual(helpers.AdminField(form, 'cb', is_first=False).label_tag(),
                             '<label for="id_cb" class="vCheckboxLabel required inline"><i>cb</i></label>')

        # normal strings needs to be escaped
        class MyForm(forms.Form):
            text = forms.CharField(label='&text')
            cb = forms.BooleanField(label='&cb')

        form = MyForm()
        self.assertHTMLEqual(helpers.AdminField(form, 'text', is_first=False).label_tag(),
                             '<label for="id_text" class="required inline">&amp;text:</label>')
        self.assertHTMLEqual(helpers.AdminField(form, 'cb', is_first=False).label_tag(),
                             '<label for="id_cb" class="vCheckboxLabel required inline">&amp;cb</label>')

    def test_flatten(self):
        flat_all = ['url', 'title', 'content', 'sites']
        inputs = (
            ((), []),
            (('url', 'title', ('content', 'sites')), flat_all),
            (('url', 'title', 'content', 'sites'), flat_all),
            ((('url', 'title'), ('content', 'sites')), flat_all)
        )
        for orig, expected in inputs:
            self.assertEqual(flatten(orig), expected)

    def test_flatten_fieldsets(self):
        """
        Regression test for #18051
        """
        fieldsets = (
            (None, {
                'fields': ('url', 'title', ('content', 'sites'))
            }),
        )
        self.assertEqual(flatten_fieldsets(fieldsets), ['url', 'title', 'content', 'sites'])

        fieldsets = (
            (None, {
                'fields': ('url', 'title', ['content', 'sites'])
            }),
        )
        self.assertEqual(flatten_fieldsets(fieldsets), ['url', 'title', 'content', 'sites'])

    def test_quote(self):
        self.assertEqual(quote('something\nor\nother'), 'something_0Aor_0Aother')
