package analytics_test

import (
	"context"
	"encoding/json"
	"testing"
	"tercul/internal/app/analytics"
	analyticsjob "tercul/internal/jobs/analytics"
	"tercul/internal/testutil"
	"time"

	"github.com/hibiken/asynq"
	"github.com/stretchr/testify/suite"
)

type WorkerIntegrationTestSuite struct {
	testutil.IntegrationTestSuite
}

func TestWorkerIntegrationTestSuite(t *testing.T) {
	suite.Run(t, new(WorkerIntegrationTestSuite))
}

func (s *WorkerIntegrationTestSuite) SetupTest() {
	s.IntegrationTestSuite.SetupSuite(nil)
	s.IntegrationTestSuite.SetupTest()
}

func (s *WorkerIntegrationTestSuite) TestWorker_ProcessTask() {
	// Create a new worker
	worker := analyticsjob.NewWorker(s.App.AnalyticsService)

	// Create a new asynq client
	redisAddr := s.Config.RedisAddr
	client := asynq.NewClient(asynq.RedisClientOpt{Addr: redisAddr})
	defer client.Close()

	// Create a new asynq server and register the handler
	srv := asynq.NewServer(
		asynq.RedisClientOpt{Addr: redisAddr},
		asynq.Config{
			Concurrency: 1,
			Queues: map[string]int{
				"analytics": 1,
			},
		},
	)
	mux := asynq.NewServeMux()
	mux.HandleFunc("analytics:event", worker.ProcessTask)

	// Enqueue a task
	work := testutil.CreateWork(s.Ctx, s.DB, "Test Work", "Test Author")
	event := analytics.AnalyticsEvent{
		EventType: analytics.EventTypeWorkViewed,
		WorkID:    &work.ID,
	}
	payload, err := json.Marshal(event)
	s.Require().NoError(err)

	task := asynq.NewTask("analytics:event", payload)
	_, err = client.Enqueue(task, asynq.Queue("analytics"))
	s.Require().NoError(err)

	// Process the task
	go func() {
		err := srv.Run(mux)
		s.Require().NoError(err)
	}()
	defer srv.Stop()

	// Verify
	s.Eventually(func() bool {
		popular, err := s.App.AnalyticsService.GetPopularWorks(context.Background(), 10)
		if err != nil {
			return false
		}

		for _, p := range popular {
			if p.WorkID == work.ID {
				return true
			}
		}
		return false
	}, 5*time.Second, 100*time.Millisecond, "work should be in popular list")
}