"""
Tests for user deletion while preserving submissions.
"""

from django.test import TestCase
from django.db import transaction
from apps.accounts.services import UserDeletionService
from apps.accounts.models import User, UserProfile


class UserDeletionServiceTest(TestCase):
    """Test cases for UserDeletionService."""

    def setUp(self):
        """Set up test data."""
        # Create test users
        self.user = User.objects.create_user(
            username="testuser", email="test@example.com", password="testpass123"
        )

        self.admin_user = User.objects.create_user(
            username="admin",
            email="admin@example.com",
            password="adminpass123",
            is_superuser=True,
        )

        # Create user profiles
        UserProfile.objects.create(
            user=self.user, display_name="Test User", bio="Test bio"
        )

        UserProfile.objects.create(
            user=self.admin_user, display_name="Admin User", bio="Admin bio"
        )

    def test_get_or_create_deleted_user(self):
        """Test that deleted user placeholder is created correctly."""
        deleted_user = UserDeletionService.get_or_create_deleted_user()

        self.assertEqual(deleted_user.username, "deleted_user")
        self.assertEqual(deleted_user.email, "deleted@thrillwiki.com")
        self.assertFalse(deleted_user.is_active)
        self.assertTrue(deleted_user.is_banned)
        self.assertEqual(deleted_user.role, User.Roles.USER)

        # Check profile was created
        self.assertTrue(hasattr(deleted_user, "profile"))
        self.assertEqual(deleted_user.profile.display_name, "Deleted User")

    def test_get_or_create_deleted_user_idempotent(self):
        """Test that calling get_or_create_deleted_user multiple times returns same user."""
        deleted_user1 = UserDeletionService.get_or_create_deleted_user()
        deleted_user2 = UserDeletionService.get_or_create_deleted_user()

        self.assertEqual(deleted_user1.id, deleted_user2.id)
        self.assertEqual(User.objects.filter(username="deleted_user").count(), 1)

    def test_can_delete_user_normal_user(self):
        """Test that normal users can be deleted."""
        can_delete, reason = UserDeletionService.can_delete_user(self.user)

        self.assertTrue(can_delete)
        self.assertIsNone(reason)

    def test_can_delete_user_superuser(self):
        """Test that superusers cannot be deleted."""
        can_delete, reason = UserDeletionService.can_delete_user(self.admin_user)

        self.assertFalse(can_delete)
        self.assertEqual(reason, "Cannot delete superuser accounts")

    def test_can_delete_user_deleted_user_placeholder(self):
        """Test that deleted user placeholder cannot be deleted."""
        deleted_user = UserDeletionService.get_or_create_deleted_user()
        can_delete, reason = UserDeletionService.can_delete_user(deleted_user)

        self.assertFalse(can_delete)
        self.assertEqual(reason, "Cannot delete the system deleted user placeholder")

    def test_delete_user_preserve_submissions_no_submissions(self):
        """Test deleting user with no submissions."""
        user_id = self.user.user_id
        username = self.user.username

        result = UserDeletionService.delete_user_preserve_submissions(self.user)

        # Check user was deleted
        self.assertFalse(User.objects.filter(user_id=user_id).exists())

        # Check result structure
        self.assertIn("deleted_user", result)
        self.assertIn("preserved_submissions", result)
        self.assertIn("transferred_to", result)

        self.assertEqual(result["deleted_user"]["username"], username)
        self.assertEqual(result["deleted_user"]["user_id"], user_id)

        # All submission counts should be 0
        for count in result["preserved_submissions"].values():
            self.assertEqual(count, 0)

    def test_delete_user_cannot_delete_deleted_user_placeholder(self):
        """Test that attempting to delete the deleted user placeholder raises error."""
        deleted_user = UserDeletionService.get_or_create_deleted_user()

        with self.assertRaises(ValueError) as context:
            UserDeletionService.delete_user_preserve_submissions(deleted_user)

        self.assertIn(
            "Cannot delete the system deleted user placeholder", str(context.exception)
        )

    def test_delete_user_with_submissions_transfers_correctly(self):
        """Test that user submissions are transferred to deleted user placeholder."""
        # This test would require creating park/ride data which is complex
        # For now, we'll test the basic functionality

        # Create deleted user first to ensure it exists
        UserDeletionService.get_or_create_deleted_user()

        # Delete the test user
        result = UserDeletionService.delete_user_preserve_submissions(self.user)

        # Verify the deleted user placeholder still exists
        self.assertTrue(User.objects.filter(username="deleted_user").exists())

        # Verify result structure
        self.assertIn("deleted_user", result)
        self.assertIn("preserved_submissions", result)
        self.assertIn("transferred_to", result)

        self.assertEqual(result["transferred_to"]["username"], "deleted_user")

    def test_delete_user_atomic_transaction(self):
        """Test that user deletion is atomic."""
        # This test ensures that if something goes wrong during deletion,
        # the transaction is rolled back

        original_user_count = User.objects.count()

        # Mock a failure during the deletion process
        with self.assertRaises(Exception):
            with transaction.atomic():
                # Start the deletion process
                UserDeletionService.get_or_create_deleted_user()

                # Simulate an error
                raise Exception("Simulated error during deletion")

        # Verify user count hasn't changed
        self.assertEqual(User.objects.count(), original_user_count)

        # Verify our test user still exists
        self.assertTrue(User.objects.filter(user_id=self.user.user_id).exists())