package service

import (
	"context"
	"errors"
	"fmt"
	"testing"
	"time"

	"github.com/gochat/gochat/internal/model"
	"github.com/gochat/gochat/internal/repository"
	"github.com/gochat/gochat/internal/worker"
	"github.com/stretchr/testify/assert"
	"github.com/stretchr/testify/require"
	"gorm.io/driver/sqlite"
	"gorm.io/gorm"
)

func setupCaptainDocumentServiceTest(t *testing.T) (*gorm.DB, *CaptainDocumentService) {
	t.Helper()
	dbName := fmt.Sprintf("file:%s?mode=memory&cache=private", t.Name())
	db, err := gorm.Open(sqlite.Open(dbName), &gorm.Config{})
	require.NoError(t, err)
	require.NoError(t, db.AutoMigrate(&model.Account{}, &model.CaptainAssistant{}, &model.CaptainDocument{}, &model.BackgroundJob{}))
	t.Cleanup(func() {
		sqlDB, _ := db.DB()
		sqlDB.Close()
	})
	documentRepo := repository.NewCaptainDocumentRepo(db)
	assistantRepo := repository.NewCaptainAssistantRepo(db)
	return db, NewCaptainDocumentService(documentRepo, nil, assistantRepo)
}

func seedCaptainDocumentSyncFixture(t *testing.T, db *gorm.DB) (*model.Account, *model.Account, *model.CaptainDocument) {
	t.Helper()
	account := &model.Account{Name: "Captain Org", Active: true}
	otherAccount := &model.Account{Name: "Other Org", Active: true}
	require.NoError(t, db.Create(account).Error)
	require.NoError(t, db.Create(otherAccount).Error)
	assistant := &model.CaptainAssistant{AccountID: account.ID, Name: "Fin", Description: "Support", Status: model.AssistantStatusActive}
	require.NoError(t, db.Create(assistant).Error)
	doc := &model.CaptainDocument{
		AccountID:    account.ID,
		AssistantID:  assistant.ID,
		Name:         "Help",
		ExternalLink: "https://example.com/help",
		Status:       model.DocumentStatusCompleted,
		SyncStatus:   model.DocumentSyncStatusSynced,
	}
	require.NoError(t, db.Create(doc).Error)
	return account, otherAccount, doc
}

func TestCaptainDocumentService_SyncDocumentByAccountDisabledMarksFailed(t *testing.T) {
	db, svc := setupCaptainDocumentServiceTest(t)
	account, _, doc := seedCaptainDocumentSyncFixture(t, db)

	updated, err := svc.SyncDocumentByAccount(context.Background(), account.ID, doc.ID)
	require.NoError(t, err)
	assert.Equal(t, model.DocumentSyncStatusFailed, updated.SyncStatus)
	assert.Equal(t, "sync_disabled", updated.LastSyncErrorCode)
	assert.NotNil(t, updated.LastSyncAttemptedAt)
}

func TestCaptainDocumentService_SyncDocumentByAccountUsesFakeBackend(t *testing.T) {
	db, svc := setupCaptainDocumentServiceTest(t)
	account, _, doc := seedCaptainDocumentSyncFixture(t, db)
	backend := &captainDocumentFakeSyncBackend{result: &CaptainDocumentSyncResult{Title: "Fresh Help", Content: "hello\n\nworld"}}
	svc.SetSyncBackend(backend)

	updated, err := svc.SyncDocumentByAccount(context.Background(), account.ID, doc.ID)
	require.NoError(t, err)
	assert.Equal(t, doc.ID, backend.documentID)
	assert.Equal(t, "Fresh Help", updated.Name)
	assert.Equal(t, "hello\n\nworld", updated.Content)
	assert.Equal(t, computeFingerprint("hello world"), updated.ContentFingerprint)
	assert.Equal(t, model.DocumentStatusCompleted, updated.Status)
	assert.Equal(t, model.DocumentSyncStatusSynced, updated.SyncStatus)
	assert.Empty(t, updated.LastSyncErrorCode)
	assert.NotNil(t, updated.LastSyncedAt)
}

func TestCaptainDocumentService_SyncDocumentByAccountRecordsBackendFailures(t *testing.T) {
	db, svc := setupCaptainDocumentServiceTest(t)
	account, _, doc := seedCaptainDocumentSyncFixture(t, db)
	svc.SetSyncBackend(&captainDocumentFakeSyncBackend{err: errors.New("boom")})

	updated, err := svc.SyncDocumentByAccount(context.Background(), account.ID, doc.ID)
	require.Error(t, err)
	assert.Equal(t, model.DocumentSyncStatusFailed, updated.SyncStatus)
	assert.Equal(t, "sync_error", updated.LastSyncErrorCode)

	svc.SetSyncBackend(&captainDocumentFakeSyncBackend{result: &CaptainDocumentSyncResult{ErrorCode: "access_denied"}})
	updated, err = svc.SyncDocumentByAccount(context.Background(), account.ID, doc.ID)
	require.NoError(t, err)
	assert.Equal(t, model.DocumentSyncStatusFailed, updated.SyncStatus)
	assert.Equal(t, "access_denied", updated.LastSyncErrorCode)
}

func TestCaptainDocumentService_SyncDocumentByAccountScopesDocument(t *testing.T) {
	db, svc := setupCaptainDocumentServiceTest(t)
	_, otherAccount, doc := seedCaptainDocumentSyncFixture(t, db)
	svc.SetSyncBackend(&captainDocumentFakeSyncBackend{result: &CaptainDocumentSyncResult{Content: "fresh"}})

	_, err := svc.SyncDocumentByAccount(context.Background(), otherAccount.ID, doc.ID)
	require.Error(t, err)
}

func TestCaptainDocumentService_RequestSyncQueuesDurableJob(t *testing.T) {
	db, svc := setupCaptainDocumentServiceTest(t)
	account, _, doc := seedCaptainDocumentSyncFixture(t, db)
	backend := &captainDocumentFakeSyncBackend{result: &CaptainDocumentSyncResult{Title: "Durable Help", Content: "fresh durable content"}}
	svc.SetSyncBackend(backend)
	now := time.Date(2026, 6, 5, 23, 0, 0, 0, time.UTC)
	wp := worker.NewWorkerPoolWithOptions(db, worker.WithNow(func() time.Time { return now }))
	svc.SetWorkerPool(wp)

	queued, err := svc.RequestSyncDocumentByAccount(context.Background(), account.ID, doc.ID)
	require.NoError(t, err)
	assert.Equal(t, model.DocumentSyncStatusPending, queued.SyncStatus)
	assert.Equal(t, uint(0), backend.documentID)

	var jobCount int64
	require.NoError(t, db.Model(&model.BackgroundJob{}).Where("job_type = ? AND queue = ? AND status = ?", TaskTypeCaptainDocumentSync, "low", model.BackgroundJobStatusQueued).Count(&jobCount).Error)
	assert.Equal(t, int64(1), jobCount)

	processed, err := wp.ProcessOne(context.Background())
	require.NoError(t, err)
	assert.True(t, processed)
	assert.Equal(t, doc.ID, backend.documentID)

	var synced model.CaptainDocument
	require.NoError(t, db.First(&synced, doc.ID).Error)
	assert.Equal(t, "Durable Help", synced.Name)
	assert.Equal(t, "fresh durable content", synced.Content)
	assert.Equal(t, model.DocumentSyncStatusSynced, synced.SyncStatus)
	assert.Empty(t, synced.LastSyncErrorCode)
}

func TestCaptainDocumentService_DocumentSyncJobRetriesMissingDocument(t *testing.T) {
	db, svc := setupCaptainDocumentServiceTest(t)
	now := time.Date(2026, 6, 5, 23, 15, 0, 0, time.UTC)
	wp := worker.NewWorkerPoolWithOptions(db, worker.WithNow(func() time.Time { return now }), worker.WithBackoff(func(attempt int) time.Duration { return time.Minute }))
	svc.SetWorkerPool(wp)

	_, err := wp.Enqueue(context.Background(), TaskTypeCaptainDocumentSync, captainDocumentSyncJob{AccountID: 999, DocumentID: 9999}, worker.WithQueue("low"), worker.WithMaxAttempts(3))
	require.NoError(t, err)
	processed, err := wp.ProcessOne(context.Background())
	require.Error(t, err)
	assert.True(t, processed)

	var job model.BackgroundJob
	require.NoError(t, db.Where("job_type = ?", TaskTypeCaptainDocumentSync).First(&job).Error)
	assert.Equal(t, model.BackgroundJobStatusRetrying, job.Status)
	assert.NotEmpty(t, job.LastError)
}

type captainDocumentFakeSyncBackend struct {
	result     *CaptainDocumentSyncResult
	err        error
	documentID uint
}

func (b *captainDocumentFakeSyncBackend) SyncCaptainDocument(ctx context.Context, doc *model.CaptainDocument) (*CaptainDocumentSyncResult, error) {
	b.documentID = doc.ID
	if b.err != nil {
		return nil, b.err
	}
	return b.result, nil
}