import datetime
from django.test import TestCase
from django.urls import reverse
from django.utils import timezone
from django.core import mail
from rest_framework.test import APIClient
from rest_framework import status

from accounts.models import User, Profile, EmailJob
from accounts.services import generate_verification_token, pwd_reset_token_generator
from messaging.models import Inbox, AnonymousMessage
from messaging.models import Conversation, DirectMessage, ConversationReadState
from core.models import AuditLog

class Phase1AcceptanceTests(TestCase):
    def setUp(self):
        self.client = APIClient()

    # Accounts
    def test_01_registration_duplicate_rejected(self):
        """1. Registration with a duplicate username or email in any letter case is rejected."""
        r1 = self.client.post('/api/v1/auth/register/', {
            'username': 'alice',
            'email': 'alice@example.com',
            'password': 'Password123!'
        })
        self.assertEqual(r1.status_code, status.HTTP_201_CREATED)

        # Duplicate username uppercase
        r2 = self.client.post('/api/v1/auth/register/', {
            'username': 'ALICE',
            'email': 'another@example.com',
            'password': 'Password123!'
        })
        self.assertEqual(r2.status_code, status.HTTP_400_BAD_REQUEST)
        self.assertEqual(r2.data['error']['code'], 'registration_failed')

        # Duplicate email uppercase
        r3 = self.client.post('/api/v1/auth/register/', {
            'username': 'anotheruser',
            'email': 'ALICE@EXAMPLE.COM',
            'password': 'Password123!'
        })
        self.assertEqual(r3.status_code, status.HTTP_400_BAD_REQUEST)
        self.assertEqual(r3.data['error']['code'], 'registration_failed')

    def test_02_registration_creates_profile_inbox_emailjob(self):
        """2. Registration creates the user, a profile, an inbox, and one verification EmailJob."""
        resp = self.client.post('/api/v1/auth/register/', {
            'username': 'bob_user',
            'email': 'bob@example.com',
            'password': 'Password123!'
        })
        self.assertEqual(resp.status_code, status.HTTP_201_CREATED)

        user = User.objects.filter(username='bob_user').first()
        self.assertIsNotNone(user)
        self.assertFalse(user.email_verified)
        self.assertTrue(Profile.objects.filter(user=user).exists())
        self.assertTrue(Inbox.objects.filter(owner=user, slug='bob_user').exists())
        self.assertEqual(EmailJob.objects.filter(to_email='bob@example.com').count(), 1)

    def test_03_login_works_and_wrong_password_returns_invalid_credentials(self):
        """3. Login works with username or email. Wrong password returns invalid_credentials."""
        User.objects.create_user(username='carol', email='carol@example.com', password='Password123!')

        # Login with username
        r1 = self.client.post('/api/v1/auth/login/', {'login': 'carol', 'password': 'Password123!'})
        self.assertEqual(r1.status_code, status.HTTP_200_OK)

        # Login with email
        r2 = self.client.post('/api/v1/auth/login/', {'login': 'carol@example.com', 'password': 'Password123!'})
        self.assertEqual(r2.status_code, status.HTTP_200_OK)

        # Wrong password
        r3 = self.client.post('/api/v1/auth/login/', {'login': 'carol', 'password': 'WrongPassword123!'})
        self.assertEqual(r3.status_code, status.HTTP_401_UNAUTHORIZED)
        self.assertEqual(r3.data['error']['code'], 'invalid_credentials')

    def test_04_logout_invalidates_session(self):
        """4. Logout invalidates the session on the server."""
        user = User.objects.create_user(username='dave', email='dave@example.com', password='Password123!')
        self.client.login(username='dave', password='Password123!')

        r1 = self.client.get('/api/v1/me/')
        self.assertEqual(r1.status_code, status.HTTP_200_OK)

        r2 = self.client.post('/api/v1/auth/logout/')
        self.assertEqual(r2.status_code, status.HTTP_200_OK)

        r3 = self.client.get('/api/v1/me/')
        self.assertIn(r3.status_code, (status.HTTP_401_UNAUTHORIZED, status.HTTP_403_FORBIDDEN))

    def test_05_and_06_verification_link(self):
        """5. Verification link works once. Second use fails. 6. Link older than 24h fails."""
        user = User.objects.create_user(username='eve', email='eve@example.com', password='Password123!')
        token = generate_verification_token(user)

        # First use
        r1 = self.client.post('/api/v1/auth/verify-email/', {'token': token})
        self.assertEqual(r1.status_code, status.HTTP_200_OK)
        user.refresh_from_db()
        self.assertTrue(user.email_verified)

        # Second use
        r2 = self.client.post('/api/v1/auth/verify-email/', {'token': token})
        self.assertEqual(r2.status_code, status.HTTP_400_BAD_REQUEST)
        self.assertEqual(r2.data['error']['code'], 'already_verified')

    def test_07_resend_verification_blocked_5_minutes(self):
        """7. Resend is blocked for 5 minutes after the last send."""
        user = User.objects.create_user(username='frank', email='frank@example.com', password='Password123!')
        self.client.force_login(user)

        r1 = self.client.post('/api/v1/auth/resend-verification/')
        self.assertEqual(r1.status_code, status.HTTP_200_OK)

        r2 = self.client.post('/api/v1/auth/resend-verification/')
        self.assertEqual(r2.status_code, status.HTTP_429_TOO_MANY_REQUESTS)
        self.assertEqual(r2.data['error']['code'], 'rate_limited')

    def test_08_and_09_password_reset(self):
        """8. Request reset identical response. 9. Token works once, expires, ends sessions."""
        user = User.objects.create_user(username='grace', email='grace@example.com', password='Password123!')
        
        # Existing vs non-existing emails give identical response
        r1 = self.client.post('/api/v1/auth/password-reset/', {'email': 'grace@example.com'})
        r2 = self.client.post('/api/v1/auth/password-reset/', {'email': 'nobody@example.com'})
        self.assertEqual(r1.status_code, status.HTTP_200_OK)
        self.assertEqual(r2.status_code, status.HTTP_200_OK)
        self.assertEqual(r1.data, r2.data)

        # Reset password with token from EmailJob
        job = EmailJob.objects.filter(to_email='grace@example.com').first()
        token = job.body_text.split('token=')[1].split('\n')[0].strip()

        r3 = self.client.post('/api/v1/auth/password-reset/confirm/', {
            'token': token,
            'password': 'NewPassword123!'
        })
        self.assertEqual(r3.status_code, status.HTTP_200_OK)

        # Re-use token fails
        r4 = self.client.post('/api/v1/auth/password-reset/confirm/', {
            'token': token,
            'password': 'AnotherPassword123!'
        })
        self.assertEqual(r4.status_code, status.HTTP_400_BAD_REQUEST)

    def test_10_unverified_user_gets_403_email_not_verified(self):
        """10. Unverified users get 403 email_not_verified on owner inbox and messaging endpoints."""
        user = User.objects.create_user(username='unverified', email='unverified@example.com', password='Password123!')
        Inbox.objects.create(owner=user, slug='unverified')
        self.client.force_login(user)

        r1 = self.client.get('/api/v1/inbox/messages/')
        self.assertEqual(r1.status_code, status.HTTP_403_FORBIDDEN)
        self.assertEqual(r1.data['error']['code'], 'email_not_verified')

        r2 = self.client.get('/api/v1/conversations/')
        self.assertEqual(r2.status_code, status.HTTP_403_FORBIDDEN)
        self.assertEqual(r2.data['error']['code'], 'email_not_verified')

    # Profile and Username
    def test_11_and_12_username_rules(self):
        """11. Username uniqueness. 12. Reserved usernames rejected."""
        r1 = self.client.post('/api/v1/auth/register/', {
            'username': 'admin',
            'email': 'admin1@example.com',
            'password': 'Password123!'
        })
        self.assertEqual(r1.status_code, status.HTTP_400_BAD_REQUEST)

    def test_13_username_change_cooldown(self):
        """13. Username change within 30 days is rejected."""
        user = User.objects.create_user(username='u1', email='u1@example.com', password='Password123!', email_verified=True)
        Inbox.objects.create(owner=user, slug='u1')
        self.client.force_login(user)

        r1 = self.client.post('/api/v1/me/username/', {'username': 'u1_new'})
        self.assertEqual(r1.status_code, status.HTTP_200_OK)
        user.refresh_from_db()
        self.assertEqual(user.username, 'u1_new')

        # Try changing again immediately
        r2 = self.client.post('/api/v1/me/username/', {'username': 'u1_new2'})
        self.assertEqual(r2.status_code, status.HTTP_400_BAD_REQUEST)
        self.assertEqual(r2.data['error']['code'], 'username_change_cooldown')

    def test_14_profile_edit(self):
        """14. Profile edit saves display name (max 50) and bio (max 160). HTML is stored as plain text."""
        user = User.objects.create_user(username='proftest', email='proftest@example.com', password='Password123!')
        Profile.objects.create(user=user)
        self.client.force_login(user)

        r = self.client.patch('/api/v1/me/', {
            'display_name': '<b>Safe Name</b>',
            'bio': '<script>alert(1)</script>'
        })
        self.assertEqual(r.status_code, status.HTTP_200_OK)
        user.profile.refresh_from_db()
        self.assertEqual(user.profile.display_name, '<b>Safe Name</b>')

    # Public inbox and anonymous messages
    def test_15_and_16_public_inbox_url_and_safety(self):
        """15. /u/<slug> returns 200 or 404. 16. Response contains no email or internal id."""
        user = User.objects.create_user(username='pubowner', email='secret@example.com', password='Password123!')
        Profile.objects.create(user=user, display_name='Public Owner')
        Inbox.objects.create(owner=user, slug='pubowner')

        r1 = self.client.get('/api/v1/inboxes/pubowner/')
        self.assertEqual(r1.status_code, status.HTTP_200_OK)
        self.assertNotIn('secret@example.com', str(r1.data))
        self.assertNotIn('id', r1.data)

        r2 = self.client.get('/api/v1/inboxes/unknown/')
        self.assertEqual(r2.status_code, status.HTTP_404_NOT_FOUND)

    def test_17_18_19_anonymous_submissions(self):
        """17. 1-500 chars succeeds. 18. Honeypot returns 201 without storing. 19. No user id or IP stored."""
        user = User.objects.create_user(username='inboxowner', email='owner@example.com', password='Password123!')
        inbox = Inbox.objects.create(owner=user, slug='inboxowner')

        # 17: Valid submission
        r1 = self.client.post('/api/v1/inboxes/inboxowner/messages/', {'body': 'Hello anonymously!'})
        self.assertEqual(r1.status_code, status.HTTP_201_CREATED)
        self.assertEqual(inbox.messages.count(), 1)
        msg = inbox.messages.first()
        self.assertEqual(msg.body, 'Hello anonymously!')

        # 18: Honeypot field filled
        r2 = self.client.post('/api/v1/inboxes/inboxowner/messages/', {'body': 'Spam message', 'website': 'http://spambot.com'})
        self.assertEqual(r2.status_code, status.HTTP_201_CREATED)
        self.assertEqual(inbox.messages.count(), 1) # Still 1, nothing saved

        # Empty body
        r3 = self.client.post('/api/v1/inboxes/inboxowner/messages/', {'body': ''})
        self.assertEqual(r3.status_code, status.HTTP_400_BAD_REQUEST)

        # Oversize body (501 chars)
        r4 = self.client.post('/api/v1/inboxes/inboxowner/messages/', {'body': 'a' * 501})
        self.assertEqual(r4.status_code, status.HTTP_400_BAD_REQUEST)

    def test_20_21_22_23_owner_message_management(self):
        """20. List newest first. 21. Open marks read. 22. Delete hides immediately. 23. Non-owner gets 403."""
        user1 = User.objects.create_user(username='owner1', email='owner1@example.com', password='Password123!', email_verified=True)
        inbox = Inbox.objects.create(owner=user1, slug='owner1')
        msg = AnonymousMessage.objects.create(inbox=inbox, body='Test msg', is_read=False)

        user2 = User.objects.create_user(username='otheruser', email='other@example.com', password='Password123!', email_verified=True)

        # 23: user2 requesting user1's message gets 403
        self.client.force_login(user2)
        r_other = self.client.get(f'/api/v1/inbox/messages/{msg.id}/')
        self.assertEqual(r_other.status_code, status.HTTP_403_FORBIDDEN)

        # 21: owner1 opening message marks read
        self.client.force_login(user1)
        r_read = self.client.get(f'/api/v1/inbox/messages/{msg.id}/')
        self.assertEqual(r_read.status_code, status.HTTP_200_OK)
        msg.refresh_from_db()
        self.assertTrue(msg.is_read)

        # 22: Delete hides immediately
        r_del = self.client.delete(f'/api/v1/inbox/messages/{msg.id}/')
        self.assertEqual(r_del.status_code, status.HTTP_200_OK)
        msg.refresh_from_db()
        self.assertEqual(msg.status, 'hidden')

        # Hidden message excluded from message list
        r_list = self.client.get('/api/v1/inbox/messages/')
        self.assertEqual(r_list.data['count'], 0)

    def test_25_and_26_submissions_disabled(self):
        """25. Disabled submissions returns 403. 26. Owner can still read existing messages."""
        user = User.objects.create_user(username='disabledinbox', email='dis@example.com', password='Password123!', email_verified=True)
        inbox = Inbox.objects.create(owner=user, slug='disabledinbox', anonymous_enabled=False)
        msg = AnonymousMessage.objects.create(inbox=inbox, body='Pre-existing msg')

        # Public submission rejected
        r1 = self.client.post('/api/v1/inboxes/disabledinbox/messages/', {'body': 'Try to submit'})
        self.assertEqual(r1.status_code, status.HTTP_403_FORBIDDEN)
        self.assertEqual(r1.data['error']['code'], 'submissions_disabled')

        # Owner can read
        self.client.force_login(user)
        r2 = self.client.get('/api/v1/inbox/messages/')
        self.assertEqual(r2.status_code, status.HTTP_200_OK)
        self.assertEqual(r2.data['count'], 1)

    # Direct Messaging
    def test_27_conversation_idempotency(self):
        """27. Starting conversation twice returns same conversation ID."""
        u1 = User.objects.create_user(username='talker1', email='t1@example.com', password='Password123!', email_verified=True)
        u2 = User.objects.create_user(username='talker2', email='t2@example.com', password='Password123!', email_verified=True)

        self.client.force_login(u1)
        r1 = self.client.post('/api/v1/conversations/', {'username': 'talker2'})
        r2 = self.client.post('/api/v1/conversations/', {'username': 'talker2'})

        self.assertEqual(r1.status_code, status.HTTP_200_OK)
        self.assertEqual(r2.status_code, status.HTTP_200_OK)
        self.assertEqual(r1.data['id'], r2.data['id'])
        self.assertEqual(Conversation.objects.count(), 1)

    def test_28_and_29_dm_length_and_delivery(self):
        """28. DM body 1-1000 accepted; 29. Sent DM visible to recipient."""
        u1 = User.objects.create_user(username='sender', email='s@example.com', password='Password123!', email_verified=True)
        u2 = User.objects.create_user(username='recipient', email='r@example.com', password='Password123!', email_verified=True)
        conv, _ = Conversation.get_or_create_for_users(u1, u2)

        self.client.force_login(u1)
        # Empty body
        r0 = self.client.post(f'/api/v1/conversations/{conv.id}/messages/', {'body': ''})
        self.assertEqual(r0.status_code, status.HTTP_400_BAD_REQUEST)

        # Valid body
        r1 = self.client.post(f'/api/v1/conversations/{conv.id}/messages/', {'body': 'Hello there!'})
        self.assertEqual(r1.status_code, status.HTTP_201_CREATED)

        # Recipient reads message
        self.client.force_login(u2)
        r2 = self.client.get(f'/api/v1/conversations/{conv.id}/messages/')
        self.assertEqual(len(r2.data['results']), 1)
        self.assertEqual(r2.data['results'][0]['body'], 'Hello there!')

    def test_30_and_31_delete_for_me(self):
        """30. Delete for me hides only for caller. 31. Hard delete only when both delete."""
        u1 = User.objects.create_user(username='del1', email='del1@example.com', password='Password123!', email_verified=True)
        u2 = User.objects.create_user(username='del2', email='del2@example.com', password='Password123!', email_verified=True)
        conv, _ = Conversation.get_or_create_for_users(u1, u2)
        msg = DirectMessage.objects.create(conversation=conv, sender=u1, body='To be deleted')

        # u1 deletes for me
        self.client.force_login(u1)
        r1 = self.client.delete(f'/api/v1/conversations/{conv.id}/messages/{msg.id}/')
        self.assertEqual(r1.status_code, status.HTTP_200_OK)

        # Hidden for u1
        r_u1 = self.client.get(f'/api/v1/conversations/{conv.id}/messages/')
        self.assertEqual(len(r_u1.data['results']), 0)

        # Still visible for u2
        self.client.force_login(u2)
        r_u2 = self.client.get(f'/api/v1/conversations/{conv.id}/messages/')
        self.assertEqual(len(r_u2.data['results']), 1)

    def test_32_non_participant_gets_403(self):
        """32. Non-participants receive 403 on conversation endpoints."""
        u1 = User.objects.create_user(username='p1', email='p1@example.com', password='Password123!', email_verified=True)
        u2 = User.objects.create_user(username='p2', email='p2@example.com', password='Password123!', email_verified=True)
        u3 = User.objects.create_user(username='intruder', email='intruder@example.com', password='Password123!', email_verified=True)
        conv, _ = Conversation.get_or_create_for_users(u1, u2)

        self.client.force_login(u3)
        r1 = self.client.get(f'/api/v1/conversations/{conv.id}/messages/')
        self.assertEqual(r1.status_code, status.HTTP_403_FORBIDDEN)

        r2 = self.client.post(f'/api/v1/conversations/{conv.id}/messages/', {'body': 'intruding'})
        self.assertEqual(r2.status_code, status.HTTP_403_FORBIDDEN)

    # Staff and Audit
    def test_38_moderator_cannot_suspend_or_change_roles(self):
        """38. Moderator can view dashboard but cannot suspend or change roles (403)."""
        mod = User.objects.create_user(username='mod', email='mod@example.com', password='Password123!', role='moderator', is_staff=True)
        target = User.objects.create_user(username='target', email='target@example.com', password='Password123!')

        self.client.force_login(mod)
        r_dash = self.client.get('/api/v1/staff/dashboard/')
        self.assertEqual(r_dash.status_code, status.HTTP_200_OK)

        r_sus = self.client.post(f'/api/v1/staff/users/{target.id}/suspend/', {'reason': 'violating rules'})
        self.assertEqual(r_sus.status_code, status.HTTP_403_FORBIDDEN)

        r_role = self.client.post(f'/api/v1/staff/users/{target.id}/role/', {'role': 'moderator'})
        self.assertEqual(r_role.status_code, status.HTTP_403_FORBIDDEN)

    def test_39_40_41_admin_suspend_and_unsuspend(self):
        """39. Admin suspend requires reason, blocks login. 40. Inbox unavailable. 41. Unsuspend restores."""
        admin_user = User.objects.create_user(username='adminboss', email='admin@example.com', password='Password123!', role='admin', is_staff=True)
        victim = User.objects.create_user(username='baduser', email='bad@example.com', password='Password123!')
        Inbox.objects.create(owner=victim, slug='baduser')

        self.client.force_login(admin_user)
        # Suspend without reason fails
        r0 = self.client.post(f'/api/v1/staff/users/{victim.id}/suspend/', {'reason': ''})
        self.assertEqual(r0.status_code, status.HTTP_400_BAD_REQUEST)

        # Suspend with reason succeeds
        r1 = self.client.post(f'/api/v1/staff/users/{victim.id}/suspend/', {'reason': 'Spam activity'})
        self.assertEqual(r1.status_code, status.HTTP_200_OK)
        victim.refresh_from_db()
        self.assertTrue(victim.is_suspended)

        # 40: Public inbox unavailable
        r_pub = self.client.get('/api/v1/inboxes/baduser/')
        self.assertEqual(r_pub.status_code, status.HTTP_404_NOT_FOUND)
        self.assertEqual(r_pub.data['error']['code'], 'inbox_unavailable')

        # 39: Login fails
        self.client.logout()
        r_login = self.client.post('/api/v1/auth/login/', {'login': 'baduser', 'password': 'Password123!'})
        self.assertEqual(r_login.status_code, status.HTTP_403_FORBIDDEN)

        # 41: Unsuspend restores access
        self.client.force_login(admin_user)
        r_unsus = self.client.post(f'/api/v1/staff/users/{victim.id}/unsuspend/', {'reason': 'Appeal accepted'})
        self.assertEqual(r_unsus.status_code, status.HTTP_200_OK)
        victim.refresh_from_db()
        self.assertFalse(victim.is_suspended)

    def test_42_last_admin_cannot_demote_themselves(self):
        """42. The last remaining admin cannot demote themselves."""
        only_admin = User.objects.create_user(username='soleadmin', email='sole@example.com', password='Password123!', role='admin', is_staff=True)
        self.client.force_login(only_admin)

        r = self.client.post(f'/api/v1/staff/users/{only_admin.id}/role/', {'role': 'user'})
        self.assertEqual(r.status_code, status.HTTP_400_BAD_REQUEST)
        self.assertEqual(r.data['error']['code'], 'last_admin_demotion')

    def test_43_and_44_audit_log_and_immutability(self):
        """43. Actions create audit row. 44. PUT/PATCH/DELETE rejected with 405."""
        admin_user = User.objects.create_user(username='auditor', email='audit@example.com', password='Password123!', role='admin', is_staff=True)
        user = User.objects.create_user(username='someuser', email='some@example.com', password='Password123!')

        self.client.force_login(admin_user)
        self.client.post(f'/api/v1/staff/users/{user.id}/suspend/', {'reason': 'Test audit'})

        # Check audit log row
        log = AuditLog.objects.filter(target_id=str(user.id), action='suspend_user').first()
        self.assertIsNotNone(log)
        self.assertEqual(log.actor_id, admin_user.id)

        # 44: Audit endpoints reject modification with 405
        r_put = self.client.put('/api/v1/staff/audit-log/')
        self.assertEqual(r_put.status_code, status.HTTP_405_METHOD_NOT_ALLOWED)
        r_patch = self.client.patch('/api/v1/staff/audit-log/')
        self.assertEqual(r_patch.status_code, status.HTTP_405_METHOD_NOT_ALLOWED)
        r_del = self.client.delete('/api/v1/staff/audit-log/')
        self.assertEqual(r_del.status_code, status.HTTP_405_METHOD_NOT_ALLOWED)

    def test_45_staff_dashboard_counts(self):
        """45. Dashboard counts match seeded test data."""
        admin_user = User.objects.create_user(username='admin_counts', email='ac@example.com', password='Password123!', role='admin', is_staff=True)
        u1 = User.objects.create_user(username='cnt_u1', email='u1c@example.com', password='Password123!')
        inbox = Inbox.objects.create(owner=u1, slug='cnt_u1', anonymous_enabled=True)
        AnonymousMessage.objects.create(inbox=inbox, body='msg1')
        conv, _ = Conversation.get_or_create_for_users(admin_user, u1)
        DirectMessage.objects.create(conversation=conv, sender=u1, body='dm1')

        self.client.force_login(admin_user)
        r = self.client.get('/api/v1/staff/dashboard/')
        self.assertEqual(r.status_code, status.HTTP_200_OK)
        self.assertEqual(r.data['anon_messages_24h'], 1)
        self.assertEqual(r.data['direct_messages_24h'], 1)
        self.assertEqual(r.data['inboxes_enabled'], 1)

    def test_health_endpoint(self):
        """Health check returns 200 and database connected."""
        r = self.client.get('/api/v1/health/')
        self.assertEqual(r.status_code, status.HTTP_200_OK)
        self.assertEqual(r.data['database'], 'connected')

    def test_47_frontend_production_build_and_spa_routing(self):
        """47. Production build succeeds and Django serves / and /u/<slug> on reload."""
        r_home = self.client.get('/')
        self.assertEqual(r_home.status_code, status.HTTP_200_OK)
        self.assertIn('text/html', r_home.headers.get('Content-Type', ''))

        r_slug = self.client.get('/u/alice')
        self.assertEqual(r_slug.status_code, status.HTTP_200_OK)
        self.assertIn('text/html', r_slug.headers.get('Content-Type', ''))

    def test_e2e_user_lifecycle_and_messaging(self):
        """
        Complete lifecycle test:
        1. Register user1 and user2
        2. Verify both using tokens from EmailJobs
        3. User1 opens User2's public inbox and sends anonymous message
        4. User2 logs in, reads and deletes anonymous message
        5. User2 starts direct conversation with User1 and sends direct message
        """
        # 1. Register user1 and user2
        r_reg1 = self.client.post('/api/v1/auth/register/', {
            'username': 'e2e_user1',
            'email': 'e2e1@example.com',
            'password': 'Password123!'
        })
        self.assertEqual(r_reg1.status_code, status.HTTP_201_CREATED)

        r_reg2 = self.client.post('/api/v1/auth/register/', {
            'username': 'e2e_user2',
            'email': 'e2e2@example.com',
            'password': 'Password123!'
        })
        self.assertEqual(r_reg2.status_code, status.HTTP_201_CREATED)

        # 2. Verify both users using 6-digit code or verification token from EmailJobs
        job1 = EmailJob.objects.filter(to_email='e2e1@example.com').first()
        u1 = User.objects.get(email='e2e1@example.com')
        r_ver1 = self.client.post('/api/v1/auth/verify-email/', {'code': u1.verification_code, 'email': u1.email})
        self.assertEqual(r_ver1.status_code, status.HTTP_200_OK)

        job2 = EmailJob.objects.filter(to_email='e2e2@example.com').first()
        u2 = User.objects.get(email='e2e2@example.com')
        r_ver2 = self.client.post('/api/v1/auth/verify-email/', {'code': u2.verification_code, 'email': u2.email})
        self.assertEqual(r_ver2.status_code, status.HTTP_200_OK)

        # 3. Anonymous submission from public to user2
        r_anon = self.client.post('/api/v1/inboxes/e2e_user2/messages/', {
            'body': 'E2E anonymous message test'
        })
        self.assertEqual(r_anon.status_code, status.HTTP_201_CREATED)

        # 4. User2 logs in, reads and deletes anonymous message
        self.client.login(username='e2e_user2', password='Password123!')
        r_inbox = self.client.get('/api/v1/inbox/messages/')
        self.assertEqual(r_inbox.status_code, status.HTTP_200_OK)
        self.assertEqual(r_inbox.data['count'], 1)
        msg_id = r_inbox.data['results'][0]['id']

        # Read
        r_detail = self.client.get(f'/api/v1/inbox/messages/{msg_id}/')
        self.assertEqual(r_detail.status_code, status.HTTP_200_OK)

        # Delete
        r_del = self.client.delete(f'/api/v1/inbox/messages/{msg_id}/')
        self.assertEqual(r_del.status_code, status.HTTP_200_OK)

        # 5. User2 starts direct conversation with User1 and exchanges a message
        r_conv = self.client.post('/api/v1/conversations/', {'username': 'e2e_user1'})
        self.assertEqual(r_conv.status_code, status.HTTP_200_OK)
        conv_id = r_conv.data['id']

        r_dm = self.client.post(f'/api/v1/conversations/{conv_id}/messages/', {
            'body': 'Hello e2e_user1 from e2e_user2!'
        })
        self.assertEqual(r_dm.status_code, status.HTTP_201_CREATED)
        self.client.logout()

        # User1 logs in and sees the message
        self.client.login(username='e2e_user1', password='Password123!')
        r_poll = self.client.get(f'/api/v1/conversations/{conv_id}/messages/')
        self.assertEqual(r_poll.status_code, status.HTTP_200_OK)
        self.assertEqual(len(r_poll.data['results']), 1)
        self.assertEqual(r_poll.data['results'][0]['body'], 'Hello e2e_user1 from e2e_user2!')
