import unittest

import precis_i18n
from precis_i18n import get_profile
from precis_i18n.unicode import UnicodeData


class TestGetProfile(unittest.TestCase):
    def test_missing(self):
        with self.assertRaises(KeyError):
            get_profile("_does_not_exist_")

    def test_unicodedata_arg(self):
        import unicodedata

        profile = get_profile("UsernameCasePreserved", unicodedata=unicodedata)
        self.assertEqual(profile.enforce("E\u0301\u0301\u0301"), "\u00c9\u0301\u0301")


class TestUsernameCasePreserved(unittest.TestCase):
    def test_enforce(self):
        profile = get_profile("UsernameCasePreserved")
        self.assertEqual(profile.enforce("Juliet"), "Juliet")
        self.assertEqual(profile.enforce("J*"), "J*")
        self.assertEqual(profile.enforce("E\u0301\u0301\u0301"), "\u00c9\u0301\u0301")
        self.assertEqual(profile.enforce(b"Juliet"), "Juliet")

        self.profile_fail(profile, "", "empty")
        self.profile_fail(profile, " J", "spaces")
        self.profile_fail(profile, "\u05d0*", "bidi_rule")

    def profile_fail(self, profile, value, reason):
        with self.assertRaisesRegex(UnicodeEncodeError, reason):
            profile.enforce(value)

    def test_invalid_argument(self):
        profile = get_profile("UsernameCasePreserved")
        with self.assertRaisesRegex(ValueError, "not a string"):
            profile.enforce(1)

    def test_identifier_oddities(self):
        # Make a list of all codepoints < 10,000 which are allowed in the
        # UsernameCasePreserved profile even though they are not allowed in
        # IdentifierClass.
        profile = get_profile("UsernameCasePreserved")
        allowed = []
        for cp in range(0, 10000):
            try:
                profile.enforce(chr(cp))
                try:
                    profile.base.enforce(chr(cp))
                except UnicodeEncodeError:
                    allowed.append(cp)
            except UnicodeEncodeError:
                pass
        self.assertEqual(
            allowed,
            [
                832,
                833,
                835,
                836,
                884,
                894,
                2392,
                2393,
                2394,
                2395,
                2396,
                2397,
                2398,
                2399,
                2524,
                2525,
                2527,
                2611,
                2614,
                2649,
                2650,
                2651,
                2654,
                2908,
                2909,
                3907,
                3917,
                3922,
                3927,
                3932,
                3945,
                3955,
                3957,
                3958,
                3960,
                3969,
                3987,
                3997,
                4002,
                4007,
                4012,
                4025,
                8049,
                8051,
                8053,
                8055,
                8057,
                8059,
                8061,
                8123,
                8126,
                8137,
                8139,
                8147,
                8155,
                8163,
                8171,
                8175,
                8185,
                8187,
                8486,
                8490,
                8491,
            ],
        )


class TestUsernameCaseMapped(unittest.TestCase):
    def test_enforce(self):
        profile = get_profile("UsernameCaseMapped")
        self.assertEqual(profile.enforce("Juliet"), "juliet")
        self.assertEqual(profile.enforce("E\u0301\u0301\u0301"), "\u00e9\u0301\u0301")


class TestNickname(unittest.TestCase):
    def test_enforce(self):
        profile = get_profile("Nickname")
        self.assertEqual(profile.enforce("Juliet"), "juliet")
        self.assertEqual(profile.enforce("E\u0301\u0301\u0301"), "\u00e9\u0301\u0301")
        self.assertEqual(profile.enforce("\u03d4"), "\u03cb")


class TestNicknameCaseMapped(unittest.TestCase):
    def test_enforce(self):
        profile = get_profile("NicknameCaseMapped:ToLower")
        self.assertEqual(profile.enforce("Juliet"), "juliet")
        self.assertEqual(profile.enforce("E\u0301\u0301\u0301"), "\u00e9\u0301\u0301")
        self.assertEqual(profile.enforce("\u03d4"), "\u03cb")


class TestUsername(unittest.TestCase):
    def test_constructor(self):
        profile = precis_i18n.profile.Username(UnicodeData(), "name", "lower")
        self.assertEqual(profile.enforce("Fu\u00dfball"), "fu\u00dfball")

    def test_constructor_fail(self):
        with self.assertRaises(ValueError):
            precis_i18n.profile.Username(UnicodeData(), "name", "unsupported-arg")