from django.test import TestCase
from django.contrib.auth import get_user_model
from django.db import IntegrityError
from django.conf import settings
import uuid


User = get_user_model()


class UserModelTests(TestCase):

    def setUp(self):
        self.user_data = {
            'email_address': 'Test@Example.com',
            'first_name': 'Test',
            'last_name': 'User',
            'date_of_birth': '1990-01-01',
        }

    def test_create_user_and_properties(self):
        user = User.objects.create_user(password='pass1234', **self.user_data)
        self.assertIsNotNone(user.pk)
        self.assertEqual(user.email_address, 'Test@example.com')
        self.assertEqual(user.full_name, 'Test User')

    def test_create_superuser(self):
        su = User.objects.create_superuser(password='adminpass', **self.user_data)
        self.assertTrue(su.is_staff)
        self.assertIsNotNone(su.pk)
        self.assertTrue(su.is_active)

    def test_password_hashed_and_check(self):
        user = User.objects.create_user(email_address='hashme@example.com', password='secret123')
        self.assertNotEqual(user.password, 'secret123')
        self.assertTrue(user.check_password('secret123'))

    def test_uuid_and_id_auto_populated(self):
        u1 = User.objects.create_user(email_address='one@example.com', password='p')
        u2 = User.objects.create_user(email_address='two@example.com', password='p')
        self.assertIsNotNone(u1.uuid)
        self.assertIsInstance(u1.uuid, uuid.UUID)
        self.assertNotEqual(u1.uuid, u2.uuid)
        self.assertIsNotNone(u1.id)
        self.assertIsNotNone(u2.id)

    def test_default_fields(self):
        u = User.objects.create_user(email_address='defaults@example.com', password='p')
        self.assertEqual(u.bio, "")
        self.assertEqual(u.timezone, settings.TIME_ZONE)
        self.assertEqual(u.avatar_url, "")
        self.assertTrue(u.is_active)
        self.assertFalse(u.is_staff)

    def test_unique_email_constraint(self):
        User.objects.create_user(email_address='dup@example.com', password='p')
        with self.assertRaises(IntegrityError):
            User.objects.create_user(email_address='dup@example.com', password='p')

    def test_create_user_without_email_raises(self):
        with self.assertRaises(ValueError):
            User.objects.create_user(email_address='', password='p')

    def test_date_of_birth_optional(self):
        u = User.objects.create_user(email_address='nodob@example.com', password='p')
        self.assertIsNone(u.date_of_birth)

    def test_str_and_full_name(self):
        u = User.objects.create_user(
            email_address='name@example.com',
            password='p',
            first_name='A',
            last_name='B'
        )
        self.assertEqual(u.full_name, 'A B')
        self.assertEqual(str(u), 'A B')

    def test_email_normalization_domain_lowercase(self):
        user1 = User.objects.create_user(email_address='Test@EXAMPLE.COM', password='p')
        self.assertEqual(user1.email_address, 'Test@example.com')
        user2 = User.objects.create_user(email_address='test@EXAMPLE.COM', password='p2')
        self.assertEqual(user2.email_address, 'test@example.com')
        self.assertNotEqual(user1.email_address, user2.email_address)

    def test_superuser_must_have_is_staff(self):
        with self.assertRaises(ValueError):
            User.objects.create_superuser(
                email_address='fail@example.com',
                password='p',
                is_staff=False
            )

    def test_role_default_is_employee(self):
        u = User.objects.create_user(email_address='role@example.com', password='p')
        self.assertEqual(u.role, User.Roles.EMPLOYEE)

    def test_role_choices(self):
        u = User.objects.create_user(
            email_address='manager@example.com',
            password='p',
            role=User.Roles.MANAGER
        )
        self.assertEqual(u.role, User.Roles.MANAGER)

    def test_timestamps_auto_set(self):
        from datetime import timedelta
        u = User.objects.create_user(email_address='timestamps@example.com', password='p')
        self.assertIsNotNone(u.created_at)
        self.assertIsNotNone(u.updated_at)
        time_diff = abs((u.updated_at - u.created_at).total_seconds())
        self.assertLess(time_diff, 1.0)

    def test_has_perm_returns_true(self):
        u = User.objects.create_user(email_address='perm@example.com', password='p')
        self.assertTrue(u.has_perm('any.permission'))
        self.assertTrue(u.has_perm('another.permission', obj=None))

    def test_has_module_perms_returns_true(self):
        u = User.objects.create_user(email_address='modperm@example.com', password='p')
        self.assertTrue(u.has_module_perms('auth'))
        self.assertTrue(u.has_module_perms('users'))