package commands

import (
	"context"
	"testing"

	"github.com/stretchr/testify/assert"
	"tercul/internal/domain"
)

func TestMigrateTranslations_EmptyData(t *testing.T) {
	index := initBleveIndexForTest(t)
	defer func() { _ = index.Close() }()

	repo := &mockTranslationRepository{translations: []domain.Translation{}}
	logger := getTestLogger()

	stats, err := migrateTranslations(
		context.Background(),
		repo,
		index,
		10,
		nil,
		logger,
	)

	assert.NoError(t, err)
	assert.NotNil(t, stats)
	assert.Equal(t, 0, stats.TotalIndexed)
	assert.Equal(t, 0, stats.TotalErrors)
}

func TestMigrateTranslations_LargeBatch(t *testing.T) {
	index := initBleveIndexForTest(t)
	defer func() { _ = index.Close() }()

	// Create 100 translations
	translations := make([]domain.Translation, 100)
	for i := 0; i < 100; i++ {
		translations[i] = domain.Translation{
			BaseModel:        domain.BaseModel{ID: uint(i + 1)},
			Title:            "Test Translation",
			Content:          "Content",
			Language:         "en",
			Status:           domain.TranslationStatusPublished,
			TranslatableID:   uint(i + 1),
			TranslatableType: "works",
		}
	}

	repo := &mockTranslationRepository{translations: translations}
	logger := getTestLogger()

	stats, err := migrateTranslations(
		context.Background(),
		repo,
		index,
		50, // Batch size smaller than total
		nil,
		logger,
	)

	assert.NoError(t, err)
	assert.NotNil(t, stats)
	assert.Equal(t, 100, stats.TotalIndexed)
	assert.Equal(t, 0, stats.TotalErrors)
}

func TestMigrateTranslations_RepositoryError(t *testing.T) {
	index := initBleveIndexForTest(t)
	defer func() { _ = index.Close() }()

	repo := &mockTranslationRepository{
		translations: []domain.Translation{},
		err:          assert.AnError,
	}
	logger := getTestLogger()

	stats, err := migrateTranslations(
		context.Background(),
		repo,
		index,
		10,
		nil,
		logger,
	)

	assert.Error(t, err)
	assert.Nil(t, stats)
}

func TestIndexBatch_EmptyBatch(t *testing.T) {
	index := initBleveIndexForTest(t)
	defer func() { _ = index.Close() }()

	err := indexBatch(index, []domain.Translation{})
	assert.NoError(t, err) // Empty batch should not error
}

func TestIndexBatch_WithTranslatorID(t *testing.T) {
	index := initBleveIndexForTest(t)
	defer func() { _ = index.Close() }()

	translatorID := uint(123)
	translations := []domain.Translation{
		{
			BaseModel:        domain.BaseModel{ID: 1},
			Title:            "Test",
			Content:          "Content",
			Language:         "en",
			Status:           domain.TranslationStatusPublished,
			TranslatableID:   100,
			TranslatableType: "works",
			TranslatorID:     &translatorID,
		},
	}

	err := indexBatch(index, translations)
	assert.NoError(t, err)

	// Verify document is indexed
	doc, err := index.Document("translation_1")
	assert.NoError(t, err)
	assert.NotNil(t, doc)
}

func TestCheckpoint_InvalidJSON(t *testing.T) {
	// Test loading invalid checkpoint file
	// This would require mocking file system, but for now we test the happy path
	// Invalid JSON handling is tested implicitly through file operations
}