"""Tests for user models"""

from django.test import TestCase
from faker import Faker

from .factories import ProfileFactory, UserFactory

fake = Faker("ru_RU")


class UserModelTest(TestCase):
    """Tests for User model"""

    def setUp(self):
        self.user = UserFactory.create_user()
        self.superuser = UserFactory.create_superuser()

    def test_user_creation(self):
        """Test user creation"""
        self.assertTrue(self.user.email)
        self.assertTrue(self.user.username)

    def test_user_str_representation(self):
        """Test user string representation"""
        expected = f"{self.user.username} ({self.user.email})"
        self.assertEqual(str(self.user), expected)

    def test_superuser_creation(self):
        """Test superuser creation"""
        self.assertTrue(self.superuser.is_staff)
        self.assertTrue(self.superuser.is_superuser)

    def test_user_email_unique(self):
        """Test email field is unique"""
        self.assertTrue(self.user._meta.get_field("email").unique)

    def test_user_username_required(self):
        """Test username is required field"""
        self.assertFalse(self.user._meta.get_field("username").blank)

    def test_user_phone_optional(self):
        """Test phone field is optional"""
        phone_field = self.user._meta.get_field("phone")
        self.assertTrue(phone_field.blank)
        self.assertTrue(phone_field.null)

    def test_user_is_verified_default_false(self):
        """Test is_verified defaults to False"""
        field = self.user._meta.get_field("is_verified")
        self.assertFalse(field.default)


class ProfileModelTest(TestCase):
    """Tests for Profile model"""

    def setUp(self):
        # Создаём профиль через фабрику с заполненными данными
        self.user = UserFactory.create_user()
        self.profile = ProfileFactory.create_profile(user=self.user)

    def test_profile_creation(self):
        """Test profile creation"""
        self.assertIsNotNone(self.profile.user)
        # Проверяем, что профиль связан с пользователем
        self.assertEqual(self.profile.user, self.user)
        # Проверяем, что имена заполнены faker'ом
        self.assertIsNotNone(self.profile.first_name)
        self.assertIsNotNone(self.profile.last_name)
        self.assertTrue(len(self.profile.first_name) > 0)
        self.assertTrue(len(self.profile.last_name) > 0)

    def test_profile_str_representation(self):
        """Test profile string representation"""
        expected = f"Profile of {self.profile.user.username}"
        self.assertEqual(str(self.profile), expected)

    def test_profile_one_to_one_relationship(self):
        """Test OneToOne relationship with User"""
        self.assertIsNotNone(self.profile.user)

    def test_profile_first_name_optional(self):
        """Test first_name field is optional"""
        field = self.profile._meta.get_field("first_name")
        self.assertTrue(field.blank)
        self.assertTrue(field.null)

    def test_profile_last_name_optional(self):
        """Test last_name field is optional"""
        field = self.profile._meta.get_field("last_name")
        self.assertTrue(field.blank)
        self.assertTrue(field.null)

    def test_profile_bio_optional(self):
        """Test bio field is optional"""
        field = self.profile._meta.get_field("bio")
        self.assertTrue(field.blank)
        self.assertTrue(field.null)

    def test_profile_avatar_optional(self):
        """Test avatar field is optional"""
        field = self.profile._meta.get_field("avatar")
        self.assertTrue(field.blank)
        self.assertTrue(field.null)

    def test_profile_date_of_birth_optional(self):
        """Test date_of_birth field is optional"""
        field = self.profile._meta.get_field("date_of_birth")
        self.assertTrue(field.blank)
        self.assertTrue(field.null)

    def test_profile_full_name_property(self):
        """Test full_name property"""
        # Test with both names
        first_name = fake.first_name()
        last_name = fake.last_name()
        self.profile.first_name = first_name
        self.profile.last_name = last_name
        self.assertEqual(self.profile.full_name, f"{first_name} {last_name}")

        # Test with only first name
        self.profile.last_name = ""
        self.assertEqual(self.profile.full_name, first_name)

        # Test with only last name
        self.profile.first_name = ""
        self.profile.last_name = last_name
        self.assertEqual(self.profile.full_name, last_name)

        # Test with no names (fallback to username)
        self.profile.first_name = ""
        self.profile.last_name = ""
        self.assertEqual(self.profile.full_name, self.profile.user.username)