package builderimp

import (
	"testing"
	"time"

	"git.sendico.io/tech/sxchnge/shared/database/record"
	"git.sendico.io/tech/sxchnge/shared/database/repository/builder"
	"go.mongodb.org/mongo-driver/v2/bson"
)

func TestPatchBuilderBuildMergesSetOperations(t *testing.T) {
	patch := NewPatchImp().
		Set(NewFieldImp("name"), "alice").
		Inc(NewFieldImp("version"), 1).
		Set(NewFieldImp("status"), "active")

	built := patch.Build()

	if got := countPatchOperator(built, string(builder.Set)); got != 1 {
		t.Fatalf("$set operator count = %d, want 1: %#v", got, built)
	}
	if got := countPatchOperator(built, string(builder.Inc)); got != 1 {
		t.Fatalf("$inc operator count = %d, want 1: %#v", got, built)
	}
	setFields := patchOperatorFields(t, built, string(builder.Set))
	for _, key := range []string{"name", "status", storable.UpdatedAtField} {
		if countPatchField(setFields, key) != 1 {
			t.Fatalf("$set field %s must be present once: %#v", key, setFields)
		}
	}
}

func TestPatchBuilderBuildOwnsUpdatedAt(t *testing.T) {
	manualUpdatedAt := time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)
	patch := NewPatchImp().
		Set(NewFieldImp(storable.UpdatedAtField), manualUpdatedAt).
		Set(NewFieldImp("status"), "active")

	built := patch.Build()
	setFields := patchOperatorFields(t, built, string(builder.Set))

	if got := countPatchField(setFields, storable.UpdatedAtField); got != 1 {
		t.Fatalf("updatedAt field count = %d, want 1: %#v", got, setFields)
	}
	value, ok := patchFieldValue(setFields, storable.UpdatedAtField).(time.Time)
	if !ok {
		t.Fatalf("updatedAt value type = %T, want time.Time", patchFieldValue(setFields, storable.UpdatedAtField))
	}
	if value.Equal(manualUpdatedAt) {
		t.Fatalf("updatedAt must be repository-owned, got manual value %s", value.Format(time.RFC3339Nano))
	}
}

func patchOperatorFields(t *testing.T, built bson.D, operator string) bson.D {
	t.Helper()
	for _, entry := range built {
		if entry.Key != operator {
			continue
		}
		fields, ok := entry.Value.(bson.D)
		if !ok {
			t.Fatalf("%s value type = %T, want bson.D", operator, entry.Value)
		}
		return fields
	}
	t.Fatalf("%s operator missing: %#v", operator, built)
	return nil
}

func countPatchOperator(built bson.D, operator string) int {
	count := 0
	for _, entry := range built {
		if entry.Key == operator {
			count++
		}
	}
	return count
}

func countPatchField(fields bson.D, key string) int {
	count := 0
	for _, field := range fields {
		if field.Key == key {
			count++
		}
	}
	return count
}

func patchFieldValue(fields bson.D, key string) any {
	for _, field := range fields {
		if field.Key == key {
			return field.Value
		}
	}
	return nil
}