from unittest.mock import Mock

from django.contrib.auth import get_user_model
from django.core.exceptions import ValidationError
from django.test import TestCase

from misago.users.models import Ban
from misago.users.validators import (
    validate_email,
    validate_email_available,
    validate_email_banned,
    validate_gmail_email,
    validate_username,
    validate_username_available,
    validate_username_banned,
    validate_username_content,
    validate_username_length,
)


User = get_user_model()


class ValidateEmailAvailableTests(TestCase):
    def setUp(self):
        self.test_user = User.objects.create_user(
            "EricTheFish", "eric@test.com", "pass123"
        )

    def test_valid_email(self):
        """validate_email_available allows available emails"""
        validate_email_available("bob@boberson.com")
        validate_email_available(self.test_user.email, exclude=self.test_user)

    def test_invalid_email(self):
        """validate_email_available disallows unvailable emails"""
        with self.assertRaises(ValidationError):
            validate_email_available(self.test_user.email)


class ValidateEmailBannedTests(TestCase):
    def setUp(self):
        Ban.objects.create(check_type=Ban.EMAIL, banned_value="ban@test.com")

    def test_unbanned_name(self):
        """unbanned email passes validation"""
        validate_email_banned("noban@test.com")

    def test_banned_name(self):
        """banned email fails validation"""
        with self.assertRaises(ValidationError):
            validate_email_banned("ban@test.com")


class ValidateEmailTests(TestCase):
    def test_validate_email(self):
        """validate_email has no crashes"""
        validate_email("bob@boberson.com")
        with self.assertRaises(ValidationError):
            validate_email("*")


class ValidateUsernameTests(TestCase):
    def test_validate_username(self):
        """validate_username has no crashes"""
        settings = Mock(username_length_min=1, username_length_max=5)
        validate_username(settings, "LeBob")
        with self.assertRaises(ValidationError):
            validate_username(settings, "*")


class ValidateUsernameAvailableTests(TestCase):
    def setUp(self):
        self.test_user = User.objects.create_user("EricTheFish", "eric@test.com")

    def test_valid_name(self):
        """validate_username_available allows available names"""
        validate_username_available("BobBoberson")
        validate_username_available(self.test_user.username, exclude=self.test_user)

    def test_invalid_name(self):
        """validate_username_available disallows unvailable names"""
        with self.assertRaises(ValidationError):
            validate_username_available(self.test_user.username)


class ValidateUsernameBannedTests(TestCase):
    def setUp(self):
        Ban.objects.create(check_type=Ban.USERNAME, banned_value="Bob")

    def test_unbanned_name(self):
        """unbanned name passes validation"""
        validate_username_banned("Luke")

    def test_banned_name(self):
        """banned name fails validation"""
        with self.assertRaises(ValidationError):
            validate_username_banned("Bob")


class ValidateUsernameContentTests(TestCase):
    def test_valid_name(self):
        """validate_username_content allows valid names"""
        validate_username_content("123")
        validate_username_content("Bob")
        validate_username_content("Bob123")

    def test_invalid_name(self):
        """validate_username_content disallows invalid names"""
        with self.assertRaises(ValidationError):
            validate_username_content("!")
        with self.assertRaises(ValidationError):
            validate_username_content("Bob!")
        with self.assertRaises(ValidationError):
            validate_username_content("Bob Boberson")
        with self.assertRaises(ValidationError):
            validate_username_content("Rafał")
        with self.assertRaises(ValidationError):
            validate_username_content("初音 ミク")


class ValidateUsernameLengthTests(TestCase):
    def test_valid_name(self):
        """validate_username_length allows valid names"""
        settings = Mock(username_length_min=1, username_length_max=5)
        validate_username_length(settings, "a" * settings.username_length_min)
        validate_username_length(settings, "a" * settings.username_length_max)

    def test_invalid_name(self):
        """validate_username_length disallows invalid names"""
        settings = Mock(username_length_min=1, username_length_max=5)
        with self.assertRaises(ValidationError):
            validate_username_length(settings, "a" * (settings.username_length_min - 1))
        with self.assertRaises(ValidationError):
            validate_username_length(settings, "a" * (settings.username_length_max + 1))


class ValidateGmailEmailTests(TestCase):
    def test_validate_gmail_email(self):
        """validate_gmail_email spots spammy gmail address"""
        added_errors = {}

        def add_errors(field_name, errors):
            added_errors[field_name] = errors

        validate_gmail_email(None, {}, add_errors)
        validate_gmail_email(None, {"email": "invalid-email"}, add_errors)
        validate_gmail_email(None, {"email": "the.bob.boberson@gmail.com"}, add_errors)
        validate_gmail_email(
            None, {"email": "the.bob.boberson@hotmail.com"}, add_errors
        )

        self.assertFalse(added_errors)

        validate_gmail_email(
            None, {"email": "the.b.o.b.b.ob.e.r.son@gmail.com"}, add_errors
        )
        self.assertTrue(added_errors)