//go:build integration

package search

import (
	"fmt"
	"os"
	"strings"
	"testing"
	"time"

	"github.com/stretchr/testify/require"
	"gorm.io/driver/postgres"
	"gorm.io/gorm"
	"senlinai-agent/backend/internal/models"
)

func TestPostgresSearchMatchesChinesePartialKeywords(t *testing.T) {
	database := newPostgresSearchTestDB(t)
	owner := createSearchUser(t, database, "postgres-search-owner@example.com")
	project := models.SaProject{OwnerID: owner.ID, Name: "中文回调平台", Identifier: "PG-CALLBACK"}
	require.NoError(t, database.Create(&project).Error)
	require.NoError(t, database.Create(&models.SaTask{ProjectID: project.ID, CreatedBy: owner.ID, Title: "回调任务", Status: "open"}).Error)
	createPostgresSearchDocument(t, database, project, owner.ID, models.SaDocumentTree{Name: "说明.md"}, "回调验签流程")

	results, err := NewService(database).Search(owner.ID, "回调")

	require.NoError(t, err)
	require.Len(t, results, 3)
}

func TestPostgresSearchKeepsAssignmentAndExplicitShareBoundaries(t *testing.T) {
	database := newPostgresSearchTestDB(t)
	owner := createSearchUser(t, database, "postgres-privacy-owner@example.com")
	viewer := createSearchUser(t, database, "postgres-privacy-viewer@example.com")
	project := models.SaProject{OwnerID: owner.ID, Name: "保密项目", Identifier: "PG-PRIVATE"}
	require.NoError(t, database.Create(&project).Error)
	assigned := models.SaTask{ProjectID: project.ID, CreatedBy: owner.ID, AssigneeID: &viewer.ID, Title: "边界词已指派", Status: "open"}
	require.NoError(t, database.Create(&assigned).Error)
	require.NoError(t, database.Create(&models.SaTask{ProjectID: project.ID, CreatedBy: owner.ID, Title: "边界词私有任务", Status: "open"}).Error)
	sharedDocument := createPostgresSearchDocument(t, database, project, owner.ID, models.SaDocumentTree{Name: "边界词共享笔记.md"}, "")
	createPostgresSearchDocument(t, database, project, owner.ID, models.SaDocumentTree{Name: "边界词私有笔记.md"}, "")
	require.NoError(t, database.Create(&models.SaTaskShare{TaskID: assigned.ID, ObjectType: "document", ObjectID: sharedDocument.ID}).Error)

	results, err := NewService(database).Search(viewer.ID, "边界词")

	require.NoError(t, err)
	require.Len(t, results, 2)
	require.ElementsMatch(t, []string{assigned.Identity, sharedDocument.Identity}, []string{results[0].ID, results[1].ID})
}

func TestPostgresSearchUsesStableFairLimitAndRuneBoundedSnippets(t *testing.T) {
	database := newPostgresSearchTestDB(t)
	owner := createSearchUser(t, database, "postgres-search-order@example.com")
	baseTime := time.Date(2026, time.July, 21, 12, 0, 0, 0, time.UTC)
	for index := 0; index < 60; index++ {
		project := models.SaProject{
			Identity:   fmt.Sprintf("00000000-0000-7001-8000-%012d", index),
			OwnerID:    owner.ID,
			Name:       fmt.Sprintf("稳定排序项目 %02d", index),
			Identifier: fmt.Sprintf("PG-SORT-%02d", index),
			UpdatedAt:  baseTime.Add(time.Duration(index) * time.Minute),
		}
		require.NoError(t, database.Create(&project).Error)
		require.NoError(t, database.Create(&models.SaTask{
			Identity:  fmt.Sprintf("00000000-0000-7002-8000-%012d", index),
			ProjectID: project.ID,
			CreatedBy: owner.ID,
			Title:     fmt.Sprintf("稳定排序任务 %02d", index),
			Status:    "open",
			UpdatedAt: baseTime.Add(time.Duration(index) * time.Minute),
		}).Error)
		createPostgresSearchDocument(t, database, project, owner.ID, models.SaDocumentTree{
			Identity:  fmt.Sprintf("00000000-0000-7003-8000-%012d", index),
			Name:      fmt.Sprintf("稳定排序笔记 %02d.md", index),
			UpdatedAt: baseTime.Add(time.Duration(index) * time.Minute),
		}, strings.Repeat("森", 300)+"尾")
	}

	service := NewService(database)
	results, err := service.Search(owner.ID, "稳定排序")
	require.NoError(t, err)
	require.Len(t, results, maxSearchResults)
	require.Equal(t,
		[]string{"project", "task", "document", "project", "task", "document", "project", "task", "document"},
		resultTypes(results[:9]),
	)
	require.Equal(t, "00000000-0000-7001-8000-000000000059", results[0].ID)
	require.Equal(t, "00000000-0000-7002-8000-000000000059", results[1].ID)
	require.Equal(t, "00000000-0000-7003-8000-000000000059", results[2].ID)
	counts := map[string]int{}
	for _, result := range results {
		counts[result.Type]++
	}
	require.Equal(t, map[string]int{"project": 17, "task": 17, "document": 16}, counts)

	again, err := service.Search(owner.ID, "稳定排序")
	require.NoError(t, err)
	require.Equal(t, results, again)

	documentResults, err := service.Search(owner.ID, "森")
	require.NoError(t, err)
	require.NotEmpty(t, documentResults)
	require.Len(t, []rune(documentResults[0].Snippet), 240)
	require.NotContains(t, documentResults[0].Snippet, "尾")
}

func createPostgresSearchDocument(
	t *testing.T,
	database *gorm.DB,
	project models.SaProject,
	ownerID uint,
	document models.SaDocumentTree,
	markdown string,
) models.SaDocumentTree {
	t.Helper()
	document.ProjectID = project.ID
	document.ProjectIdentity = project.Identity
	document.OwnerID = ownerID
	document.Kind = models.DocumentKindFile
	document.Extension = ".md"
	document.MimeType = "text/markdown; charset=utf-8"
	document.NormalizedName = strings.ToLower(document.Name)
	document.Revision = 1
	require.NoError(t, database.Create(&document).Error)
	require.NoError(t, database.Create(&models.SaDocumentContent{DocumentID: document.ID, Markdown: markdown}).Error)
	return document
}

func newPostgresSearchTestDB(t *testing.T) *gorm.DB {
	t.Helper()
	dsn := os.Getenv("TEST_DATABASE_URL")
	require.NotEmpty(t, dsn, "TEST_DATABASE_URL is required for integration tests and must point to an isolated database")
	database, err := gorm.Open(postgres.Open(dsn), &gorm.Config{TranslateError: true})
	require.NoError(t, err)
	transaction := database.Begin()
	require.NoError(t, transaction.Error)
	t.Cleanup(func() { transaction.Rollback() })
	require.NoError(t, models.AutoMigrate(transaction))
	return transaction
}