# tests/integration/test_webhook_routing_complete.py
"""
Integration tests for complete Cloudinary webhook routing flow.

Tests:
  - Avatar webhook → UnifiedUser.avatar updated correctly
  - Product image webhook → Product.image updated correctly
  - Idempotent processing (same webhook twice = single DB update)
  - Concurrent webhooks (race conditions)
  - Atomic rollback on errors
  - Audit trail logging
"""

import pytest
from django.test import TestCase, TransactionTestCase
from django.utils import timezone
from django.db import transaction

from apps.authentication.models import UnifiedUser
from apps.common.utils.cloudinary_metadata import parse_cloudinary_public_id, ModelTarget
from apps.common.utils.webhook_idempotency import (
    generate_idempotency_key,
    is_duplicate,
    mark_processed,
)
from apps.common.models import CloudinaryProcessedWebhook


@pytest.mark.django_db
class TestWebhookRouting(TestCase):
    """Integration tests for webhook routing to models."""
    
    def setUp(self):
        """Set up test data."""
        self.user = UnifiedUser.objects.create_user(
            email="testuser@example.com",
            password="testpass123"
        )
        self.avatar_url = "https://res.cloudinary.com/fashionistar/image/upload/v1234/avatars/user_550e8400-e29b-41d4-a716-446655440000/avatar_abc123.jpg"
    
    def test_avatar_webhook_updates_user_model(self):
        """Webhook for avatar updates UnifiedUser.avatar field."""
        # Arrange
        user_uuid = str(self.user.id)
        payload = {
            "public_id": f"/avatars/user_{user_uuid}/avatar.jpg",
            "secure_url": self.avatar_url,
            "width": 200,
            "height": 200,
            "format": "jpg",
            "resource_type": "image",
            "notification_type": "upload",
        }
        
        # Parse metadata
        metadata = parse_cloudinary_public_id(
            payload["public_id"],
            resource_type=payload.get("resource_type")
        )
        
        # Simulate webhook processing
        from apps.common.tasks.cloudinary import process_cloudinary_upload_webhook
        
        # Act
        process_cloudinary_upload_webhook(payload=payload)
        
        # Assert
        self.user.refresh_from_db()
        assert str(self.user.avatar) in self.avatar_url
        assert metadata.is_valid
        assert metadata.model_target == ModelTarget.AVATAR
    
    def test_webhook_idempotency_single_db_update(self):
        """Processing same webhook twice results in single DB update."""
        # Arrange
        user_uuid = str(self.user.id)
        public_id = f"/avatars/user_{user_uuid}/avatar.jpg"
        timestamp = str(int(timezone.now().timestamp()))
        idempotency_key = generate_idempotency_key(public_id, timestamp, "image")
        
        payload = {
            "public_id": public_id,
            "secure_url": self.avatar_url,
            "resource_type": "image",
            "notification_type": "upload",
            "created_at": timestamp,
        }
        
        # Act 1: First webhook
        from apps.common.tasks.cloudinary import process_cloudinary_upload_webhook
        
        process_cloudinary_upload_webhook(payload=payload)
        self.user.refresh_from_db()
        first_avatar = self.user.avatar
        first_updated_at = self.user.updated_at
        
        # Act 2: Same webhook again (duplicate)
        is_dup = is_duplicate(idempotency_key, check_database=True)
        if not is_dup:
            mark_processed(
                idempotency_key=idempotency_key,
                public_id=public_id,
                asset_type="image",
                model_target=ModelTarget.AVATAR.value,
                model_pk=str(self.user.id),
                secure_url=self.avatar_url,
                success=True,
            )
        
        # Replaying should detect as duplicate
        assert is_duplicate(idempotency_key, check_database=True)
        
        # Updated_at should not change
        self.user.refresh_from_db()
        assert str(self.user.avatar) == str(first_avatar)
    
    def test_webhook_creates_audit_trail(self):
        """Webhook processing creates CloudinaryProcessedWebhook record."""
        # Arrange
        user_uuid = str(self.user.id)
        public_id = f"/avatars/user_{user_uuid}/avatar.jpg"
        timestamp = str(int(timezone.now().timestamp()))
        idempotency_key = generate_idempotency_key(public_id, timestamp, "image")
        
        # Act
        mark_processed(
            idempotency_key=idempotency_key,
            public_id=public_id,
            asset_type="image",
            model_target="avatar",
            model_pk=str(self.user.id),
            secure_url=self.avatar_url,
            processing_time_ms=45.2,
            success=True,
        )
        
        # Assert
        webhook_record = CloudinaryProcessedWebhook.objects.get(
            idempotency_key=idempotency_key
        )
        assert webhook_record.public_id == public_id
        assert webhook_record.model_target == "avatar"
        assert webhook_record.success is True
        assert webhook_record.processing_time_ms == 45.2
    
    def test_webhook_failure_recorded_in_audit(self):
        """Failed webhook processing is recorded with error message."""
        # Arrange
        public_id = "/unknown/path/file.jpg"
        timestamp = str(int(timezone.now().timestamp()))
        idempotency_key = generate_idempotency_key(public_id, timestamp, "image")
        error_msg = "Unrecognized public_id format"
        
        # Act
        mark_processed(
            idempotency_key=idempotency_key,
            public_id=public_id,
            asset_type="image",
            model_target="unknown",
            success=False,
            error_message=error_msg,
        )
        
        # Assert
        webhook_record = CloudinaryProcessedWebhook.objects.get(
            idempotency_key=idempotency_key
        )
        assert webhook_record.success is False
        assert error_msg in webhook_record.error_message


@pytest.mark.django_db(transaction=True)
class TestWebhookAtomicity(TransactionTestCase):
    """Test atomic transaction behavior for webhook processing."""
    
    def setUp(self):
        """Set up test data."""
        self.user = UnifiedUser.objects.create_user(
            email="testuser2@example.com",
            password="testpass123"
        )
    
    def test_webhook_rollback_on_error(self):
        """If error during processing, database transaction rolls back."""
        with transaction.atomic():
            try:
                # Simulate successful webhook processing
                mark_processed(
                    idempotency_key="test_key_123",
                    public_id="/avatars/user_abc/avatar.jpg",
                    asset_type="image",
                    model_target="avatar",
                    model_pk=str(self.user.id),
                    success=True,
                )
                
                # Simulate an error (e.g., database constraint violation)
                raise Exception("Simulated processing error")
            except Exception:
                # Transaction should rollback
                pass
        
        # After rollback, the record should not exist (or be marked with error)
        # This depends on whether we save the record before or after the error


# ─────────────────────────────────────────────────────────────────────────────
# CONCURRENCY TESTS
# ─────────────────────────────────────────────────────────────────────────────

@pytest.mark.django_db
class TestWebhookConcurrency:
    """Test concurrent webhook processing scenarios."""
    
    @pytest.mark.slow
    def test_concurrent_avatar_uploads_same_user(self):
        """Multiple concurrent avatar uploads for same user."""
        import concurrent.futures
        
        user = UnifiedUser.objects.create_user(
            email="concurrent_test@example.com",
            password="testpass123"
        )
        
        def upload_avatar(image_num):
            url = f"https://res.cloudinary.com/fashionistar/image/upload/avatar_v{image_num}.jpg"
            public_id = f"/avatars/user_{user.id}/avatar_v{image_num}.jpg"
            idempotency_key = generate_idempotency_key(public_id, "1234567890", "image")
            
            mark_processed(
                idempotency_key=idempotency_key,
                public_id=public_id,
                asset_type="image",
                model_target="avatar",
                model_pk=str(user.id),
                secure_url=url,
                success=True,
            )
            
            return idempotency_key
        
        # Upload 10 different avatars concurrently
        with concurrent.futures.ThreadPoolExecutor(max_workers=5) as executor:
            futures = [executor.submit(upload_avatar, i) for i in range(10)]
            results = [f.result() for f in concurrent.futures.as_completed(futures)]
        
        # All 10 should complete successfully
        assert len(results) == 10
        assert len(set(results)) == 10  # All unique keys
        
        # All 10 should be recorded in audit
        webhooks = CloudinaryProcessedWebhook.objects.filter(
            model_target="avatar",
            model_pk=str(user.id)
        )
        assert webhooks.count() == 10


if __name__ == "__main__":
    pytest.main([__file__, "-v", "-s"])