package integration

import (
	"Coves/internal/atproto/identity"
	"Coves/internal/atproto/jetstream"
	"Coves/internal/core/blobs"
	"Coves/internal/core/communities"
	"Coves/internal/core/posts"
	"Coves/internal/core/users"
	"Coves/internal/db/postgres"
	"bytes"
	"context"
	"encoding/json"
	"fmt"
	"image"
	"image/color"
	"image/jpeg"
	"image/png"
	"net/http"
	"net/http/httptest"
	"strings"
	"testing"
	"time"

	"github.com/stretchr/testify/assert"
	"github.com/stretchr/testify/require"
)

// TestBlobUpload_E2E_PostWithImages tests the full blob upload flow for posts with images:
// 1. Create post with embedded images
// 2. Verify blobs uploaded to PDS via com.atproto.repo.uploadBlob
// 3. Verify blob references in post record
// 4. Verify blob URLs are transformed in feed responses
// 5. Test multiple images in single post
//
// This is a TRUE E2E test that validates:
// - Blob upload to PDS
// - Blob references in atProto records
// - URL transformation in AppView responses
func TestBlobUpload_E2E_PostWithImages(t *testing.T) {
	if testing.Short() {
		t.Skip("Skipping blob upload E2E test in short mode")
	}

	// Check if PDS is available before running E2E test
	pdsURL := getTestPDSURL()
	healthResp, err := http.Get(pdsURL + "/xrpc/_health")
	if err != nil {
		t.Skipf("PDS not running at %s: %v. Run 'make dev-up' to start PDS.", pdsURL, err)
	}
	defer func() { _ = healthResp.Body.Close() }()
	if healthResp.StatusCode != http.StatusOK {
		t.Skipf("PDS health check failed at %s: status %d", pdsURL, healthResp.StatusCode)
	}

	db := setupTestDB(t)
	defer func() {
		if err := db.Close(); err != nil {
			t.Logf("Failed to close database: %v", err)
		}
	}()

	ctx := context.Background()

	// Setup repositories
	communityRepo := postgres.NewCommunityRepository(db)
	postRepo := postgres.NewPostRepository(db)
	userRepo := postgres.NewUserRepository(db)

	// Setup services (pdsURL already declared in health check above)
	blobService := blobs.NewBlobService(pdsURL)
	identityConfig := identity.DefaultConfig()
	identityResolver := identity.NewResolver(db, identityConfig)
	userService := users.NewUserService(userRepo, identityResolver, pdsURL)

	// Create test author
	author := createTestUser(t, db, "blobtest.test", "did:plc:blobtest123")

	// Create test community with PDS credentials
	community := createTestCommunityWithBlobCredentials(t, communityRepo, "blobtest")

	t.Run("Post with single embedded image", func(t *testing.T) {
		// STEP 1: Create a test image blob (1x1 PNG)
		imageData := createTestPNG(t, 1, 1, color.RGBA{R: 255, G: 0, B: 0, A: 255})

		// STEP 2: Upload blob to PDS
		blobRef, err := blobService.UploadBlob(ctx, community, imageData, "image/png")
		require.NoError(t, err, "Blob upload to PDS should succeed")
		require.NotNil(t, blobRef, "Blob reference should not be nil")

		// Verify blob reference structure
		assert.Equal(t, "blob", blobRef.Type, "Blob type should be 'blob'")
		assert.NotEmpty(t, blobRef.Ref, "Blob ref should contain CID")
		assert.Equal(t, "image/png", blobRef.MimeType, "MIME type should match")
		assert.Greater(t, blobRef.Size, 0, "Blob size should be positive")

		t.Logf("✓ Uploaded blob: CID=%v, Size=%d bytes", blobRef.Ref, blobRef.Size)

		// STEP 3: Create post with image embed (as map for Jetstream record)
		rkey := generateTID()
		jetstreamEvent := jetstream.JetstreamEvent{
			Did:  community.DID,
			Kind: "commit",
			Commit: &jetstream.CommitEvent{
				Operation:  "create",
				Collection: "social.coves.community.post",
				RKey:       rkey,
				CID:        "bafy2bzaceblobimage001",
				Record: map[string]interface{}{
					"$type":     "social.coves.community.post",
					"community": community.DID,
					"author":    author.DID,
					"title":     "Post with Image",
					"content":   "This post has an embedded image",
					"embed": map[string]interface{}{
						"$type": "social.coves.embed.images",
						"images": []interface{}{
							map[string]interface{}{
								"image": blobRef,
								"alt":   "Test image",
							},
						},
					},
					"createdAt": time.Now().UTC().Format(time.RFC3339),
				},
			},
		}

		// STEP 4: Process through consumer
		consumer := jetstream.NewPostEventConsumer(postRepo, communityRepo, userService, db)
		err = consumer.HandleEvent(ctx, &jetstreamEvent)
		require.NoError(t, err, "Consumer should process image post")

		// STEP 5: Verify post was indexed with blob reference
		postURI := fmt.Sprintf("at://%s/social.coves.community.post/%s", community.DID, rkey)
		indexedPost, err := postRepo.GetByURI(ctx, postURI)
		require.NoError(t, err, "Post should be indexed")

		// Verify embed contains blob (Embed is stored as *string JSON in DB)
		require.NotNil(t, indexedPost.Embed, "Post embed should not be nil")

		// Parse embed JSON
		var embedMap map[string]interface{}
		err = json.Unmarshal([]byte(*indexedPost.Embed), &embedMap)
		require.NoError(t, err, "Should parse embed JSON")
		assert.Equal(t, "social.coves.embed.images", embedMap["$type"], "Embed type should be images")

		images, ok := embedMap["images"].([]interface{})
		require.True(t, ok, "Images should be an array")
		require.Len(t, images, 1, "Should have 1 image")

		imageObj := images[0].(map[string]interface{})
		imageBlobRaw := imageObj["image"]
		require.NotNil(t, imageBlobRaw, "Image blob should exist")

		// Verify blob structure (could be map[string]interface{} from JSON)
		imageBlobMap, ok := imageBlobRaw.(map[string]interface{})
		if ok {
			assert.Equal(t, "blob", imageBlobMap["$type"], "Image should be a blob type")
			assert.NotEmpty(t, imageBlobMap["ref"], "Blob should have ref")
		}

		t.Logf("✓ Post indexed with image embed: URI=%s", postURI)

		// STEP 6: Verify blob URL transformation in feed responses
		// This is what the feed handler would do before returning to client
		postView := &posts.PostView{
			URI:       indexedPost.URI,
			CID:       indexedPost.CID,
			Title:     indexedPost.Title,
			Text:      indexedPost.Content, // Content maps to Text in PostView
			Embed:     embedMap,            // Use parsed embed map
			CreatedAt: indexedPost.CreatedAt,
			Community: &posts.CommunityRef{
				DID:    community.DID,
				PDSURL: community.PDSURL,
			},
		}

		// Transform blob refs to URLs (this happens in feed handlers)
		posts.TransformBlobRefsToURLs(postView)

		// NOTE: TransformBlobRefsToURLs only transforms external embed thumbs,
		// not image embeds. For image embeds, clients fetch blobs using:
		// GET /xrpc/com.atproto.sync.getBlob?did={did}&cid={cid}
		// The blob reference is preserved in the embed for clients to construct URLs

		t.Logf("✓ Blob references preserved for client-side URL construction")
	})

	t.Run("Post with multiple images", func(t *testing.T) {
		// Create 3 test images with different colors
		colors := []color.RGBA{
			{R: 255, G: 0, B: 0, A: 255}, // Red
			{R: 0, G: 255, B: 0, A: 255}, // Green
			{R: 0, G: 0, B: 255, A: 255}, // Blue
		}

		var blobRefs []*blobs.BlobRef
		for i, col := range colors {
			imageData := createTestPNG(t, 2, 2, col)
			blobRef, err := blobService.UploadBlob(ctx, community, imageData, "image/png")
			require.NoError(t, err, fmt.Sprintf("Blob upload %d should succeed", i+1))
			blobRefs = append(blobRefs, blobRef)
			t.Logf("✓ Uploaded image %d: CID=%v", i+1, blobRef.Ref)
		}

		// Create post with multiple images
		imageEmbeds := make([]interface{}, len(blobRefs))
		for i, ref := range blobRefs {
			imageEmbeds[i] = map[string]interface{}{
				"image": ref,
				"alt":   fmt.Sprintf("Test image %d", i+1),
			}
		}

		// Index post via consumer
		rkey := generateTID()
		jetstreamEvent := jetstream.JetstreamEvent{
			Did:  community.DID,
			Kind: "commit",
			Commit: &jetstream.CommitEvent{
				Operation:  "create",
				Collection: "social.coves.community.post",
				RKey:       rkey,
				CID:        "bafy2bzaceblobmulti001",
				Record: map[string]interface{}{
					"$type":     "social.coves.community.post",
					"community": community.DID,
					"author":    author.DID,
					"title":     "Post with Multiple Images",
					"content":   "This post has 3 images",
					"embed": map[string]interface{}{
						"$type":  "social.coves.embed.images",
						"images": imageEmbeds,
					},
					"createdAt": time.Now().UTC().Format(time.RFC3339),
				},
			},
		}

		consumer := jetstream.NewPostEventConsumer(postRepo, communityRepo, userService, db)
		err := consumer.HandleEvent(ctx, &jetstreamEvent)
		require.NoError(t, err, "Consumer should process multi-image post")

		// Verify all images indexed
		postURI := fmt.Sprintf("at://%s/social.coves.community.post/%s", community.DID, rkey)
		indexedPost, err := postRepo.GetByURI(ctx, postURI)
		require.NoError(t, err, "Multi-image post should be indexed")

		// Parse embed JSON
		var embedMap map[string]interface{}
		err = json.Unmarshal([]byte(*indexedPost.Embed), &embedMap)
		require.NoError(t, err, "Should parse embed JSON")

		images := embedMap["images"].([]interface{})
		assert.Len(t, images, 3, "Should have 3 images indexed")

		t.Logf("✓ Multi-image post indexed: URI=%s with %d images", postURI, len(images))
	})

	t.Run("Post with external embed thumbnail", func(t *testing.T) {
		// This tests the existing thumbnail upload flow for external embeds
		// (like link previews with thumbnails)

		// Create thumbnail image
		thumbData := createTestPNG(t, 10, 10, color.RGBA{R: 128, G: 128, B: 128, A: 255})
		thumbRef, err := blobService.UploadBlob(ctx, community, thumbData, "image/png")
		require.NoError(t, err, "Thumbnail upload should succeed")

		// Create post with external embed and thumbnail
		rkey := generateTID()
		jetstreamEvent := jetstream.JetstreamEvent{
			Did:  community.DID,
			Kind: "commit",
			Commit: &jetstream.CommitEvent{
				Operation:  "create",
				Collection: "social.coves.community.post",
				RKey:       rkey,
				CID:        "bafy2bzaceblobthumb001",
				Record: map[string]interface{}{
					"$type":     "social.coves.community.post",
					"community": community.DID,
					"author":    author.DID,
					"title":     "Post with Link Preview",
					"content":   "Check out this link",
					"embed": map[string]interface{}{
						"$type": "social.coves.embed.external",
						"external": map[string]interface{}{
							"uri":         "https://example.com/article",
							"title":       "Example Article",
							"description": "An interesting article",
							"thumb":       thumbRef, // Blob reference
						},
					},
					"createdAt": time.Now().UTC().Format(time.RFC3339),
				},
			},
		}

		consumer := jetstream.NewPostEventConsumer(postRepo, communityRepo, userService, db)
		err = consumer.HandleEvent(ctx, &jetstreamEvent)
		require.NoError(t, err, "Consumer should process external embed with thumbnail")

		// Verify thumbnail blob indexed
		postURI := fmt.Sprintf("at://%s/social.coves.community.post/%s", community.DID, rkey)
		indexedPost, err := postRepo.GetByURI(ctx, postURI)
		require.NoError(t, err, "External embed post should be indexed")

		// Parse embed JSON
		var embedMap map[string]interface{}
		err = json.Unmarshal([]byte(*indexedPost.Embed), &embedMap)
		require.NoError(t, err, "Should parse embed JSON")

		external := embedMap["external"].(map[string]interface{})
		assert.NotNil(t, external["thumb"], "Thumbnail should exist")

		// Test URL transformation (this is what TransformBlobRefsToURLs does)
		postView := &posts.PostView{
			URI:   indexedPost.URI,
			Embed: embedMap,
			Community: &posts.CommunityRef{
				DID:    community.DID,
				PDSURL: community.PDSURL,
			},
		}

		posts.TransformBlobRefsToURLs(postView)

		// After transformation, thumb should be a URL string
		transformedEmbed := postView.Embed.(map[string]interface{})
		transformedExternal := transformedEmbed["external"].(map[string]interface{})
		thumbURL, isString := transformedExternal["thumb"].(string)

		// NOTE: TransformBlobRefsToURLs may keep it as a blob ref if transformation
		// conditions aren't met. Check the actual implementation behavior.
		if isString {
			assert.Contains(t, thumbURL, "/xrpc/com.atproto.sync.getBlob", "Thumb should be blob URL")
			assert.Contains(t, thumbURL, fmt.Sprintf("did=%s", community.DID), "URL should contain DID")
			t.Logf("✓ Thumbnail transformed to URL: %s", thumbURL)
		} else {
			t.Logf("✓ Thumbnail preserved as blob ref (transformation skipped)")
		}
	})
}

// TestBlobUpload_E2E_CommentWithImage tests image upload in comments
func TestBlobUpload_E2E_CommentWithImage(t *testing.T) {
	if testing.Short() {
		t.Skip("Skipping comment image E2E test in short mode")
	}

	// Check if PDS is available before running E2E test
	pdsURL := getTestPDSURL()
	healthResp, err := http.Get(pdsURL + "/xrpc/_health")
	if err != nil {
		t.Skipf("PDS not running at %s: %v. Run 'make dev-up' to start PDS.", pdsURL, err)
	}
	defer func() { _ = healthResp.Body.Close() }()
	if healthResp.StatusCode != http.StatusOK {
		t.Skipf("PDS health check failed at %s: status %d", pdsURL, healthResp.StatusCode)
	}

	db := setupTestDB(t)
	defer func() {
		if err := db.Close(); err != nil {
			t.Logf("Failed to close database: %v", err)
		}
	}()

	ctx := context.Background()

	// Setup repositories
	communityRepo := postgres.NewCommunityRepository(db)
	commentRepo := postgres.NewCommentRepository(db)

	// Setup services (pdsURL already declared in health check above)
	blobService := blobs.NewBlobService(pdsURL)

	// Create test author
	author := createTestUser(t, db, "commentblob.test", "did:plc:commentblob123")

	// Create test community
	community := createTestCommunityWithBlobCredentials(t, communityRepo, "commentblob")

	// Create a test post to comment on
	postURI := createTestPost(t, db, community.DID, author.DID, "Post for Comment Test", 0, time.Now())

	t.Run("Comment with embedded image", func(t *testing.T) {
		// Create test image
		imageData := createTestPNG(t, 5, 5, color.RGBA{R: 255, G: 165, B: 0, A: 255})
		blobRef, err := blobService.UploadBlob(ctx, community, imageData, "image/png")
		require.NoError(t, err, "Blob upload for comment should succeed")

		t.Logf("✓ Uploaded comment image: CID=%v", blobRef.Ref)

		// Create comment with image
		commentRkey := generateTID()
		commentURI := fmt.Sprintf("at://%s/social.coves.community.comment/%s", author.DID, commentRkey)

		jetstreamEvent := jetstream.JetstreamEvent{
			Did:  author.DID, // Comments live in user's repo, not community repo
			Kind: "commit",
			Commit: &jetstream.CommitEvent{
				Operation:  "create",
				Collection: "social.coves.community.comment",
				RKey:       commentRkey,
				CID:        "bafy2bzacecommentimg001",
				Record: map[string]interface{}{
					"$type":   "social.coves.community.comment",
					"content": "Here's an image in my comment!",
					"reply": map[string]interface{}{
						"root": map[string]interface{}{
							"uri": postURI,
							"cid": "fakecid",
						},
						"parent": map[string]interface{}{
							"uri": postURI,
							"cid": "fakecid",
						},
					},
					"embed": map[string]interface{}{
						"$type": "social.coves.embed.images",
						"images": []interface{}{
							map[string]interface{}{
								"image": blobRef,
								"alt":   "Comment image",
							},
						},
					},
					"createdAt": time.Now().UTC().Format(time.RFC3339),
				},
			},
		}

		// Process through consumer
		commentConsumer := jetstream.NewCommentEventConsumer(commentRepo, db)
		err = commentConsumer.HandleEvent(ctx, &jetstreamEvent)
		require.NoError(t, err, "Consumer should process comment with image")

		// Verify comment indexed with blob
		indexedComment, err := commentRepo.GetByURI(ctx, commentURI)
		require.NoError(t, err, "Comment should be indexed")

		require.NotNil(t, indexedComment.Embed, "Comment embed should not be nil")

		// Parse embed JSON
		var embedMap map[string]interface{}
		err = json.Unmarshal([]byte(*indexedComment.Embed), &embedMap)
		require.NoError(t, err, "Should parse embed JSON")
		assert.Equal(t, "social.coves.embed.images", embedMap["$type"], "Embed type should be images")

		images := embedMap["images"].([]interface{})
		require.Len(t, images, 1, "Comment should have 1 image")

		t.Logf("✓ Comment with image indexed: URI=%s", commentURI)
	})
}

// TestBlobUpload_PDS_MockServer tests blob upload with a mock PDS server
// This allows testing without a live PDS instance
func TestBlobUpload_PDS_MockServer(t *testing.T) {
	// Create mock PDS server
	mockPDS := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		// Verify request
		assert.Equal(t, "POST", r.Method, "Should be POST request")
		assert.Equal(t, "/xrpc/com.atproto.repo.uploadBlob", r.URL.Path, "Should hit uploadBlob endpoint")
		assert.Equal(t, "image/png", r.Header.Get("Content-Type"), "Should have correct content type")
		assert.Contains(t, r.Header.Get("Authorization"), "Bearer ", "Should have auth header")

		// Return mock blob reference
		response := map[string]interface{}{
			"blob": map[string]interface{}{
				"$type":    "blob",
				"ref":      map[string]string{"$link": "bafymockblobcid123"},
				"mimeType": "image/png",
				"size":     1234,
			},
		}

		w.Header().Set("Content-Type", "application/json")
		w.WriteHeader(http.StatusOK)
		_ = json.NewEncoder(w).Encode(response)
	}))
	defer mockPDS.Close()

	// Create blob service pointing to mock
	blobService := blobs.NewBlobService(mockPDS.URL)

	// Create test community
	community := &communities.Community{
		DID:            "did:plc:mocktest123",
		PDSURL:         mockPDS.URL,
		PDSAccessToken: "mock_access_token",
	}

	// Create test image
	imageData := createTestPNG(t, 1, 1, color.RGBA{R: 100, G: 100, B: 100, A: 255})

	// Upload blob
	ctx := context.Background()
	blobRef, err := blobService.UploadBlob(ctx, community, imageData, "image/png")
	require.NoError(t, err, "Mock blob upload should succeed")

	// Verify blob reference
	assert.Equal(t, "blob", blobRef.Type)
	assert.Equal(t, "bafymockblobcid123", blobRef.Ref["$link"])
	assert.Equal(t, "image/png", blobRef.MimeType)
	assert.Equal(t, 1234, blobRef.Size)

	t.Log("✓ Mock PDS blob upload succeeded")
}

// TestBlobUpload_Validation tests blob upload validation
func TestBlobUpload_Validation(t *testing.T) {
	db := setupTestDB(t)
	defer func() { _ = db.Close() }()

	communityRepo := postgres.NewCommunityRepository(db)
	blobService := blobs.NewBlobService(getTestPDSURL())
	community := createTestCommunityWithBlobCredentials(t, communityRepo, "validation")
	ctx := context.Background()

	t.Run("Reject empty data", func(t *testing.T) {
		_, err := blobService.UploadBlob(ctx, community, []byte{}, "image/png")
		assert.Error(t, err, "Should reject empty data")
		assert.Contains(t, err.Error(), "cannot be empty", "Error should mention empty data")
	})

	t.Run("Reject invalid MIME type", func(t *testing.T) {
		imageData := createTestPNG(t, 1, 1, color.White)
		_, err := blobService.UploadBlob(ctx, community, imageData, "application/pdf")
		assert.Error(t, err, "Should reject unsupported MIME type")
		assert.Contains(t, err.Error(), "unsupported MIME type", "Error should mention MIME type")
	})

	t.Run("Reject oversized blob", func(t *testing.T) {
		// Create data larger than 1MB limit
		largeData := make([]byte, 1048577) // 1MB + 1 byte
		_, err := blobService.UploadBlob(ctx, community, largeData, "image/png")
		assert.Error(t, err, "Should reject oversized blob")
		assert.Contains(t, err.Error(), "exceeds maximum", "Error should mention size limit")
	})

	t.Run("Accept matching image formats with correct MIME types", func(t *testing.T) {
		testCases := []struct {
			createFunc func(*testing.T, int, int, color.Color) []byte
			format     string
			mimeType   string
		}{
			{createTestPNG, "PNG", "image/png"},
			{createTestJPEG, "JPEG", "image/jpeg"},
			// Note: WebP requires external library (golang.org/x/image/webp)
			// For now, we test that the MIME type is accepted even with PNG data
			// In production, actual WebP validation would happen at PDS
			{createTestPNG, "WebP (MIME only)", "image/webp"},
		}

		for _, tc := range testCases {
			t.Run(tc.format, func(t *testing.T) {
				// Create actual image data in the specified format
				imageData := tc.createFunc(t, 1, 1, color.White)

				// The validation happens inside UploadBlob before making HTTP request
				// Since we don't have a real PDS, this will fail at HTTP stage
				// but we verify the MIME type validation passes
				_, err := blobService.UploadBlob(ctx, community, imageData, tc.mimeType)

				// Error is expected (no real PDS), but it shouldn't be a validation error
				if err != nil && !strings.Contains(err.Error(), "unsupported MIME type") {
					t.Logf("✓ %s with MIME type %s passed validation (failed at PDS stage as expected)", tc.format, tc.mimeType)
				} else if err != nil && strings.Contains(err.Error(), "unsupported MIME type") {
					t.Fatalf("❌ %s with MIME type %s should be supported but got validation error: %v", tc.format, tc.mimeType, err)
				}
			})
		}
	})
}

// Helper functions

// createTestPNG creates a simple PNG image of the specified size and color
func createTestPNG(t *testing.T, width, height int, fillColor color.Color) []byte {
	t.Helper()

	// Create image
	img := image.NewRGBA(image.Rect(0, 0, width, height))

	// Fill with color
	for y := 0; y < height; y++ {
		for x := 0; x < width; x++ {
			img.Set(x, y, fillColor)
		}
	}

	// Encode to PNG
	var buf bytes.Buffer
	err := png.Encode(&buf, img)
	require.NoError(t, err, "PNG encoding should succeed")

	return buf.Bytes()
}

// createTestJPEG creates a simple JPEG image of the specified size and color
func createTestJPEG(t *testing.T, width, height int, fillColor color.Color) []byte {
	t.Helper()

	// Create image
	img := image.NewRGBA(image.Rect(0, 0, width, height))

	// Fill with color
	for y := 0; y < height; y++ {
		for x := 0; x < width; x++ {
			img.Set(x, y, fillColor)
		}
	}

	// Encode to JPEG with quality 90
	var buf bytes.Buffer
	err := jpeg.Encode(&buf, img, &jpeg.Options{Quality: 90})
	require.NoError(t, err, "JPEG encoding should succeed")

	return buf.Bytes()
}

// createTestCommunityWithBlobCredentials creates a test community with valid PDS credentials for blob uploads
func createTestCommunityWithBlobCredentials(t *testing.T, repo communities.Repository, suffix string) *communities.Community {
	t.Helper()

	ctx := context.Background()
	pdsURL := getTestPDSURL()
	uniqueID := time.Now().Unix() // Use seconds instead of nanoseconds to keep handle short

	// Create REAL PDS account for the community (instead of fake credentials)
	// Use .local.coves.dev domain (same as user_journey_e2e_test.go) which is supported by test PDS
	// Keep handle short to avoid "Handle too long" error (max 63 chars for atProto handles)
	handle := fmt.Sprintf("blob%d.local.coves.dev", uniqueID)
	email := fmt.Sprintf("blob%d@test.example", uniqueID)
	password := "test-blob-password-123"

	t.Logf("Creating real PDS account for blob test: %s", handle)
	accessToken, communityDID, err := createPDSAccount(pdsURL, handle, email, password)
	if err != nil {
		t.Skipf("Failed to create PDS account (PDS may not be running): %v", err)
	}

	t.Logf("✓ Created real PDS account: DID=%s", communityDID)

	community := &communities.Community{
		DID:             communityDID, // Use REAL DID from PDS
		Handle:          handle,
		Name:            fmt.Sprintf("blob%d", uniqueID),
		DisplayName:     "Blob Upload Test Community",
		OwnerDID:        communityDID,
		CreatedByDID:    "did:plc:creator123",
		HostedByDID:     "did:web:coves.test",
		Visibility:      "public",
		ModerationType:  "moderator",
		PDSURL:          pdsURL,
		PDSAccessToken:  accessToken,          // Use REAL access token from PDS
		PDSRefreshToken: "refresh-not-needed", // PDS doesn't return refresh token in createAccount
		RecordURI:       fmt.Sprintf("at://%s/social.coves.community.profile/self", communityDID),
		RecordCID:       "fakecidblob" + suffix,
	}

	_, err = repo.Create(ctx, community)
	require.NoError(t, err, "Failed to create test community in database")

	return community
}