package tests

// DB-backed repository integration test using a disposable Postgres testcontainer.

import (
	"context"
	"testing"
	"time"

	domain "knowfoolery/backend/services/question-bank-service/internal/domain/question"
	qent "knowfoolery/backend/services/question-bank-service/internal/infra/persistence/ent"
	sharedpostgres "knowfoolery/backend/shared/infra/database/postgres"
	sharedcontainers "knowfoolery/backend/shared/testutil/containers"
)

// TestRepositoryLifecycle ensures repository lifecycle behavior is handled correctly.
func TestRepositoryLifecycle(t *testing.T) {
	pg := sharedcontainers.StartPostgres(t)
	cfg := pg.Config()

	ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
	defer cancel()

	client, err := sharedpostgres.NewClient(ctx, cfg)
	if err != nil {
		t.Fatalf("new client: %v", err)
	}
	defer client.Close()

	repo := qent.NewQuestionRepository(client)
	if err := repo.EnsureSchema(ctx); err != nil {
		t.Fatalf("ensure schema: %v", err)
	}

	created, err := repo.Create(ctx, &domain.Question{
		Theme:      "Science",
		Text:       "What is H2O?",
		Answer:     "water",
		Hint:       "liquid",
		Difficulty: domain.DifficultyEasy,
		IsActive:   true,
	})
	if err != nil {
		t.Fatalf("create: %v", err)
	}

	got, err := repo.GetByID(ctx, created.ID)
	if err != nil {
		t.Fatalf("get: %v", err)
	}
	if got.ID != created.ID {
		t.Fatalf("id mismatch")
	}

	count, err := repo.CountRandomCandidates(ctx, domain.RandomFilter{Theme: "Science"})
	if err != nil {
		t.Fatalf("count candidates: %v", err)
	}
	if count < 1 {
		t.Fatalf("expected at least one candidate, got %d", count)
	}

	random, err := repo.RandomByOffset(ctx, domain.RandomFilter{Theme: "Science"}, 0)
	if err != nil {
		t.Fatalf("random by offset: %v", err)
	}
	if random.ID == "" {
		t.Fatalf("expected non-empty random question ID")
	}
}